@cedarjs/internal 5.0.4-next.167 → 5.0.4

package/dist/cjs/build/api.js

@@ -0,0 +1,251 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+__export(api_exports, {
+  buildApi: () => buildApi,
+  buildApiWithVite: () => buildApiWithVite,
+  cleanApiBuild: () => cleanApiBuild,
+  fixSourceMaps: () => fixSourceMaps,
+  rebuildApi: () => rebuildApi
+});
+module.exports = __toCommonJS(api_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_esbuild = require("esbuild");
+var import_vite = require("vite");
+var import_babel_config = require("@cedarjs/babel-config");
+var import_project_config = require("@cedarjs/project-config");
+var import_files = require("../files.js");
+var import_esbuild_plugin_cedar_context_wrapping = require("./esbuild-plugin-cedar-context-wrapping.js");
+let BUILD_CTX = null;
+const buildApi = async () => {
+  BUILD_CTX?.dispose();
+  BUILD_CTX = null;
+  return transpileApi((0, import_files.findApiFiles)());
+};
+const rebuildApi = async () => {
+  const apiFiles = (0, import_files.findApiFiles)();
+  if (!BUILD_CTX) {
+    BUILD_CTX = await (0, import_esbuild.context)(getEsbuildOptions(apiFiles));
+  }
+  const result = await BUILD_CTX.rebuild();
+  const cedarPaths = (0, import_project_config.getPaths)();
+  await fixSourceMaps(cedarPaths.api.dist, cedarPaths.api.src);
+  return result;
+};
+const cleanApiBuild = async () => {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  return import_node_fs.default.promises.rm(cedarPaths.api.dist, { recursive: true, force: true });
+};
+const runCedarBabelTransformsPlugin = {
+  name: "cedar-esbuild-babel-transform",
+  setup(build2) {
+    const cedarConfig = (0, import_project_config.getConfig)();
+    build2.onLoad({ filter: /\.(js|ts|tsx|jsx)$/ }, async (args) => {
+      const fileContents = await import_node_fs.default.promises.readFile(args.path, "utf-8");
+      const transformedCode = await (0, import_babel_config.transformWithBabel)(
+        fileContents,
+        args.path,
+        (0, import_babel_config.getApiSideBabelPlugins)({
+          openTelemetry: cedarConfig.experimental.opentelemetry.enabled && cedarConfig.experimental.opentelemetry.wrapApi,
+          projectIsEsm: (0, import_project_config.projectSideIsEsm)("api")
+        })
+      );
+      if (transformedCode?.code) {
+        const functionsDir = (0, import_vite.normalizePath)(
+          import_node_path.default.join((0, import_project_config.getPaths)().api.src, "functions")
+        );
+        const code = (0, import_vite.normalizePath)(args.path).startsWith(functionsDir + "/") ? (0, import_esbuild_plugin_cedar_context_wrapping.applyContextWrapping)(transformedCode.code, {
+          projectIsEsm: (0, import_project_config.projectSideIsEsm)("api")
+        }) ?? transformedCode.code : transformedCode.code;
+        return {
+          contents: code,
+          loader: "js"
+        };
+      }
+      throw new Error(`Could not transform file: ${args.path}`);
+    });
+  }
+};
+function createCedarViteApiPlugin() {
+  const cedarConfig = (0, import_project_config.getConfig)();
+  const isEsm = (0, import_project_config.projectSideIsEsm)("api");
+  return {
+    name: "cedar-vite-api-babel-transform",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!/\.(js|ts|tsx|jsx)$/.test(id)) {
+        return null;
+      }
+      if (id.includes("node_modules")) {
+        return null;
+      }
+      const cedarPaths = (0, import_project_config.getPaths)();
+      if (!(0, import_vite.normalizePath)(id).startsWith((0, import_vite.normalizePath)(cedarPaths.api.base))) {
+        return null;
+      }
+      const transformedCode = await (0, import_babel_config.transformWithBabel)(
+        code,
+        id,
+        (0, import_babel_config.getApiSideBabelPlugins)({
+          openTelemetry: cedarConfig.experimental.opentelemetry.enabled && cedarConfig.experimental.opentelemetry.wrapApi,
+          projectIsEsm: isEsm
+        }),
+        true
+      );
+      if (transformedCode?.code) {
+        const functionsDir = (0, import_vite.normalizePath)(
+          import_node_path.default.join(cedarPaths.api.src, "functions")
+        );
+        const code2 = (0, import_vite.normalizePath)(id).startsWith(functionsDir + "/") ? (0, import_esbuild_plugin_cedar_context_wrapping.applyContextWrapping)(transformedCode.code, {
+          projectIsEsm: isEsm
+        }) ?? transformedCode.code : transformedCode.code;
+        return {
+          code: code2,
+          map: transformedCode.map ?? null
+        };
+      }
+      throw new Error(`Could not transform file: ${id}`);
+    }
+  };
+}
+const buildApiWithVite = async () => {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const isEsm = (0, import_project_config.projectSideIsEsm)("api");
+  const format = isEsm ? "es" : "cjs";
+  const apiFiles = (0, import_files.findApiFiles)();
+  const input = {};
+  for (const f of apiFiles) {
+    const key = import_node_path.default.relative(cedarPaths.api.src, f).replace(/\.(ts|tsx|mts|js|jsx|mjs)$/, "");
+    input[key] = f;
+  }
+  return (0, import_vite.build)({
+    root: cedarPaths.api.base,
+    logLevel: "warn",
+    build: {
+      ssr: true,
+      sourcemap: true,
+      outDir: cedarPaths.api.dist,
+      rollupOptions: {
+        input,
+        output: {
+          format,
+          preserveModules: true,
+          preserveModulesRoot: cedarPaths.api.src,
+          entryFileNames: "[name].js",
+          // Directives (and other entry modules) intentionally use both named
+          // and default exports (e.g. `export const schema` + `export default`).
+          // Tell Rollup to expect this so it doesn't warn about mixed exports.
+          exports: "named"
+        },
+        external: (id) => {
+          if (id.startsWith("node:")) {
+            return true;
+          }
+          if (!id.startsWith(".") && !import_node_path.default.isAbsolute(id)) {
+            return true;
+          }
+          return false;
+        }
+      }
+    },
+    plugins: [createCedarViteApiPlugin()]
+  });
+};
+const transpileApi = async (files) => {
+  const result = await (0, import_esbuild.build)(getEsbuildOptions(files));
+  const cedarPaths = (0, import_project_config.getPaths)();
+  await fixSourceMaps(cedarPaths.api.dist, cedarPaths.api.src);
+  return result;
+};
+async function fixSourceMaps(distDir, srcDir) {
+  let entries;
+  try {
+    entries = await import_node_fs.default.promises.readdir(distDir, {
+      recursive: true,
+      withFileTypes: true
+    });
+  } catch {
+    return;
+  }
+  const mapFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".js.map")).map((e) => import_node_path.default.join(e.parentPath ?? e.path, e.name));
+  await Promise.all(
+    mapFiles.map(async (mapFile) => {
+      try {
+        const raw = await import_node_fs.default.promises.readFile(mapFile, "utf8");
+        const map = JSON.parse(raw);
+        if (!Array.isArray(map.sources) || map.sources.length === 0) {
+          return;
+        }
+        const jsFile = mapFile.slice(0, -4);
+        const baseName = import_node_path.default.relative(distDir, jsFile).replace(/\.js$/, "");
+        const srcFile = [".ts", ".tsx", ".jsx", ".js"].map((ext) => import_node_path.default.join(srcDir, baseName + ext)).find((f) => import_node_fs.default.existsSync(f));
+        if (!srcFile) {
+          return;
+        }
+        const correctRelPath = (0, import_vite.normalizePath)(
+          import_node_path.default.relative(import_node_path.default.dirname(mapFile), srcFile)
+        );
+        if (map.sources[0] === correctRelPath) {
+          return;
+        }
+        map.sources = [correctRelPath];
+        await import_node_fs.default.promises.writeFile(mapFile, JSON.stringify(map), "utf8");
+      } catch {
+      }
+    })
+  );
+}
+function getEsbuildOptions(files) {
+  const cedarPaths = (0, import_project_config.getPaths)();
+  const format = (0, import_project_config.projectSideIsEsm)("api") ? "esm" : "cjs";
+  return {
+    absWorkingDir: cedarPaths.api.base,
+    entryPoints: files,
+    platform: "node",
+    target: "node24",
+    format,
+    allowOverwrite: true,
+    bundle: false,
+    plugins: [runCedarBabelTransformsPlugin],
+    outdir: cedarPaths.api.dist,
+    // setting this to 'true' will generate an external sourcemap x.js.map
+    // AND set the sourceMappingURL comment
+    // (setting it to 'external' will ONLY generate the file, but won't add the comment)
+    sourcemap: true
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildApi,
+  buildApiWithVite,
+  cleanApiBuild,
+  fixSourceMaps,
+  rebuildApi
+});

