@vizhub/runtime 0.3.0 → 0.3.1

package/dist/cjs/buildHTML.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHTML = void 0;
+const magic_sandbox_1 = require("magic-sandbox");
+const determineRuntimeVersion_1 = require("./determineRuntimeVersion");
+const v2_1 = require("./v2");
+const v3_1 = require("./v3");
+const v4_1 = require("./v4");
+const vizCache_1 = require("./v3/vizCache");
+const createVizContent_1 = require("./v3/createVizContent");
+const vizContentToFileCollection_1 = require("./utils/vizContentToFileCollection");
+const DEBUG = false;
+const buildHTML = async ({ files, rollup, enableSourcemap = true, vizCache, vizId, slugCache, getSvelteCompiler, }) => {
+    if (!files && !vizCache) {
+        throw new Error("Either files or vizCache is required");
+    }
+    if (!files && vizCache && !vizId) {
+        throw new Error("vizId is required when using vizCache");
+    }
+    if (!files && vizCache && vizId) {
+        files = (0, vizContentToFileCollection_1.vizContentToFileCollection)(await vizCache.get(vizId));
+    }
+    if (!files) {
+        throw new Error("Upable to extract viz files");
+    }
+    const version = (0, determineRuntimeVersion_1.determineRuntimeVersion)(files);
+    DEBUG && console.log("[buildHTML] version:", version);
+    if (version === "v1") {
+        return (0, magic_sandbox_1.magicSandbox)(files);
+    }
+    if (version === "v2") {
+        if (!rollup) {
+            throw new Error("Rollup is required for v2 runtime");
+        }
+        return (0, magic_sandbox_1.magicSandbox)(await (0, v2_1.v2Build)({ files, rollup, enableSourcemap }));
+    }
+    if (version === "v3") {
+        if (!rollup) {
+            throw new Error("Rollup is required for v3 runtime");
+        }
+        if (!vizCache && !vizId) {
+            const vizContent = (0, createVizContent_1.createVizContent)(files);
+            vizId = vizContent.id;
+            vizCache = (0, vizCache_1.createVizCache)({
+                initialContents: [vizContent],
+                handleCacheMiss: async () => {
+                    throw new Error("Cache miss handler not implemented");
+                },
+            });
+        }
+        if (!vizCache || !vizId) {
+            throw new Error("vizCache and vizId are required for v3 runtime");
+        }
+        return await (0, v3_1.v3Build)({
+            files,
+            rollup,
+            vizCache,
+            vizId,
+            slugCache,
+            getSvelteCompiler,
+        });
+    }
+    if (version === "v4") {
+        if (!rollup) {
+            throw new Error("Rollup is required for v4 runtime");
+        }
+        return (0, magic_sandbox_1.magicSandbox)(await (0, v4_1.v4Build)({ files, rollup, enableSourcemap }));
+    }
+    throw new Error(`Unsupported runtime version: ${version}`);
+};
+exports.buildHTML = buildHTML;

