@redmix/api 9.0.0-canary.581 → 9.0.0-canary.582

package/dist/cjs/cors.js

@@ -0,0 +1,93 @@
+"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 cors_exports = {};
+__export(cors_exports, {
+  createCorsContext: () => createCorsContext
+});
+module.exports = __toCommonJS(cors_exports);
+var import_fetch = require("@whatwg-node/fetch");
+function createCorsContext(cors) {
+  const corsHeaders = new import_fetch.Headers();
+  if (cors) {
+    if (cors.methods) {
+      if (typeof cors.methods === "string") {
+        corsHeaders.set("access-control-allow-methods", cors.methods);
+      } else if (Array.isArray(cors.methods)) {
+        corsHeaders.set("access-control-allow-methods", cors.methods.join(","));
+      }
+    }
+    if (cors.allowedHeaders) {
+      if (typeof cors.allowedHeaders === "string") {
+        corsHeaders.set("access-control-allow-headers", cors.allowedHeaders);
+      } else if (Array.isArray(cors.allowedHeaders)) {
+        corsHeaders.set(
+          "access-control-allow-headers",
+          cors.allowedHeaders.join(",")
+        );
+      }
+    }
+    if (cors.exposedHeaders) {
+      if (typeof cors.exposedHeaders === "string") {
+        corsHeaders.set("access-control-expose-headers", cors.exposedHeaders);
+      } else if (Array.isArray(cors.exposedHeaders)) {
+        corsHeaders.set(
+          "access-control-expose-headers",
+          cors.exposedHeaders.join(",")
+        );
+      }
+    }
+    if (cors.credentials) {
+      corsHeaders.set("access-control-allow-credentials", "true");
+    }
+    if (typeof cors.maxAge === "number") {
+      corsHeaders.set("access-control-max-age", cors.maxAge.toString());
+    }
+  }
+  return {
+    shouldHandleCors(request) {
+      return request.method === "OPTIONS";
+    },
+    getRequestHeaders(request) {
+      const eventHeaders = new import_fetch.Headers(request.headers);
+      const requestCorsHeaders = new import_fetch.Headers(corsHeaders);
+      if (cors?.origin) {
+        const requestOrigin = eventHeaders.get("origin");
+        if (typeof cors.origin === "string") {
+          requestCorsHeaders.set("access-control-allow-origin", cors.origin);
+        } else if (requestOrigin && (typeof cors.origin === "boolean" || Array.isArray(cors.origin) && requestOrigin && cors.origin.includes(requestOrigin))) {
+          requestCorsHeaders.set("access-control-allow-origin", requestOrigin);
+        }
+        const requestAccessControlRequestHeaders = eventHeaders.get(
+          "access-control-request-headers"
+        );
+        if (!cors.allowedHeaders && requestAccessControlRequestHeaders) {
+          requestCorsHeaders.set(
+            "access-control-allow-headers",
+            requestAccessControlRequestHeaders
+          );
+        }
+      }
+      return Object.fromEntries(requestCorsHeaders.entries());
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCorsContext
+});

package/dist/cjs/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class RedwoodError extends Error {
+    extensions: Record<string, any> | undefined;
+    constructor(message: string, extensions?: Record<string, any>);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAa,SAAQ,KAAK;IACrC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAA;gBAC/B,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAQ9D"}

package/dist/cjs/errors.js

@@ -0,0 +1,38 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  RedwoodError: () => RedwoodError
+});
+module.exports = __toCommonJS(errors_exports);
+class RedwoodError extends Error {
+  extensions;
+  constructor(message, extensions) {
+    super(message);
+    this.name = "RedwoodError";
+    this.extensions = {
+      ...extensions,
+      code: extensions?.code || "REDWOODJS_ERROR"
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedwoodError
+});

package/dist/cjs/event.d.ts

@@ -0,0 +1,3 @@
+import type { APIGatewayProxyEvent } from 'aws-lambda';
+export declare const getEventHeader: (event: APIGatewayProxyEvent | Request, headerName: string) => string | null | undefined;
+//# sourceMappingURL=event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAKtD,eAAO,MAAM,cAAc,UAClB,oBAAoB,GAAG,OAAO,cACzB,MAAM,8BAOnB,CAAA"}

package/dist/cjs/event.js

@@ -0,0 +1,34 @@
+"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 event_exports = {};
+__export(event_exports, {
+  getEventHeader: () => getEventHeader
+});
+module.exports = __toCommonJS(event_exports);
+var import_transforms = require("./transforms.js");
+const getEventHeader = (event, headerName) => {
+  if ((0, import_transforms.isFetchApiRequest)(event)) {
+    return event.headers.get(headerName);
+  }
+  return event.headers[headerName] || event.headers[headerName.toLowerCase()];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEventHeader
+});

