testeranto 0.47.34 → 0.47.52

package/dist/common/Puppeteer.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const fs_1 = __importDefault(require("fs"));
+const main_js_1 = require("./PM/main.js");
+const utils_js_1 = require("./utils.js");
+var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
+const node2web = {};
+const web2node = {};
+const childProcesses = {};
+readline_1.default.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+        process.exit();
+    }
+});
+exports.default = async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    fs_1.default.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    const pm = new main_js_1.PM_Main(config);
+    await pm.startPuppeteer({
+        waitForInitialPage: false,
+        executablePath: "/opt/homebrew/bin/chromium",
+        headless: true,
+        // dumpio: true,
+        args: [
+            "--disable-features=IsolateOrigins,site-per-process",
+            "--disable-site-isolation-trials",
+            "--allow-insecure-localhost",
+            "--allow-file-access-from-files",
+            "--allow-running-insecure-content",
+            // "--auto-open-devtools-for-tabs",
+            "--disable-dev-shm-usage",
+            "--disable-extensions",
+            "--disable-gpu",
+            "--disable-setuid-sandbox",
+            "--disable-site-isolation-trials",
+            "--disable-web-security",
+            "--no-first-run",
+            "--no-sandbox",
+            "--no-startup-window",
+            // "--no-zygote",
+            "--reduce-security-for-testing",
+            "--remote-allow-origins=*",
+            "--unsafely-treat-insecure-origin-as-secure=*",
+            // "--disable-features=IsolateOrigins",
+            // "--remote-allow-origins=ws://localhost:3234",
+            // "--single-process",
+            // "--unsafely-treat-insecure-origin-as-secure",
+            // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+            `--remote-debugging-port=3234`,
+            // "--disk-cache-dir=/dev/null",
+            // "--disk-cache-size=1",
+            // "--start-maximized",
+        ],
+    }, ".");
+    config.tests.forEach(([test, runtime, tr, sidecars]) => {
+        if (runtime === "node") {
+            pm.launchNode(test, (0, utils_js_1.destinationOfRuntime)(test, "node", config));
+        }
+        else if (runtime === "web") {
+            pm.launchWeb(test, (0, utils_js_1.destinationOfRuntime)(test, "web", config), sidecars);
+        }
+        else {
+            console.error("runtime makes no sense", runtime);
+        }
+    });
+    console.log("ready and watching for changes...", config.buildDir);
+    fs_1.default.watch(config.buildDir, {
+        recursive: true,
+    }, (eventType, changedFile) => {
+        if (changedFile) {
+            config.tests.forEach(([test, runtime, tr, sidecars]) => {
+                if (eventType === "change" || eventType === "rename") {
+                    if (changedFile ===
+                        test
+                            .replace("./", "node/")
+                            .split(".")
+                            .slice(0, -1)
+                            .concat("mjs")
+                            .join(".")) {
+                        pm.launchNode(test, (0, utils_js_1.destinationOfRuntime)(test, "node", config));
+                    }
+                    if (changedFile ===
+                        test
+                            .replace("./", "web/")
+                            .split(".")
+                            .slice(0, -1)
+                            .concat("mjs")
+                            .join(".")) {
+                        pm.launchWeb(test, (0, utils_js_1.destinationOfRuntime)(test, "web", config), sidecars);
+                    }
+                }
+            });
+        }
+    });
+};

