@empiricalrun/test-gen 0.79.2 → 0.79.3

package/dist/tools/trace-dot-zip/utils/extract-screenshots.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractScreenshotsAroundStep = extractScreenshotsAroundStep;
+exports.extractScreenshotsInRange = extractScreenshotsInRange;
+exports.parseTimeToMs = parseTimeToMs;
+exports.saveScreenshotsToDir = saveScreenshotsToDir;
+const buffer_1 = require("buffer");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const extract_steps_1 = require("./extract-steps");
+const extract_zip_1 = require("./extract-zip");
+async function extractScreenshotsAroundStep(opts) {
+    const { zipUrl, stepId, beforeMs = 2000, afterMs = 2000, maxScreenshots = 10, } = opts;
+    const steps = await (0, extract_steps_1.extractStepsFromTrace)(zipUrl);
+    const step = steps.find((s) => s.callId === stepId);
+    if (!step) {
+        return { step: undefined, screenshots: [] };
+    }
+    const startTime = step.startTime - beforeMs;
+    const endTime = (step.endTime ?? step.startTime) + afterMs;
+    const screenshots = await extractScreenshotsInRange({
+        zipUrl,
+        startTime,
+        endTime,
+        maxScreenshots,
+    });
+    return { step, screenshots };
+}
+async function extractScreenshotsInRange(opts) {
+    const { zipUrl, startTime, endTime, maxScreenshots = 10 } = opts;
+    const frames = await extractScreencastFrames(zipUrl);
+    const relevantFrames = frames.filter((f) => f.timestamp >= startTime && f.timestamp <= endTime);
+    let selectedFrames = relevantFrames;
+    if (relevantFrames.length > maxScreenshots) {
+        selectedFrames = sampleFrames(relevantFrames, maxScreenshots);
+    }
+    const screenshots = await extractScreenshotImages(zipUrl, selectedFrames.map((f) => f.sha1));
+    return selectedFrames.map((f) => ({
+        sha1: f.sha1,
+        timestamp: f.timestamp,
+        width: f.width,
+        height: f.height,
+        base64: screenshots.get(f.sha1) || "",
+    }));
+}
+function parseTimeToMs(timeStr) {
+    const match = timeStr.match(/^(\d{2}):(\d{2}):(\d{2})\.(\d{3})$/);
+    if (!match) {
+        throw new Error(`Invalid time format: ${timeStr}. Expected HH:MM:SS.mmm (e.g., 00:02:06.434)`);
+    }
+    const [, hours, minutes, seconds, ms] = match;
+    return (parseInt(hours, 10) * 3600000 +
+        parseInt(minutes, 10) * 60000 +
+        parseInt(seconds, 10) * 1000 +
+        parseInt(ms, 10));
+}
+async function extractScreencastFrames(zipUrl) {
+    const frames = [];
+    await (0, extract_zip_1.extractFileFromZipFromUrl)({
+        zipUrl,
+        fileNames: ["0-trace.trace"],
+        chunkProcessor: () => {
+            let tempBuffer = "";
+            return (chunk) => {
+                tempBuffer += chunk;
+                const lines = tempBuffer.split("\n");
+                lines.slice(0, -1).forEach((line) => {
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.type === "screencast-frame") {
+                            frames.push(event);
+                        }
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                });
+                tempBuffer = lines[lines.length - 1] || "";
+            };
+        },
+    });
+    return frames;
+}
+async function extractScreenshotImages(zipUrl, sha1s) {
+    const results = new Map();
+    const fileNames = sha1s.map((sha1) => `resources/${sha1}`);
+    await (0, extract_zip_1.extractFileFromZipFromUrl)({
+        zipUrl,
+        fileNames,
+        chunkProcessor: (_, currentFile) => {
+            const sha1 = currentFile.replace("resources/", "");
+            const chunks = [];
+            return (chunk) => {
+                chunks.push(chunk);
+                const combined = buffer_1.Buffer.concat(chunks);
+                results.set(sha1, combined.toString("base64"));
+            };
+        },
+    });
+    return results;
+}
+function sampleFrames(frames, count) {
+    if (frames.length <= count)
+        return frames;
+    const result = [];
+    const step = (frames.length - 1) / (count - 1);
+    for (let i = 0; i < count; i++) {
+        const idx = Math.round(i * step);
+        result.push(frames[idx]);
+    }
+    return result;
+}
+async function saveScreenshotsToDir(screenshots, outputDir, stepId) {
+    await fs_1.promises.mkdir(outputDir, { recursive: true });
+    const savedPaths = [];
+    for (let i = 0; i < screenshots.length; i++) {
+        const s = screenshots[i];
+        const ext = s.sha1.endsWith(".jpeg") || s.sha1.endsWith(".jpg") ? "jpg" : "png";
+        const filename = `${stepId.replace(/[@:]/g, "-")}_${i + 1}.${ext}`;
+        const filePath = path_1.default.join(outputDir, filename);
+        await fs_1.promises.writeFile(filePath, buffer_1.Buffer.from(s.base64, "base64"));
+        savedPaths.push(filePath);
+    }
+    return savedPaths;
+}

