@zintrust/core 0.1.19 → 0.1.21

package/src/http/ValidationHelper.js

@@ -0,0 +1,121 @@
+/**
+ * Validation Helper
+ * Utilities for working with validated request data
+ */
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+const getValidated = (req) => {
+    return req.validated;
+};
+/**
+ * Extract validated body from request
+ * Returns the validated body if present, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * const body = getValidatedBody(req);
+ * if (!body) {
+ *   Logger.error('Validation middleware not configured');
+ *   return res.setStatus(500).json({ error: 'Internal server error' });
+ * }
+ * const email = getString(body['email']);
+ * ```
+ */
+export function getValidatedBody(req) {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.body === undefined)
+        return undefined;
+    return validated.body;
+}
+/**
+ * Check if request has a validated body
+ * Type guard for validated body existence
+ *
+ * @example
+ * ```typescript
+ * if (!hasValidatedBody(req)) {
+ *   Logger.error('Validation middleware not configured');
+ *   return res.setStatus(500).json({ error: 'Internal server error' });
+ * }
+ * const body = getValidatedBody(req)!; // Safe to use non-null assertion
+ * ```
+ */
+export function hasValidatedBody(req) {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return false;
+    if (validated.body === undefined)
+        return false;
+    return true;
+}
+/**
+ * Extract validated body or throw error
+ * Throws if validation middleware is not properly configured
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const body = requireValidatedBody(req);
+ *   const email = getString(body['email']);
+ * } catch (error) {
+ *   Logger.error('Validation middleware error', error);
+ *   return res.setStatus(500).json({ error: 'Internal server error' });
+ * }
+ * ```
+ */
+export function requireValidatedBody(req) {
+    const body = getValidatedBody(req);
+    if (body === undefined) {
+        throw ErrorFactory.createValidationError('Validation middleware did not populate req.validated.body');
+    }
+    return body;
+}
+/**
+ * Extract validated query parameters from request
+ * Returns the validated query if present, undefined otherwise
+ */
+export function getValidatedQuery(req) {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.query === undefined)
+        return undefined;
+    return validated.query;
+}
+/**
+ * Extract validated route parameters from request
+ * Returns the validated params if present, undefined otherwise
+ */
+export function getValidatedParams(req) {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.params === undefined)
+        return undefined;
+    return validated.params;
+}
+/**
+ * Extract validated headers from request
+ * Returns the validated headers if present, undefined otherwise
+ */
+export function getValidatedHeaders(req) {
+    const validated = getValidated(req);
+    if (validated === undefined)
+        return undefined;
+    if (validated.headers === undefined)
+        return undefined;
+    return validated.headers;
+}
+/**
+ * Validation Helper - Sealed namespace
+ */
+export const ValidationHelper = Object.freeze({
+    getValidatedBody,
+    hasValidatedBody,
+    requireValidatedBody,
+    getValidatedQuery,
+    getValidatedParams,
+    getValidatedHeaders,
+});
+export default ValidationHelper;

package/src/http/error-pages/ErrorPageRenderer.d.ts

@@ -0,0 +1,17 @@
+import type { IRequest } from '../Request';
+type RenderInput = {
+    statusCode: number;
+    errorName: string;
+    errorMessage: string;
+    requestPath: string;
+    stackPretty?: string;
+    stackRaw?: string;
+    requestPretty?: string;
+    requestRaw?: string;
+};
+export declare const ErrorPageRenderer: Readonly<{
+    shouldSendHtml(request: IRequest): boolean;
+    renderHtml(publicRoot: string, input: RenderInput): string | undefined;
+}>;
+export {};
+//# sourceMappingURL=ErrorPageRenderer.d.ts.map

package/src/http/error-pages/ErrorPageRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorPageRenderer.d.ts","sourceRoot":"","sources":["../../../../src/http/error-pages/ErrorPageRenderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAM9C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AA2EF,eAAO,MAAM,iBAAiB;4BACJ,QAAQ,GAAG,OAAO;2BAInB,MAAM,SAAS,WAAW,GAAG,MAAM,GAAG,SAAS;EAUtE,CAAC"}

package/src/http/error-pages/ErrorPageRenderer.js

