miqro 6.3.0 → 7.0.2

package/src/inflate/setup-log.ts

@@ -26,7 +26,7 @@ export async function setupLogConfig(logger: Logger, servicePath: string, servic
         });
         logger.log("writing [%s]", relative(cwd(), inflatePath));
         writeFileSync(inflatePath, await inflateJSX(logPath, {
-          embemedJSX: false,
+          // embemedJSX: false,
           minify: false,
           useExport: true,
           platform: "node",

package/src/inflate/setup-middleware.ts

@@ -25,7 +25,7 @@ export async function setupMiddleware(logger: Logger, servicePath: string, servi
         });
         logger.log("writing [%s]", relative(cwd(), inflatePath));
         writeFileSync(inflatePath, await inflateJSX(middlewarePath, {
-          embemedJSX: false,
+          // embemedJSX: false,
           minify: false,
           platform: "node",
           useExport: true,

package/src/inflate/setup-server-config.ts

@@ -29,7 +29,7 @@ export async function setupServerConfig(logger: Logger, servicePath: string, ser
         });
         logger.log("writing [%s]", relative(cwd(), inflatePath));
         writeFileSync(inflatePath, await inflateJSX(serverPath, {
-          embemedJSX: false,
+          // embemedJSX: false,
           minify: false,
           platform: "node",
           useExport: true,

package/src/inflate/setup-ws.ts

@@ -29,7 +29,7 @@ export async function inflateWSConfig(logger: Logger, servicePath: string, servi
         });
         logger.log("writing [%s]", relative(cwd(), inflatePath));
         writeFileSync(inflatePath, await inflateJSX(wsPath, {
-          embemedJSX: false,
+          // embemedJSX: false,
           minify: false,
           platform: "node",
           useExport: true,

package/src/inflate/setup.doc.ts

@@ -5,10 +5,10 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { cwd } from "node:process";
 import { getDocOutput } from "../bin/generate-doc.js";
-import { RouteFileMap } from "./setup-http.js";
+import { RouteFileMap, StaticFileMap } from "./setup-http.js";
 import { CONTENT_TYPE_MAP } from "../common/content-type.js";
 
-export async function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, inflateDir: string | undefined | false, errors: InflateError[]) {
+export async function setupDoc(logger: Logger, servicePath: string, service: string, mainRouter: Router, fileMap: RouteFileMap, staticFileMap: StaticFileMap, inflateDir: string | undefined | false, errors: InflateError[]) {
   const docPath = getDocConfigPath(servicePath); //resolve(process.cwd(), service, "auth.ts");
 
   if (docPath) {
@@ -20,11 +20,13 @@ export async function setupDoc(logger: Logger, servicePath: string, service: str
         for (const path of paths) {
           const config = docModule.publish[path];
 
+          const contentType = config.type === "MD" ? CONTENT_TYPE_MAP[".md"] :
+            config.type === "JSON" ? CONTENT_TYPE_MAP[".json"] : CONTENT_TYPE_MAP[".html"];
+
           const body = await getDocOutput(mainRouter, fileMap, config.all, config.type);
           mainRouter.get(path, async (_, res) => {
             switch (config.type) {
               case "MD": {
-                const contentType = CONTENT_TYPE_MAP[".md"];
                 return await res.asyncEnd({
                   headers: {
                     "content-type": contentType
@@ -51,6 +53,28 @@ export async function setupDoc(logger: Logger, servicePath: string, service: str
             });
             logger.log("writing [%s]", relative(cwd(), inflatePath));
             writeFileSync(inflatePath, body);
+
+            fileMap[docPath + path] = {
+              routes: [{
+                method: "GET",
+                path
+              }],
+              service,
+              filePath: docPath,
+              previewMethod: "html"
+            };
+
+            if (staticFileMap) {
+              staticFileMap[docPath + path] = {
+                contentType,
+                filePath: docPath,
+                previewMethod: "html",
+                method: "GET",
+                path,
+                body: Buffer.from(body),
+                inflatePath: inflateDir ? join(inflateDir, service, "static", path) : undefined
+              }
+            }
           }
         }
       }

package/src/inflate/utils/sea-utils.ts

@@ -1,14 +1,14 @@
 import { Router } from "@miqro/core";
 import { describeFilePath } from "../../common/fs.js";
 import { getRoutes } from "../../services/utils/get-route.js";
-import { assertGlobalTampered } from "../../services/globals.js";
+// import { assertGlobalTampered } from "../../services/globals.js";
 import { dirname, join, relative } from "node:path";
 
 export async function appendAPIModule(router: Router, dir: string, filePath: string, module: any) {
   const file = describeFilePath(filePath);
   const routes = getRoutes(join("/", dirname(relative(dir, file.filePath))), file.subName, module);
   for (const r of routes) {
-    router.use(assertGlobalTampered);
+    // router.use(assertGlobalTampered);
     router.use(module.handler, r.path, r.method as any, r.options);
   }
 }

package/src/lib.ts

@@ -1,3 +1,6 @@
+import { Component, enableDebugLog, Fragment, Props, createElement as realCreateElement } from "@miqro/jsx";
+import { jsx2HTML } from "./common/jsx.js";
+
 /*export * from "@miqro/core";
 export * from "@miqro/query";*/
 export * from "./types.js";
@@ -9,11 +12,23 @@ export { WebSocketManager, WebSocketManagerOptions } from "./services/utils/webs
 export { DBManager } from "./services/utils/db-manager.js";
 export { LogProvider, LogProviderOptions } from "./services/utils/log.js";
 export { Miqro, MiqroOptions, ServerRequestHandler } from "./services/app.js";
-export { initGlobals, assertGlobalTampered } from "./services/globals.js";
+// export { initGlobals, assertGlobalTampered } from "./services/globals.js";
+export { jsx2HTML } from "./common/jsx.js";
 
 //exported for --inflate-sea
 export { appendAPIModule } from "./inflate/utils/sea-utils.js";
 export { createServerInterface, ServerInterfaceImplOptions } from "./services/utils/server-interface.js";
 export { App, LoggerHandler, Router } from "@miqro/core";
 export { migration } from "@miqro/query";
-
+export { middleware } from "./services/utils/middleware.js";
+export { jwt } from "./services/utils/jwt.js";
+export const JSX = {
+  createElement: (...args: [tag: string | Component | typeof Fragment, attributes: Props | null | undefined, ...children: Array<any>]) => {
+    const ret = realCreateElement(...args);
+    ret.toString = () => jsx2HTML(ret)
+    return ret;
+  },
+  Fragment,
+  enableDebugLog
+}
+export * as jsx from "@miqro/jsx";

package/src/main.ts

@@ -11,7 +11,7 @@ import { TEST_SOCKET } from "./common/paths.js";
 import { Logger } from "@miqro/core";
 
 async function main(args: Arguments) {
-  if (args.installTypes || args.installTSConfig || args.installMiqroJSON) {
+  if (args.install || args.installTSConfig || args.installMiqroJSON) {
     await installTypings(args, new Logger(""));
     process.exit(EXIT_CODES.NORMAL_EXIT);
   } else {

package/src/services/app.ts

@@ -17,7 +17,7 @@ import { createEditorRouter } from "./editor.js";
 import { EDITOR_CONFIG_KEY, HOT_RELOAD_PATH } from "../common/constants.js";
 import { watchAndServer } from "../common/watch.js";
 import { LocalCache } from "./utils/cache.js";
-import { initGlobals } from "./globals.js";
+// import { initGlobals } from "./globals.js";
 import { EditorAdminInterface } from "../../editor/common/admin-interface.js";
 import { LogProvider, LogProviderOptions } from "./utils/log.js";
 import { initAssets } from "../common/assets.js";
@@ -219,7 +219,7 @@ export class Miqro {
     if (this.inflated !== null) {
       throw new Error("already inflated! call deflate()");
     }
-    initGlobals();
+    // initGlobals();
     // block others from inflating while inflateApp is running
     this.inflated = undefined;
     this.inflated = {
@@ -280,7 +280,7 @@ export class Miqro {
     // init assets only once for all ApplicationServer's
     if (Miqro.initAssetsPromise === null) {
       // init globals only once for all inflations
-      initGlobals();
+      // initGlobals();
       Miqro.initAssetsPromise = initAssets(this.logger);
     }
     await Miqro.initAssetsPromise;
@@ -328,7 +328,7 @@ export class Miqro {
       // init assets only once for all ApplicationServer's
       if (Miqro.initAssetsPromise === null) {
         // init globals only once for all inflations
-        initGlobals();
+        // initGlobals();
         Miqro.initAssetsPromise = initAssets(this.logger);
       }
       await Miqro.initAssetsPromise;

package/src/services/migrations.ts

@@ -25,7 +25,7 @@ export async function runMigrations(logger: Logger | undefined, db: Database | n
         });
         logger?.log("writing [%s]", relative(cwd(), inflatePath));
         writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
-          embemedJSX: false,
+          // embemedJSX: false,
           minify: false,
           useExport: true,
           platform: "node",
@@ -55,7 +55,7 @@ export async function runMigrationsDown(logger: Logger | Console | undefined, db
         });
         logger?.log("writing [%s]", relative(cwd(), inflatePath));
         writeFileSync(inflatePath, await inflateJSX(resolve(migrationsFolderPath, migration), {
-          embemedJSX: false,
+          // embemedJSX: false,
           platform: "node",
           minify: false,
           useExport: true,

package/src/services/utils/jwt.ts

@@ -0,0 +1,25 @@
+import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../../common/jwt.js";
+import { JWTInterface } from "../../types.js";
+import { createSecretKey } from "node:crypto";
+
+export const jwt: JWTInterface = {
+  createSecretKey,
+  decode(jwt) {
+    return decodeJWT(jwt);
+  },
+  decodeProtectedHeader(token) {
+    return decodeProtectedHeaderJWT(token);
+  },
+  decrypt(jwt, secret, options) {
+    return decryptJWT(jwt, secret, options);
+  },
+  encrypt(payload, secret, options) {
+    return encryptJWT(payload, secret, options);
+  },
+  sign(payload, secret, options) {
+    return signJWT(payload, secret, options);
+  },
+  verify(jwt, secret, options) {
+    return verifyJWT(jwt, secret, options);
+  }
+};

package/src/services/utils/middleware.ts

@@ -0,0 +1,10 @@
+import { CORS, JSONParser, ReadBuffer, SessionHandler, TextParser, URLEncodedParser } from "@miqro/core";
+
+export const middleware = Object.freeze({
+  buffer: ReadBuffer,
+  url: URLEncodedParser,
+  json: JSONParser,
+  text: TextParser,
+  cors: CORS,
+  session: SessionHandler
+});

package/src/services/utils/server-interface.ts

@@ -1,13 +1,21 @@
-import { WebSocketServer, Logger } from "@miqro/core";
-import { Database } from "@miqro/query";
+import { Logger } from "@miqro/core";
 import cluster from "node:cluster";
-import { CacheInterface, MigrateOptions, NamedMigration, ServerInterface } from "../../types.js";
+import { CacheInterface, NamedMigration, ServerInterface } from "../../types.js";
 import { DBManager } from "./db-manager.js";
 import { Miqro } from "../app.js";
 import { WebSocketManager } from "./websocketmanager.js";
 import { execSync } from "node:child_process";
 import { LogProvider } from "./log.js";
-import { initGlobals } from "../globals.js";
+import { HTMLEncode } from "../../../editor/common/html-encode.js";
+import { inflateMD2HTML } from "../../inflate/md.js";
+
+import { Parser } from "@miqro/parser";
+import { ClusterCache } from "./cluster-cache.js";
+import { LocalCache } from "./cache.js";
+import { middleware } from "./middleware.js";
+import { jwt } from "./jwt.js";
+
+// import { initGlobals } from "../globals.js";
 
 export interface ServerInterfaceImplOptions {
   cache: CacheInterface;
@@ -21,8 +29,30 @@ export interface ServerInterfaceImplOptions {
 }
 
 export function createServerInterface(options: ServerInterfaceImplOptions): ServerInterface {
-  initGlobals();
+  // initGlobals();
   return Object.freeze<ServerInterface>({
+    middleware,
+    encodeHTML: HTMLEncode,
+    inflateMDtoHTML: inflateMD2HTML,
+    newParser() {
+      return new Parser();
+    },
+    newClusterCache(name, logger) {
+      return new ClusterCache(name, logger);
+    },
+    newLocalCache(name, logger) {
+      return new LocalCache(name, logger);
+    },
+    getWorkerNumber(): number {
+      return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
+    },
+    getWorkerCount(): number {
+      return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
+    },
+    isPrimaryWorker(): boolean {
+      return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
+    },
+    jwt,
     cache: options.cache,
     localCache: options.localCache,
     logger: options.logger,
@@ -86,7 +116,7 @@ export function createServerInterface(options: ServerInterfaceImplOptions): Serv
     },
     getLogger(identifier, loggerOptions) {
       return options?.loggerProvider?.getLogger(identifier, loggerOptions);
-    },
-    ...server
+    }
+    // ...server
   });
 }

package/src/types.ts

@@ -33,7 +33,7 @@ export interface JWTSignOptions {
   options?: SignOptions;
 }
 
-declare global {
+/*declare global {
   // jsx only for the default value of tsconfig.json
   //var React: {};
   var JSX: {
@@ -60,11 +60,61 @@ declare global {
     useElement: typeof jsxLib.useElement;
     useRefresh: typeof jsxLib.useRefresh;
   }
-}
+}*/
 
 export { APIRoute } from "@miqro/core";
 export { Migration } from "@miqro/query";
 
+export interface JWTInterface {
+  createSecretKey: (key: string, encoding: BufferEncoding) => KeyObject;
+  /**
+ * creates a JWT encrypted token with jose
+ * 
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns 
+ */
+  encrypt: (payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>) => Promise<string>
+  /**
+   * decrypts a JWT token with jose
+   * @param jwt the JWT token
+   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+   * @param options options like issuer and audience
+   * @returns 
+   */
+  decrypt: <PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>) => Promise<JWTDecryptResult<PayloadType>>;
+  /**
+   * verify a JWT token with jose
+   * @param jwt the JWT token
+   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+   * @param options options like issuer and audience
+   * @returns 
+   */
+  verify: <PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>) => Promise<JWTVerifyResult<PayloadType>>;
+  /**
+   * creates a signed JWT with jose
+   * 
+   * @param payload the payload to encrypt
+   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+   * @param options options like expiratation date, issuer and audience
+   * @returns 
+   */
+  sign: (payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>) => Promise<string>;
+  /**
+   * decodes a protected header with jose
+   * @param token 
+   * @returns 
+   */
+  decodeProtectedHeader: (token: string | object) => ProtectedHeaderParameters;
+  /**
+   * decodes a jwt token
+   * @param jwt 
+   * @returns 
+   */
+  decode: <PayloadType = JWTPayload>(jwt: string) => PayloadType & JWTPayload;
+}
+
 export interface ServerGlobal {
   encodeHTML: (str: string) => string;
   inflateMDtoHTML: (str: string) => string;
@@ -79,58 +129,11 @@ export interface ServerGlobal {
   newParser(): Parser;
   newClusterCache: (name: string, logger?: Logger) => CacheInterface;
   newLocalCache: (name: string, logger?: Logger) => CacheInterface;
-  createSecretKey: (key: string, encoding: BufferEncoding) => KeyObject;
+  
   getWorkerCount: () => number;
   getWorkerNumber: () => number;
   isPrimaryWorker: () => boolean;
-  jwt: {
-    /**
-   * creates a JWT encrypted token with jose
-   * 
-   * @param payload the payload to encrypt
-   * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
-   * @param options options like expiratation date, issuer and audience
-   * @returns 
-   */
-    encrypt: (payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>) => Promise<string>
-    /**
-     * decrypts a JWT token with jose
-     * @param jwt the JWT token
-     * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
-     * @param options options like issuer and audience
-     * @returns 
-     */
-    decrypt: <PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>) => Promise<JWTDecryptResult<PayloadType>>;
-    /**
-     * verify a JWT token with jose
-     * @param jwt the JWT token
-     * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
-     * @param options options like issuer and audience
-     * @returns 
-     */
-    verify: <PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>) => Promise<JWTVerifyResult<PayloadType>>;
-    /**
-     * creates a signed JWT with jose
-     * 
-     * @param payload the payload to encrypt
-     * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
-     * @param options options like expiratation date, issuer and audience
-     * @returns 
-     */
-    sign: (payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>) => Promise<string>;
-    /**
-     * decodes a protected header with jose
-     * @param token 
-     * @returns 
-     */
-    decodeProtectedHeader: (token: string | object) => ProtectedHeaderParameters;
-    /**
-     * decodes a jwt token
-     * @param jwt 
-     * @returns 
-     */
-    decode: <PayloadType = JWTPayload>(jwt: string) => PayloadType & JWTPayload;
-  }
+  jwt: JWTInterface;
 }
 
 export interface CacheInterface {
@@ -233,7 +236,7 @@ export interface TestHelperGlobal {
   }
 }
 
-declare global {
+/*declare global {
   // only available server side
   var server: ServerGlobal;
 
@@ -245,7 +248,7 @@ declare global {
   var describe: Function;
   var before: Function;
   var after: Function;
-}
+}*/
 
 export interface AuthConfig extends SessionHandlerOptions {
 

package/.eslintrc

@@ -1,15 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "extends": [
-    "plugin:@typescript-eslint/recommended"
-  ],
-  "parserOptions": {
-    "ecmaVersion": 2018,
-    "sourceType": "module"
-  },
-  "rules": {
-    // Aca puedes modificar alguna regla específica, por ejemplo:
-    // "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/no-explicit-any": "off"
-  }
-}

package/build/esm/src/services/globals.d.ts

@@ -1,3 +0,0 @@
-export declare function browserJSXGlobals(inFile: string, jsxPath?: string | false, useExport?: boolean): string;
-export declare function initGlobals(): void;
-export declare function assertGlobalTampered(): void;

package/build/esm/src/services/globals.js

@@ -1,182 +0,0 @@
-//@ts-ignore
-import { ReadBuffer, URLEncodedParser, JSONParser, TextParser, CORS, SessionHandler } from "@miqro/core";
-import cluster from "node:cluster";
-import { strictEqual } from "node:assert";
-import { HTMLEncode } from "@miqro/jsx-node";
-import { createElement as realCreateElement, enableDebugLog, useRuntime, Link, Router, usePathname, Fragment, useEffect, useRef, useState, useQuery, useRefresh, useElement, createContext, useContext } from "@miqro/jsx";
-import { jsx2HTML } from "../common/jsx.js";
-import { inflateMD2HTML } from "../inflate/md.js";
-import { EXIT_CODES } from "../common/constants.js";
-import { ClusterCache, LocalCache } from "../lib.js";
-import { decodeJWT, decodeProtectedHeaderJWT, decryptJWT, encryptJWT, signJWT, verifyJWT } from "../common/jwt.js";
-import { createSecretKey } from "node:crypto";
-import { Parser } from "@miqro/parser";
-/*const globaljsx: any = Object.freeze({
-  useContext,
-  useRuntime,
-  createContext,
-  useState,
-  useEffect,
-  useQuery,
-  useRef,
-  useElement,
-  useRefresh,
-  Link,
-  Router,
-  usePathname
-});*/
-const globalJSX = Object.freeze({
-    createElement: (...args) => {
-        const ret = realCreateElement(...args);
-        ret.toString = () => jsx2HTML(ret);
-        return ret;
-    },
-    Fragment,
-    enableDebugLog
-});
-const globaljsx = Object.freeze({
-    useContext,
-    useRuntime,
-    createContext,
-    useState,
-    useEffect,
-    useQuery,
-    useRef,
-    useElement,
-    useRefresh,
-    Link,
-    Router,
-    usePathname,
-    define: function define() {
-        /*const callSites = getCallSite();
-        const caller = callSites[2];
-        if (CLEAR_JSX_CACHE) {
-          const scriptName = basename(caller.scriptName);
-          const originalName = scriptName.substring(0, scriptName.length - ".mjs".length);
-          //server.logger.debug("browser.define not available server side!");
-          //server.logger.trace("browser.define not available server side! %s", originalName);
-        } else {
-          //server.logger.debug("browser.define not available server side!");
-          //server.logger.trace("browser.define not available server side! %s:%s:%s", caller.scriptName, caller.lineNumber, caller.column);
-        }*/
-    }
-});
-const globalWindow = Object.freeze({
-    addEventListener: function define() {
-        /*const callSites = getCallSite();
-        const caller = callSites[2];
-        if (CLEAR_JSX_CACHE) {
-          const scriptName = basename(caller.scriptName);
-          //server.logger.debug("window.addEventListener not available server side!");
-          server.logger.trace("window.addEventListener not available server side! %s", scriptName.substring(0, scriptName.length - ".mjs".length));
-        } else {
-          //server.logger.debug("window.addEventListener not available server side!");
-          server.logger.trace("window.addEventListener not available server side! %s:%s:%s", caller.scriptName, caller.lineNumber, caller.column);
-        }*/
-    }
-});
-const globalServer = Object.freeze({
-    middleware: Object.freeze({
-        buffer: ReadBuffer,
-        url: URLEncodedParser,
-        json: JSONParser,
-        text: TextParser,
-        cors: CORS,
-        session: SessionHandler
-    }),
-    encodeHTML: HTMLEncode,
-    inflateMDtoHTML: inflateMD2HTML,
-    createSecretKey,
-    newParser() {
-        return new Parser();
-    },
-    newClusterCache(name, logger) {
-        return new ClusterCache(name, logger);
-    },
-    newLocalCache(name, logger) {
-        return new LocalCache(name, logger);
-    },
-    getWorkerNumber() {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined ? 0 : parseInt(process.env["CLUSTER_NODE_NUMBER"], 10);
-    },
-    getWorkerCount() {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === undefined || process.env["CLUSTER_COUNT"] === undefined ? 1 : parseInt(process.env["CLUSTER_COUNT"], 10);
-    },
-    isPrimaryWorker() {
-        return cluster.isPrimary || process.env["CLUSTER_NODE_NUMBER"] === "0";
-    },
-    jwt: {
-        decode(jwt) {
-            return decodeJWT(jwt);
-        },
-        decodeProtectedHeader(token) {
-            return decodeProtectedHeaderJWT(token);
-        },
-        decrypt(jwt, secret, options) {
-            return decryptJWT(jwt, secret, options);
-        },
-        encrypt(payload, secret, options) {
-            return encryptJWT(payload, secret, options);
-        },
-        sign(payload, secret, options) {
-            return signJWT(payload, secret, options);
-        },
-        verify(jwt, secret, options) {
-            return verifyJWT(jwt, secret, options);
-        }
-    }
-});
-export function browserJSXGlobals(inFile, jsxPath = false, useExport = true) {
-    const PRE = `import { enableDebugLog, useRuntime, Link, usePathname, createContext, useContext, useElement, useRefresh, useQuery, define, Router, useState, useEffect, useRef, createElement, Fragment } from "${jsxPath}";
-    globalThis.JSX = Object.freeze({
-      createElement,
-      Fragment,
-      enableDebugLog
-    });
-    
-    globalThis.newParser = () => new Parser();
-    globalThis.jsx = Object.freeze({
-      define,
-      useRuntime,
-      createContext, 
-      useContext, 
-      useState,
-      useEffect,
-      useQuery,
-      useRef,
-      useElement,
-      useRefresh,
-      usePathname,
-      Link,
-      Router
-    });`;
-    return `${jsxPath ? PRE : ""}\n${useExport ? `export * from "${inFile}";import * as lib from "${inFile}";export default lib.default;` : `import * as lib from "${inFile}"`}`;
-}
-export function initGlobals() {
-    //const logger = getLogger(SERVER_IDENTIFIER);  
-    globalThis.server = globalServer;
-    //globalThis.jsx = globaljsx;
-    /*for (const key of Object.keys(globaljsx)) {
-      globalThis[key] = globaljsx[key];
-    }*/
-    globalThis.JSX = globalJSX;
-    globalThis.jsx = globaljsx;
-    globalThis.window = globalWindow;
-}
-export function assertGlobalTampered() {
-    try {
-        //strictEqual(globalThis.utils, globalUtils, "globalThis.utils tamperered");
-        strictEqual(globalThis.JSX, globalJSX, "globalThis.JSX tamperered");
-        //strictEqual(globalThis.jsx, globaljsx, "globalThis.jsx tamperered");
-        /*for (const key of Object.keys(globaljsx)) {
-          strictEqual(globalThis[key], globaljsx[key], "globalThis.jsx tamperered");
-        }*/
-        strictEqual(globalThis.server, globalServer, "globalThis.server tamperered");
-        strictEqual(globalThis.jsx, globaljsx, "globalThis.jsx tamperered");
-        strictEqual(globalThis.window, globalWindow, "globalThis.window tamperered");
-    }
-    catch (e) {
-        console.error(e);
-        process.exit(EXIT_CODES.GLOBALS_ALTERED);
-    }
-}