@cedarjs/vite 0.0.4

package/dist/plugins/vite-plugin-rsc-analyze.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+import * as swc from "@swc/core";
+function rscAnalyzePlugin(clientEntryCallback, serverEntryCallback) {
+  return {
+    name: "redwood-rsc-analyze-plugin",
+    transform(code, id) {
+      const ext = path.extname(id);
+      if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+        const mod = swc.parseSync(code, {
+          syntax: ext === ".ts" || ext === ".tsx" ? "typescript" : "ecmascript",
+          tsx: ext === ".tsx"
+        });
+        let directiveFound = false;
+        for (const item of mod.body) {
+          if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral") {
+            if (item.expression.value === "use client") {
+              clientEntryCallback(id);
+              directiveFound = true;
+            } else if (item.expression.value === "use server") {
+              serverEntryCallback(id);
+              directiveFound = true;
+            }
+          }
+        }
+        if (!directiveFound && code.includes("use server") && containsServerAction(mod)) {
+          serverEntryCallback(id);
+        }
+      }
+      return code;
+    }
+  };
+}
+function isServerAction(node) {
+  return node.body?.type === "BlockStatement" && node.body.stmts.some(
+    (s) => s.type === "ExpressionStatement" && s.expression.type === "StringLiteral" && s.expression.value === "use server"
+  );
+}
+function isFunctionDeclaration(node) {
+  return node.type === "FunctionDeclaration";
+}
+function isFunctionExpression(node) {
+  return node.type === "FunctionExpression";
+}
+function isArrowFunctionExpression(node) {
+  return node.type === "ArrowFunctionExpression";
+}
+function containsServerAction(mod) {
+  function walk(node) {
+    if (isFunctionDeclaration(node) || isFunctionExpression(node) || isArrowFunctionExpression(node)) {
+      if (isServerAction(node)) {
+        return true;
+      }
+    }
+    return Object.values(node).some(
+      (value) => (Array.isArray(value) ? value : [value]).some((v) => {
+        if (typeof v?.type === "string") {
+          return walk(v);
+        }
+        if (typeof v?.expression?.type === "string") {
+          return walk(v.expression);
+        }
+        return false;
+      })
+    );
+  }
+  return walk(mod);
+}
+export {
+  rscAnalyzePlugin
+};

package/dist/plugins/vite-plugin-rsc-reload.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function rscReloadPlugin(fn: (type: 'full-reload') => void): Plugin;
+//# sourceMappingURL=vite-plugin-rsc-reload.d.ts.map

package/dist/plugins/vite-plugin-rsc-reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-rsc-reload.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-rsc-reload.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,wBAAgB,eAAe,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,CAgDzE"}