@@ -0,0 +1,88 @@
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import * as fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+const escapeHtml = (value) => {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+};
+const getAcceptHeader = (request) => {
+    const accept = request.getHeader('accept');
+    if (typeof accept === 'string')
+        return accept;
+    if (Array.isArray(accept))
+        return accept.join(',');
+    return '';
+};
+const prefersHtml = (request) => {
+    if (request.getPath().startsWith('/api'))
+        return false;
+    const accept = getAcceptHeader(request).toLowerCase();
+    if (accept === '')
+        return false;
+    // Browser Accept values almost always include one of these.
+    return accept.includes('text/html') || accept.includes('application/xhtml+xml');
+};
+const prefersJson = (request) => {
+    if (request.getPath().startsWith('/api'))
+        return true;
+    const accept = getAcceptHeader(request).toLowerCase();
+    // If the client explicitly accepts HTML, treat it as an HTML preference.
+    if (accept.includes('text/html') || accept.includes('application/xhtml+xml'))
+        return false;
+    if (accept.includes('application/json'))
+        return true;
+    // Default to JSON when the client doesn't express a preference.
+    return accept === '' || accept.includes('*/*');
+};
+const interpolate = (template, data) => {
+    return template
+        .replaceAll('{{statusCode}}', escapeHtml(String(data.statusCode)))
+        .replaceAll('{{errorName}}', escapeHtml(data.errorName))
+        .replaceAll('{{errorMessage}}', escapeHtml(data.errorMessage))
+        .replaceAll('{{requestPath}}', escapeHtml(data.requestPath))
+        .replaceAll('{{stackPretty}}', escapeHtml(data.stackPretty ?? ''))
+        .replaceAll('{{stackRaw}}', escapeHtml(data.stackRaw ?? ''))
+        .replaceAll('{{requestPretty}}', escapeHtml(data.requestPretty ?? ''))
+        .replaceAll('{{requestRaw}}', escapeHtml(data.requestRaw ?? ''));
+};
+const resolveTemplatePath = (publicRoot, templateName) => {
+    return path.join(publicRoot, 'error-pages', `${templateName}.html`);
+};
+const safeReadTemplate = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath))
+            return undefined;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return typeof content === 'string' && content.length > 0 ? content : undefined;
+    }
+    catch (error) {
+        ErrorFactory.createTryCatchError(`Failed to read error page template: ${filePath}`, error);
+        return undefined;
+    }
+};
+const toTemplateName = (statusCode) => {
+    if (statusCode === 404)
+        return '404';
+    if (statusCode === 500)
+        return '500';
+    return undefined;
+};
+export const ErrorPageRenderer = Object.freeze({
+    shouldSendHtml(request) {
+        return prefersHtml(request) && !prefersJson(request);
+    },
+    renderHtml(publicRoot, input) {
+        const templateName = toTemplateName(input.statusCode);
+        if (templateName === undefined)
+            return undefined;
+        const templatePath = resolveTemplatePath(publicRoot, templateName);
+        const template = safeReadTemplate(templatePath);
+        if (template === undefined)
+            return undefined;
+        return interpolate(template, input);
+    },
+});

package/src/http/middleware/BodyParsingMiddleware.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Content Type Detection & Body Parsing Middleware
+ * Detects content-type and parses non-JSON request bodies
+ */
+import type { Middleware } from '../../middleware/MiddlewareStack';
+/**
+ * Body parsing middleware
+ * Automatically detects content-type and parses non-JSON bodies
+ */
+export declare const bodyParsingMiddleware: Middleware;
+export default bodyParsingMiddleware;
+//# sourceMappingURL=BodyParsingMiddleware.d.ts.map

package/src/http/middleware/BodyParsingMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BodyParsingMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/http/middleware/BodyParsingMiddleware.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAqO9D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,UAgDnC,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/src/http/middleware/BodyParsingMiddleware.js