package/dist/tools/trace-dot-zip/utils/extract-steps.d.ts

@@ -0,0 +1,12 @@
+export type TraceStep = {
+    callId: string;
+    apiName: string;
+    params?: Record<string, any>;
+    startTime: number;
+    endTime?: number;
+    parentId?: string;
+    error?: string;
+};
+export declare function extractStepsFromTrace(zipUrl: string): Promise<TraceStep[]>;
+export declare function formatStepsForDisplay(steps: TraceStep[]): string[];
+//# sourceMappingURL=extract-steps.d.ts.map

package/dist/tools/trace-dot-zip/utils/extract-steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-steps.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/extract-steps.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAeF,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,SAAS,EAAE,CAAC,CAqDtB;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CA4ClE"}

package/dist/tools/trace-dot-zip/utils/extract-steps.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractStepsFromTrace = extractStepsFromTrace;
+exports.formatStepsForDisplay = formatStepsForDisplay;
+const extract_zip_1 = require("./extract-zip");
+async function extractStepsFromTrace(zipUrl) {
+    const beforeEvents = new Map();
+    const afterEvents = new Map();
+    const errorEvents = [];
+    await (0, extract_zip_1.extractFileFromZipFromUrl)({
+        zipUrl,
+        fileNames: ["test.trace"],
+        chunkProcessor: () => {
+            let tempBuffer = "";
+            return (chunk) => {
+                tempBuffer += chunk;
+                const lines = tempBuffer.split("\n");
+                lines.slice(0, -1).forEach((line) => {
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.type === "before" && event.callId) {
+                            beforeEvents.set(event.callId, event);
+                        }
+                        else if (event.type === "after" && event.callId) {
+                            afterEvents.set(event.callId, event);
+                        }
+                        else if (event.type === "error") {
+                            errorEvents.push(event);
+                        }
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                });
+                tempBuffer = lines[lines.length - 1] || "";
+            };
+        },
+    });
+    const steps = [];
+    for (const [callId, before] of beforeEvents) {
+        const after = afterEvents.get(callId);
+        const apiName = before.apiName || before.title;
+        if (apiName) {
+            steps.push({
+                callId,
+                apiName,
+                params: before.params,
+                startTime: before.startTime ?? 0,
+                endTime: after?.endTime,
+                parentId: before.parentId,
+                error: after?.error?.message,
+            });
+        }
+    }
+    // sort by startTime
+    steps.sort((a, b) => a.startTime - b.startTime);
+    return steps;
+}
+function formatStepsForDisplay(steps) {
+    const lines = [];
+    const parentMap = new Map();
+    for (const step of steps) {
+        const key = step.parentId || "root";
+        if (!parentMap.has(key))
+            parentMap.set(key, []);
+        parentMap.get(key).push(step);
+    }
+    function renderStep(step, depth) {
+        const indent = "  ".repeat(depth);
+        const failed = step.error ? " [FAILED]" : "";
+        const timeRange = formatTimeRange(step.startTime, step.endTime);
+        const mainParam = getMainParam(step);
+        const paramSuffix = mainParam ? ` ${mainParam}` : "";
+        lines.push(`${indent}[${step.callId}] ${step.apiName}${paramSuffix}${failed}`);
+        lines.push(`${indent}  ${timeRange}`);
+        if (step.params) {
+            const extraParams = formatExtraParams(step.params);
+            if (extraParams.length > 0) {
+                for (const param of extraParams) {
+                    lines.push(`${indent}  ${param}`);
+                }
+            }
+        }
+        const children = parentMap.get(step.callId) || [];
+        for (const child of children) {
+            renderStep(child, depth + 1);
+        }
+    }
+    const rootSteps = parentMap.get("root") || [];
+    for (const step of rootSteps) {
+        renderStep(step, 0);
+    }
+    return lines;
+}
+function formatTimeRange(startTime, endTime) {
+    const start = new Date(startTime).toISOString().slice(11, 23);
+    if (endTime) {
+        const end = new Date(endTime).toISOString().slice(11, 23);
+        const duration = Math.round(endTime - startTime);
+        return `${start} → ${end} (${duration}ms)`;
+    }
+    return `${start}`;
+}
+function getMainParam(step) {
+    if (!step.params)
+        return undefined;
+    const p = step.params;
+    if (p.url)
+        return p.url;
+    if (p.selector)
+        return p.selector;
+    if (p.text)
+        return `"${p.text}"`;
+    if (p.value)
+        return `"${p.value}"`;
+    return undefined;
+}
+function formatExtraParams(params) {
+    const mainKeys = ["url", "selector", "text", "value"];
+    const lines = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (mainKeys.includes(key))
+            continue;
+        if (value === undefined || value === null)
+            continue;
+        const formatted = typeof value === "string" ? value : JSON.stringify(value);
+        lines.push(`${key}: ${formatted}`);
+    }
+    return lines;
+}