package/dist/plugins/vite-plugin-rsc-reload.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import * as swc from "@swc/core";
+function rscReloadPlugin(fn) {
+  let enabled = false;
+  const isClientEntry = (id, code) => {
+    const ext = path.extname(id);
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+      const mod = swc.parseSync(code, {
+        syntax: ext === ".ts" || ext === ".tsx" ? "typescript" : "ecmascript",
+        tsx: ext === ".tsx"
+      });
+      for (const item of mod.body) {
+        if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral" && item.expression.value === "use client") {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  return {
+    name: "reload-plugin",
+    configResolved(config) {
+      if (config.mode === "development") {
+        enabled = true;
+      }
+    },
+    async handleHotUpdate(ctx) {
+      if (!enabled) {
+        return [];
+      }
+      if (ctx.modules.length && !isClientEntry(ctx.file, await ctx.read())) {
+        return fn("full-reload");
+      } else {
+        return [];
+      }
+    }
+  };
+}
+export {
+  rscReloadPlugin
+};

package/dist/plugins/vite-plugin-rsc-routes-auto-loader.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function rscRoutesAutoLoader(): Plugin;
+//# sourceMappingURL=vite-plugin-rsc-routes-auto-loader.d.ts.map

package/dist/plugins/vite-plugin-rsc-routes-auto-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-rsc-routes-auto-loader.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-rsc-routes-auto-loader.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AA6BlC,wBAAgB,mBAAmB,IAAI,MAAM,CAgK5C"}

package/dist/plugins/vite-plugin-rsc-routes-auto-loader.js

@@ -0,0 +1,130 @@
+import path from "path";
+import babelGenerator from "@babel/generator";
+const generate = babelGenerator.default;
+import { parse as babelParse } from "@babel/parser/index.cjs";
+import babelTraverse from "@babel/traverse";
+const traverse = babelTraverse.default;
+import * as t from "@babel/types";
+import { normalizePath } from "vite";
+import {
+  ensurePosixPath,
+  getPaths,
+  importStatementPath,
+  processPagesDir
+} from "@cedarjs/project-config";
+const getPathRelativeToSrc = (maybeAbsolutePath) => {
+  if (!path.isAbsolute(maybeAbsolutePath)) {
+    return maybeAbsolutePath;
+  }
+  return `./${path.relative(getPaths().web.src, maybeAbsolutePath)}`;
+};
+const withRelativeImports = (page) => {
+  return {
+    ...page,
+    relativeImport: ensurePosixPath(getPathRelativeToSrc(page.importPath))
+  };
+};
+function rscRoutesAutoLoader() {
+  const routesFileId = normalizePath(getPaths().web.routes);
+  const pages = processPagesDir().map(withRelativeImports);
+  const duplicatePageImportNames = /* @__PURE__ */ new Set();
+  const sortedPageImportNames = pages.map((page) => page.importName).sort();
+  for (let i = 0; i < sortedPageImportNames.length - 1; i++) {
+    if (sortedPageImportNames[i + 1] === sortedPageImportNames[i]) {
+      duplicatePageImportNames.add(sortedPageImportNames[i]);
+    }
+  }
+  if (duplicatePageImportNames.size > 0) {
+    const pageNames = Array.from(duplicatePageImportNames).map((name) => `'${name}'`).join(", ");
+    throw new Error(
+      `Unable to find only a single file ending in 'Page.{js,jsx,ts,tsx}' in the following page directories: ${pageNames}`
+    );
+  }
+  return {
+    name: "rsc-routes-auto-loader-dev",
+    transform: async function(code, id) {
+      if (id !== routesFileId) {
+        return null;
+      }
+      if (pages.length === 0) {
+        return null;
+      }
+      const ext = path.extname(id);
+      const plugins = [];
+      if (ext === ".jsx") {
+        plugins.push("jsx");
+      }
+      const ast = babelParse(code, {
+        sourceType: "unambiguous",
+        plugins
+      });
+      const importedNames = /* @__PURE__ */ new Set();
+      const allImports = /* @__PURE__ */ new Map();
+      const wrappers = /* @__PURE__ */ new Set();
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const importPath = path2.node.source.value;
+          if (importPath === null) {
+            return;
+          }
+          const userImportRelativePath = getPathRelativeToSrc(
+            importStatementPath(importPath)
+          );
+          const defaultSpecifier = path2.node.specifiers.filter(
+            (specifier) => t.isImportDefaultSpecifier(specifier)
+          )[0];
+          if (userImportRelativePath && defaultSpecifier) {
+            importedNames.add(defaultSpecifier.local.name);
+          }
+          path2.node.specifiers.forEach((specifier) => {
+            allImports.set(specifier.local.name, path2.node);
+          });
+        },
+        JSXElement() {
+        },
+        CallExpression(path2) {
+          if ((t.isIdentifier(path2.node.callee, { name: "jsxs" }) || t.isIdentifier(path2.node.callee, { name: "jsx" })) && t.isIdentifier(path2.node.arguments[0]) && path2.node.arguments[0].name === "Set") {
+            const jsxArgs = path2.node.arguments;
+            if (t.isObjectExpression(jsxArgs[1])) {
+              const wrapProp = jsxArgs[1].properties.find(
+                (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key, { name: "wrap" })
+              );
+              if (t.isArrayExpression(wrapProp?.value)) {
+                wrapProp.value.elements.forEach((element) => {
+                  if (t.isIdentifier(element)) {
+                    wrappers.add(element.name);
+                  }
+                });
+              } else if (t.isIdentifier(wrapProp?.value)) {
+                wrappers.add(wrapProp.value.name);
+              }
+            }
+          }
+        }
+      });
+      const nonImportedPages = pages.filter(
+        (page) => !importedNames.has(page.importName)
+      );
+      wrappers.forEach((wrapper) => {
+        const wrapperImport = allImports.get(wrapper);
+        if (wrapperImport) {
+          wrapperImport.source.value = "@cedarjs/router/dist/dummyComponent";
+        }
+      });
+      for (const page of nonImportedPages) {
+        ast.program.body.unshift(
+          t.variableDeclaration("const", [
+            t.variableDeclarator(
+              t.identifier(page.constName),
+              t.arrowFunctionExpression([], t.nullLiteral())
+            )
+          ])
+        );
+      }
+      return generate(ast).code;
+    }
+  };
+}
+export {
+  rscRoutesAutoLoader
+};