@@ -0,0 +1,251 @@
+/**
+ * Content Type Detection & Body Parsing Middleware
+ * Detects content-type and parses non-JSON request bodies
+ */
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { MultipartParser } from '../parsers/MultipartParser.js';
+/**
+ * Get content-type from request headers
+ */
+const getContentType = (req) => {
+    const contentType = req.getHeader('content-type');
+    if (typeof contentType === 'string')
+        return contentType.split(';')[0].toLowerCase().trim();
+    if (Array.isArray(contentType) && typeof contentType[0] === 'string') {
+        return contentType[0].split(';')[0].toLowerCase().trim();
+    }
+    return '';
+};
+const shouldReadRequestBody = (req) => {
+    const method = (req.getMethod?.() ?? 'GET').toUpperCase();
+    if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS')
+        return false;
+    return true;
+};
+const toBuffer = (chunk) => {
+    if (Buffer.isBuffer(chunk))
+        return chunk;
+    if (typeof chunk === 'string')
+        return Buffer.from(chunk);
+    if (chunk instanceof Uint8Array)
+        return Buffer.from(chunk);
+    if (chunk instanceof ArrayBuffer)
+        return Buffer.from(new Uint8Array(chunk));
+    return Buffer.from(String(chunk));
+};
+const validateSize = (bytes, maxBytes) => {
+    if (bytes.length > maxBytes) {
+        return { ok: false, statusCode: 413, message: 'Payload Too Large' };
+    }
+    return null;
+};
+const handleMockedStringBody = (body, maxBytes) => {
+    const bytes = Buffer.from(body);
+    const sizeError = validateSize(bytes, maxBytes);
+    if (sizeError)
+        return sizeError;
+    return { ok: true, bytes, text: body };
+};
+const handleMockedBufferBody = (body, maxBytes) => {
+    const sizeError = validateSize(body, maxBytes);
+    if (sizeError)
+        return sizeError;
+    return { ok: true, bytes: body, text: body.toString('utf-8') };
+};
+const handleMockedObjectBody = (body, maxBytes) => {
+    try {
+        const text = JSON.stringify(body);
+        const bytes = Buffer.from(text, 'utf-8');
+        const sizeError = validateSize(bytes, maxBytes);
+        if (sizeError)
+            return sizeError;
+        return { ok: true, bytes, text };
+    }
+    catch {
+        return { ok: false, statusCode: 400, message: 'Invalid request body' };
+    }
+};
+const handleMockedBody = (mockedBody, maxBytes) => {
+    if (typeof mockedBody === 'string') {
+        return handleMockedStringBody(mockedBody, maxBytes);
+    }
+    if (Buffer.isBuffer(mockedBody)) {
+        return handleMockedBufferBody(mockedBody, maxBytes);
+    }
+    if (typeof mockedBody === 'object' && mockedBody !== null) {
+        return handleMockedObjectBody(mockedBody, maxBytes);
+    }
+    return null;
+};
+const readStreamBody = async (raw, maxBytes) => {
+    const chunks = [];
+    let totalSize = 0;
+    try {
+        for await (const chunk of raw) {
+            const buf = toBuffer(chunk);
+            totalSize += buf.length;
+            if (totalSize > maxBytes) {
+                try {
+                    raw.destroy?.();
+                }
+                catch {
+                    // best-effort
+                }
+                return { ok: false, statusCode: 413, message: 'Payload Too Large' };
+            }
+            chunks.push(buf);
+        }
+    }
+    catch {
+        return { ok: false, statusCode: 400, message: 'Invalid request body' };
+    }
+    if (chunks.length === 0)
+        return { ok: true, bytes: Buffer.from(''), text: '' };
+    const bytes = Buffer.concat(chunks);
+    return { ok: true, bytes, text: bytes.toString('utf-8') };
+};
+const readRawBody = async (req, maxBytes) => {
+    const raw = req.getRaw();
+    // Support tests/mocks that stuff a body directly on the raw request.
+    const mockedBody = raw.body;
+    const mockedResult = handleMockedBody(mockedBody, maxBytes);
+    if (mockedResult) {
+        return mockedResult;
+    }
+    // Read from actual stream
+    return readStreamBody(raw, maxBytes);
+};
+const convertExistingToRawResult = (existingBytes, existingText) => {
+    if (Buffer.isBuffer(existingBytes)) {
+        return { ok: true, bytes: existingBytes, text: existingBytes.toString('utf-8') };
+    }
+    if (typeof existingText === 'string') {
+        return { ok: true, bytes: Buffer.from(existingText, 'utf-8'), text: existingText };
+    }
+    // Should be unreachable (guarded by `hasExisting`), but keep a safe fallback.
+    return { ok: true, bytes: Buffer.from('', 'utf-8'), text: '' };
+};
+const parseJsonBody = (text, contentType, res) => {
+    try {
+        return text === '' ? null : JSON.parse(text);
+    }
+    catch {
+        Logger.debug('[Body Parser] Invalid JSON body', {
+            contentType,
+            byteLength: Buffer.byteLength(text),
+            rawBodyPreview: text.slice(0, 256),
+        });
+        res.setStatus(400).json({ error: 'Invalid JSON body' });
+        return null;
+    }
+};
+const setRequestBody = (req, rawResult, contentType) => {
+    const isUrlEncoded = contentType.includes('application/x-www-form-urlencoded');
+    const isText = contentType.startsWith('text/') || contentType.includes('application/xml');
+    if (isUrlEncoded) {
+        req.setBody(parseUrlEncodedBody(rawResult.text));
+    }
+    else if (isText) {
+        req.setBody(rawResult.text);
+    }
+    else if (contentType !== '') {
+        req.setBody(rawResult.bytes);
+    }
+};
+const parseUrlEncodedBody = (text) => {
+    const out = {};
+    const params = new URLSearchParams(text);
+    for (const [key, value] of params.entries()) {
+        const existing = out[key];
+        if (existing === undefined) {
+            out[key] = value;
+            continue;
+        }
+        if (Array.isArray(existing)) {
+            existing.push(value);
+            continue;
+        }
+        out[key] = [existing, value];
+    }
+    return out;
+};
+const processBodyParsing = async (req, res, contentType, maxBytes) => {
+    const rawResult = await readRawBody(req, maxBytes);
+    if (rawResult.ok === false) {
+        res.setStatus(rawResult.statusCode).json({ error: rawResult.message });
+        return false;
+    }
+    // Store raw body for downstream consumers
+    req.context['rawBodyBytes'] = rawResult.bytes;
+    req.context['rawBodyText'] = rawResult.text;
+    // Parse and set body based on content type
+    try {
+        const isJson = contentType.includes('application/json');
+        if (isJson) {
+            const parsed = parseJsonBody(rawResult.text, contentType, res);
+            if (parsed === null && res.getStatus() === 400) {
+                return false; // JSON parsing failed, response already sent
+            }
+            req.setBody(parsed);
+        }
+        else {
+            setRequestBody(req, rawResult, contentType);
+        }
+        if (Env.getBool('ZIN_DEBUG_BODY_PARSING', false)) {
+            Logger.debug('[Body Parser] Parsed request body', {
+                contentType,
+                byteLength: rawResult.bytes.length,
+                parsedType: typeof req.getBody?.(),
+            });
+        }
+    }
+    catch (error) {
+        Logger.error('[Body Parser] Unexpected error during body parsing', error);
+    }
+    return true;
+};
+/**
+ * Body parsing middleware
+ * Automatically detects content-type and parses non-JSON bodies
+ */
+export const bodyParsingMiddleware = async (req, res, next) => {
+    const contentType = getContentType(req);
+    // Early exit if body already set
+    const existingBody = req.getBody?.();
+    if (existingBody !== null && existingBody !== undefined) {
+        await next();
+        return;
+    }
+    // Early exit for multipart (handled by upload middleware)
+    if (MultipartParser.isMultipart(contentType)) {
+        await next();
+        return;
+    }
+    // Early exit for methods that don't have bodies
+    if (!shouldReadRequestBody(req)) {
+        await next();
+        return;
+    }
+    // Determine if we have existing raw body from adapter
+    const existingBytes = req.context['rawBodyBytes'];
+    const existingText = req.context['rawBodyText'];
+    const hasExisting = Buffer.isBuffer(existingBytes) || typeof existingText === 'string';
+    // Calculate size limit based on content type
+    const isJson = contentType.includes('application/json');
+    const maxJsonSize = Env.getInt('MAX_JSON_SIZE', 1024 * 1024);
+    const maxBytes = isJson ? maxJsonSize : Env.MAX_BODY_SIZE;
+    // Read or reuse raw body
+    if (hasExisting) {
+        const rawResult = convertExistingToRawResult(existingBytes, existingText);
+        if (rawResult.ok) {
+            req.context['rawBodyBytes'] = rawResult.bytes;
+            req.context['rawBodyText'] = rawResult.text;
+        }
+    }
+    else {
+        await processBodyParsing(req, res, contentType, maxBytes);
+    }
+    await next();
+};
+export default bodyParsingMiddleware;

