xpine 0.0.4 → 0.0.6

package/dist/index.js

@@ -0,0 +1,658 @@
+// src/runDevServer.ts
+import expressWs from "express-ws";
+import http from "http";
+import express from "express";
+import EventEmitter from "events";
+import chokidar from "chokidar";
+
+// src/scripts/build.ts
+import path3 from "path";
+import fs2 from "fs-extra";
+import { build } from "esbuild";
+import builtinModules from "builtin-modules";
+import ts2 from "typescript";
+
+// src/build/typescript-builder.ts
+import ts from "typescript";
+import fs from "fs-extra";
+import path from "path";
+function findDataAttributesAndFunctions(node, sourceFile, foundDataAttributes = [], foundFunctions = []) {
+  if (node.kind === ts.SyntaxKind.JsxAttribute) {
+    const attribute = getAttributeValuePair(node, sourceFile);
+    if (attribute?.[0] === "x-data" && attribute?.[1]) {
+      foundDataAttributes.push(attribute[1].replace(/[^a-zA-Z0-9]/g, ""));
+    }
+  }
+  if (node.kind === ts.SyntaxKind.SourceFile) {
+    node.forEachChild((child) => {
+      if ([ts.SyntaxKind.FunctionDeclaration, ts.SyntaxKind.VariableDeclaration].includes(child.kind)) {
+        const functions = getFunctionDeclarationValue(child, sourceFile);
+        foundFunctions.push(functions);
+      }
+    });
+  }
+  node.forEachChild((child) => {
+    findDataAttributesAndFunctions(child, sourceFile, foundDataAttributes, foundFunctions);
+  });
+  return {
+    foundDataAttributes,
+    foundFunctions
+  };
+}
+function getAttributeValuePair(node, sourceFile) {
+  const result = [];
+  node.forEachChild((child) => {
+    result.push(child.getText(sourceFile));
+  });
+  return result;
+}
+function getFunctionDeclarationValue(node, sourceFile) {
+  const result = {
+    name: null,
+    isDefaultExport: false,
+    hasExport: false
+  };
+  node.forEachChild((child) => {
+    if (child.kind === ts.SyntaxKind.ExportKeyword) {
+      result.hasExport = true;
+    }
+    if (child.kind === ts.SyntaxKind.DefaultKeyword) {
+      result.isDefaultExport = true;
+    }
+    if (child.kind === ts.SyntaxKind.Identifier) {
+      result.name = child.getText(sourceFile);
+    }
+  });
+  return result;
+}
+function convertEntryPointsToSingleFile(entryPoints, tempWritePath) {
+  fs.writeFileSync(
+    tempWritePath,
+    entryPoints.map((entry) => `import "${entry}"`).join(";\n")
+  );
+}
+function removeClientScriptInTSXFile(pathName) {
+  const content = fs.readFileSync(pathName, "utf-8");
+  const source = ts.createSourceFile(
+    pathName,
+    content,
+    ts.ScriptTarget.Latest
+  );
+  let toRemoveFrom;
+  let clientDataStart;
+  const clientImportsToHoist = [];
+  const clientImportsToReplace = [];
+  source.forEachChild((child) => {
+    if (child.kind === ts.SyntaxKind.ExpressionStatement) {
+      const text = child.getText(source);
+      if (text.startsWith("<script")) {
+        toRemoveFrom = child.pos;
+        clientDataStart = child.end;
+      }
+    }
+    if (child.kind === ts.SyntaxKind.ImportDeclaration && child.pos >= clientDataStart) {
+      const text = child.getText(source);
+      child.forEachChild((child2) => {
+        if (child2.kind === ts.SyntaxKind.StringLiteral) {
+          const text2 = child2.getText(source);
+          const importPath = text2.replace(/[\"\']/g, "");
+          const isRelativeImport = importPath.startsWith(".") || importPath.startsWith("/");
+          if (!isRelativeImport) return;
+          clientImportsToReplace.push({
+            old: importPath,
+            new: path.join(path.dirname(pathName), importPath)
+          });
+        }
+      });
+      clientImportsToHoist.push(text);
+    }
+  });
+  let clientContent = !isNaN(clientDataStart) ? content.slice(clientDataStart) : "";
+  for (const clientImport of clientImportsToReplace) {
+    clientContent = clientContent.replace(clientImport.old, clientImport.new);
+  }
+  return {
+    content: !isNaN(toRemoveFrom) ? clientImportsToHoist.join("\n") + content.slice(0, toRemoveFrom) : content,
+    clientContent,
+    fullContent: content,
+    toRemoveFrom,
+    clientDataStart
+  };
+}
+
+// src/scripts/build.ts
+import { globSync } from "glob";
+import postcss from "postcss";
+import tailwindPostcss from "@tailwindcss/postcss";
+
+// src/util/get-config.ts
+import path2 from "path";
+
+// src/util/require.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var require_default = require2;
+
+// src/util/get-config.ts
+var rootDir = process.cwd();
+function fromRoot(pathName) {
+  if (!pathName) return rootDir;
+  return path2.join(rootDir, pathName);
+}
+var userConfig = require_default(path2.join(process.cwd(), "./xpine.config.mjs")).default;
+var configDefaults = {
+  rootDir: fromRoot(),
+  srcDir: fromRoot("./src"),
+  distDir: fromRoot("./dist"),
+  packageJsonPath: fromRoot("package.json"),
+  // We need to use getters here in the event someone wants to change folders, such as the dist folder
+  get distPublicDir() {
+    return path2.join(this.distDir, "./public");
+  },
+  get distPublicScriptsDir() {
+    return path2.join(this.distPublicDir, "./scripts");
+  },
+  get distTempFolder() {
+    return path2.join(this.distDir, "./temp");
+  },
+  get clientJSBundlePath() {
+    return path2.join(this.distPublicScriptsDir, "./app.js");
+  },
+  get alpineDataPath() {
+    return path2.join(this.distTempFolder, "./alpine-data.ts");
+  },
+  get serverDistDir() {
+    return path2.join(this.distDir, "./server");
+  },
+  get serverDistAppPath() {
+    return path2.join(this.serverDistDir, "./app.js");
+  },
+  // Important dirs/paths
+  get pagesDir() {
+    return path2.join(this.srcDir, "./pages");
+  },
+  get publicDir() {
+    return path2.join(this.srcDir, "./public");
+  },
+  get serverDir() {
+    return path2.join(this.srcDir, "./server");
+  },
+  get runDir() {
+    return path2.join(this.serverDir, "./run");
+  },
+  get serverAppPath() {
+    return path2.join(this.serverDir, "./app.ts");
+  },
+  get globalCSSFile() {
+    return path2.join(this.publicDir, "./styles/global.css");
+  }
+};
+var config = {
+  ...configDefaults,
+  ...userConfig
+};
+
+// src/scripts/build.ts
+var extensions = [".ts", ".tsx"];
+var packageJson = JSON.parse(fs2.readFileSync(config.packageJsonPath, "utf-8"));
+var allPackages = Object.keys(packageJson.devDependencies).concat(Object.keys(packageJson.dependencies));
+var allPackagesIncludingNode = allPackages.concat(builtinModules);
+async function buildApp(isDev = false) {
+  try {
+    const srcDirFiles = globSync(config.srcDir + "/**/*.{js,ts,tsx,jsx}");
+    const { componentData, dataFiles } = await buildAppFiles(srcDirFiles, isDev);
+    const alpineDataFile = await buildAlpineDataFile(componentData, dataFiles);
+    await buildClientSideFiles([alpineDataFile], isDev);
+    fs2.removeSync(config.distTempFolder);
+    await buildCSS();
+    await buildPublicFolderSymlinks();
+  } catch (err) {
+    console.error("Build failed");
+    console.error(err);
+  }
+}
+async function buildAppFiles(files, isDev) {
+  const componentData = [];
+  const dataFiles = [];
+  const backendFiles = files.filter((file) => extensions.find((ext) => file.endsWith(ext))).filter((file) => !file.startsWith(config.publicDir));
+  fs2.ensureDirSync(config.distDir);
+  await build({
+    entryPoints: backendFiles,
+    format: "esm",
+    platform: "node",
+    outdir: config.distDir,
+    bundle: true,
+    sourcemap: isDev ? "inline" : false,
+    external: allPackages,
+    jsx: "transform",
+    minify: !isDev,
+    plugins: [
+      {
+        name: "add-dot-js",
+        setup(build2) {
+          build2.onResolve({ filter: /.*/ }, (args) => {
+            const hasAtSign = args.path.startsWith("@");
+            const isPackage = hasAtSign ? allPackagesIncludingNode.includes(args.path) : allPackagesIncludingNode.includes(args.path.split("/").shift());
+            if (args.importer && !isPackage) {
+              const calculatedDir = path3.join(args.resolveDir, args.path);
+              let existsAsFile = false;
+              for (const extension of extensions) {
+                const asFile = calculatedDir + extension;
+                const exists = fs2.existsSync(asFile);
+                if (exists) existsAsFile = true;
+              }
+              let outputPath = args.path + (existsAsFile ? "" : "/index") + ".js";
+              outputPath = args.path.endsWith(".js") || args.path.endsWith(".mjs") ? args.path : outputPath;
+              return { path: outputPath, external: true };
+            }
+          });
+        }
+      },
+      {
+        name: "insert-html-banner-and-remove-client-scripts",
+        setup(build2) {
+          build2.onLoad({ filter: /.tsx/ }, (args) => {
+            const cleanedContent = removeClientScriptInTSXFile(args.path);
+            const htmlImportStart = "import { html } from 'xpine';\n";
+            const newContent = `${htmlImportStart}${cleanedContent.content}`;
+            componentData.push({
+              ...args,
+              contents: `${htmlImportStart}${cleanedContent.fullContent}`,
+              clientContent: cleanedContent.clientContent
+            });
+            return {
+              contents: newContent,
+              loader: "tsx"
+            };
+          });
+        }
+      },
+      {
+        name: "get-data-files",
+        setup(build2) {
+          build2.onLoad({ filter: /\.data\.(js|mjs|ts)$/ }, (args) => {
+            const contents = fs2.readFileSync(args.path, "utf-8");
+            dataFiles.push({
+              ...args,
+              contents
+            });
+            return {
+              contents,
+              loader: "ts"
+            };
+          });
+        }
+      }
+    ]
+  });
+  await logSize(config.distDir, "app");
+  return {
+    componentData,
+    dataFiles
+  };
+}
+async function buildClientSideFiles(alpineDataFiles = [], isDev) {
+  const tempFilePath = path3.join(config.distTempFolder, "./app.ts");
+  fs2.ensureFileSync(tempFilePath);
+  const pagesScriptsGlob = config.publicDir + "/scripts/pages/**/*.{js,ts}";
+  const clientFiles = globSync(
+    config.publicDir + "/**/*.{js,ts}",
+    {
+      ignore: pagesScriptsGlob
+    }
+  );
+  convertEntryPointsToSingleFile(alpineDataFiles.concat(clientFiles), tempFilePath);
+  if (isDev) writeDevServerClientSideCode(tempFilePath);
+  writeSpaClientSideCode(tempFilePath);
+  await build({
+    entryPoints: [tempFilePath],
+    bundle: true,
+    outdir: config.distPublicScriptsDir,
+    minify: !isDev,
+    sourcemap: isDev ? "inline" : false
+  });
+  const pagesFiles = globSync(pagesScriptsGlob);
+  await build({
+    entryPoints: pagesFiles || [],
+    bundle: true,
+    outdir: config.distPublicScriptsDir + "/pages",
+    minify: !isDev,
+    sourcemap: isDev ? "inline" : false
+  });
+  await logSize(config.distPublicDir, "client");
+}
+function writeDevServerClientSideCode(tempFilePath) {
+  const devServerPath = path3.join(import.meta.dirname, "../static/dev-server.js");
+  const content = fs2.readFileSync(devServerPath, "utf-8");
+  fs2.appendFileSync(tempFilePath, `
+` + content);
+}
+function writeSpaClientSideCode(tempFilePath) {
+  const spaPath = path3.join(import.meta.dirname, "../static/spa.js");
+  const content = fs2.readFileSync(spaPath, "utf-8");
+  fs2.appendFileSync(tempFilePath, `
+` + content);
+}
+async function buildAlpineDataFile(componentData, dataFiles) {
+  const output = {
+    imports: [
+      "import Alpine from 'alpinejs';"
+    ],
+    code: [],
+    end: [
+      "window.Alpine = Alpine;"
+    ]
+  };
+  const dataFunctionResults = {
+    foundDataAttributes: [],
+    foundFunctions: [],
+    foundImports: []
+  };
+  const componentsAndDataFiles = componentData.concat(dataFiles);
+  for (const component of componentsAndDataFiles) {
+    const sourceFile = ts2.createSourceFile(
+      component.path,
+      component.contents,
+      ts2.ScriptTarget.Latest
+    );
+    const dataFunctionResult = findDataAttributesAndFunctions(sourceFile, sourceFile);
+    dataFunctionResults.foundDataAttributes.push(...dataFunctionResult.foundDataAttributes);
+    const foundFunctionsWithPath = dataFunctionResult.foundFunctions.map((item) => {
+      return {
+        ...item,
+        path: component.path,
+        content: component.clientContent
+      };
+    });
+    dataFunctionResults.foundFunctions.push(...foundFunctionsWithPath);
+  }
+  const validDataFunctions = dataFunctionResults.foundFunctions.filter((item) => {
+    return dataFunctionResults.foundDataAttributes.includes(item.name) && item.content;
+  });
+  for (const dataFunction of validDataFunctions) {
+    if (!dataFunction.hasExport) continue;
+    output.code.push(dataFunction.content);
+    output.code.push(`Alpine.data('${dataFunction.name}', ${dataFunction.name});`);
+  }
+  const result = output.imports.join("\n") + "\n" + output.code.join("\n") + "\n" + output.end.join("\n");
+  fs2.ensureFileSync(config.alpineDataPath);
+  fs2.writeFileSync(config.alpineDataPath, result);
+  return config.alpineDataPath;
+}
+async function buildCSS() {
+  const cssFiles = globSync(config.srcDir + "/**/*.css");
+  for (const file of cssFiles) {
+    const fileContents = fs2.readFileSync(file, "utf-8");
+    const result = await postcss([tailwindPostcss()]).process(fileContents, { from: file });
+    const newPath = file.replace(config.srcDir, config.distDir);
+    fs2.ensureFileSync(newPath);
+    fs2.writeFileSync(newPath, result.css);
+  }
+  logSize(config.distPublicDir, "css");
+}
+async function buildPublicFolderSymlinks() {
+  const files = globSync(config.publicDir + "/**/*.*", {
+    ignore: "/**/*.{css,js,ts,tsx,jsx}"
+  });
+  for (const file of files) {
+    try {
+      const newPath = file.replace(config.srcDir, config.distDir);
+      const splitNewPath = newPath.split("/");
+      splitNewPath.pop();
+      const newDir = splitNewPath.join("/");
+      fs2.ensureDirSync(newDir);
+      fs2.symlinkSync(file, newPath);
+    } catch {
+    }
+  }
+}
+async function logSize(pathName, type, validExtensions = [".js", ".css"]) {
+  const files = globSync(pathName + "/**/*" + (type === "css" ? ".css" : ""));
+  const fileSizes = files.map((file) => {
+    if (!validExtensions.find((ext) => file.endsWith(ext))) return false;
+    return {
+      file,
+      size: fs2.statSync(file).size / (1024 * 1e3)
+    };
+  }).filter(Boolean);
+  const totalSize = fileSizes.reduce((total, current) => {
+    return current.size + total;
+  }, 0);
+  console.info(`[${totalSize.toFixed(3)} MB] Built ${type}`);
+}
+
+// src/runDevServer.ts
+import path5 from "path";
+
+// src/util/env.ts
+import dotenv from "dotenv";
+import path4 from "path";
+function setupEnv() {
+  dotenv.config({ path: path4.join(config.rootDir, `./.env.${process.env.STAGE || "dev"}`) });
+}
+
+// src/runDevServer.ts
+setupEnv();
+async function runDevServer() {
+  process.env.NODE_ENV = "development";
+  const startServer = await import(config.serverDistAppPath + `?cache=${Date.now()}`);
+  await buildApp(true);
+  let appServer = await startServer.default();
+  const watcher = chokidar.watch(config.srcDir, {
+    ignoreInitial: true,
+    // Ignore map and prisma files
+    ignored: (pathName) => pathName.endsWith(".map") || pathName.startsWith(path5.join(config.serverDir, "./prisma"))
+  });
+  watcher.on("all", async (event, path6) => {
+    const shouldReloadServer = path6.startsWith(config.serverDir) && !path6.startsWith(config.runDir) || ["add", "unlink"].includes(event) && path6.startsWith(config.pagesDir);
+    if (shouldReloadServer) {
+      appServer.server.close();
+      await buildApp(true);
+      const startServer2 = await import(config.serverDistAppPath + `?cache=${Date.now()}`);
+      appServer = await startServer2.default();
+      return;
+    }
+    await buildApp(true);
+    refreshEmitter.emit("refresh");
+  });
+  const wsApp = express();
+  const wsServer = http.createServer(wsApp);
+  expressWs(wsApp, wsServer);
+  class RefreshEmitter extends EventEmitter {
+  }
+  ;
+  const refreshEmitter = new RefreshEmitter();
+  wsApp.ws("/dev-server", function(ws) {
+    refreshEmitter.removeAllListeners();
+    refreshEmitter.on("refresh", () => {
+      ws.send("refresh:client");
+    });
+  });
+  const wsPort = 3001;
+  wsServer.listen(wsPort);
+  wsServer.on("listening", () => {
+    console.info(`Dev server listening on port ${wsPort}`);
+  });
+}
+
+// src/express.ts
+import express2 from "express";
+import { globSync as globSync2 } from "glob";
+
+// src/auth.ts
+import jsonwebtoken from "jsonwebtoken";
+var { verify, sign } = jsonwebtoken;
+async function signUser(email, username) {
+  return new Promise((resolve, reject) => {
+    sign(
+      {
+        user: {
+          email,
+          username
+        }
+      },
+      // @ts-ignore
+      process.env.JWT_PRIVATE_KEY,
+      { expiresIn: "30d" },
+      (err, token) => {
+        if (err) reject(err);
+        resolve(token);
+      }
+    );
+  });
+}
+async function verifyUser(token) {
+  return new Promise((resolve, reject) => {
+    verify(token, process.env.JWT_PRIVATE_KEY, (err, authorizedData) => {
+      if (err) reject(err);
+      resolve(authorizedData);
+    });
+  });
+}
+function getTokenFromRequest(req) {
+  const { authorization } = req.headers;
+  if (!authorization) return null;
+  const token = authorization.split(" ").pop() || "";
+  return token || null;
+}
+
+// src/express.ts
+import requestIP from "request-ip";
+var doctypeHTML = "<!DOCTYPE html>";
+async function createRouter() {
+  const methods = ["get", "post", "put", "patch", "delete"];
+  const router = express2.Router();
+  const routes = globSync2(config.pagesDir + "/**/*.{tsx,ts}");
+  const routeMap = routes.map((route) => {
+    return {
+      route: route.split(config.pagesDir).pop().replace(".tsx", "").replace(".js", "").replace(".ts", "").replace("/index", "/"),
+      path: route.replace(config.srcDir, config.distDir).replace(".tsx", ".js").replace(".ts", ".js"),
+      originalRoute: route
+    };
+  });
+  const routeResults = [];
+  for (const route of routeMap) {
+    const isJSX = route.originalRoute.endsWith(".tsx") || route.originalRoute.endsWith(".jsx");
+    const routeItem = process.env.NODE_ENV === "development" ? null : (await import(route.path)).default;
+    const slugRoute = route.route.toLowerCase().replace(/[ ]/g, "");
+    const foundMethod = methods.find((method) => slugRoute.endsWith(`.${method}`));
+    const isDynamicRoute = slugRoute.match(/\[(.*)\]/g);
+    let formattedRouteItem = slugRoute;
+    if (foundMethod) formattedRouteItem = formattedRouteItem.split(".").shift();
+    if (isDynamicRoute) {
+      const result = [...formattedRouteItem.matchAll(/(\[)(.*?)(\])/g)];
+      for (const match of result) {
+        formattedRouteItem = formattedRouteItem.replace(match[0], ":" + match[2]);
+      }
+    }
+    routeResults.push({
+      formattedRouteItem,
+      foundMethod,
+      route
+    });
+    router[foundMethod || "get"](formattedRouteItem, async (req, res) => {
+      try {
+        if (routeItem) {
+          if (isJSX) {
+            res.send(doctypeHTML + await routeItem(req, res));
+          } else {
+            await routeItem(req, res);
+          }
+          return;
+        }
+        const defaultRouteImport = (await import(route.path + `?cache=${Date.now()}`)).default;
+        if (isJSX) {
+          res.send(doctypeHTML + await defaultRouteImport(req, res));
+        } else {
+          await defaultRouteImport(req, res);
+        }
+      } catch (err) {
+        console.error(err);
+        res.status(err?.status || 500).send(err?.message || "Error");
+      }
+    });
+  }
+  return {
+    router,
+    routeResults
+  };
+}
+async function verifyUserMiddleware(req, _res, next) {
+  const { usertoken } = req.cookies;
+  if (!usertoken) {
+    req.user = null;
+  }
+  try {
+    const { user } = await verifyUser(usertoken);
+    req.user = user;
+  } catch (err) {
+    req.user = null;
+  }
+  next();
+}
+async function createXPineRouter(app, beforeErrorRoute) {
+  app.use(express2.static(config.distPublicDir));
+  app.use(verifyUserMiddleware);
+  app.use(requestIP.mw());
+  const { router, routeResults } = await createRouter();
+  app.use(function replaceableRouter(req, res, next) {
+    router(req, res, next);
+  });
+  const found404 = routeResults?.find((item) => item?.formattedRouteItem === "/404");
+  const import404 = process.env.NODE_ENV === "development" ? null : (await import(found404.route.path)).default;
+  if (beforeErrorRoute) beforeErrorRoute(app);
+  app.use(async function(req, res) {
+    res.status(404);
+    if (import404) {
+      res.send(doctypeHTML + await import404(req, res));
+    } else if (found404 && process.env.NODE_ENV === "development") {
+      const import404Item = (await import(found404.route.path + `?cache=${Date.now()}`)).default;
+      res.send(doctypeHTML + await import404Item(req, res));
+    } else {
+      res.send("Error");
+    }
+  });
+}
+
+// src/util/html.ts
+var html = class {
+  static attributeObjectToString(props) {
+    if (!props) return "";
+    return Object.entries(props).filter(([, value]) => value !== null && value !== void 0).map(([key, value], index) => {
+      const start = index === 0 ? " " : "";
+      return `${start}${key}="${value}"`;
+    }).join(" ");
+  }
+  static async fragment(props) {
+    const childrenResult = await Promise.all(props.children.flat());
+    return childrenResult.filter(Boolean).join("");
+  }
+  static async createElement(type, props, ...children) {
+    const childrenResult = await Promise.all(children.flat());
+    if (typeof type === "function") {
+      const result = await type({ ...props, children: childrenResult });
+      return result;
+    }
+    return `<${type}${this.attributeObjectToString(props)}>${childrenResult.filter(Boolean).join("")}</${type}>`;
+  }
+};
+function JSXRuntime() {
+  return true;
+}
+export {
+  JSXRuntime,
+  buildApp,
+  buildCSS,
+  buildPublicFolderSymlinks,
+  config,
+  createRouter,
+  createXPineRouter,
+  fromRoot,
+  getTokenFromRequest,
+  html,
+  logSize,
+  runDevServer,
+  setupEnv,
+  signUser,
+  verifyUser
+};

package/dist/src/build/dev-server.js

@@ -0,0 +1,10 @@
+// src/build/dev-server.mjs
+var socketProtocol = "ws:";
+var echoSocketUrl = socketProtocol + "//" + window.location.hostname + ":3001/dev-server/";
+var socket = new WebSocket(echoSocketUrl);
+socket.addEventListener("message", async (msg) => {
+  if (msg.data === "refresh:client") {
+    window.location.reload();
+  }
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2J1aWxkL2Rldi1zZXJ2ZXIubWpzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJjb25zdCBzb2NrZXRQcm90b2NvbCA9ICd3czonO1xuY29uc3QgZWNob1NvY2tldFVybCA9IHNvY2tldFByb3RvY29sICsgJy8vJyArIHdpbmRvdy5sb2NhdGlvbi5ob3N0bmFtZSArICc6MzAwMS9kZXYtc2VydmVyLyc7XG5jb25zdCBzb2NrZXQgPSBuZXcgV2ViU29ja2V0KGVjaG9Tb2NrZXRVcmwpO1xuXG5zb2NrZXQuYWRkRXZlbnRMaXN0ZW5lcignbWVzc2FnZScsIGFzeW5jIChtc2cpID0+IHtcbiAgaWYgKG1zZy5kYXRhID09PSAncmVmcmVzaDpjbGllbnQnKSB7XG4gICAgd2luZG93LmxvY2F0aW9uLnJlbG9hZCgpO1xuICB9XG59KTtcbiJdLAogICJtYXBwaW5ncyI6ICI7QUFBQSxJQUFNLGlCQUFpQjtBQUN2QixJQUFNLGdCQUFnQixpQkFBaUIsT0FBTyxPQUFPLFNBQVMsV0FBVztBQUN6RSxJQUFNLFNBQVMsSUFBSSxVQUFVLGFBQWE7QUFFMUMsT0FBTyxpQkFBaUIsV0FBVyxPQUFPLFFBQVE7QUFDaEQsTUFBSSxJQUFJLFNBQVMsa0JBQWtCO0FBQ2pDLFdBQU8sU0FBUyxPQUFPO0FBQUEsRUFDekI7QUFDRixDQUFDOyIsCiAgIm5hbWVzIjogW10KfQo=