package/dist/plugins/vite-plugin-rsc-routes-imports.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function rscRoutesImports(): Plugin;
+//# sourceMappingURL=vite-plugin-rsc-routes-imports.d.ts.map

package/dist/plugins/vite-plugin-rsc-routes-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-rsc-routes-imports.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-rsc-routes-imports.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AA2BlC,wBAAgB,gBAAgB,IAAI,MAAM,CAiGzC"}

package/dist/plugins/vite-plugin-rsc-routes-imports.js

@@ -0,0 +1,96 @@
+import path from "path";
+import babelGenerator from "@babel/generator";
+const { default: generate } = babelGenerator;
+import { parse as babelParse } from "@babel/parser/index.cjs";
+import babelTraverse from "@babel/traverse";
+const { default: traverse } = babelTraverse;
+import * as t from "@babel/types";
+import { normalizePath } from "vite";
+import {
+  ensurePosixPath,
+  getPaths,
+  importStatementPath,
+  processPagesDir
+} from "@cedarjs/project-config";
+const getPathRelativeToSrc = (maybeAbsolutePath) => {
+  if (!path.isAbsolute(maybeAbsolutePath)) {
+    return maybeAbsolutePath;
+  }
+  return `./${path.relative(getPaths().web.src, maybeAbsolutePath)}`;
+};
+const withRelativeImports = (page) => {
+  return {
+    ...page,
+    relativeImport: ensurePosixPath(getPathRelativeToSrc(page.importPath))
+  };
+};
+function rscRoutesImports() {
+  const routesFileId = normalizePath(getPaths().web.routes);
+  const pages = processPagesDir().map(withRelativeImports);
+  const duplicatePageImportNames = /* @__PURE__ */ new Set();
+  const sortedPageImportNames = pages.map((page) => page.importName).sort();
+  for (let i = 0; i < sortedPageImportNames.length - 1; i++) {
+    if (sortedPageImportNames[i + 1] === sortedPageImportNames[i]) {
+      duplicatePageImportNames.add(sortedPageImportNames[i]);
+    }
+  }
+  if (duplicatePageImportNames.size > 0) {
+    const pageNames = Array.from(duplicatePageImportNames).map((name) => `'${name}'`).join(", ");
+    throw new Error(
+      `Unable to find only a single file ending in 'Page.{js,jsx,ts,tsx}' in the following page directories: ${pageNames}`
+    );
+  }
+  return {
+    name: "rsc-routes-imports",
+    transform: async function(code, id) {
+      if (id !== routesFileId) {
+        return null;
+      }
+      if (pages.length === 0) {
+        return null;
+      }
+      const ext = path.extname(id);
+      const plugins = [];
+      if (ext === ".jsx") {
+        plugins.push("jsx");
+      }
+      const ast = babelParse(code, {
+        sourceType: "unambiguous",
+        plugins
+      });
+      const importedNames = /* @__PURE__ */ new Set();
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const importPath = path2.node.source.value;
+          if (importPath === null) {
+            return;
+          }
+          const userImportRelativePath = getPathRelativeToSrc(
+            importStatementPath(path2.node.source?.value)
+          );
+          const defaultSpecifier = path2.node.specifiers.filter(
+            (specifier) => t.isImportDefaultSpecifier(specifier)
+          )[0];
+          if (userImportRelativePath && defaultSpecifier) {
+            importedNames.add(defaultSpecifier.local.name);
+          }
+        }
+      });
+      const nonImportedPages = pages.filter((page) => {
+        return !importedNames.has(page.importName);
+      });
+      for (const page of nonImportedPages) {
+        ast.program.body.unshift(
+          t.importDeclaration(
+            [t.importDefaultSpecifier(t.identifier(page.importName))],
+            t.stringLiteral(page.importPath)
+          )
+        );
+      }
+      return generate(ast).code;
+    }
+  };
+}
+export {
+  rscRoutesImports
+};

package/dist/plugins/vite-plugin-rsc-ssr-router-import.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from 'vite';
+/**
+ * Transform `import { Router } from '@cedarjs/router/RscRouter'` to
+ * `import { Router } from '@cedarjs/router/SsrRouter'`
+ */
+export declare function rscSsrRouterImport(): Plugin;
+//# sourceMappingURL=vite-plugin-rsc-ssr-router-import.d.ts.map