package/dist/common/Reporter.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const fs_1 = __importDefault(require("fs"));
+const jsonc_1 = require("jsonc");
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+// import { PM_Main } from "./PM/main.js";
+// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
+// const node2web: Record<string, string[]> = {};
+// const web2node: Record<string, string[]> = {};
+// const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
+readline_1.default.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+        process.exit();
+    }
+});
+const main = async () => {
+    const configs = jsonc_1.jsonc.parse((await fs_1.default.readFileSync("./docs/testeranto.json")).toString());
+    // const pm = new PM_Main(configs);
+    // await puppeteer.launch(options);
+    const browser = await puppeteer_core_1.default.launch({
+        waitForInitialPage: false,
+        executablePath: "/opt/homebrew/bin/chromium",
+        headless: false,
+        args: [
+            "--allow-file-access-from-files",
+            "--allow-running-insecure-content",
+            // "--auto-open-devtools-for-tabs",
+            "--disable-dev-shm-usage",
+            "--disable-extensions",
+            "--disable-gpu",
+            "--disable-setuid-sandbox",
+            "--disable-site-isolation-trials",
+            "--disable-web-security",
+            "--disable-web-security",
+            "--no-first-run",
+            "--no-sandbox",
+            "--no-startup-window",
+            "--no-zygote",
+            "--reduce-security-for-testing",
+            "--remote-allow-origins=*",
+            // "--remote-allow-origins=ws://localhost:3234",
+            "--unsafely-treat-insecure-origin-as-secure=*",
+            // "--disable-features=IsolateOrigins",
+            // "--single-process",
+            // "--unsafely-treat-insecure-origin-as-secure",
+            // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+            // `--remote-debugging-port=3234`,
+        ],
+    }
+    // "."
+    );
+    console.log("Creating new page...");
+    const page = await browser.newPage();
+    await page.setViewport({ width: 0, height: 0 });
+    console.log("Requesting url...");
+    await page.goto(`file://${process.cwd()}/docs/report.html?local=true`);
+    // configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+    //   if (runtime === "node") {
+    //     pm.launchNode(test, destinationOfRuntime(test, "node"));
+    //   } else if (runtime === "web") {
+    //     pm.launchWeb(test, destinationOfRuntime(test, "web"));
+    //   } else {
+    //     console.error("runtime makes no sense", runtime);
+    //   }
+    // });
+    // console.log("ready and watching for changes...", configs.buildDir);
+    // fs.watch(
+    //   configs.buildDir,
+    //   {
+    //     recursive: true,
+    //   },
+    //   (eventType, changedFile) => {
+    //     if (changedFile) {
+    //       configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+    //         if (eventType === "change" || eventType === "rename") {
+    //           if (
+    //             changedFile ===
+    //             test
+    //               .replace("./", "node/")
+    //               .split(".")
+    //               .slice(0, -1)
+    //               .concat("mjs")
+    //               .join(".")
+    //           ) {
+    //             pm.launchNode(test, destinationOfRuntime(test, "node"));
+    //           }
+    //           if (
+    //             changedFile ===
+    //             test
+    //               .replace("./", "web/")
+    //               .split(".")
+    //               .slice(0, -1)
+    //               .concat("mjs")
+    //               .join(".")
+    //           ) {
+    //             pm.launchWeb(test, destinationOfRuntime(test, "web"));
+    //           }
+    //         }
+    //       });
+    //     }
+    //   }
+    // );
+};
+main();

package/dist/common/Scheduler.js

@@ -0,0 +1 @@
+"use strict";

package/dist/common/SubPackages/puppeteer.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const Node_js_1 = __importDefault(require("../Node.js"));
+exports.default = (testInput, testSpecifications, testImplementations, testInterface) => {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
+            // process.parentPort.postMessage(
+            //   `/docs/web/src/ClassicalComponent/test.html`
+            // );
+            return x;
+        }, beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(react_1.default.createElement(testInput, {}, []));
+            });
+        }, andWhen: function (s, whenCB) {
+            return whenCB()(s);
+        } }, testInterface));
+};

package/dist/common/{subPackages → SubPackages}/react/component/node.js

@@ -4,16 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
-const Node_1 = __importDefault(require("../../../Node"));
+const Node_js_1 = __importDefault(require("../../../Node.js"));
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    return (0, Node_1.default)(testInput, testSpecifications, testImplementations, {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, {
         beforeEach: async () => {
             return new Promise((resolve, rej) => {
                 resolve(react_1.default.createElement(testInput, {}, []));
             });
         },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
+        andWhen: function (s, whenCB) {
+            return whenCB()(s);
         },
     });
 };

package/dist/common/{subPackages → SubPackages}/react/component/web.js

@@ -4,16 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
-const Web_1 = __importDefault(require("../../../Web"));
+const Web_js_1 = __importDefault(require("../../../Web.js"));
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    return (0, Web_1.default)(testInput, testSpecifications, testImplementations, {
+    return (0, Web_js_1.default)(testInput, testSpecifications, testImplementations, {
         beforeEach: async () => {
             return new Promise((resolve, rej) => {
                 resolve(react_1.default.createElement(testInput, {}, []));
             });
         },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
+        andWhen: function (s, whenCB) {
+            return whenCB()(s);
         },
     });
 };

package/dist/common/SubPackages/react/jsx/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInterface = void 0;
+const react_1 = __importDefault(require("react"));
+exports.testInterface = {
+    // beforeAll: async (proto, testResource, artificer, pm): Promise<IStore> => {
+    //   return React.createElement(proto);
+    //   // return new Promise((resolve, rej) => {
+    //   //   resolve(x());
+    //   // });
+    // },
+    beforeEach: async (subject, initializer, artificer) => {
+        return new Promise((resolve, rej) => {
+            const x = react_1.default.createElement(subject);
+            console.log("react-element", x);
+            resolve(x);
+        });
+    },
+    andWhen: function (s, whenCB) {
+        return whenCB(s);
+    },
+};

package/dist/common/SubPackages/react/jsx/node.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_js_1 = __importDefault(require("../../../Node.js"));
+const index_js_1 = require("./index.js");
+exports.default = (testImplementations, testSpecifications, testInput, testInterface) => {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, index_js_1.testInterface), testInterface));
+};