package/src/http/middleware/FileUploadMiddleware.d.ts

@@ -0,0 +1,12 @@
+/**
+ * File Upload Middleware
+ * Processes multipart/form-data requests and makes files available on request
+ */
+import type { Middleware } from '../../middleware/MiddlewareStack';
+/**
+ * File upload middleware
+ * Automatically parses multipart/form-data and makes files available
+ */
+export declare const fileUploadMiddleware: Middleware;
+export default fileUploadMiddleware;
+//# sourceMappingURL=FileUploadMiddleware.d.ts.map

package/src/http/middleware/FileUploadMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileUploadMiddleware.d.ts","sourceRoot":"","sources":["../../../../src/http/middleware/FileUploadMiddleware.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAW9D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,UA8DlC,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/src/http/middleware/FileUploadMiddleware.js

@@ -0,0 +1,74 @@
+/**
+ * File Upload Middleware
+ * Processes multipart/form-data requests and makes files available on request
+ */
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { MultipartParser } from '../parsers/MultipartParser.js';
+import { MultipartParserRegistry } from '../parsers/MultipartParserRegistry.js';
+/**
+ * Extract content-type header safely
+ */
+const getContentType = (req) => {
+    const contentType = req.getHeader('content-type');
+    if (typeof contentType === 'string')
+        return contentType.toLowerCase().trim();
+    return '';
+};
+/**
+ * File upload middleware
+ * Automatically parses multipart/form-data and makes files available
+ */
+export const fileUploadMiddleware = async (req, res, next) => {
+    const contentType = getContentType(req);
+    // Only process multipart/form-data requests
+    if (!MultipartParser.isMultipart(contentType)) {
+        await next();
+        return;
+    }
+    // Phase 4 default behavior: multipart requires external streaming parser.
+    const provider = MultipartParserRegistry.get();
+    if (provider === null) {
+        res.setStatus(415).json({
+            error: 'multipart/form-data not supported. Install @zintrust/storage to enable uploads.',
+        });
+        return;
+    }
+    try {
+        const maxFileSizeBytes = Env.getInt('MAX_FILE_SIZE', 50 * 1024 * 1024);
+        const maxFiles = Env.getInt('MAX_FILES', 20);
+        const maxFields = Env.getInt('MAX_FIELDS', 200);
+        const maxFieldSizeBytes = Env.getInt('MAX_FIELD_SIZE', 128 * 1024);
+        const parsed = await provider({
+            req: req.getRaw(),
+            contentType,
+            limits: {
+                maxFileSizeBytes,
+                maxFiles,
+                maxFields,
+                maxFieldSizeBytes,
+            },
+        });
+        const currentBody = req.getBody?.();
+        const updatedBody = typeof currentBody === 'object' && currentBody !== null ? currentBody : {};
+        // Merge fields directly into the request body for ergonomics.
+        // Files remain under __files for FileUpload helper compatibility.
+        req.setBody({
+            ...updatedBody,
+            ...parsed.fields,
+            __files: parsed.files,
+        });
+        if (Env.getBool('ZIN_DEBUG_FILE_UPLOAD', false)) {
+            Logger.debug('[File Upload] Successfully parsed multipart data', {
+                fieldsCount: Object.keys(parsed.fields).length,
+                filesCount: Object.keys(parsed.files).length,
+            });
+        }
+    }
+    catch (error) {
+        Logger.error('[File Upload] Error parsing multipart data', error);
+        // Continue with unparsed body
+    }
+    await next();
+};
+export default fileUploadMiddleware;