package/dist/plugins/vite-plugin-rsc-ssr-router-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-rsc-ssr-router-import.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-rsc-ssr-router-import.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAKlC;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAqC3C"}

package/dist/plugins/vite-plugin-rsc-ssr-router-import.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import babelGenerator from "@babel/generator";
+const { default: generate } = babelGenerator;
+import { parse as babelParse } from "@babel/parser/index.cjs";
+import babelTraverse from "@babel/traverse";
+const { default: traverse } = babelTraverse;
+import * as t from "@babel/types";
+import { normalizePath } from "vite";
+import { getPaths } from "@cedarjs/project-config";
+function rscSsrRouterImport() {
+  const routesFileId = normalizePath(getPaths().web.routes);
+  return {
+    name: "rsc-ssr-router-import",
+    transform: async function(code, id) {
+      if (id !== routesFileId) {
+        return null;
+      }
+      const ext = path.extname(id);
+      const plugins = [];
+      if (ext === ".jsx") {
+        plugins.push("jsx");
+      }
+      const ast = babelParse(code, {
+        sourceType: "unambiguous",
+        plugins
+      });
+      traverse(ast, {
+        ImportDeclaration(path2) {
+          const source = path2.node.source.value;
+          if (source === "@cedarjs/router/RscRouter") {
+            path2.node.source = t.stringLiteral("@cedarjs/router/SsrRouter");
+          }
+        }
+      });
+      return generate(ast).code;
+    }
+  };
+}
+export {
+  rscSsrRouterImport
+};

package/dist/plugins/vite-plugin-rsc-transform-client.d.ts

@@ -0,0 +1,3 @@
+import { type Plugin } from 'vite';
+export declare function rscTransformUseClientPlugin(clientEntryFiles: Record<string, string>): Plugin;
+//# sourceMappingURL=vite-plugin-rsc-transform-client.d.ts.map

package/dist/plugins/vite-plugin-rsc-transform-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-rsc-transform-client.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-rsc-transform-client.ts"],"names":[],"mappings":"AAIA,OAAO,EAAiB,KAAK,MAAM,EAAE,MAAM,MAAM,CAAA;AAIjD,wBAAgB,2BAA2B,CACzC,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,CAoER"}

package/dist/plugins/vite-plugin-rsc-transform-client.js