package/dist/common/SubPackages/react/jsx/web.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Web_js_1 = __importDefault(require("../../../Web.js"));
+const index_js_1 = require("./index.js");
+exports.default = (testImplementations, testSpecifications, testInput, testInterface) => {
+    return (0, Web_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, index_js_1.testInterface), testInterface));
+};

package/dist/common/{subPackages/react-dom/jsx → SubPackages/react-dom/component}/node.js

@@ -10,9 +10,9 @@ Object.defineProperty(exports, "renderToStaticMarkup", { enumerable: true, get:
 Object.defineProperty(exports, "renderToStaticNodeStream", { enumerable: true, get: function () { return server_1.renderToStaticNodeStream; } });
 const stream_1 = __importDefault(require("stream"));
 exports.Stream = stream_1.default;
-const Node_1 = __importDefault(require("../../../Node"));
+const Node_js_1 = __importDefault(require("../../../Node.js"));
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    return (0, Node_1.default)(testInput, testSpecifications, testImplementations, {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, {
         // beforeAll: async (
         //   prototype,
         //   artificer
@@ -30,9 +30,9 @@ exports.default = (testImplementations, testSpecifications, testInput) => {
                 resolve((0, react_1.createElement)(testInput));
             });
         },
-        andWhen: async function (s, actioner) {
-            // return actioner()(s);
-            return s;
+        andWhen: async function (s, whenCB) {
+            return whenCB(s);
+            // return s
         },
         butThen: async function (s) {
             return s;
@@ -93,7 +93,7 @@ exports.default = (testImplementations, testSpecifications, testInput) => {
 //           resolve(ReactDOMServer.renderToStaticMarkup(element));
 //         });
 //       },
-//       andWhen: function (s: IStore, actioner): Promise<ISelection> {
+//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
 //         throw new Error(`"andWhens" are not permitted`);
 //       }
 //     },

package/dist/common/SubPackages/react-dom/component/web.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 react_1 = require("react");
+const client_1 = __importDefault(require("react-dom/client"));
+const Web_js_1 = __importDefault(require("../../../Web.js"));
+exports.default = (testInput, testSpecifications, testImplementations, testInterface) => {
+    class TesterantoComponent extends testInput {
+        constructor(props) {
+            super(props);
+            this.done = props.done;
+        }
+        componentDidMount() {
+            super.componentDidMount && super.componentDidMount();
+            return this.done(this);
+        }
+    }
+    const t = (0, Web_js_1.default)(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (initialProps, artificer) => {
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = client_1.default.createRoot(htmlElement);
+                    // Ignore these type errors
+                    domRoot.render((0, react_1.createElement)(TesterantoComponent, Object.assign(Object.assign({}, initialProps), { done: (reactElement) => {
+                            resolve({
+                                htmlElement,
+                                reactElement,
+                                domRoot,
+                            });
+                        } }), []));
+                    // resolve({ htmlElement });
+                }
+            });
+        },
+        // beforeEach: async (
+        //   s,
+        //   initializer,
+        //   testResource,
+        //   artificer,
+        //   initialValues
+        // ): Promise<IStore> => {
+        //   return new Promise((resolve, rej) => {
+        //     console.log("beforeEach" + TesterantoComponent);
+        //     // const domRoot = ReactDom.createRoot(htmlElement);
+        //     // // Ignore these type errors
+        //     // domRoot.render(
+        //     //   createElement(
+        //     //     TesterantoComponent,
+        //     //     {
+        //     //       ...initializer,
+        //     //       done: (reactElement) => {
+        //     //         resolve({
+        //     //           htmlElement,
+        //     //           reactElement,
+        //     //           domRoot,
+        //     //         });
+        //     //       },
+        //     //     },
+        //     //     []
+        //     //   )
+        //     // );
+        //   });
+        // },
+        andWhen: function (s, whenCB) {
+            return whenCB(s);
+        },
+        butThen: async function (s, thenCB) {
+            return thenCB(s);
+        },
+        afterEach: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
+            async function (store, ndx, artificer, utils) {
+                return store;
+            },
+        afterAll: async (store, artificer, utils) => {
+            // setTimeout(() => {
+            //   console.log("This will run after 1 second");
+            // }, 1000); // 1000 milliseconds = 1 second
+            // store.htmlElement.remove();
+            // store.htmlElement = document.createElement("root");
+            return store;
+        },
+    });
+    document.addEventListener("DOMContentLoaded", function () {
+        const elem = document.getElementById("root");
+        if (elem) {
+            return t;
+        }
+    });
+    return t;
+};

package/dist/common/SubPackages/react-dom/jsx/index.js

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

package/dist/common/SubPackages/react-dom/jsx/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.Stream = exports.renderToStaticNodeStream = exports.renderToStaticMarkup = void 0;
+const react_1 = require("react");
+const server_1 = require("react-dom/server");
+Object.defineProperty(exports, "renderToStaticMarkup", { enumerable: true, get: function () { return server_1.renderToStaticMarkup; } });
+Object.defineProperty(exports, "renderToStaticNodeStream", { enumerable: true, get: function () { return server_1.renderToStaticNodeStream; } });
+const stream_1 = __importDefault(require("stream"));
+exports.Stream = stream_1.default;
+const Node_js_1 = __importDefault(require("../../../Node.js"));
+exports.default = (testImplementations, testSpecifications, testInput) => {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (prototype, artificer) => {
+            return await new Promise((resolve, rej) => {
+                resolve(null);
+            });
+        },
+        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
+            return new Promise((resolve, rej) => {
+                resolve((0, react_1.createElement)(testInput));
+            });
+        },
+        andWhen: async function (s, whenCB) {
+            return s;
+        },
+        butThen: async function (s) {
+            return s;
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return {};
+        },
+        afterAll: (store, artificer) => {
+            return;
+        },
+    });
+};