package/dist/cjs/functions/fixtures/apiGatewayProxyEvent.fixture.d.ts

@@ -0,0 +1,4 @@
+import type { APIGatewayProxyEvent } from 'aws-lambda';
+export declare const mockedAPIGatewayProxyEvent: APIGatewayProxyEvent;
+export default mockedAPIGatewayProxyEvent;
+//# sourceMappingURL=apiGatewayProxyEvent.fixture.d.ts.map

package/dist/cjs/functions/fixtures/apiGatewayProxyEvent.fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiGatewayProxyEvent.fixture.d.ts","sourceRoot":"","sources":["../../../../src/functions/fixtures/apiGatewayProxyEvent.fixture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,eAAO,MAAM,0BAA0B,EAAE,oBA0CxC,CAAA;AAED,eAAe,0BAA0B,CAAA"}

package/dist/cjs/functions/fixtures/apiGatewayProxyEvent.fixture.js

@@ -0,0 +1,72 @@
+"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 apiGatewayProxyEvent_fixture_exports = {};
+__export(apiGatewayProxyEvent_fixture_exports, {
+  default: () => apiGatewayProxyEvent_fixture_default,
+  mockedAPIGatewayProxyEvent: () => mockedAPIGatewayProxyEvent
+});
+module.exports = __toCommonJS(apiGatewayProxyEvent_fixture_exports);
+const mockedAPIGatewayProxyEvent = {
+  body: "MOCKED_BODY",
+  headers: {},
+  multiValueHeaders: {},
+  httpMethod: "POST",
+  isBase64Encoded: false,
+  path: "/MOCK_PATH",
+  pathParameters: null,
+  queryStringParameters: null,
+  multiValueQueryStringParameters: null,
+  stageVariables: null,
+  requestContext: {
+    accountId: "MOCKED_ACCOUNT",
+    apiId: "MOCKED_API_ID",
+    authorizer: { name: "MOCKED_AUTHORIZER" },
+    protocol: "HTTP",
+    identity: {
+      accessKey: null,
+      accountId: null,
+      apiKey: null,
+      apiKeyId: null,
+      caller: null,
+      clientCert: null,
+      cognitoAuthenticationProvider: null,
+      cognitoAuthenticationType: null,
+      cognitoIdentityId: null,
+      cognitoIdentityPoolId: null,
+      principalOrgId: null,
+      sourceIp: "123.123.123.123",
+      user: null,
+      userAgent: null,
+      userArn: null
+    },
+    httpMethod: "POST",
+    path: "/MOCK_PATH",
+    stage: "MOCK_STAGE",
+    requestId: "MOCKED_REQUEST_ID",
+    requestTimeEpoch: 1,
+    resourceId: "MOCKED_RESOURCE_ID",
+    resourcePath: "MOCKED_RESOURCE_PATH"
+  },
+  resource: "MOCKED_RESOURCE"
+};
+var apiGatewayProxyEvent_fixture_default = mockedAPIGatewayProxyEvent;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mockedAPIGatewayProxyEvent
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,11 @@
+export * from './auth/index.js';
+export * from './errors.js';
+export * from './validations/validations.js';
+export * from './validations/errors.js';
+export * from './types.js';
+export * from './transforms.js';
+export * from './cors.js';
+export * from './event.js';
+export declare const prismaVersion: any;
+export declare const redwoodVersion: any;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAGA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAM1B,eAAO,MAAM,aAAa,KAA8C,CAAA;AACxE,eAAO,MAAM,cAAc,KAAuB,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,63 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 index_exports = {};
+__export(index_exports, {
+  prismaVersion: () => prismaVersion,
+  redwoodVersion: () => redwoodVersion
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+__reExport(index_exports, require("./auth/index.js"), module.exports);
+__reExport(index_exports, require("./errors.js"), module.exports);
+__reExport(index_exports, require("./validations/validations.js"), module.exports);
+__reExport(index_exports, require("./validations/errors.js"), module.exports);
+__reExport(index_exports, require("./types.js"), module.exports);
+__reExport(index_exports, require("./transforms.js"), module.exports);
+__reExport(index_exports, require("./cors.js"), module.exports);
+__reExport(index_exports, require("./event.js"), module.exports);
+const packageJson = JSON.parse(
+  import_node_fs.default.readFileSync(import_node_path.default.join(__dirname, "../package.json"), "utf8")
+);
+const prismaVersion = packageJson?.dependencies["@prisma/client"];
+const redwoodVersion = packageJson?.version;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prismaVersion,
+  redwoodVersion,
+  ...require("./auth/index.js"),
+  ...require("./errors.js"),
+  ...require("./validations/validations.js"),
+  ...require("./validations/errors.js"),
+  ...require("./types.js"),
+  ...require("./transforms.js"),
+  ...require("./cors.js"),
+  ...require("./event.js")
+});

