testeranto 0.203.0 → 0.205.0

package/dist/common/scripts/build-example.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+console.log("Building example project (ES module version)...");
+try {
+    // Always work from the project root
+    const projectRoot = path_1.default.resolve(import.meta.dirname, "..");
+    console.log(`Project root: ${projectRoot}`);
+    // Change to project root
+    process.chdir(projectRoot);
+    console.log(`Current working directory (build-example): ${projectRoot}`);
+    // The example directory is now relative to project root
+    const exampleDir = path_1.default.join(projectRoot, "example");
+    console.log(`Example directory: ${exampleDir}`);
+    // Ensure go.mod exists - create one if it doesn't
+    const goModPath = path_1.default.join(exampleDir, "go.mod");
+    if (!fs_1.default.existsSync(goModPath)) {
+        console.log("go.mod not found, creating a new one...");
+        const defaultGoMod = `module example
+
+go 1.19
+`;
+        fs_1.default.writeFileSync(goModPath, defaultGoMod);
+        console.log("Created default go.mod");
+    }
+    else {
+        // Read the existing go.mod and remove any replace directives
+        let goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+        // Remove any replace directives that might cause issues
+        const lines = goModContent.split('\n').filter(line => !line.trim().startsWith('replace '));
+        // Also remove any require directives for testeranto
+        const cleanedLines = lines.filter(line => !line.trim().startsWith('require github.com/adamwong246/testeranto'));
+        goModContent = cleanedLines.join('\n');
+        fs_1.default.writeFileSync(goModPath, goModContent);
+        console.log("Cleaned up go.mod by removing replace and testeranto require directives");
+    }
+    // Read the current go.mod content
+    let goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+    // Ensure the module is properly set up
+    if (!goModContent.includes("module ")) {
+        console.log("Initializing go module...");
+        (0, child_process_1.execSync)("go mod init example", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+        // Re-read the content
+        goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+    }
+    // Add the replace directive to point to the local testeranto
+    // This tells Go to use the local directory instead of trying to download from GitHub
+    if (!goModContent.includes("replace github.com/adamwong246/testeranto")) {
+        console.log("Adding replace directive...");
+        (0, child_process_1.execSync)("go mod edit -replace github.com/adamwong246/testeranto=../", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+    }
+    // Add the require directive to explicitly list the dependency
+    // This ensures the dependency is tracked even if it's not imported directly in the example
+    console.log("Adding require directive...");
+    try {
+        (0, child_process_1.execSync)("go mod edit -require github.com/adamwong246/testeranto@v0.0.0", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+    }
+    catch (error) {
+        // It's okay if this fails - the require might already be there
+        console.log("Require directive may already exist");
+    }
+    // Read the updated content
+    goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+    console.log("Updated go.mod content:");
+    console.log(goModContent);
+    // Run go mod tidy to ensure dependencies are correct
+    console.log("Running go mod tidy...");
+    try {
+        const tidyOutput = (0, child_process_1.execSync)("go mod tidy -v", {
+            stdio: "pipe",
+            encoding: "utf-8",
+            cwd: exampleDir,
+        });
+        console.log("go mod tidy output:");
+        console.log(tidyOutput);
+    }
+    catch (error) {
+        console.error("go mod tidy failed:");
+        if (error.stdout)
+            console.error("stdout:", error.stdout.toString());
+        if (error.stderr)
+            console.error("stderr:", error.stderr.toString());
+        console.error("Continuing despite go mod tidy error...");
+    }
+    console.log("Example project built successfully!");
+}
+catch (error) {
+    console.error("Failed to build example project:");
+    console.error(error);
+    process.exit(1);
+}

package/dist/common/src/CoreTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/common/src/Helpo.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helpo = void 0;
+const react_1 = __importDefault(require("react"));
+const Helpo = () => (react_1.default.createElement("div", { className: "d-flex flex-column h-100" },
+    react_1.default.createElement("div", { className: "border-bottom p-3" }),
+    react_1.default.createElement("div", { className: "flex-grow-1 p-3", style: { overflowY: "auto" } },
+        react_1.default.createElement("div", { className: "d-flex mb-3" },
+            react_1.default.createElement("div", { className: "me-2" },
+                react_1.default.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-primary text-white", style: { width: "40px", height: "40px" } }, "\uD83E\uDD16")),
+            react_1.default.createElement("div", { className: "flex-grow-1" },
+                react_1.default.createElement("div", { className: "fw-bold" }, "Helpo"),
+                react_1.default.createElement("div", { className: "bg-light p-3 rounded" },
+                    react_1.default.createElement("p", null, "Hello! I'm Helpo, your helpful robot assistant. How can I assist you today?")))),
+        react_1.default.createElement("div", { className: "d-flex mb-3 justify-content-end" },
+            react_1.default.createElement("div", { className: "flex-grow-1 me-2 text-end" },
+                react_1.default.createElement("div", { className: "fw-bold" }, "You"),
+                react_1.default.createElement("div", { className: "bg-primary text-white p-3 rounded" },
+                    react_1.default.createElement("p", null,
+                        "Can you show me how to format text with ",
+                        react_1.default.createElement("strong", null, "bold"),
+                        " and",
+                        " ",
+                        react_1.default.createElement("em", null, "italic"),
+                        "?"))),
+            react_1.default.createElement("div", null,
+                react_1.default.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-secondary text-white", style: { width: "40px", height: "40px" } }, "\uD83D\uDC64"))),
+        react_1.default.createElement("div", { className: "d-flex mb-3" },
+            react_1.default.createElement("div", { className: "me-2" },
+                react_1.default.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-primary text-white", style: { width: "40px", height: "40px" } }, "\uD83E\uDD16")),
+            react_1.default.createElement("div", { className: "flex-grow-1" },
+                react_1.default.createElement("div", { className: "fw-bold" }, "Helpo"),
+                react_1.default.createElement("div", { className: "bg-light p-3 rounded" },
+                    react_1.default.createElement("p", null, "Sure! Here's an example:"),
+                    react_1.default.createElement("ul", null,
+                        react_1.default.createElement("li", null,
+                            "Use ",
+                            react_1.default.createElement("code", null, "<strong>"),
+                            " for ",
+                            react_1.default.createElement("strong", null, "bold text")),
+                        react_1.default.createElement("li", null,
+                            "Use ",
+                            react_1.default.createElement("code", null, "<em>"),
+                            " for ",
+                            react_1.default.createElement("em", null, "italic text")),
+                        react_1.default.createElement("li", null, "You can even include lists and other HTML elements")),
+                    react_1.default.createElement("p", null, "Let me know if you need help with anything else!"))))),
+    react_1.default.createElement("div", { className: "border-top p-3" },
+        react_1.default.createElement("div", { className: "input-group" },
+            react_1.default.createElement("input", { type: "text", className: "form-control", placeholder: "Type your message...", disabled: true }),
+            react_1.default.createElement("button", { className: "btn btn-primary", type: "button", disabled: true }, "Send")))));
+exports.Helpo = Helpo;

package/dist/common/src/Init.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const fs_1 = __importDefault(require("fs"));
+exports.default = async () => {
+    [
+        `testeranto/`,
+        `testeranto/bundles/`,
+        `testeranto/bundles/node`,
+        `testeranto/bundles/web`,
+        `testeranto/bundles/pure`,
+        `testeranto/bundles/golang`,
+        `testeranto/bundles/python`,
+        `testeranto/reports/`,
+        `testeranto/features/`,
+        // `testeranto/externalTests/`,
+        `testeranto/metafiles/`,
+        `testeranto/metafiles/node`,
+        `testeranto/metafiles/web`,
+        `testeranto/metafiles/pure`,
+        `testeranto/metafiles/golang`,
+        `testeranto/metafiles/python`,
+    ].forEach((f) => {
+        try {
+            fs_1.default.mkdirSync(`${process.cwd()}/${f}`);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/App.js`, `testeranto/App.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/App.css`, `testeranto/App.css`);
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/ReportClient.js`,
+    //   `testeranto/ReportClient.js`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/Project.css`,
+    //   `testeranto/Project.css`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/ReportClient.css`,
+    //   `testeranto/ReportClient.css`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/TestReport.js`,
+    //   `testeranto/TestReport.js`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/TestReport.css`,
+    //   `testeranto/TestReport.css`
+    // );
+};

package/dist/common/src/Node.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTesteranto = void 0;
+const index_js_1 = require("./lib/index.js");
+const node_js_1 = require("./PM/node.js");
+const Tiposkripto_js_1 = __importDefault(require("./lib/Tiposkripto.js"));
+let ipcfile;
+class NodeTesteranto extends Tiposkripto_js_1.default {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
+            // no-op
+        });
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        return await this.testJobs[0].receiveTestResourceConfig(new node_js_1.PM_Node(JSON.parse(partialTestResource), ipcfile));
+    }
+}
+exports.NodeTesteranto = NodeTesteranto;
+const testeranto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
+    try {
+        const t = new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
+        process.on("unhandledRejection", (reason, promise) => {
+            console.error("Unhandled Rejection at:", promise, "reason:", reason);
+            // Optionally, terminate the process or perform cleanup
+            // t.registerUncaughtPromise(reason, promise);
+        });
+        ipcfile = process.argv[3];
+        process.exit((await t.receiveTestResourceConfig(process.argv[2])).fails);
+    }
+    catch (e) {
+        console.error(e);
+        console.error(e.stack);
+        process.exit(-1);
+    }
+};
+exports.default = testeranto;

package/dist/common/src/NodeSidecar.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSidecar = void 0;
+const Sidecar_1 = require("./lib/Sidecar");
+const nodeSidecar_1 = require("./PM/nodeSidecar");
+class NodeSidecar extends Sidecar_1.Sidecar {
+    constructor(t) {
+        super();
+        this.pm = new nodeSidecar_1.PM_Node_Sidecar(t);
+        this.pm.start(this.stop).then(() => {
+            this.start(JSON.parse(process.argv[2]));
+        });
+    }
+}
+exports.NodeSidecar = NodeSidecar;

package/dist/common/src/PM/__tests__/nodeSidecar.testeranto.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nodeSidecar_1 = require("../nodeSidecar");
+const Node_1 = __importDefault(require("../../Node"));
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new nodeSidecar_1.PM_Node_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            const mockProcess = {
+                on: (event, callback) => {
+                    if (event === "message") {
+                        callbackFn = callback;
+                        callback(JSON.stringify({
+                            key: "mock-key",
+                            payload: message,
+                        }));
+                    }
+                    return mockProcess;
+                },
+                addListener: () => mockProcess,
+                removeListener: () => mockProcess,
+            };
+            process = mockProcess;
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            const mockProcess = {
+                addListener: () => {
+                    addListenerCalled = true;
+                    return mockProcess;
+                },
+                removeListener: () => {
+                    removeListenerCalled = true;
+                    return mockProcess;
+                },
+            };
+            process = mockProcess;
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+};
+const testAdapter = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+exports.default = (0, Node_1.default)(() => new nodeSidecar_1.PM_Node_Sidecar({}), specification, implementation, testAdapter);

package/dist/common/src/PM/__tests__/pureSidecar.testeranto.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../../Node"));
+const pureSidecar_1 = require("../pureSidecar");
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Pure Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-pure-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new pureSidecar_1.PM_Pure_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            process.on = (event, callback) => {
+                if (event === "message") {
+                    callbackFn = callback;
+                    callback(JSON.stringify({
+                        key: "mock-key",
+                        payload: message,
+                    }));
+                }
+            };
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            process.addListener = () => (addListenerCalled = true);
+            process.removeListener = () => (removeListenerCalled = true);
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+};
+const testAdapter = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+exports.default = (0, Node_1.default)(() => new pureSidecar_1.PM_Pure_Sidecar({}), specification, implementation, testAdapter);

package/dist/common/src/PM/__tests__/webSidecar.testeranto.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webSidecar_1 = require("../webSidecar");
+const Node_1 = __importDefault(require("../../Node"));
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Web Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-web-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new webSidecar_1.PM_Web_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            process.on = (event, callback) => {
+                if (event === "message") {
+                    callbackFn = callback;
+                    callback(JSON.stringify({
+                        key: "mock-key",
+                        payload: message,
+                    }));
+                }
+            };
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            process.addListener = () => (addListenerCalled = true);
+            process.removeListener = () => (removeListenerCalled = true);
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+};
+const testAdapter = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+exports.default = (0, Node_1.default)(() => new webSidecar_1.PM_Web_Sidecar({}), specification, implementation, testAdapter);

package/dist/common/src/PM/golingvuBuild.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GolingvuBuild = void 0;
+const golingvuMetafile_1 = require("../utils/golingvuMetafile");
+const golingvuWatcher_1 = require("../utils/golingvuWatcher");
+class GolingvuBuild {
+    constructor(config, testName) {
+        this.watcher = null;
+        this.config = config;
+        this.testName = testName;
+    }
+    async build() {
+        // Filter golang tests
+        const golangTests = this.config.tests.filter((test) => test[1] === "golang");
+        const hasGolangTests = golangTests.length > 0;
+        if (hasGolangTests) {
+            // Get the entry points
+            const golangEntryPoints = golangTests.map((test) => test[0]);
+            // Generate and write metafile
+            const metafile = await (0, golingvuMetafile_1.generateGolingvuMetafile)(this.testName, golangEntryPoints);
+            (0, golingvuMetafile_1.writeGolingvuMetafile)(this.testName, metafile);
+            // Start watching for changes
+            this.watcher = new golingvuWatcher_1.GolingvuWatcher(this.testName, golangEntryPoints);
+            await this.watcher.start();
+            return golangEntryPoints;
+        }
+        return [];
+    }
+    async rebuild() {
+        if (this.watcher) {
+            await this.watcher.regenerateMetafile();
+        }
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+        }
+    }
+    onBundleChange(callback) {
+        if (this.watcher) {
+            this.watcher.onMetafileChange(callback);
+        }
+    }
+}
+exports.GolingvuBuild = GolingvuBuild;

package/dist/common/src/PM/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM = void 0;
+class PM {
+}
+exports.PM = PM;