package/src/http/parsers/BodyParsers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Body Parsers - Content-Type specific parsing
+ * Handles form-data, plain text, CSV, and other non-JSON formats
+ */
+interface BodyParserResult {
+    ok: boolean;
+    data?: Record<string, unknown> | string | unknown[];
+    error?: string;
+}
+interface IBodyParser {
+    canParse(contentType: string): boolean;
+    parse(body: string | Buffer): BodyParserResult;
+}
+export declare const BodyParsers: Readonly<{
+    FormDataParser: IBodyParser;
+    TextParser: IBodyParser;
+    CSVParser: IBodyParser;
+    /**
+     * Get all registered parsers
+     */
+    getAll(): IBodyParser[];
+    /**
+     * Find parser for content-type
+     */
+    findParser(contentType: string): IBodyParser | undefined;
+    /**
+     * Parse body based on content-type
+     */
+    parse(contentType: string, body: string | Buffer): BodyParserResult;
+}>;
+export default BodyParsers;
+//# sourceMappingURL=BodyParsers.d.ts.map

package/src/http/parsers/BodyParsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BodyParsers.d.ts","sourceRoot":"","sources":["../../../../src/http/parsers/BodyParsers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,UAAU,gBAAgB;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC;IACpD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;IACvC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,CAAC;CAChD;AA6ID,eAAO,MAAM,WAAW;;;;IAKtB;;OAEG;cACO,WAAW,EAAE;IAIvB;;OAEG;4BACqB,MAAM,GAAG,WAAW,GAAG,SAAS;IAIxD;;OAEG;uBACgB,MAAM,QAAQ,MAAM,GAAG,MAAM,GAAG,gBAAgB;EAQnE,CAAC;AAEH,eAAe,WAAW,CAAC"}