package/dist/cjs/common/packageJson.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobals = exports.getConfiguredGlobals = exports.getLicense = exports.dependencySource = exports.getConfiguredLibraries = exports.dependencies = exports.packageJSON = void 0;
+const EMPTY_PKG_JSON = {
+    dependencies: {},
+    vizhub: {},
+    license: "MIT",
+};
+const DEBUG = false;
+const packageJSON = (files) => {
+    const packageJsonText = files["package.json"];
+    DEBUG &&
+        console.log("[packageJSON] packageJsonText:", packageJsonText);
+    try {
+        const pkg = packageJsonText
+            ? JSON.parse(packageJsonText)
+            : EMPTY_PKG_JSON;
+        DEBUG &&
+            console.log("[packageJSON] pkg:", JSON.stringify(pkg, null, 2));
+        return pkg;
+    }
+    catch {
+        DEBUG &&
+            console.log("[packageJSON] Error parsing package.json");
+        return EMPTY_PKG_JSON;
+    }
+};
+exports.packageJSON = packageJSON;
+const dependencies = (files) => (0, exports.packageJSON)(files).dependencies || {};
+exports.dependencies = dependencies;
+const getConfiguredLibraries = (files) => {
+    const vizhubConfig = (0, exports.packageJSON)(files).vizhub || {};
+    return vizhubConfig.libraries || {};
+};
+exports.getConfiguredLibraries = getConfiguredLibraries;
+const dependencySource = ({ name, version }, libraries, cdn = "jsdelivr") => {
+    const path = libraries[name]
+        ? libraries[name].path || ""
+        : "";
+    const src = cdn === "jsdelivr"
+        ? `https://cdn.jsdelivr.net/npm/${name}@${version}${path}`
+        : `https://unpkg.com/${name}@${version}${path}`;
+    return src;
+};
+exports.dependencySource = dependencySource;
+const getLicense = (files) => {
+    const license = (0, exports.packageJSON)(files).license;
+    if (typeof license === "object" &&
+        license !== null &&
+        "type" in license) {
+        return license.type;
+    }
+    return license || EMPTY_PKG_JSON.license;
+};
+exports.getLicense = getLicense;
+const getConfiguredGlobals = (pkg) => {
+    const libraries = pkg?.vizhub?.libraries;
+    if (libraries) {
+        return Object.entries(libraries).reduce((accumulator, [packageName, config]) => {
+            if (config.global) {
+                accumulator[packageName] = config.global;
+            }
+            return accumulator;
+        }, {});
+    }
+    return {};
+};
+exports.getConfiguredGlobals = getConfiguredGlobals;
+const defaultGlobals = {
+    d3: "d3",
+    react: "React",
+    "react-dom": "ReactDOM",
+};
+const getGlobals = (pkg) => {
+    const configuredGlobals = (0, exports.getConfiguredGlobals)(pkg);
+    return {
+        ...defaultGlobals,
+        ...configuredGlobals,
+    };
+};
+exports.getGlobals = getGlobals;