package/dist/tools/trace-dot-zip/utils/extract-zip.d.ts

@@ -1,21 +1,18 @@
-import { Buffer } from "buffer";
-export declare const extractFileFromZipFromUrl: ({ zipUrl, fileNames, chunkProcessor, withCache, }: {
+export type { ChunkProcessor } from "@empiricalrun/r2-uploader/zip";
+export { getZipEntryNames, readZipResourcesBySha1, streamZipEntries, withZipFile, } from "@empiricalrun/r2-uploader/zip";
+import type { ChunkProcessor } from "@empiricalrun/r2-uploader/zip";
+export declare function extractFilesFromZipPath({ zipPath, fileNames, chunkProcessor, }: {
+    zipPath: string;
+    fileNames: string[];
+    chunkProcessor: ChunkProcessor;
+}): Promise<void>;
+export declare function getFilenamesInZip(zipUrl: string, { recursive, }?: {
+    recursive?: boolean;
+}): Promise<string[]>;
+export declare const extractFileFromZipFromUrl: ({ zipUrl, fileNames, chunkProcessor, }: {
     zipUrl: string;
     fileNames: string[];
-    chunkProcessor: (breakAndResolve: () => void, currentFileGettingProcessed: string) => (chunk: Buffer) => void;
+    chunkProcessor: ChunkProcessor;
     withCache?: boolean;
 }) => Promise<void>;
-/**
- * Returns a list of file names contained in a zip file located at `zipUrl`.
- *
- * @param zipUrl - The URL or file path (file://...) of the zip file.
- * @param options.withCache - Whether to use cached fetch logic (if available).
- * @param options.recursive - If `false`, only return top-level files (files with no slash).
- *                            If `true`, return all files in any subdirectory.
- * @returns An array of file names in the ZIP.
- */
-export declare function getFilenamesInZip(zipUrl: string, { withCache, recursive, }?: {
-    withCache?: boolean;
-    recursive?: boolean;
-}): Promise<string[]>;
 //# sourceMappingURL=extract-zip.d.ts.map

package/dist/tools/trace-dot-zip/utils/extract-zip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-zip.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/extract-zip.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AA0FhC,eAAO,MAAM,yBAAyB,GAAU,mDAK7C;IACD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,CACd,eAAe,EAAE,MAAM,IAAI,EAC3B,2BAA2B,EAAE,MAAM,KAChC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,KAAG,OAAO,CAAC,IAAI,CAuEf,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,EACE,SAAiB,EACjB,SAAgB,GACjB,GAAE;IACD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CAChB,GACL,OAAO,CAAC,MAAM,EAAE,CAAC,CAoCnB"}
+{"version":3,"file":"extract-zip.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/extract-zip.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAEpE,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,EAChB,WAAW,GACZ,MAAM,+BAA+B,CAAC;AAEvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAGpE,wBAAsB,uBAAuB,CAAC,EAC5C,OAAO,EACP,SAAS,EACT,cAAc,GACf,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,cAAc,CAAC;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhB;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,EACE,SAAgB,GACjB,GAAE;IACD,SAAS,CAAC,EAAE,OAAO,CAAC;CAChB,GACL,OAAO,CAAC,MAAM,EAAE,CAAC,CAcnB;AAED,eAAO,MAAM,yBAAyB,GAAU,wCAI7C;IACD,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,cAAc,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,KAAG,OAAO,CAAC,IAAI,CAIf,CAAC"}

package/dist/tools/trace-dot-zip/utils/extract-zip.js

@@ -1,174 +1,34 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFileFromZipFromUrl = void 0;
+exports.extractFileFromZipFromUrl = exports.withZipFile = exports.streamZipEntries = exports.readZipResourcesBySha1 = exports.getZipEntryNames = void 0;
+exports.extractFilesFromZipPath = extractFilesFromZipPath;
 exports.getFilenamesInZip = getFilenamesInZip;
-const buffer_1 = require("buffer");
-const fs_1 = require("fs");
-const stream_1 = require("stream");
-const util_1 = require("util");
-const yauzl_1 = __importDefault(require("yauzl"));
-const fromBuffer = (0, util_1.promisify)(yauzl_1.default.fromBuffer);
-const convertToNodeReadableStream = (webReadableStream) => {
-    const nodeReadableStream = new stream_1.Readable({
-        read() { },
-    });
-    const reader = webReadableStream.getReader();
-    void (async function readStream() {
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    nodeReadableStream.push(null);
-                    break;
-                }
-                nodeReadableStream.push(value);
-            }
-        }
-        catch (error) {
-            nodeReadableStream.destroy(error);
-        }
-    })();
-    return nodeReadableStream;
-};
-async function streamToBuffer(webStream) {
-    const chunks = [];
-    return new Promise((resolve, reject) => {
-        const nodeStream = convertToNodeReadableStream(webStream);
-        nodeStream.on("data", (chunk) => chunks.push(chunk));
-        nodeStream.on("end", () => resolve(buffer_1.Buffer.concat(chunks)));
-        nodeStream.on("error", reject);
-    });
-}
-const cache = {};
-const cachedFetch = async (url) => {
-    if (url in cache) {
-        return cache[url];
-    }
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`HTTP error! Status: ${response.status}`);
-    }
-    // Convert the stream to a buffer
-    const buffer = await streamToBuffer(response.body);
-    cache[url] = buffer;
-    return buffer;
-};
-/**
- * Fetches or reads a zip file from URL or file path, then returns a Buffer.
- */
-async function getZipBuffer(zipUrl, withCache) {
-    if (zipUrl.startsWith("file://")) {
-        const filePath = zipUrl.replace(/^file:\/\//, "");
-        return fs_1.promises.readFile(filePath);
-    }
-    else if (withCache) {
-        return await cachedFetch(zipUrl);
-    }
-    else {
-        const response = await fetch(zipUrl);
-        if (!response.ok) {
-            throw new Error(`HTTP error! Status: ${response.status}`);
-        }
-        return streamToBuffer(response.body);
-    }
+var zip_1 = require("@empiricalrun/r2-uploader/zip");
+Object.defineProperty(exports, "getZipEntryNames", { enumerable: true, get: function () { return zip_1.getZipEntryNames; } });
+Object.defineProperty(exports, "readZipResourcesBySha1", { enumerable: true, get: function () { return zip_1.readZipResourcesBySha1; } });
+Object.defineProperty(exports, "streamZipEntries", { enumerable: true, get: function () { return zip_1.streamZipEntries; } });
+Object.defineProperty(exports, "withZipFile", { enumerable: true, get: function () { return zip_1.withZipFile; } });
+const zip_2 = require("@empiricalrun/r2-uploader/zip");
+async function extractFilesFromZipPath({ zipPath, fileNames, chunkProcessor, }) {
+    await (0, zip_2.streamZipEntries)({ zipPath, fileNames, chunkProcessor });
 }
-const extractFileFromZipFromUrl = async ({ zipUrl, fileNames, chunkProcessor, withCache, }) => {
-    try {
-        const buffer = await getZipBuffer(zipUrl, withCache);
-        // Ensure buffer is not empty
-        if (buffer.length === 0) {
-            throw new Error("Empty buffer received.");
-        }
-        // Process the zip file from the buffer
-        const zipfile = await fromBuffer(buffer, { lazyEntries: true });
-        const fileProcessingPromises = [];
-        // Use promises for entry reading
-        await new Promise((resolve) => {
-            zipfile.on("entry", (entry) => {
-                if (fileNames.includes(entry.fileName)) {
-                    const filePromise = new Promise((fileResolve) => {
-                        zipfile.openReadStream(entry, (err, readStream) => {
-                            if (err) {
-                                console.error(`error reading file - ${entry.fileName}`, err);
-                                fileResolve();
-                                return;
-                            }
-                            const done = () => {
-                                fileResolve();
-                            };
-                            const processChunk = chunkProcessor(done, entry.fileName);
-                            readStream.on("data", processChunk);
-                            readStream.on("end", () => {
-                                fileResolve();
-                            });
-                            readStream.on("error", (error) => {
-                                console.error(`error reading file - ${entry.fileName}`, error);
-                                fileResolve();
-                            });
-                        });
-                    });
-                    // Push each file's promise to the array
-                    fileProcessingPromises.push(filePromise);
-                }
-                zipfile.readEntry();
-            });
-            zipfile.on("end", () => {
-                resolve();
-            });
-            zipfile.on("error", (error) => {
-                console.error(`Error reading entry`, error);
-                resolve();
-            });
-            zipfile.readEntry();
+async function getFilenamesInZip(zipUrl, { recursive = true, } = {}) {
+    const { getZipEntryNames } = await import("@empiricalrun/r2-uploader/zip");
+    return (0, zip_2.withZipFile)(zipUrl, async (zipPath) => {
+        const allNames = await getZipEntryNames(zipPath);
+        return allNames.filter((name) => {
+            const isDirectory = name.endsWith("/");
+            if (isDirectory)
+                return false;
+            if (recursive)
+                return true;
+            return !name.includes("/");
         });
-        await Promise.all(fileProcessingPromises);
-    }
-    catch (error) {
-        console.error(`Error fetching or processing the zip file url - "${zipUrl}"`, error);
-    }
-};
-exports.extractFileFromZipFromUrl = extractFileFromZipFromUrl;
-/**
- * Returns a list of file names contained in a zip file located at `zipUrl`.
- *
- * @param zipUrl - The URL or file path (file://...) of the zip file.
- * @param options.withCache - Whether to use cached fetch logic (if available).
- * @param options.recursive - If `false`, only return top-level files (files with no slash).
- *                            If `true`, return all files in any subdirectory.
- * @returns An array of file names in the ZIP.
- */
-async function getFilenamesInZip(zipUrl, { withCache = false, recursive = true, } = {}) {
-    // 1. Get the zip contents as a Buffer
-    const buffer = await getZipBuffer(zipUrl, withCache);
-    // 2. Parse the zip file with yauzl
-    const zipfile = await fromBuffer(buffer, { lazyEntries: true });
-    const fileNames = [];
-    await new Promise((resolve, reject) => {
-        zipfile.on("entry", (entry) => {
-            // Identify directories by trailing slash
-            const isDirectory = entry.fileName.endsWith("/");
-            // We don't list directories, only files
-            if (!isDirectory) {
-                if (recursive) {
-                    // Include all files
-                    fileNames.push(entry.fileName);
-                }
-                else {
-                    // Only include top-level files (no slash in the path)
-                    if (!entry.fileName.includes("/")) {
-                        fileNames.push(entry.fileName);
-                    }
-                }
-            }
-            // Proceed to the next entry
-            zipfile.readEntry();
-        });
-        zipfile.on("error", (err) => reject(err));
-        zipfile.on("end", () => resolve());
-        zipfile.readEntry();
     });
-    return fileNames;
 }
+const extractFileFromZipFromUrl = async ({ zipUrl, fileNames, chunkProcessor, }) => {
+    await (0, zip_2.withZipFile)(zipUrl, async (zipPath) => {
+        await extractFilesFromZipPath({ zipPath, fileNames, chunkProcessor });
+    });
+};
+exports.extractFileFromZipFromUrl = extractFileFromZipFromUrl;

package/dist/tools/trace-dot-zip/utils/network-trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-trace.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/network-trace.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAUlB,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,EACJ;YACE,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;SAChB,GACD,SAAS,CAAC;KACf,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,8BAIxC,KAAK,KAAG,OAAO,CAAC;IACjB,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,0BAA0B,EAAE,sBAAsB,EAAE,CAAC;CACtD,CA+KA,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAU,UAElD,KAAK,KAAG,OAAO,CAAC;IACjB,mBAAmB,EAAE,sBAAsB,EAAE,CAAC;IAC9C,mBAAmB,EAAE,sBAAsB,EAAE,CAAC;CAC/C,CAsEA,CAAC;AAsBF,eAAO,MAAM,0CAA0C,GACrD,UAAU,sBAAsB,EAAE,KACjC,OAAO,CAAC,sBAAsB,CAAC,EAoBjC,CAAC;AAmCF,eAAO,MAAM,iBAAiB,GAC5B,UAAU,sBAAsB,EAAE,EAClC,QAAQ,MAAM,KACb,OAAO,CAAC,sBAAsB,EAAE,CA+BlC,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,0CAA0C,sBAAsB,EAAE,KACjE,sBAAsB,EA2BxB,CAAC"}
+{"version":3,"file":"network-trace.d.ts","sourceRoot":"","sources":["../../../../src/tools/trace-dot-zip/utils/network-trace.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAelB,KAAK,KAAK,GAAG;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,EACJ;YACE,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,MAAM,EAAE,MAAM,CAAC;SAChB,GACD,SAAS,CAAC;KACf,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,8BAIxC,KAAK,KAAG,OAAO,CAAC;IACjB,cAAc,EAAE,sBAAsB,EAAE,CAAC;IACzC,0BAA0B,EAAE,sBAAsB,EAAE,CAAC;CACtD,CAiLA,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAU,UAElD,KAAK,KAAG,OAAO,CAAC;IACjB,mBAAmB,EAAE,sBAAsB,EAAE,CAAC;IAC9C,mBAAmB,EAAE,sBAAsB,EAAE,CAAC;CAC/C,CAmBA,CAAC;AAsGF,eAAO,MAAM,0CAA0C,GACrD,UAAU,sBAAsB,EAAE,KACjC,OAAO,CAAC,sBAAsB,CAAC,EAoBjC,CAAC;AAmEF,eAAO,MAAM,iBAAiB,GAC5B,UAAU,sBAAsB,EAAE,EAClC,QAAQ,MAAM,KACb,OAAO,CAAC,sBAAsB,EAAE,CAIlC,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,0CAA0C,sBAAsB,EAAE,KACjE,sBAAsB,EA0BxB,CAAC"}