package/dist/cjs/build/esbuild-plugin-cedar-context-wrapping.d.ts

@@ -0,0 +1,4 @@
+export declare function applyContextWrapping(code: string, { projectIsEsm }?: {
+    projectIsEsm?: boolean;
+}): string | null;
+//# sourceMappingURL=esbuild-plugin-cedar-context-wrapping.d.ts.map

package/dist/cjs/build/esbuild-plugin-cedar-context-wrapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-plugin-cedar-context-wrapping.d.ts","sourceRoot":"","sources":["../../../src/build/esbuild-plugin-cedar-context-wrapping.ts"],"names":[],"mappings":"AAOA,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,EAAE,YAAoB,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACxD,MAAM,GAAG,IAAI,CA0Cf"}

package/dist/cjs/build/esbuild-plugin-cedar-context-wrapping.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var esbuild_plugin_cedar_context_wrapping_exports = {};
+__export(esbuild_plugin_cedar_context_wrapping_exports, {
+  applyContextWrapping: () => applyContextWrapping
+});
+module.exports = __toCommonJS(esbuild_plugin_cedar_context_wrapping_exports);
+function applyContextWrapping(code, { projectIsEsm = false } = {}) {
+  const handlerRe = /^export\s+(?:const|let|var)\s+handler(?:[^=]|=>)*?=(?![>=])/m;
+  const handlerMatch = handlerRe.exec(code);
+  if (!handlerMatch) {
+    return null;
+  }
+  const afterEquals = code.slice(handlerMatch.index + handlerMatch[0].length).trimStart();
+  const isAsync = /^async(?:\s*[\(\*]|\s+function)/.test(afterEquals);
+  const storePath = projectIsEsm ? "@cedarjs/context/dist/store.js" : "@cedarjs/context/dist/store";
+  const importStatement = `import { getAsyncStoreInstance as __rw_getAsyncStoreInstance } from '${storePath}'
+`;
+  const handlerStart = handlerMatch.index;
+  const before = code.slice(0, handlerStart);
+  const after = code.slice(handlerStart);
+  const renamed = after.replace(handlerRe, "const __rw_handler =");
+  const wrappedHandler = `
+export const handler = ${isAsync ? "async " : ""}(__rw_event, __rw__context) => {
+  // The store will be undefined if no context isolation has been performed yet
+  const __rw_contextStore = __rw_getAsyncStoreInstance().getStore()
+  if (__rw_contextStore === undefined) {
+    return __rw_getAsyncStoreInstance().run(
+      new Map(),
+      __rw_handler,
+      __rw_event,
+      __rw__context
+    )
+  }
+  return __rw_handler(__rw_event, __rw__context)
+}
+`;
+  return before + importStatement + renamed + wrappedHandler;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyContextWrapping
+});