package/dist/cjs/logger/index.d.ts

@@ -0,0 +1,179 @@
+import type P from 'pino';
+/**
+ * Types from Pino
+ * @see https://github.com/pinojs/pino/blob/master/pino.d.ts
+ */
+export type Logger = P.Logger;
+export type BaseLogger = P.BaseLogger;
+export type DestinationStream = P.DestinationStream;
+export type LevelWithSilent = P.LevelWithSilent;
+export type LoggerOptions = P.LoggerOptions;
+export type LogLevel = 'info' | 'query' | 'warn' | 'error';
+type PrismaClient = any;
+type LogDefinition = {
+    level: LogLevel;
+    emit: 'stdout' | 'event';
+};
+/**
+ * Determines if log environment is development
+ *
+ * @type {boolean}
+ *
+ */
+export declare const isDevelopment: boolean;
+/**
+ * Determines if log environment is test
+ *
+ * @type {boolean}
+ *
+ */
+export declare const isTest: boolean;
+/**
+ * Determines if log environment is production by checking if not development
+ *
+ * @type {boolean}
+ *
+ */
+export declare const isProduction: boolean;
+export declare const redactionsList: string[];
+/**
+ * Determines if log level based on environment variables and
+ * development or deployment environment defaults
+ *
+ * Set `LOG_LEVEL` env to the desired logging level. In order of priority, available levels are:
+ *
+ * - 'fatal'
+ * - 'error'
+ * - 'warn'
+ * - 'info'
+ * - 'debug'
+ * - 'trace'
+ *
+ * The logging level is a __minimum__ level. For instance if `logger.level` is `'info'` then all `'fatal'`, `'error'`, `'warn'`,
+ * and `'info'` logs will be enabled.
+ *
+ * You can pass `'silent'` to disable logging.
+ *
+ * @default 'warn' in Production
+ * @default 'trace' in Development
+ * @default 'silent' in Test
+ *
+ */
+export declare const logLevel: LevelWithSilent | string;
+/**
+ * Defines an opinionated base logger configuration that defines
+ * how to log and what to ignore.
+ *
+ * @default logger options are:
+ *
+ * - Ignore certain event attributes like hostname and pid for cleaner log statements
+ * - Prefix the log output with log level
+ * - Use a shorted log message that omits server name
+ * - Humanize time in GMT
+ * - Set the default log level in test to silent, development to trace
+ *   and warn in prod
+ *   Or set via LOG_LEVEL environment variable
+ * - Redact the host and other keys via a set redactionList
+ *
+ * Each path must be a string using a syntax which corresponds to JavaScript dot and bracket notation.
+ *
+ * If an object is supplied, three options can be specified:
+ *
+ *      paths (String[]): Required. An array of paths
+ *      censor (String): Optional. A value to overwrite key which are to be redacted. Default: '[Redacted]'
+ *      remove (Boolean): Optional. Instead of censoring the value, remove both the key and the value. Default: false
+ *
+ * @see {@link https://github.com/pinojs/pino/blob/master/docs/api.md}
+ */
+export declare const defaultLoggerOptions: {
+    level: string;
+    redact: string[];
+};
+/**
+ * RedwoodLoggerOptions defines custom logger options that extend those available in LoggerOptions
+ * and can define a destination like a file or other supported pin log transport stream
+ *
+ * @typedef {Object} RedwoodLoggerOptions
+ * @extends LoggerOptions
+ * @property {options} LoggerOptions - options define how to log
+ * @property {string | DestinationStream} destination - destination defines where to log
+ * @property {boolean} showConfig - Display logger configuration on initialization
+ */
+export interface RedwoodLoggerOptions {
+    options?: LoggerOptions;
+    destination?: string | DestinationStream;
+    showConfig?: boolean;
+}
+/**
+ * Creates the logger
+ *
+ * @param options {RedwoodLoggerOptions} - Override the default logger configuration
+ * @param destination {DestinationStream} - An optional destination stream
+ * @param showConfig {Boolean} - Show the logger configuration. This is off by default.
+ *
+ * @example
+ * // Create the logger to log just at the error level
+ * createLogger({ options: { level: 'error' } })
+ *
+ * @example
+ * // Create the logger to log to a file
+ * createLogger({ destination: { 'var/logs/redwood-api.log' } })
+ *
+ * @return {Logger} - The configured logger
+ */
+export declare const createLogger: ({ options, destination, showConfig, }: RedwoodLoggerOptions) => Logger;
+/**
+ * Determines the type and level of logging.
+ *
+ * @see {@link https://www.prisma.io/docs/reference/api-reference/prisma-client-reference#log}
+ */
+export declare const defaultLogLevels: LogLevel[];
+/**
+ * Generates the Prisma Log Definitions for the Prisma Client to emit
+ *
+ * @return Prisma.LogDefinition[]
+ */
+export declare const emitLogLevels: (setLogLevels: LogLevel[]) => LogDefinition[];
+/**
+ * Defines what is needed to setup Prisma Client logging used in handlePrismaLogging
+ *
+ *
+ * @param db {PrismaClient} - The Prisma Client instance
+ * @param logger {BaseLogger} - The Redwood logger instance
+ * @param logLevels {LogLevel[]} - The log levels . Should match those set with emitLogLevels
+ * @param slowQueryThreshold {number} - The threshold for slow queries. Default: 2 seconds
+ *
+ * @see emitLogLevels
+ *
+ */
+interface PrismaLoggingConfig {
+    db: PrismaClient;
+    logger: Logger;
+    logLevels: LogLevel[];
+    slowQueryThreshold?: number;
+}
+/**
+ * Sets up event-based logging on the Prisma client
+ *
+ * Sets emit to event for a specific log level, such as query
+ * using the $on() method to subscribe to the event
+ *
+ * @see {@link https://www.prisma.io/docs/concepts/components/prisma-client/working-with-prismaclient/logging}
+ *
+ * @param PrismaLoggingConfig
+ *
+ * @example
+ *
+ * handlePrismaLogging({
+ *  db,
+ *  logger,
+ *  logLevels: ['info', 'warn', 'error'],
+ *  slowQueryThreshold: 2000,
+ * })
+ *
+ * @return {void}
+ *
+ */
+export declare const handlePrismaLogging: (config: PrismaLoggingConfig) => void;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/logger/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,MAAM,CAAA;AAGzB;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAA;AAC7B,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,UAAU,CAAA;AACrC,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,iBAAiB,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,eAAe,CAAA;AAC/C,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,aAAa,CAAA;AAC3C,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,CAAA;AAI1D,KAAK,YAAY,GAAG,GAAG,CAAA;AAEvB,KAAK,aAAa,GAAG;IACnB,KAAK,EAAE,QAAQ,CAAA;IACf,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAA;CACzB,CAAA;AAgBD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,SAAyC,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,MAAM,SAAkC,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,SAA4B,CAAA;AAQrD,eAAO,MAAM,cAAc,EAAE,MAAM,EAgClC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,QAAQ,EAAE,eAAe,GAAG,MAUrC,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB;;;CAGR,CAAA;AAEzB;;;;;;;;;GASG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAA;IACxC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY,0CAItB,oBAAoB,KAAG,MAyCzB,CAAA;AAQD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,EAA8B,CAAA;AAErE;;;;GAIG;AACH,eAAO,MAAM,aAAa,iBAAkB,QAAQ,EAAE,KAAG,aAAa,EAIrE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,UAAU,mBAAmB;IAC3B,EAAE,EAAE,YAAY,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,QAAQ,EAAE,CAAA;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,WAAY,mBAAmB,KAAG,IA8CjE,CAAA"}