@cedarjs/internal 5.0.4-next.167 → 5.0.4

package/dist/cjs/files.js

@@ -0,0 +1,230 @@
+"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 files_exports = {};
+__export(files_exports, {
+  findApiDistFunctions: () => findApiDistFunctions,
+  findApiFiles: () => findApiFiles,
+  findApiServerFunctions: () => findApiServerFunctions,
+  findCells: () => findCells,
+  findDirectoryNamedModules: () => findDirectoryNamedModules,
+  findGraphQLSchemas: () => findGraphQLSchemas,
+  findPages: () => findPages,
+  findRouteHooksSrc: () => findRouteHooksSrc,
+  findScripts: () => findScripts,
+  findWebFiles: () => findWebFiles,
+  isApiFunction: () => isApiFunction,
+  isCellFile: () => isCellFile,
+  isDirectoryNamedModuleFile: () => isDirectoryNamedModuleFile,
+  isFileInsideFolder: () => isFileInsideFolder,
+  isGraphQLSchemaFile: () => isGraphQLSchemaFile,
+  isPageFile: () => isPageFile
+});
+module.exports = __toCommonJS(files_exports);
+var import_path = __toESM(require("path"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_ast = require("./ast.js");
+const findCells = (cwd = (0, import_project_config.getPaths)().web.src) => {
+  const modules = import_fast_glob.default.sync("**/*Cell.{js,jsx,ts,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+  return modules.filter(isCellFile);
+};
+const findPages = (cwd = (0, import_project_config.getPaths)().web.pages) => {
+  const modules = import_fast_glob.default.sync("**/*Page.{tsx,js,jsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+  return modules.filter(isPageFile);
+};
+const findDirectoryNamedModules = (cwd = (0, import_project_config.getPaths)().base) => {
+  const modules = import_fast_glob.default.sync("(api|web)/src/**/*.{ts,js,jsx,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+  return modules.filter(isDirectoryNamedModuleFile).filter((p) => !isCellFile(p));
+};
+const findGraphQLSchemas = (cwd = (0, import_project_config.getPaths)().api.graphql) => {
+  return import_fast_glob.default.sync("**/*.sdl.{ts,js}", { cwd, absolute: true }).filter(isGraphQLSchemaFile);
+};
+const ignoreApiFiles = [
+  "**/*.test.{js,ts}",
+  "**/*.scenarios.{js,ts}",
+  "**/*.fixtures.{js,ts}",
+  "**/*.d.ts"
+];
+const findApiFiles = (cwd = (0, import_project_config.getPaths)().api.src) => {
+  const files = import_fast_glob.default.sync("**/*.{js,ts,jsx,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ignoreApiFiles
+  });
+  return files;
+};
+const findWebFiles = (cwd = (0, import_project_config.getPaths)().web.src) => {
+  const files = import_fast_glob.default.sync("**/*.{js,ts,jsx,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: [
+      "**/*.test.{js,ts,tsx,jsx}",
+      "**/*.fixtures.{js,ts,tsx,jsx}",
+      "**/*.mock.{js,ts,tsx,jsx}",
+      "**/*.d.ts"
+    ]
+  });
+  return files;
+};
+const findApiServerFunctions = (cwd = (0, import_project_config.getPaths)().api.functions) => {
+  const files = import_fast_glob.default.sync("**/*.{js,ts}", {
+    cwd,
+    absolute: true,
+    deep: 2,
+    // We don't support deeply nested api functions.
+    ignore: ignoreApiFiles
+  });
+  return files.filter((f) => isApiFunction(f, cwd));
+};
+const findApiDistFunctions = (params) => {
+  const {
+    cwd = (0, import_project_config.getPaths)().api.base,
+    options = {},
+    discoverFunctionsGlob = "dist/functions/**/*.{ts,js}"
+  } = params;
+  return import_fast_glob.default.sync(discoverFunctionsGlob, {
+    cwd,
+    // We don't support deeply nested api functions, to maximise compatibility
+    // with deployment providers
+    deep: 2,
+    absolute: true,
+    ...options
+  });
+};
+const findRouteHooksSrc = (cwd = (0, import_project_config.getPaths)().web.src) => {
+  return import_fast_glob.default.sync("**/*.routeHooks.{js,ts,tsx,jsx}", {
+    absolute: true,
+    cwd
+  });
+};
+const isCellFile = (p) => {
+  const { dir, name } = import_path.default.parse(p);
+  if (!isFileInsideFolder(p, (0, import_project_config.getPaths)().web.src)) {
+    return false;
+  }
+  if (!dir.endsWith(name)) {
+    return false;
+  }
+  const ast = (0, import_ast.fileToAst)(p);
+  if ((0, import_ast.hasDefaultExport)(ast)) {
+    return false;
+  }
+  const exports2 = (0, import_ast.getNamedExports)(ast);
+  const exportedQUERY = exports2.findIndex((v) => v.name === "QUERY") !== -1;
+  const exportedSuccess = exports2.findIndex((v) => v.name === "Success") !== -1;
+  if (!exportedQUERY && !exportedSuccess) {
+    return false;
+  }
+  return true;
+};
+const findScripts = (cwd = (0, import_project_config.getPaths)().scripts) => {
+  return import_fast_glob.default.sync("./**/*.{js,jsx,ts,tsx}", {
+    cwd,
+    absolute: true,
+    ignore: ["node_modules"]
+  });
+};
+const isPageFile = (p) => {
+  const { name } = import_path.default.parse(p);
+  if (!name.endsWith("Page")) {
+    return false;
+  }
+  if (!isFileInsideFolder(p, (0, import_project_config.getPaths)().web.pages)) {
+    return false;
+  }
+  const ast = (0, import_ast.fileToAst)(p);
+  if (!(0, import_ast.hasDefaultExport)(ast)) {
+    return false;
+  }
+  return true;
+};
+const isDirectoryNamedModuleFile = (p) => {
+  const { dir, name } = import_path.default.parse(p);
+  return dir.endsWith(name);
+};
+const isGraphQLSchemaFile = (p) => {
+  if (!p.match(/\.sdl\.(ts|js)$/)?.[0]) {
+    return false;
+  }
+  const ast = (0, import_ast.fileToAst)(p);
+  const exports2 = (0, import_ast.getNamedExports)(ast);
+  return exports2.findIndex((v) => v.name === "schema") !== -1;
+};
+const isApiFunction = (p, functionsPath) => {
+  p = import_path.default.relative(functionsPath, p);
+  const { dir, name } = import_path.default.parse(p);
+  if (dir === name) {
+    return true;
+  } else if (dir === "") {
+    return true;
+  } else if (dir.length && name === "index") {
+    return true;
+  }
+  return false;
+};
+const isFileInsideFolder = (filePath, folderPath) => {
+  const { dir } = import_path.default.parse(filePath);
+  const relativePathFromFolder = import_path.default.relative(folderPath, dir);
+  if (!relativePathFromFolder || relativePathFromFolder.startsWith("..") || import_path.default.isAbsolute(relativePathFromFolder)) {
+    return false;
+  } else {
+    return true;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findApiDistFunctions,
+  findApiFiles,
+  findApiServerFunctions,
+  findCells,
+  findDirectoryNamedModules,
+  findGraphQLSchemas,
+  findPages,
+  findRouteHooksSrc,
+  findScripts,
+  findWebFiles,
+  isApiFunction,
+  isCellFile,
+  isDirectoryNamedModuleFile,
+  isFileInsideFolder,
+  isGraphQLSchemaFile,
+  isPageFile
+});

package/dist/cjs/generate/clientPreset.d.ts

@@ -0,0 +1,17 @@
+export declare const shouldGenerateTrustedDocuments: () => boolean;
+export declare const generateClientPreset: () => Promise<{
+    clientPresetFiles: string[];
+    trustedDocumentsStoreFile: never[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+} | {
+    clientPresetFiles: string[];
+    trustedDocumentsStoreFile: string;
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+//# sourceMappingURL=clientPreset.d.ts.map

package/dist/cjs/generate/clientPreset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientPreset.d.ts","sourceRoot":"","sources":["../../../src/generate/clientPreset.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,8BAA8B,QAAO,OAIjD,CAAA;AAED,eAAO,MAAM,oBAAoB;;;;iBAGN,MAAM;eAAS,OAAO;;;;;;iBAAtB,MAAM;eAAS,OAAO;;EAoDhD,CAAA"}

package/dist/cjs/generate/clientPreset.js

@@ -0,0 +1,84 @@
+"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 clientPreset_exports = {};
+__export(clientPreset_exports, {
+  generateClientPreset: () => generateClientPreset,
+  shouldGenerateTrustedDocuments: () => shouldGenerateTrustedDocuments
+});
+module.exports = __toCommonJS(clientPreset_exports);
+var import_cli = require("@graphql-codegen/cli");
+var import_client_preset = require("@graphql-codegen/client-preset");
+var import_project_config = require("@cedarjs/project-config");
+var import_trustedDocuments = require("./trustedDocuments.js");
+const shouldGenerateTrustedDocuments = () => {
+  const config = (0, import_project_config.getConfig)();
+  return config.graphql.trustedDocuments;
+};
+const generateClientPreset = async () => {
+  let clientPresetFiles = [];
+  const errors = [];
+  if (!shouldGenerateTrustedDocuments()) {
+    return { clientPresetFiles, trustedDocumentsStoreFile: [], errors };
+  }
+  const documentsGlob = `${(0, import_project_config.getPaths)().web.src}/**/!(*.d).{ts,tsx,js,jsx}`;
+  const config = {
+    schema: (0, import_project_config.getPaths)().generated.schema,
+    documents: documentsGlob,
+    silent: true,
+    // Plays nicely with cli task output
+    generates: {
+      [`${(0, import_project_config.getPaths)().web.src}/graphql/`]: {
+        preset: "client",
+        presetConfig: {
+          persistedDocuments: true
+        },
+        documentTransforms: [import_client_preset.addTypenameSelectionDocumentTransform],
+        config: {
+          // DO NOT USE documentMode: 'string',
+        }
+      }
+    }
+  };
+  try {
+    const generatedFiles = await (0, import_cli.generate)(config, true);
+    clientPresetFiles = generatedFiles.map((f) => f.filename);
+    const trustedDocumentsStoreFile = await (0, import_trustedDocuments.trustedDocumentsStore)(generatedFiles);
+    (0, import_trustedDocuments.replaceGqlTagWithTrustedDocumentGraphql)(generatedFiles);
+    return {
+      clientPresetFiles,
+      trustedDocumentsStoreFile,
+      errors
+    };
+  } catch (e) {
+    errors.push({
+      message: "Error: Could not generate GraphQL client preset",
+      error: e
+    });
+    return {
+      clientPresetFiles,
+      trustedDocumentsStoreFile: [],
+      errors
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateClientPreset,
+  shouldGenerateTrustedDocuments
+});

package/dist/cjs/generate/generate.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+export declare const generate: () => Promise<{
+    files: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+export declare const run: () => Promise<void>;
+//# sourceMappingURL=generate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/generate/generate.ts"],"names":[],"mappings":";AAWA,eAAO,MAAM,QAAQ;;;;;;EA2CpB,CAAA;AAED,eAAO,MAAM,GAAG,qBAoCf,CAAA"}

package/dist/cjs/generate/generate.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+"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 generate_exports = {};
+__export(generate_exports, {
+  generate: () => generate,
+  run: () => run
+});
+module.exports = __toCommonJS(generate_exports);
+var import_loadEnvFiles = require("@cedarjs/cli-helpers/loadEnvFiles");
+var import_project_config = require("@cedarjs/project-config");
+var import_clientPreset = require("./clientPreset.js");
+var import_gqlormSchema = require("./gqlormSchema.js");
+var import_graphqlSchema = require("./graphqlSchema.js");
+var import_possibleTypes = require("./possibleTypes.js");
+var import_typeDefinitions = require("./typeDefinitions.js");
+const generate = async () => {
+  const config = (0, import_project_config.getConfig)();
+  const { schemaPath, errors: generateGraphQLSchemaErrors } = await (0, import_graphqlSchema.generateGraphQLSchema)();
+  const { typeDefFiles, errors: generateTypeDefsErrors } = await (0, import_typeDefinitions.generateTypeDefs)();
+  const clientPresetFiles = [];
+  const { possibleTypesFiles, errors: generatePossibleTypesErrors } = await (0, import_possibleTypes.generatePossibleTypes)();
+  const { files: gqlormFiles, errors: gqlormErrors } = await (0, import_gqlormSchema.generateGqlormArtifacts)();
+  if (config.graphql.trustedDocuments) {
+    const preset = await (0, import_clientPreset.generateClientPreset)();
+    clientPresetFiles.push(...preset.clientPresetFiles);
+  }
+  let files = [];
+  if (schemaPath !== "") {
+    files.push(schemaPath);
+  }
+  files = [
+    ...files,
+    ...typeDefFiles,
+    ...clientPresetFiles,
+    ...possibleTypesFiles,
+    ...gqlormFiles
+  ].filter((x) => typeof x === "string");
+  return {
+    files,
+    errors: [
+      ...generateGraphQLSchemaErrors,
+      ...generateTypeDefsErrors,
+      ...generatePossibleTypesErrors,
+      ...gqlormErrors
+    ]
+  };
+};
+const run = async () => {
+  (0, import_loadEnvFiles.loadEnvFiles)();
+  console.log("Generating...");
+  console.log();
+  const { files, errors } = await generate();
+  const rwjsPaths = (0, import_project_config.getPaths)();
+  for (const f of files) {
+    console.log("-", f.replace(rwjsPaths.base + "/", ""));
+  }
+  console.log();
+  if (errors.length === 0) {
+    console.log("... done.");
+    console.log();
+    return;
+  }
+  process.exitCode ||= 1;
+  console.log("... done with errors.");
+  console.log();
+  for (const { message, error } of errors) {
+    console.error(message);
+    console.log();
+    console.error(error);
+    console.log();
+  }
+};
+if (process.env.NODE_ENV !== "test" && process.argv[1]?.endsWith("generate.js")) {
+  run();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generate,
+  run
+});

package/dist/cjs/generate/gqlormSchema.d.ts

@@ -0,0 +1,113 @@
+import type * as DMMF from '@prisma/dmmf';
+type ModelSchema = Record<string, string[]>;
+interface FrontendFieldInfo {
+    name: string;
+    tsType: string;
+}
+interface FrontendModelInfo {
+    modelName: string;
+    camelName: string;
+    fields: FrontendFieldInfo[];
+}
+export interface BackendFieldInfo {
+    name: string;
+    graphqlType: string;
+    isRequired: boolean;
+    isId: boolean;
+    hasDefaultValue: boolean;
+    isUpdatedAt: boolean;
+}
+export interface BackendModelInfo {
+    modelName: string;
+    camelName: string;
+    pluralName: string;
+    fields: BackendFieldInfo[];
+    idField: BackendFieldInfo | undefined;
+}
+export interface GqlormBackendConfig {
+    membershipModel: string;
+    membershipModelCamel: string;
+    membershipUserField: string;
+    membershipOrganizationField: string;
+    membershipModelExists: boolean;
+}
+/**
+ * Map a DMMF field type to its GraphQL SDL equivalent.
+ *
+ * Enum fields (kind === 'enum') are mapped to String. Unknown scalar types
+ * fall back to String.
+ */
+export declare function mapDmmfTypeToGraphql(type: string, kind: string): string;
+export declare function buildFrontendModelInfo(dmmf: DMMF.Document): FrontendModelInfo[];
+export declare function generateWebGqlormModelsContent(models: FrontendModelInfo[]): string;
+/**
+ * Build a ModelSchema from a Prisma DMMF document.
+ *
+ * This is a pure function with no I/O — it can be called directly in tests
+ * with a mock DMMF object.
+ */
+export declare function buildModelSchema(dmmf: DMMF.Document): ModelSchema;
+/**
+ * Build enriched model information from the DMMF, applying the same visibility
+ * rules as `buildModelSchema()` but also collecting type, nullability, and
+ * @id flag per field.
+ *
+ * **Note:** This function silently excludes sensitive fields without emitting
+ * warnings. It is designed to run after `buildModelSchema()` (which emits the
+ * warnings). In `generateGqlormArtifacts()` the call order is guaranteed, but
+ * callers using this function standalone should be aware that no warnings will
+ * be printed for auto-hidden sensitive fields.
+ *
+ * This is a pure function — safe for testing.
+ */
+export declare function buildBackendModelInfo(dmmf: DMMF.Document): BackendModelInfo[];
+/**
+ * Scan all SDL files in the given directory and return the set of GraphQL type
+ * names that are already defined by user-authored SDLs.
+ *
+ * This prevents gqlorm from generating duplicate type definitions that would
+ * cause merge conflicts in `makeMergedSchema`.
+ */
+export declare function getExistingSdlTypeNames(graphqlDir: string): Set<string>;
+/**
+ * Generate the full TypeScript source for `.cedar/gqlorm/backend.ts`.
+ *
+ * The generated file exports:
+ * - `schema`: a gql DocumentNode with type defs and Query fields
+ * - `createGqlormResolvers(db: GqlormDb)`: a factory function that takes a
+ *   Prisma client-like object and returns a resolvers object
+ *
+ * The file does NOT import `db` directly. Instead, the Babel inject plugin
+ * imports `db` from `src/lib/db` in `graphql.ts` (where that alias resolves
+ * correctly) and passes it to `createGqlormResolvers`.
+ *
+ * The generated `GqlormDb` interface is scoped to exactly the visible models
+ * and fields — no hidden/sensitive fields, no @gqlorm hide models, no
+ * dependency on the generated Prisma client path or @prisma/client.
+ */
+export declare function generateGqlormBackendContent(models: BackendModelInfo[], config?: GqlormBackendConfig): string;
+/**
+ * Generate gqlorm artifacts from the Prisma schema.
+ *
+ * Reads the project's Prisma schema via DMMF, applies visibility rules
+ * (@gqlorm directives + sensitivity heuristics), and writes:
+ *
+ * 1. `.cedar/gqlorm-schema.json` — the frontend ModelSchema (field names only)
+ * 2. `.cedar/gqlorm/backend.ts` — auto-generated GraphQL types and resolvers
+ *    for models that don't already have manually-written SDL files
+ *
+ * Cedar targets Node.js 24, which strips TypeScript types natively without any
+ * flags, so backend.ts can be imported directly at runtime
+ *
+ * Returns the same `{ files, errors }` shape used by other generators so it
+ * can be integrated into `generate.ts` without special handling.
+ */
+export declare function generateGqlormArtifacts(): Promise<{
+    files: string[];
+    errors: {
+        message: string;
+        error: unknown;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=gqlormSchema.d.ts.map

package/dist/cjs/generate/gqlormSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gqlormSchema.d.ts","sourceRoot":"","sources":["../../../src/generate/gqlormSchema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,IAAI,MAAM,cAAc,CAAA;AA8BzC,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;AAE3C,UAAU,iBAAiB;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf;AAED,UAAU,iBAAiB;IACzB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,iBAAiB,EAAE,CAAA;CAC5B;AAMD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,IAAI,EAAE,OAAO,CAAA;IACb,eAAe,EAAE,OAAO,CAAA;IACxB,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAC1B,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAA;CACtC;AAED,MAAM,WAAW,mBAAmB;IAClC,eAAe,EAAE,MAAM,CAAA;IACvB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,2BAA2B,EAAE,MAAM,CAAA;IACnC,qBAAqB,EAAE,OAAO,CAAA;CAC/B;AA6DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMvE;AAoGD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAClB,iBAAiB,EAAE,CAiDrB;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,iBAAiB,EAAE,GAC1B,MAAM,CA2CR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,WAAW,CAkDjE;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,gBAAgB,EAAE,CA6D7E;AAkBD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CA6BvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,gBAAgB,EAAE,EAC1B,MAAM,GAAE,mBAAmD,GAC1D,MAAM,CA+rBR;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC;IACvD,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAC9C,CAAC,CAkID"}