@@ -0,0 +1,195 @@
+import path from "node:path";
+import * as acorn from "acorn-loose";
+import { normalizePath } from "vite";
+import { getPaths } from "@cedarjs/project-config";
+function rscTransformUseClientPlugin(clientEntryFiles) {
+  return {
+    name: "rsc-transform-use-client-plugin",
+    transform: async function(code, id) {
+      if (!code.includes("use client")) {
+        return code;
+      }
+      if (code.includes("$$id")) {
+        return code;
+      }
+      let body;
+      try {
+        body = acorn.parse(code, {
+          ecmaVersion: 2024,
+          sourceType: "module"
+        }).body;
+      } catch (x) {
+        console.error("Error parsing %s %s", id, x.message);
+        return code;
+      }
+      let useClient = false;
+      let useServer = false;
+      for (const node of body) {
+        if (node.type !== "ExpressionStatement" || !node.directive) {
+          break;
+        }
+        if (node.directive === "use client") {
+          useClient = true;
+        }
+        if (node.directive === "use server") {
+          useServer = true;
+        }
+      }
+      if (!useClient) {
+        return code;
+      }
+      if (useClient && useServer) {
+        throw new Error(
+          'Cannot have both "use client" and "use server" directives in the same file.'
+        );
+      }
+      const transformedCode = await transformClientModule(
+        code,
+        body,
+        id,
+        clientEntryFiles
+      );
+      return transformedCode;
+    }
+  };
+}
+function addExportNames(names, node) {
+  switch (node.type) {
+    case "Identifier":
+      names.push(node.name);
+      return;
+    case "ObjectPattern":
+      for (const property of node.properties) {
+        addExportNames(names, property);
+      }
+      return;
+    case "ArrayPattern":
+      for (const element of node.elements) {
+        if (element) {
+          addExportNames(names, element);
+        }
+      }
+      return;
+    case "Property":
+      addExportNames(names, node.value);
+      return;
+    case "AssignmentPattern":
+      addExportNames(names, node.left);
+      return;
+    case "RestElement":
+      addExportNames(names, node.argument);
+      return;
+    case "ParenthesizedExpression":
+      addExportNames(names, node.expression);
+      return;
+  }
+}
+async function parseExportNamesIntoNames(code, body, names) {
+  for (const node of body) {
+    switch (node.type) {
+      case "ExportAllDeclaration":
+        if (node.exported) {
+          addExportNames(names, node.exported);
+          continue;
+        } else {
+          let childBody;
+          try {
+            childBody = acorn.parse(code, {
+              ecmaVersion: 2024,
+              sourceType: "module"
+            }).body;
+          } catch (x) {
+            console.error("Error parsing %s %s", "", x.message);
+            continue;
+          }
+          await parseExportNamesIntoNames(code, childBody, names);
+          continue;
+        }
+      case "ExportDefaultDeclaration":
+        names.push("default");
+        continue;
+      case "ExportNamedDeclaration":
+        if (node.declaration) {
+          if (node.declaration.type === "VariableDeclaration") {
+            const declarations = node.declaration.declarations;
+            for (const declaration of declarations) {
+              addExportNames(names, declaration.id);
+            }
+          } else {
+            addExportNames(names, node.declaration.id);
+          }
+        }
+        if (node.specifiers) {
+          const specifiers = node.specifiers;
+          for (const specifier of specifiers) {
+            addExportNames(names, specifier.exported);
+          }
+        }
+        continue;
+      // For CJS support
+      case "ExpressionStatement": {
+        let assignmentExpression = null;
+        if (node.expression.type === "AssignmentExpression") {
+          assignmentExpression = node.expression;
+        } else if (node.expression.type === "LogicalExpression" && node.expression.right.type === "AssignmentExpression") {
+          assignmentExpression = node.expression.right;
+        }
+        if (!assignmentExpression) {
+          continue;
+        }
+        if (assignmentExpression.left.type !== "MemberExpression") {
+          continue;
+        }
+        if (assignmentExpression.left.object.type !== "Identifier") {
+          continue;
+        }
+        if (assignmentExpression.left.object.name === "exports" && assignmentExpression.left.property.type === "Identifier") {
+          if (!names.includes(assignmentExpression.left.property.name)) {
+            names.push(assignmentExpression.left.property.name);
+          }
+        } else if (assignmentExpression.left.object.name === "module" && assignmentExpression.left.property.type === "Identifier" && assignmentExpression.left.property.name === "exports" && assignmentExpression.right.type === "ObjectExpression") {
+          assignmentExpression.right.properties.forEach((property) => {
+            if (property.type === "Property" && property.key.type === "Identifier") {
+              if (!names.includes(property.key.name)) {
+                names.push(property.key.name);
+              }
+            }
+          });
+        }
+        continue;
+      }
+    }
+  }
+}
+async function transformClientModule(code, body, url, clientEntryFiles) {
+  const names = [];
+  await parseExportNamesIntoNames(code, body, names);
+  console.log("transformClientModule names", names);
+  const entryRecord = Object.entries(clientEntryFiles).find(
+    ([_key, value]) => value === url
+  );
+  const loadId = normalizePath(
+    entryRecord ? path.join(getPaths().web.distRsc, "assets", `${entryRecord[0]}.mjs`) : url
+  );
+  let newSrc = 'import {registerClientReference} from "react-server-dom-webpack/server";\n';
+  for (const name of names) {
+    if (name === "default") {
+      newSrc += "export default registerClientReference(function() {";
+      newSrc += "throw new Error(" + JSON.stringify(
+        "Attempted to call the default export of " + url + " from the server but it's on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component."
+      ) + ");";
+    } else {
+      newSrc += "export const " + name + " = ";
+      newSrc += "registerClientReference(function() {";
+      newSrc += "throw new Error(" + JSON.stringify(
+        "Attempted to call " + name + "() from the server but " + name + " is on the client. It's not possible to invoke a client function from the server, it can only be rendered as a Component or passed to props of a Client Component."
+      ) + ");";
+    }
+    newSrc += `},${JSON.stringify(loadId)},${JSON.stringify(name)})
+;`;
+  }
+  return newSrc;
+}
+export {
+  rscTransformUseClientPlugin
+};

package/dist/plugins/vite-plugin-rsc-transform-server.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function rscTransformUseServerPlugin(outDir: string, serverEntryFiles: Record<string, string>): Plugin;
+//# sourceMappingURL=vite-plugin-rsc-transform-server.d.ts.map

package/dist/plugins/vite-plugin-rsc-transform-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plugin-rsc-transform-server.d.ts","sourceRoot":"","sources":["../../src/plugins/vite-plugin-rsc-transform-server.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAElC,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACvC,MAAM,CA8GR"}