package/dist/cjs/cliLogger.d.ts

@@ -0,0 +1,11 @@
+type CLog = (typeof console)['log'];
+/**
+ * An alternative to createLogger which supports the same logging levels
+ * but allows for full ANSI when printing to the console.
+ */
+export declare const cliLogger: CLog & {
+    trace: CLog;
+    debug: CLog;
+};
+export {};
+//# sourceMappingURL=cliLogger.d.ts.map

package/dist/cjs/cliLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cliLogger.d.ts","sourceRoot":"","sources":["../../src/cliLogger.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,CAAC,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,IAAI,GAAG;IAC7B,KAAK,EAAE,IAAI,CAAA;IACX,KAAK,EAAE,IAAI,CAAA;CAGZ,CAAA"}

package/dist/cjs/cliLogger.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cliLogger_exports = {};
+__export(cliLogger_exports, {
+  cliLogger: () => cliLogger
+});
+module.exports = __toCommonJS(cliLogger_exports);
+var import_logger = require("@cedarjs/api/logger");
+const logLevel = import_logger.defaultLoggerOptions.level;
+const cliLogger = function(...data) {
+  console.log(...data);
+};
+cliLogger.trace = logLevel === "trace" ? console.log : () => {
+};
+cliLogger.debug = logLevel === "trace" || logLevel === "debug" ? console.log : () => {
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cliLogger
+});

package/dist/cjs/dev.d.ts

@@ -0,0 +1,2 @@
+export declare const shutdownPort: (port: number, method?: "tcp" | "udp") => Promise<void>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/cjs/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/dev.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,SAAQ,KAAK,GAAG,KAAa,kBAEvE,CAAA"}

package/dist/cjs/dev.js

@@ -0,0 +1,41 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dev_exports = {};
+__export(dev_exports, {
+  shutdownPort: () => shutdownPort
+});
+module.exports = __toCommonJS(dev_exports);
+var import_kill_port = __toESM(require("kill-port"), 1);
+const shutdownPort = (port, method = "tcp") => {
+  return (0, import_kill_port.default)(port, method);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shutdownPort
+});