package/dist/cjs/common/packageJson.test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const packageJson_1 = require("./packageJson");
+(0, vitest_1.describe)("packageJson", () => {
+    const mockFiles = {
+        "package.json": JSON.stringify({
+            dependencies: {
+                react: "17.0.2",
+                d3: "7.0.0",
+            },
+            vizhub: {
+                libraries: {
+                    d3: { path: "/dist/d3.min.js" },
+                },
+            },
+            license: "Apache-2.0",
+        }),
+    };
+    const emptyFiles = {};
+    const invalidFiles = {
+        "package.json": "invalid json",
+    };
+    (0, vitest_1.describe)("packageJSON", () => {
+        (0, vitest_1.it)("should parse valid package.json", () => {
+            const result = (0, packageJson_1.packageJSON)(mockFiles);
+            (0, vitest_1.expect)(result).toHaveProperty("dependencies");
+            (0, vitest_1.expect)(result.dependencies).toHaveProperty("react", "17.0.2");
+        });
+        (0, vitest_1.it)("should return empty object for missing package.json", () => {
+            const result = (0, packageJson_1.packageJSON)(emptyFiles);
+            (0, vitest_1.expect)(result).toEqual({
+                dependencies: {},
+                vizhub: {},
+                license: "MIT",
+            });
+        });
+        (0, vitest_1.it)("should handle invalid JSON", () => {
+            const result = (0, packageJson_1.packageJSON)(invalidFiles);
+            (0, vitest_1.expect)(result).toEqual({
+                dependencies: {},
+                vizhub: {},
+                license: "MIT",
+            });
+        });
+    });
+    (0, vitest_1.describe)("dependencies", () => {
+        (0, vitest_1.it)("should return dependencies from package.json", () => {
+            const result = (0, packageJson_1.dependencies)(mockFiles);
+            (0, vitest_1.expect)(result).toEqual({
+                react: "17.0.2",
+                d3: "7.0.0",
+            });
+        });
+        (0, vitest_1.it)("should return empty object when no dependencies", () => {
+            const result = (0, packageJson_1.dependencies)(emptyFiles);
+            (0, vitest_1.expect)(result).toEqual({});
+        });
+    });
+    (0, vitest_1.describe)("getConfiguredLibraries", () => {
+        (0, vitest_1.it)("should return configured libraries", () => {
+            const result = (0, packageJson_1.getConfiguredLibraries)(mockFiles);
+            (0, vitest_1.expect)(result).toEqual({
+                d3: { path: "/dist/d3.min.js" },
+            });
+        });
+        (0, vitest_1.it)("should return empty object when no libraries configured", () => {
+            const result = (0, packageJson_1.getConfiguredLibraries)(emptyFiles);
+            (0, vitest_1.expect)(result).toEqual({});
+        });
+    });
+    (0, vitest_1.describe)("dependencySource", () => {
+        (0, vitest_1.it)("should generate correct URL with path - jsdelivr", () => {
+            const dependency = { name: "d3", version: "7.0.0" };
+            const libraries = { d3: { path: "/dist/d3.min.js" } };
+            const result = (0, packageJson_1.dependencySource)(dependency, libraries);
+            (0, vitest_1.expect)(result).toBe("https://cdn.jsdelivr.net/npm/d3@7.0.0/dist/d3.min.js");
+        });
+        (0, vitest_1.it)("should generate correct URL without path - jsdelivr", () => {
+            const dependency = {
+                name: "react",
+                version: "17.0.2",
+            };
+            const libraries = {};
+            const result = (0, packageJson_1.dependencySource)(dependency, libraries);
+            (0, vitest_1.expect)(result).toBe("https://cdn.jsdelivr.net/npm/react@17.0.2");
+        });
+        (0, vitest_1.it)("should generate correct URL with path - unpkg", () => {
+            const dependency = { name: "d3", version: "7.0.0" };
+            const libraries = { d3: { path: "/dist/d3.min.js" } };
+            const result = (0, packageJson_1.dependencySource)(dependency, libraries, "unpkg");
+            (0, vitest_1.expect)(result).toBe("https://unpkg.com/d3@7.0.0/dist/d3.min.js");
+        });
+        (0, vitest_1.it)("should generate correct URL without path - unpkg", () => {
+            const dependency = {
+                name: "react",
+                version: "17.0.2",
+            };
+            const libraries = {};
+            const result = (0, packageJson_1.dependencySource)(dependency, libraries, "unpkg");
+            (0, vitest_1.expect)(result).toBe("https://unpkg.com/react@17.0.2");
+        });
+    });
+    (0, vitest_1.describe)("getLicense", () => {
+        (0, vitest_1.it)("should return license from package.json", () => {
+            const result = (0, packageJson_1.getLicense)(mockFiles);
+            (0, vitest_1.expect)(result).toBe("Apache-2.0");
+        });
+        (0, vitest_1.it)("should return default MIT license when not specified", () => {
+            const result = (0, packageJson_1.getLicense)(emptyFiles);
+            (0, vitest_1.expect)(result).toBe("MIT");
+        });
+    });
+    (0, vitest_1.describe)("Edge cases", () => {
+        (0, vitest_1.it)("should handle malformed library configuration", () => {
+            const malformedFiles = {
+                "package.json": JSON.stringify({
+                    dependencies: { d3: "7.0.0" },
+                    vizhub: { libraries: { d3: null } },
+                }),
+            };
+            const result = (0, packageJson_1.getConfiguredLibraries)(malformedFiles);
+            (0, vitest_1.expect)(result).toEqual({ d3: null });
+        });
+        (0, vitest_1.it)("should handle empty version strings", () => {
+            const dependency = { name: "react", version: "" };
+            const result = (0, packageJson_1.dependencySource)(dependency, {});
+            (0, vitest_1.expect)(result).toBe("https://cdn.jsdelivr.net/npm/react@");
+        });
+        (0, vitest_1.it)("should handle special characters in dependency names", () => {
+            const specialCharDep = {
+                name: "@angular/core",
+                version: "14.0.0",
+            };
+            const result = (0, packageJson_1.dependencySource)(specialCharDep, {});
+            (0, vitest_1.expect)(result).toBe("https://cdn.jsdelivr.net/npm/@angular/core@14.0.0");
+        });
+        (0, vitest_1.it)("should handle unusual license formats", () => {
+            const unusualLicenseFiles = {
+                "package.json": JSON.stringify({
+                    license: { type: "MIT" },
+                }),
+            };
+            const result = (0, packageJson_1.getLicense)(unusualLicenseFiles);
+            (0, vitest_1.expect)(result).toBe("MIT");
+        });
+    });
+});

