@fluojs/validation 1.0.0-beta.1

package/dist/decorators.js

@@ -0,0 +1,443 @@
+import { metadataSymbol } from '@fluojs/core/internal';
+import { createClassValidatorFromStandardSchema, isStandardSchemaLike } from './standard-schema.js';
+const standardDtoValidationMetadataKey = Symbol.for('fluo.standard.dto-validation');
+const standardClassValidationMetadataKey = Symbol.for('fluo.standard.class-validation');
+function getStandardMetadataBag(metadata) {
+  if (metadata === null || metadata === undefined) {
+    throw new Error('Decorator metadata is not available. Ensure your environment supports TC39 decorator metadata (Stage 3).');
+  }
+  void metadataSymbol;
+  return metadata;
+}
+function getStandardDtoValidationMap(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardDtoValidationMetadataKey];
+  if (current) {
+    return current;
+  }
+  const created = new Map();
+  bag[standardDtoValidationMetadataKey] = created;
+  return created;
+}
+function getStandardClassValidationList(metadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[standardClassValidationMetadataKey];
+  if (current) {
+    return current;
+  }
+  const created = [];
+  bag[standardClassValidationMetadataKey] = created;
+  return created;
+}
+function appendStandardDtoValidationRule(metadata, propertyKey, rule) {
+  const map = getStandardDtoValidationMap(metadata);
+  map.set(propertyKey, [...(map.get(propertyKey) ?? []), rule]);
+}
+function appendStandardClassValidationRule(metadata, rule) {
+  getStandardClassValidationList(metadata).push(rule);
+}
+function resolveClassValidator(validate) {
+  if (!isStandardSchemaLike(validate)) {
+    return validate;
+  }
+  return createClassValidatorFromStandardSchema(validate);
+}
+function createValidationDecorator(ruleFactory) {
+  const decorator = (_value, context) => {
+    appendStandardDtoValidationRule(context.metadata, context.name, ruleFactory());
+  };
+  return decorator;
+}
+function createValidationOptionsWithConfigDecorator(ruleFactory) {
+  return (value, options) => {
+    return createValidationDecorator(() => ruleFactory(value, options));
+  };
+}
+function createFlagValidationDecorator(ruleFactory) {
+  return options => {
+    return createValidationDecorator(() => ruleFactory(options));
+  };
+}
+function createArrayValidationDecorator(ruleFactory) {
+  return (values, options) => {
+    return createValidationDecorator(() => ruleFactory(values, options));
+  };
+}
+function createValidatorJsDecorator(validator) {
+  return (args, options) => {
+    return createValidationDecorator(() => ({
+      args,
+      kind: 'validatorjs',
+      validator,
+      ...options
+    }));
+  };
+}
+
+/**
+ * Validates that the decorated field is a string value.
+ *
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that registers a string validation rule.
+ */
+export function IsString(options) {
+  return createValidationDecorator(() => ({
+    kind: 'string',
+    ...options
+  }));
+}
+
+/**
+ * Validates that the decorated field is a number value.
+ *
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that registers a number validation rule.
+ */
+export function IsNumber(options) {
+  return createValidationDecorator(() => ({
+    kind: 'number',
+    ...options
+  }));
+}
+
+/**
+ * Validates that the decorated field is a boolean value.
+ *
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that registers a boolean validation rule.
+ */
+export function IsBoolean(options) {
+  return createValidationDecorator(() => ({
+    kind: 'boolean',
+    ...options
+  }));
+}
+
+/**
+ * Applies subsequent validators only when the condition returns `true`.
+ *
+ * @param validateIf Predicate that decides whether subsequent validators should run.
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that adds conditional validation execution.
+ */
+export const ValidateIf = (validateIf, options) => createValidationDecorator(() => ({
+  kind: 'validateIf',
+  validateIf,
+  ...options
+}));
+export const IsDefined = createFlagValidationDecorator(options => ({
+  kind: 'defined',
+  ...options
+}));
+export const IsOptional = createFlagValidationDecorator(options => ({
+  kind: 'optional',
+  ...options
+}));
+export const Equals = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'equals',
+  value,
+  ...options
+}));
+export const NotEquals = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'notEquals',
+  value,
+  ...options
+}));
+export const IsEmpty = createFlagValidationDecorator(options => ({
+  kind: 'empty',
+  ...options
+}));
+export const IsNotEmpty = createFlagValidationDecorator(options => ({
+  kind: 'notEmpty',
+  ...options
+}));
+export const IsIn = createArrayValidationDecorator((values, options) => ({
+  kind: 'in',
+  values,
+  ...options
+}));
+export const IsNotIn = createArrayValidationDecorator((values, options) => ({
+  kind: 'notIn',
+  values,
+  ...options
+}));
+export const IsDate = createFlagValidationDecorator(options => ({
+  kind: 'date',
+  ...options
+}));
+export const IsArray = createFlagValidationDecorator(options => ({
+  kind: 'array',
+  ...options
+}));
+export const IsObject = createFlagValidationDecorator(options => ({
+  kind: 'object',
+  ...options
+}));
+export const IsInt = createFlagValidationDecorator(options => ({
+  kind: 'int',
+  ...options
+}));
+export const IsPositive = createFlagValidationDecorator(options => ({
+  kind: 'positive',
+  ...options
+}));
+export const IsNegative = createFlagValidationDecorator(options => ({
+  kind: 'negative',
+  ...options
+}));
+
+/**
+ * Validates that the field value is included in the given enum-like set.
+ *
+ * @param values Enum object or literal value list that defines the accepted set.
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that registers an enum-membership rule.
+ */
+export function IsEnum(values, options) {
+  const normalized = Array.isArray(values) ? values : Object.values(values);
+  return createValidationDecorator(() => ({
+    kind: 'enum',
+    values: normalized,
+    ...options
+  }));
+}
+export const IsDivisibleBy = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'divisibleBy',
+  value,
+  ...options
+}));
+export const Min = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'min',
+  value,
+  ...options
+}));
+export const Max = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'max',
+  value,
+  ...options
+}));
+export const MinDate = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'minDate',
+  value,
+  ...options
+}));
+export const MaxDate = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'maxDate',
+  value,
+  ...options
+}));
+export const Contains = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'contains',
+  value,
+  ...options
+}));
+export const NotContains = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'notContains',
+  value,
+  ...options
+}));
+
+/**
+ * Validates string length using optional min/max boundaries.
+ *
+ * @param min Minimum inclusive length.
+ * @param max Optional maximum inclusive length.
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that registers a bounded-length rule.
+ */
+export function Length(min, max, options) {
+  return createValidationDecorator(() => ({
+    kind: 'length',
+    max,
+    min,
+    ...options
+  }));
+}
+
+/**
+ * Validates a nested DTO instance using the provided constructor.
+ *
+ * @param dto DTO constructor (or lazy constructor factory) used for nested validation/materialization.
+ * @param options Optional validation behavior (`message`, `groups`, `always`, `each`).
+ * @returns A field decorator that registers recursive nested DTO validation.
+ */
+export function ValidateNested(dto, options) {
+  return createValidationDecorator(() => ({
+    dto,
+    kind: 'nested',
+    ...options
+  }));
+}
+export const MinLength = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'minLength',
+  value,
+  ...options
+}));
+export const MaxLength = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'maxLength',
+  value,
+  ...options
+}));
+
+/**
+ * Validates the field using a regular expression pattern.
+ *
+ * @param pattern Pattern source (`RegExp` or string) passed to validator.js `matches`.
+ * @param modifiersOrOptions Regex modifiers string (for string patterns) or validation options.
+ * @param options Validation options used when modifiers are provided separately.
+ * @returns A field decorator that registers a regex-matching rule.
+ */
+export function Matches(pattern, modifiersOrOptions, options) {
+  const resolvedOptions = typeof modifiersOrOptions === 'object' ? modifiersOrOptions : options;
+  if (pattern instanceof RegExp) {
+    return createValidationDecorator(() => ({
+      args: [pattern.source, pattern.flags],
+      kind: 'validatorjs',
+      validator: 'matches',
+      ...resolvedOptions
+    }));
+  }
+  return createValidationDecorator(() => ({
+    args: [pattern, typeof modifiersOrOptions === 'string' ? modifiersOrOptions : undefined].filter(value => value !== undefined),
+    kind: 'validatorjs',
+    validator: 'matches',
+    ...resolvedOptions
+  }));
+}
+export const IsAlpha = options => createValidatorJsDecorator('alpha')(undefined, options);
+export const IsAlphanumeric = options => createValidatorJsDecorator('alphanumeric')(undefined, options);
+export const IsAscii = options => createValidatorJsDecorator('ascii')(undefined, options);
+export const IsBase64 = options => createValidatorJsDecorator('base64')(undefined, options);
+export const IsBooleanString = options => createValidatorJsDecorator('booleanString')(undefined, options);
+export const IsDataURI = options => createValidatorJsDecorator('dataURI')(undefined, options);
+export const IsDateString = options => createValidatorJsDecorator('dateString')(undefined, options);
+export const IsDecimal = options => createValidatorJsDecorator('decimal')(undefined, options);
+export const IsEmail = options => createValidatorJsDecorator('email')(undefined, options);
+export const IsFQDN = options => createValidatorJsDecorator('fqdn')(undefined, options);
+export const IsHexColor = options => createValidatorJsDecorator('hexColor')(undefined, options);
+export const IsHexadecimal = options => createValidatorJsDecorator('hexadecimal')(undefined, options);
+export const IsJSON = options => createValidatorJsDecorator('json')(undefined, options);
+export const IsJWT = options => createValidatorJsDecorator('jwt')(undefined, options);
+export const IsLocale = options => createValidatorJsDecorator('locale')(undefined, options);
+export const IsLowercase = options => createValidatorJsDecorator('lowercase')(undefined, options);
+export const IsMagnetURI = options => createValidatorJsDecorator('magnetURI')(undefined, options);
+export const IsMimeType = options => createValidatorJsDecorator('mimeType')(undefined, options);
+export const IsMongoId = options => createValidatorJsDecorator('mongoId')(undefined, options);
+export const IsNumberString = options => createValidatorJsDecorator('numberString')(undefined, options);
+export const IsPort = options => createValidatorJsDecorator('port')(undefined, options);
+export const IsRFC3339 = options => createValidatorJsDecorator('rfc3339')(undefined, options);
+export const IsSemVer = options => createValidatorJsDecorator('semVer')(undefined, options);
+export const IsUppercase = options => createValidatorJsDecorator('uppercase')(undefined, options);
+export const IsISO8601 = options => createValidatorJsDecorator('iso8601')(undefined, options);
+export const IsLatitude = options => createValidatorJsDecorator('latitude')(undefined, options);
+export const IsLongitude = options => createValidatorJsDecorator('longitude')(undefined, options);
+export const IsLatLong = options => createValidatorJsDecorator('latLong')(undefined, options);
+
+/** Validates that a value is an IPv4/IPv6 address. */
+export function IsIP(version, options) {
+  return createValidatorJsDecorator('ip')(version ? [version] : undefined, options);
+}
+
+/** Validates that a value is an ISBN string. */
+export function IsISBN(version, options) {
+  return createValidatorJsDecorator('isbn')(version ? [String(version)] : undefined, options);
+}
+export function IsISSN(options) {
+  return createValidatorJsDecorator('issn')(undefined, options);
+}
+export function IsMobilePhone(locale, options) {
+  return createValidatorJsDecorator('mobilePhone')(locale ? [locale] : undefined, options);
+}
+export function IsPostalCode(locale, options) {
+  return createValidatorJsDecorator('postalCode')(locale ? [locale] : undefined, options);
+}
+export function IsRgbColor(includePercentValues, options) {
+  return createValidatorJsDecorator('rgbColor')(includePercentValues === undefined ? undefined : [includePercentValues], options);
+}
+export function IsUrl(options) {
+  return createValidatorJsDecorator('url')(undefined, options);
+}
+export function IsUUID(version, options) {
+  return createValidatorJsDecorator('uuid')(version ? [version] : undefined, options);
+}
+export function IsCurrency(options) {
+  return createValidatorJsDecorator('currency')(undefined, options);
+}
+export const ArrayContains = createArrayValidationDecorator((values, options) => ({
+  kind: 'arrayContains',
+  values,
+  ...options
+}));
+export const ArrayNotContains = createArrayValidationDecorator((values, options) => ({
+  kind: 'arrayNotContains',
+  values,
+  ...options
+}));
+export const ArrayNotEmpty = createFlagValidationDecorator(options => ({
+  kind: 'arrayNotEmpty',
+  ...options
+}));
+export const ArrayMinSize = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'arrayMinSize',
+  value,
+  ...options
+}));
+export const ArrayMaxSize = createValidationOptionsWithConfigDecorator((value, options) => ({
+  kind: 'arrayMaxSize',
+  value,
+  ...options
+}));
+
+/**
+ * Ensures all values in the array are unique, optionally by selector.
+ *
+ * @param selectorOrOptions Optional selector callback used to compute uniqueness keys, or validation options.
+ * @param options Validation options used when a selector callback is provided.
+ * @returns A field decorator that registers an array-uniqueness rule.
+ */
+export function ArrayUnique(selectorOrOptions, options) {
+  const selector = typeof selectorOrOptions === 'function' ? selectorOrOptions : undefined;
+  const resolvedOptions = typeof selectorOrOptions === 'function' ? options : selectorOrOptions;
+  return createValidationDecorator(() => ({
+    kind: 'arrayUnique',
+    selector,
+    ...resolvedOptions
+  }));
+}
+
+/**
+ * Registers a custom field-level validation function.
+ *
+ * @param validate Custom validator callback invoked with `(dto, value)`.
+ * @param options Optional custom-validator metadata (`message`, `code`, `source`, `each`).
+ * @returns A field decorator that registers a custom validation rule.
+ */
+export function Validate(validate, options) {
+  return createValidationDecorator(() => ({
+    code: options?.code,
+    each: options?.each,
+    kind: 'custom',
+    message: options?.message,
+    source: options?.source,
+    validate
+  }));
+}
+
+/**
+ * Registers class-level validation logic.
+ * Supports either a custom validator callback or a Standard Schema object.
+ *
+ * @param validate Class-level validator callback or a Standard Schema-compatible validator definition.
+ * @param options Optional validation behavior (`message`, `code`).
+ * @returns A class decorator that appends class-level validation rules.
+ */
+export function ValidateClass(validate, options) {
+  const decorator = (_target, context) => {
+    appendStandardClassValidationRule(context.metadata, {
+      code: options?.code,
+      message: options?.message,
+      validate: resolveClassValidator(validate)
+    });
+  };
+  return decorator;
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+import type { ValidationIssue } from './types.js';
+export declare class DtoValidationError extends Error {
+    readonly issues: readonly ValidationIssue[];
+    constructor(message: string, issues: readonly ValidationIssue[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,qBAAa,kBAAmB,SAAQ,KAAK;IAGzC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE;gBAD3C,OAAO,EAAE,MAAM,EACN,MAAM,EAAE,SAAS,eAAe,EAAE;CAM9C"}

package/dist/errors.js

@@ -0,0 +1,8 @@
+export class DtoValidationError extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = 'DtoValidationError';
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './decorators.js';
+export * from './errors.js';
+export * from './mapped-types.js';
+export * from './types.js';
+export * from './validation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './decorators.js';
+export * from './errors.js';
+export * from './mapped-types.js';
+export * from './types.js';
+export * from './validation.js';

package/dist/mapped-types.d.ts

@@ -0,0 +1,99 @@
+import { type Constructor } from '@fluojs/core';
+type DtoConstructor<T = object> = Constructor<T>;
+/**
+ * Derive a DTO class that keeps only the selected properties from a base DTO.
+ *
+ * Validation and binding metadata are copied only for the requested keys, which
+ * keeps request materialization aligned with the subset contract documented in
+ * the base DTO.
+ *
+ * @typeParam TBase Base DTO constructor to derive from.
+ * @typeParam TKey String keys preserved on the derived DTO.
+ * @param BaseDto Source DTO that already declares binding and validation metadata.
+ * @param keys Property names to keep on the derived DTO.
+ * @returns A derived DTO constructor that materializes and validates only the selected fields.
+ *
+ * @example
+ * ```ts
+ * class UserDto {
+ *   email = '';
+ *   name = '';
+ * }
+ *
+ * class UserEmailDto extends PickType(UserDto, ['email']) {}
+ * ```
+ */
+export declare function PickType<TBase extends DtoConstructor, TKey extends Extract<keyof InstanceType<TBase>, string>>(BaseDto: TBase, keys: readonly TKey[]): DtoConstructor<Pick<InstanceType<TBase>, TKey>>;
+/**
+ * Derive a DTO class that removes specific properties from a base DTO.
+ *
+ * Binding and validation metadata for omitted properties are intentionally not
+ * copied, so downstream transports cannot bind or validate those fields on the
+ * derived contract.
+ *
+ * @typeParam TBase Base DTO constructor to derive from.
+ * @typeParam TKey String keys removed from the derived DTO.
+ * @param BaseDto Source DTO that already declares binding and validation metadata.
+ * @param keys Property names to exclude from the derived DTO.
+ * @returns A derived DTO constructor that preserves every base field except the omitted keys.
+ *
+ * @example
+ * ```ts
+ * class UserDto {
+ *   id = '';
+ *   passwordHash = '';
+ * }
+ *
+ * class PublicUserDto extends OmitType(UserDto, ['passwordHash']) {}
+ * ```
+ */
+export declare function OmitType<TBase extends DtoConstructor, TKey extends Extract<keyof InstanceType<TBase>, string>>(BaseDto: TBase, keys: readonly TKey[]): DtoConstructor<Omit<InstanceType<TBase>, TKey>>;
+type UnionToIntersection<T> = (T extends unknown ? (value: T) => void : never) extends (value: infer TResult) => void ? TResult : never;
+type IntersectionInstance<TBaseDtos extends readonly DtoConstructor[]> = UnionToIntersection<InstanceType<TBaseDtos[number]>>;
+/**
+ * Combine multiple DTO classes into one intersection DTO.
+ *
+ * The derived constructor initializes every property discovered across the
+ * source DTOs and copies each source DTO's binding and validation metadata.
+ *
+ * @typeParam TBaseDtos Tuple of DTO constructors to merge.
+ * @param baseDtos DTO constructors whose fields and rules should be combined.
+ * @returns A DTO constructor whose instance type is the intersection of every input DTO.
+ *
+ * @example
+ * ```ts
+ * class PaginationDto {
+ *   page = 1;
+ * }
+ *
+ * class SearchDto {
+ *   query = '';
+ * }
+ *
+ * class SearchPageDto extends IntersectionType(PaginationDto, SearchDto) {}
+ * ```
+ */
+export declare function IntersectionType<TBaseDtos extends readonly [DtoConstructor, DtoConstructor, ...DtoConstructor[]]>(...baseDtos: TBaseDtos): DtoConstructor<IntersectionInstance<TBaseDtos>>;
+/**
+ * Derive a DTO class where every bound field from the base DTO becomes optional.
+ *
+ * Existing validators are preserved, and an `optional` validation rule is added
+ * when the base field did not already declare one.
+ *
+ * @typeParam TBase Base DTO constructor to derive from.
+ * @param BaseDto Source DTO that defines the original field contract.
+ * @returns A derived DTO constructor suited for patch/update style payloads.
+ *
+ * @example
+ * ```ts
+ * class CreateUserDto {
+ *   email = '';
+ *   name = '';
+ * }
+ *
+ * class UpdateUserDto extends PartialType(CreateUserDto) {}
+ * ```
+ */
+export declare function PartialType<TBase extends DtoConstructor>(BaseDto: TBase): DtoConstructor<Partial<InstanceType<TBase>>>;
+export {};
+//# sourceMappingURL=mapped-types.d.ts.map

package/dist/mapped-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapped-types.d.ts","sourceRoot":"","sources":["../src/mapped-types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEjB,MAAM,cAAc,CAAC;AAUtB,KAAK,cAAc,CAAC,CAAC,GAAG,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAiEjD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,cAAc,EAAE,IAAI,SAAS,OAAO,CAAC,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,EAC5G,OAAO,EAAE,KAAK,EACd,IAAI,EAAE,SAAS,IAAI,EAAE,GACpB,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAcjD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,cAAc,EAAE,IAAI,SAAS,OAAO,CAAC,MAAM,YAAY,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,EAC5G,OAAO,EAAE,KAAK,EACd,IAAI,EAAE,SAAS,IAAI,EAAE,GACpB,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAcjD;AAED,KAAK,mBAAmB,CAAC,CAAC,IAAI,CAC5B,CAAC,SAAS,OAAO,GAAG,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,KAAK,CAC/C,SAAS,CAAC,KAAK,EAAE,MAAM,OAAO,KAAK,IAAI,GAAG,OAAO,GAAG,KAAK,CAAC;AAE3D,KAAK,oBAAoB,CAAC,SAAS,SAAS,SAAS,cAAc,EAAE,IAAI,mBAAmB,CAAC,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;AAE9H;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,SAAS,SAAS,CAAC,cAAc,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CAAC,EAC/G,GAAG,QAAQ,EAAE,SAAS,GACrB,cAAc,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAkBjD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,cAAc,EAAE,OAAO,EAAE,KAAK,GAAG,cAAc,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAkCtH"}