package/dist/common/SubPackages/react-dom/jsx/web.js

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importStar(require("react"));
+const react_2 = require("react");
+const client_1 = __importDefault(require("react-dom/client"));
+const react_dom_1 = require("react-dom");
+const Web_js_1 = __importDefault(require("../../../Web.js"));
+exports.default = (testImplementations, testSpecifications, testInput) => {
+    console.log("testInput", testInput);
+    const TesterantoComponent = function ({ done, innerComp, }) {
+        const myContainer = (0, react_1.useRef)(null);
+        (0, react_1.useEffect)(() => {
+            console.log("useEffect called!", myContainer.current);
+            done(myContainer.current);
+        }, []);
+        // debugger;
+        return react_1.default.createElement("div", { ref: myContainer }, innerComp());
+    };
+    const t = (0, Web_js_1.default)(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (reactElement, itr) => {
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = client_1.default.createRoot(htmlElement);
+                    domRoot.render((0, react_2.createElement)(TesterantoComponent, {
+                        // ...initialProps,
+                        innerComp: reactElement,
+                        done: (reactElement) => {
+                            resolve({
+                                htmlElement,
+                                reactElement,
+                                domRoot,
+                            });
+                        },
+                    }, []));
+                    // resolve({ htmlElement });
+                }
+            });
+        },
+        beforeEach: async (subject, initializer, artificer, testResource, pm) => {
+            return new Promise((resolve, rej) => {
+                (0, react_dom_1.createPortal)(TesterantoComponent({
+                    innerComp: () => testInput({
+                        port: 3003,
+                        address: "some-address",
+                        secretKey: "someSecretKey",
+                        abi: "foo",
+                    }),
+                    done: (reactElement) => {
+                        process.nextTick(() => {
+                            resolve(reactElement);
+                        });
+                    },
+                }), subject.domRoot);
+            });
+        },
+        andWhen: function (s, whenCB) {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve(whenCB()(s));
+                });
+            });
+        },
+        butThen: async function (s) {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve(s);
+                });
+            });
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve({});
+                });
+            });
+        },
+        afterAll: (store, artificer) => {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve({});
+                });
+            });
+        },
+    });
+    document.addEventListener("DOMContentLoaded", function () {
+        const rootElement = document.getElementById("root");
+        if (rootElement) {
+        }
+    });
+    return t;
+};