package/dist/cjs/common/sucrasePlugin.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sucrasePlugin = sucrasePlugin;
+const sucrase_1 = require("sucrase");
+function sucrasePlugin() {
+    return {
+        name: "sucrase",
+        transform(code, id) {
+            // Transform .js, .jsx, and .tsx files
+            if (!id.match(/\.(?:js|[jt]sx)$/)) {
+                return null;
+            }
+            const result = (0, sucrase_1.transform)(code, {
+                transforms: ["jsx", "typescript"],
+                filePath: id, // For source maps
+                sourceMapOptions: {
+                    compiledFilename: "bundle.js",
+                },
+                production: true,
+            });
+            return {
+                code: result.code,
+                map: result.sourceMap,
+            };
+        },
+    };
+}

package/dist/cjs/common/virtualFileSystem.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.virtualFileSystem = void 0;
+const normalizePath = (filepath) => {
+    // Remove leading ./
+    let normalized = filepath.replace(/^\.\//, "");
+    // Replace multiple slashes with single slash
+    normalized = normalized.replace(/\/+/g, "/");
+    // Remove trailing slash
+    normalized = normalized.replace(/\/$/, "");
+    return normalized;
+};
+const joinPaths = (base, relative) => {
+    // Get directory name of base path
+    const baseDir = base.includes("/")
+        ? base.slice(0, base.lastIndexOf("/"))
+        : "";
+    // Handle .. by removing one directory level
+    const parts = relative.split("/");
+    const resultParts = baseDir
+        ? baseDir.split("/")
+        : [];
+    for (const part of parts) {
+        if (part === "..") {
+            resultParts.pop();
+        }
+        else if (part !== "." && part !== "") {
+            resultParts.push(part);
+        }
+    }
+    return resultParts.join("/");
+};
+const virtualFileSystem = (files) => {
+    return {
+        name: "virtual-file-system",
+        resolveId(source, importer) {
+            // Handle relative paths
+            if (source.startsWith("./") ||
+                source.startsWith("../")) {
+                const resolvedPath = importer
+                    ? normalizePath(joinPaths(importer, source))
+                    : normalizePath(source);
+                // Try exact match first
+                if (files[resolvedPath]) {
+                    return resolvedPath;
+                }
+                // Try with extensions if no exact match is found
+                const extensions = [".js", ".jsx", ".ts", ".tsx"];
+                for (const ext of extensions) {
+                    const pathWithExt = resolvedPath + ext;
+                    if (files[pathWithExt]) {
+                        return pathWithExt;
+                    }
+                }
+            }
+            // Handle bare module imports
+            if (files[source]) {
+                return source;
+            }
+            // Try bare imports with extensions
+            const extensions = [".js", ".jsx", ".ts", ".tsx"];
+            for (const ext of extensions) {
+                const pathWithExt = source + ext;
+                if (files[pathWithExt]) {
+                    return pathWithExt;
+                }
+            }
+            return null;
+        },
+        load(id) {
+            // Return the contents if the file exists in our virtual system
+            if (files[id]) {
+                return files[id];
+            }
+            return null;
+        },
+    };
+};
+exports.virtualFileSystem = virtualFileSystem;

package/dist/cjs/determineRuntimeVersion.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineRuntimeVersion = void 0;
+const determineRuntimeVersion = (files) => {
+    if (Object.keys(files).length === 0) {
+        return null;
+    }
+    const hasIndexHTML = "index.html" in files;
+    const hasIndexJS = "index.js" in files;
+    const hasIndexJSX = "index.jsx" in files;
+    if (hasIndexHTML) {
+        const hasModuleScript = files["index.html"].includes('type="module"');
+        if (hasModuleScript) {
+            return "v4";
+        }
+        if (hasIndexJS || hasIndexJSX) {
+            return "v2";
+        }
+        return "v1";
+    }
+    if (!hasIndexHTML && hasIndexJS) {
+        return "v3";
+    }
+    return null;
+};
+exports.determineRuntimeVersion = determineRuntimeVersion;

package/dist/cjs/determineRuntimeVersion.test.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const determineRuntimeVersion_1 = require("./determineRuntimeVersion");
+const v4_1 = require("./test/fixtures/v4");
+(0, vitest_1.describe)("determineRuntimeVersion", () => {
+    (0, vitest_1.it)("should return null when there are no files", () => {
+        const mockFiles = {};
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe(null);
+    });
+    (0, vitest_1.it)("should return v1 when only index.html exists", () => {
+        const mockFiles = {
+            "index.html": "<html></html>",
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe("v1");
+    });
+    (0, vitest_1.it)("should return v2 when both index.html and index.js exist", () => {
+        const mockFiles = {
+            "index.html": "<html></html>",
+            "index.js": 'console.log("Hello");',
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe("v2");
+    });
+    (0, vitest_1.it)("should return v2 when both index.html and index.jsx exist", () => {
+        const mockFiles = {
+            "index.html": "<html></html>",
+            "index.jsx": 'console.log("Hello");',
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe("v2");
+    });
+    (0, vitest_1.it)("should return v3 when only index.js exists", () => {
+        const mockFiles = {
+            "index.js": 'console.log("Hello");',
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe("v3");
+    });
+    (0, vitest_1.it)("should return null when only index.jsx exists (no v3 support for JSX)", () => {
+        const mockFiles = {
+            "index.jsx": 'console.log("Hello");',
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe(null);
+    });
+    (0, vitest_1.it)("should return v4 when index.html contains script type=module with importmap", () => {
+        const mockFiles = {
+            "index.html": `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <script type="importmap">
+              { "imports": { "test": "./test.js" } }
+            </script>
+          </head>
+          <body>
+            <script type="module" src="index.js"></script>
+          </body>
+        </html>
+      `,
+            "index.js": 'import { hello } from "test"; console.log(hello);',
+            "test.js": 'export const hello = "world";',
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe("v4");
+    });
+    (0, vitest_1.it)("should return v4 when multiple module scripts are present", () => {
+        const mockFiles = {
+            "index.html": `
+        <!DOCTYPE html>
+        <html>
+          <body>
+            <script type="module" src="index.js"></script>
+          </body>
+        </html>
+      `,
+            "index.js": 'import { hello } from "./utils.js"; console.log(hello);',
+            "utils.js": 'export const hello = "world";',
+        };
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(mockFiles);
+        (0, vitest_1.expect)(result).toBe("v4");
+    });
+    // Test v4 fixtures
+    (0, vitest_1.it)("should detect v4 for jsScriptTagTypeModule fixture", () => {
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(v4_1.jsScriptTagTypeModule);
+        (0, vitest_1.expect)(result).toBe("v4");
+    });
+    (0, vitest_1.it)("should detect v4 for jsScriptTagTypeModules fixture", () => {
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(v4_1.jsScriptTagTypeModules);
+        (0, vitest_1.expect)(result).toBe("v4");
+    });
+    (0, vitest_1.it)("should detect v4 for fetchInterception fixture", () => {
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(v4_1.fetchInterception);
+        (0, vitest_1.expect)(result).toBe("v4");
+    });
+    (0, vitest_1.it)("should detect v4 for esmBuild fixture", () => {
+        const result = (0, determineRuntimeVersion_1.determineRuntimeVersion)(v4_1.esmBuild);
+        (0, vitest_1.expect)(result).toBe("v4");
+    });
+});

package/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSlugCache = exports.createVizCache = exports.buildHTML = void 0;
+var buildHTML_js_1 = require("./buildHTML.js");
+Object.defineProperty(exports, "buildHTML", { enumerable: true, get: function () { return buildHTML_js_1.buildHTML; } });
+var vizCache_js_1 = require("./v3/vizCache.js");
+Object.defineProperty(exports, "createVizCache", { enumerable: true, get: function () { return vizCache_js_1.createVizCache; } });
+var slugCache_js_1 = require("./v3/slugCache.js");
+Object.defineProperty(exports, "createSlugCache", { enumerable: true, get: function () { return slugCache_js_1.createSlugCache; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/test/fixtures/v1/basicHTML.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicHTML = void 0;
+exports.basicHTML = {
+    "index.html": `<!DOCTYPE html>
+<html>
+  <head>
+    <title>My HTML Document</title>
+  </head>
+  <body>
+    <h1>Hello, World!</h1>
+    <p>This is my first HTML document.</p>
+    <script>
+      console.log('Hello, World!');
+    </script>
+  </body>
+</html>`,
+};

package/dist/cjs/test/fixtures/v1/fetchProxy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchProxy = void 0;
+exports.fetchProxy = {
+    "index.html": `<!DOCTYPE html>
+<html>
+  <body>
+    <script src="index.js"></script>
+  </body>
+</html>`,
+    "index.js": `fetch("data.csv")
+        .then((response) => response.text())
+        .then(console.log);`,
+    "data.csv": `Hello, Fetch!`,
+};

package/dist/cjs/test/fixtures/v1/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocolTest = exports.xmlTest = exports.styleTest = exports.fetchProxy = exports.jsScriptTag = exports.basicHTML = void 0;
+var basicHTML_1 = require("./basicHTML");
+Object.defineProperty(exports, "basicHTML", { enumerable: true, get: function () { return basicHTML_1.basicHTML; } });
+var jsScriptTag_1 = require("./jsScriptTag");
+Object.defineProperty(exports, "jsScriptTag", { enumerable: true, get: function () { return jsScriptTag_1.jsScriptTag; } });
+var fetchProxy_1 = require("./fetchProxy");
+Object.defineProperty(exports, "fetchProxy", { enumerable: true, get: function () { return fetchProxy_1.fetchProxy; } });
+var styleTest_1 = require("./styleTest");
+Object.defineProperty(exports, "styleTest", { enumerable: true, get: function () { return styleTest_1.styleTest; } });
+var xmlTest_1 = require("./xmlTest");
+Object.defineProperty(exports, "xmlTest", { enumerable: true, get: function () { return xmlTest_1.xmlTest; } });
+var protocolTest_1 = require("./protocolTest");
+Object.defineProperty(exports, "protocolTest", { enumerable: true, get: function () { return protocolTest_1.protocolTest; } });

package/dist/cjs/test/fixtures/v1/jsScriptTag.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsScriptTag = void 0;
+exports.jsScriptTag = {
+    "index.html": `<!DOCTYPE html>
+<html>
+  <body>
+    <script src="index.js"></script>
+  </body>
+</html>`,
+    "index.js": `console.log('Hello, JS!');`,
+};

package/dist/cjs/test/fixtures/v1/protocolTest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.protocolTest = void 0;
+exports.protocolTest = {
+    "index.html": `<!DOCTYPE html>
+<html>
+  <head>
+    <link href="//fonts.googleapis.com/css?family=Roboto" rel="stylesheet">
+    <script src="//code.jquery.com/jquery-3.6.0.min.js"></script>
+  </head>
+  <body>
+    <div>Protocol Test</div>
+    <script>
+      console.log('Protocol test loaded');
+    </script>
+  </body>
+</html>`,
+};

package/dist/cjs/test/fixtures/v1/styleTest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.styleTest = void 0;
+exports.styleTest = {
+    "index.html": `<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" href="styles.css">
+  </head>
+  <body>
+    <div id="test">Test</div>
+    <script>
+      console.log(window.getComputedStyle(document.getElementById('test')).color);
+    </script>
+  </body>
+</html>`,
+    "styles.css": `#test { color: rgb(255, 0, 0); }`,
+};