package/dist/cjs/files.d.ts

@@ -0,0 +1,56 @@
+import { type Options as FastGlobOptions } from 'fast-glob';
+export declare const findCells: (cwd?: string) => string[];
+export declare const findPages: (cwd?: string) => string[];
+/**
+ * This function finds all modules in the 'web' and 'api' directories excluding 'node_modules' and Cell files.
+ * Cell files are also directory named modules but they have their special type mirror file, so they are ignored.
+ *
+ * @param {string} cwd - The directory path to start searching from. By default, it is the base path of the project.
+ * @returns {Array} modules - An array of absolute paths for the found modules.
+ *
+ * @example
+ * // Assuming the base directory of your project is '/Users/user/myproject'
+ * findDirectoryNamedModules('/Users/user/myproject');
+ * // This will return an array with the absolute paths of all matching files, e.g.:
+ * // ['/Users/user/myproject/web/src/components/Author/Author.tsx', '/Users/user/myproject/web/src/pages/AboutPage/AboutPage.tsx']
+ */
+export declare const findDirectoryNamedModules: (cwd?: string) => string[];
+export declare const findGraphQLSchemas: (cwd?: string) => string[];
+export declare const findApiFiles: (cwd?: string) => string[];
+export declare const findWebFiles: (cwd?: string) => string[];
+export declare const findApiServerFunctions: (cwd?: string) => string[];
+export declare const findApiDistFunctions: (params: {
+    cwd: string;
+    options?: FastGlobOptions;
+    discoverFunctionsGlob?: string | string[];
+}) => string[];
+export declare const findRouteHooksSrc: (cwd?: string) => string[];
+export declare const isCellFile: (p: string) => boolean;
+export declare const findScripts: (cwd?: string) => string[];
+export declare const isPageFile: (p: string) => boolean;
+/**
+ * This function checks if the given path belongs to a directory named module.
+ * A directory named module is where the filename (without extension) is the same as the directory it is in.
+ *
+ * @param {string} p - The absolute path of the file.
+ * @returns {boolean} - Returns true if the path belongs to a directory named module, false otherwise.
+ *
+ * @example
+ * isDirectoryNamedModuleFile('/Users/user/myproject/web/src/components/Author/Author.tsx');
+ * // Returns: true
+ *
+ * isDirectoryNamedModuleFile('/Users/user/myproject/web/src/components/Author/AuthorInfo.tsx');
+ * // Returns: false
+ */
+export declare const isDirectoryNamedModuleFile: (p: string) => boolean;
+export declare const isGraphQLSchemaFile: (p: string) => boolean;
+/**
+ * The following patterns are supported for api functions:
+ *
+ * 1. a module at the top level: `/graphql.js`
+ * 2. a module in a folder with a module of the same name: `/health/health.js`
+ * 3. a module in a folder named index: `/x/index.js`
+ */
+export declare const isApiFunction: (p: string, functionsPath: string) => boolean;
+export declare const isFileInsideFolder: (filePath: string, folderPath: string) => boolean;
+//# sourceMappingURL=files.d.ts.map

package/dist/cjs/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../src/files.ts"],"names":[],"mappings":"AAEA,OAAW,EAAE,KAAK,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAA;AAM/D,eAAO,MAAM,SAAS,GAAI,MAAK,MAA2B,aAOzD,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,MAAK,MAA6B,aAQ3D,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,GAAI,MAAK,MAAwB,aAUtE,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAK,MAA+B,aAItE,CAAA;AASD,eAAO,MAAM,YAAY,GAAI,MAAK,MAA2B,aAO5D,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,MAAK,MAA2B,aAY5D,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,MAAK,MAAiC,aAUvC,CAAA;AAKD,eAAO,MAAM,oBAAoB,GAAI,QAAQ;IAC3C,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,eAAe,CAAA;IACzB,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;CAC1C,aAcA,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,MAAK,MAA2B,aAKjE,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,GAAG,MAAM,YA6BnC,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,MAAK,MAA2B,aAM3D,CAAA;AAED,eAAO,MAAM,UAAU,GAAI,GAAG,MAAM,YAoBnC,CAAA;AACD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,0BAA0B,GAAI,GAAG,MAAM,YAGnD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,GAAG,MAAM,YAQ5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,GAAG,MAAM,EAAE,eAAe,MAAM,YAc7D,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,UAAU,MAAM,EAAE,YAAY,MAAM,YAYtE,CAAA"}