@nicolastoulemont/std 0.5.1 → 0.7.0

package/dist/index-DKS1g1oC.d.mts

@@ -0,0 +1,449 @@
+import { h as Prettify, t as Result } from "./result.types-_xDAei3-.mjs";
+import { t as Discriminator } from "./discriminator.types-CTURejXz.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/adt/adt.match.d.ts
+
+/**
+ * Handler functions for each variant in a discriminated union.
+ * Each key maps to a function that receives the variant value and returns TResult.
+ *
+ * @template T - The discriminated union type (must have readonly _tag)
+ * @template TResult - The return type of all handlers
+ */
+type AdtMatchHandlers<T extends {
+  readonly _tag: string;
+}, TResult> = { [K in T["_tag"]]: (value: Extract<T, {
+  readonly _tag: K;
+}>) => TResult };
+/**
+ * Exhaustive pattern matching for discriminated unions.
+ *
+ * TypeScript will error if any variant is missing from handlers,
+ * ensuring exhaustive handling of all cases.
+ *
+ * @template T - The discriminated union type (must have readonly _tag)
+ * @template TResult - The return type of all handlers
+ * @template Handlers - The handler object type (inferred)
+ * @param value - A discriminated union value with _tag
+ * @param handlers - An object with a handler function for each variant
+ * @returns The result of calling the matching handler
+ *
+ * @see {@link union} for creating discriminated unions
+ * @see {@link variant} for creating individual variant types
+ *
+ * @example
+ * ```ts
+ * const Shape = union('Shape', { Circle, Square })
+ * type Shape = AdtInfer<typeof Shape>
+ *
+ * function describeShape(shape: Shape): string {
+ *   return match(shape, {
+ *     Circle: (c) => `Circle with radius ${c.radius}`,
+ *     Square: (s) => `Square with size ${s.size}`,
+ *   })
+ * }
+ * ```
+ */
+declare function match$1<T extends {
+  readonly _tag: string;
+}, TResult, Handlers extends AdtMatchHandlers<T, TResult> = AdtMatchHandlers<T, TResult>>(value: T, handlers: Handlers): TResult;
+//#endregion
+//#region src/adt/adt.types.d.ts
+/**
+ * Validation error containing issues from schema validation.
+ * Mirrors the Standard Schema issue format.
+ */
+type AdtValidationError = {
+  readonly issues: ReadonlyArray<{
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey> | undefined;
+  }>;
+};
+/**
+ * Constraint for custom codec definitions.
+ * Ensures codecs have properly typed `to` and `from` methods.
+ * Used to constrain the Codecs generic parameter throughout the codebase.
+ */
+type AdtCodecConstraint<Tag$1 extends string, S$1 extends StandardSchemaV1> = Record<string, {
+  to: (value: AdtInferOutput<S$1> & Discriminator<Tag$1>) => any;
+  from: (input: any) => any;
+}>;
+/**
+ * Error type for codec operations.
+ * Used when encoding fails or when decoded data fails validation.
+ */
+type AdtCodecError = {
+  readonly kind: "EncodingError" | "DecodingError" | "ValidationError";
+  readonly message: string;
+  readonly cause?: unknown;
+  readonly validationIssues?: AdtValidationError["issues"];
+};
+/**
+ * Infer the input type from a Standard Schema.
+ * This is what the user provides to create().
+ */
+type AdtInferInput<S$1 extends StandardSchemaV1> = NonNullable<S$1["~standard"]["types"]>["input"];
+/**
+ * Infer the output type from a Standard Schema.
+ * This is what validation returns (after transforms/defaults).
+ */
+type AdtInferOutput<S$1 extends StandardSchemaV1> = NonNullable<S$1["~standard"]["types"]>["output"];
+/**
+ * Extract the return type from a codec's `to` method.
+ * This is what the encoding function returns (e.g., string, Uint8Array).
+ */
+type ExtractToReturn<C> = C extends {
+  to: (value: any) => infer R;
+} ? R : never;
+/**
+ * Extract the input type from a codec's `from` method.
+ * This is what the decoding function accepts (e.g., string, Uint8Array).
+ */
+type ExtractFromInput<C> = C extends {
+  from: (input: infer I) => any;
+} ? I : never;
+/**
+ * Build the "to" object containing encoding methods.
+ * Always includes 'json' plus any custom codec names.
+ * Uses type extraction to infer return types from codec definitions.
+ * All methods return Result<T, AdtCodecError> for consistent error handling.
+ */
+type ToMethods<S$1 extends StandardSchemaV1, Codecs> = {
+  json: (value: AdtInferInput<S$1>) => Result<string, AdtCodecError>;
+} & (Codecs extends Record<string, any> ? { [K in keyof Codecs]: (value: AdtInferInput<S$1>) => Result<ExtractToReturn<Codecs[K]>, AdtCodecError> } : object);
+/**
+ * Build the "from" object containing decoding methods.
+ * Always includes 'json' plus any custom codec names.
+ * All methods return Result<T, AdtCodecError> for consistent error handling.
+ * Uses type extraction to infer input types from codec definitions.
+ */
+type FromMethods<Tag$1 extends string, S$1 extends StandardSchemaV1, Codecs> = {
+  json: (input: string) => Result<AdtInferOutput<S$1> & Discriminator<Tag$1>, AdtCodecError>;
+} & (Codecs extends Record<string, any> ? { [K in keyof Codecs]: (input: ExtractFromInput<Codecs[K]>) => Result<AdtInferOutput<S$1> & Discriminator<Tag$1>, AdtCodecError> } : object);
+/**
+ * A tagged variant created by the variant() function.
+ * Can be used standalone or composed into an AdtUnion via union().
+ * Callable as a function to create instances.
+ */
+type AdtVariant<Tag$1 extends string = string, S$1 extends StandardSchemaV1 = StandardSchemaV1, Codecs extends AdtCodecConstraint<Tag$1, S$1> | undefined = undefined> = {
+  /** Marker to identify this as a AdtVariant */
+  readonly _variant: true;
+  /** The _tag discriminator value */
+  readonly _tag: Tag$1;
+  /** The underlying Standard Schema */
+  readonly schema: S$1;
+  /** Codec definitions (if provided) */
+  readonly codecs?: Codecs;
+  /**
+   * Create an instance of this variant.
+   * @param input - The input data (schema defaults apply)
+   * @returns Result with tagged output or validation error
+   */
+  (input: AdtInferInput<S$1>): Result<AdtInferOutput<S$1> & Discriminator<Tag$1>, AdtValidationError>;
+  /**
+   * Type guard to check if a value is this variant type.
+   * @param value - The value to check
+   */
+  is(value: unknown): value is AdtInferOutput<S$1> & Discriminator<Tag$1>;
+  /**
+   * Encoding methods for serializing variant values.
+   * Always includes 'json' plus any custom codecs.
+   */
+  readonly to: ToMethods<S$1, Codecs>;
+  /**
+   * Decoding methods for deserializing to variant values.
+   * Always includes 'json' plus any custom codecs.
+   * All methods validate through the schema before returning.
+   */
+  readonly from: FromMethods<Tag$1, S$1, Codecs>;
+  /**
+   * Compare two instances of this variant for value equality.
+   * Performs deep comparison of all fields.
+   */
+  equals(a: AdtInferOutput<S$1> & Discriminator<Tag$1>, b: AdtInferOutput<S$1> & Discriminator<Tag$1>): boolean;
+  /**
+   * Compute a hash code for a variant instance.
+   * Equal values always produce the same hash.
+   * Useful for Map/Set keys.
+   */
+  hash(value: AdtInferOutput<S$1> & Discriminator<Tag$1>): number;
+};
+/**
+ * A variant definition can be either:
+ * - A raw Standard Schema (will be wrapped internally)
+ * - A pre-built AdtVariant from variant()
+ */
+type AdtVariantDef = StandardSchemaV1 | AdtVariant<string, any, any>;
+/**
+ * Extract the schema from a AdtVariantDef (handles both raw schema and AdtVariant)
+ */
+type AdtExtractSchema<T extends AdtVariantDef> = T extends AdtVariant<string, infer S, any> ? S : T extends StandardSchemaV1 ? T : never;
+/**
+ * Extract the codecs from a AdtVariantDef (if it's a AdtVariant with codecs)
+ */
+type ExtractCodecs<T extends AdtVariantDef> = T extends AdtVariant<string, any, infer Codecs> ? Codecs : undefined;
+/**
+ * The AdtUnion returned by union().
+ * Contains all variant accessors plus a root type guard.
+ * Codecs from variants are preserved in AdtUnion variants.
+ */
+type AdtUnion<R$1 extends Record<string, AdtVariantDef>> = {
+  /** The name of this AdtUnion */
+  readonly _name: string;
+  /**
+   * Type guard to check if a value is any variant of this AdtUnion.
+   */
+  is(value: unknown): value is InferADTUnion<R$1>;
+  /**
+   * Compare two AdtUnion values for equality.
+   * First checks _tag matches, then compares fields.
+   */
+  equals(a: InferADTUnion<R$1>, b: InferADTUnion<R$1>): boolean;
+  /**
+   * Compute a hash code for any AdtUnion variant.
+   */
+  hash(value: InferADTUnion<R$1>): number;
+} & { [K in keyof R$1]: AdtVariant<K & string, AdtExtractSchema<R$1[K]>, ExtractCodecs<R$1[K]>> };
+/**
+ * Infer the output type for a single variant within an AdtUnion.
+ */
+type InferRecordOutput<Tag$1 extends string, R$1 extends AdtVariantDef> = AdtInferOutput<AdtExtractSchema<R$1>> & {
+  readonly _tag: Tag$1;
+};
+/**
+ * Infer the union of all variant output types in an AdtUnion.
+ */
+type InferADTUnion<R$1 extends Record<string, AdtVariantDef>> = { [K in keyof R$1]: InferRecordOutput<K & string, R$1[K]> }[keyof R$1];
+/**
+ * AdtInfer types from an AdtUnion or AdtVariant, following Zod's `z.infer` pattern.
+ *
+ * - For ADTs: Returns the union of all variant types
+ * - For AdtVariants: Returns the individual variant type
+ *
+ * @example
+ * ```ts
+ * // AdtInfer union type from AdtUnion
+ * const Shape = union('Shape', { Circle, Square })
+ * type Shape = AdtInfer<typeof Shape>
+ * // => { _tag: 'Circle', radius: number } | { _tag: 'Square', size: number }
+ *
+ * // Infer individual variant type
+ * type Circle = AdtInfer<typeof Shape.Circle>
+ * // => { _tag: 'Circle', radius: number }
+ * ```
+ */
+type AdtInfer$1<T> = T extends AdtUnion<infer R> ? Prettify<InferADTUnion<R>> : T extends AdtVariant<infer Tag, infer S> ? Prettify<AdtInferOutput<S> & Discriminator<Tag>> : never;
+/**
+ * Extract the union of all variant names from an AdtUnion.
+ *
+ * @example
+ * ```ts
+ * const Shape = union('Shape', { Circle, Square })
+ * type Names = AdtVariantNames<typeof Shape> // "Circle" | "Square"
+ * ```
+ */
+type AdtVariantNames$1<T> = T extends AdtUnion<infer R> ? keyof R & string : never;
+/**
+ * Extract the type of a specific variant from an AdtUnion.
+ *
+ * @example
+ * ```ts
+ * const Shape = union('Shape', { Circle, Square })
+ * type CircleType = AdtVariantOf<typeof Shape, "Circle">
+ * // => { _tag: "Circle", radius: number }
+ * ```
+ */
+type AdtVariantOf$1<T, K$1 extends string> = T extends AdtUnion<infer R> ? K$1 extends keyof R ? Prettify<AdtInferOutput<AdtExtractSchema<R[K$1]>> & Discriminator<K$1>> : never : never;
+//#endregion
+//#region src/adt/adt.union.d.ts
+/**
+ * Compose records or schemas into a discriminated union (AdtUnion).
+ *
+ * Accepts either:
+ * - Pre-built AdtVariants from variant() (codecs are preserved)
+ * - Raw Standard Schema validators (will be wrapped internally)
+ *
+ * When using pre-built records, the object key overrides the original _tag.
+ *
+ * @template R - Record of variant names to AdtVariants or StandardSchema validators
+ * @param name - The name of this AdtUnion (for identification)
+ * @param records - An object mapping _tag names to AdtVariants or schemas
+ * @returns An AdtUnion object with accessors for each variant
+ *
+ * @see {@link variant} for creating individual variant types
+ * @see {@link match} for exhaustive pattern matching on AdtUnion values
+ *
+ * @example
+ * ```ts
+ * // From pre-built variants
+ * const Circle = variant('Circle', CircleSchema)
+ * const Square = variant('Square', SquareSchema)
+ * const Shape = union('Shape', { Circle, Square })
+ *
+ * // From raw schemas (JSON codec is automatically included)
+ * const Shape = union('Shape', {
+ *   Circle: CircleSchema,
+ *   Square: SquareSchema
+ * })
+ *
+ * // JSON codec works on all variants
+ * Shape.Circle.to.json({ radius: 10 })
+ * Shape.Circle.from.json(jsonString)
+ *
+ * // Mixed
+ * const Shape = union('Shape', {
+ *   Circle,              // Pre-built variant
+ *   Square: SquareSchema // Raw schema
+ * })
+ *
+ * // Usage
+ * Shape.Circle({ radius: 10 })
+ * Shape.is(someValue)        // type guard for any variant
+ * Shape.Circle.is(someValue) // type guard for Circle
+ * ```
+ */
+declare function union$1<R$1 extends Record<string, AdtVariantDef>>(name: string, records: R$1): AdtUnion<R$1>;
+//#endregion
+//#region src/adt/adt.variant.d.ts
+/**
+ * Create a standalone tagged variant from a Standard Schema with optional codecs.
+ *
+ * Variants can be used independently or composed into an AdtUnion via union().
+ * All defaults should be defined at the schema level (e.g., Zod's .default()).
+ *
+ * @template Tag - The string literal type for the _tag discriminator
+ * @template S - The Standard Schema type for validation
+ * @template Codecs - Optional codec definitions for custom serialization formats
+ * @param _tag - The _tag discriminator value
+ * @param schema - A Standard Schema compliant validator
+ * @param codecs - Optional codec definitions for custom serialization formats
+ * @returns A callable AdtVariant with is(), to, and from methods
+ *
+ * @see {@link union} for composing variants into discriminated unions
+ * @see {@link tagged} for unvalidated tagged value constructors
+ *
+ * @example
+ * ```ts
+ * const CircleSchema = z.object({
+ *   radius: z.number().positive(),
+ *   color: z.string().default('blue')
+ * })
+ *
+ * // Basic variant with JSON codec (always included)
+ * const Circle = variant('Circle', CircleSchema)
+ *
+ * const result = Circle({ radius: 10 })
+ * // { _tag: "Ok", value: { _tag: "Circle", radius: 10, color: "blue" } }
+ *
+ * Circle.is(someValue) // type guard
+ *
+ * const json = Circle.to.json({ radius: 10 }) // JSON string
+ * const result2 = Circle.from.json(json) // Result<Circle, AdtCodecError>
+ *
+ * // Variant with custom codec
+ * const Circle2 = variant('Circle', CircleSchema, {
+ *   graphic: {
+ *     to: (circle) => `(${circle.radius})`,
+ *     from: (input: string) => {
+ *       const match = input.match(/^\((\d+)\)$/)
+ *       return match ? { radius: parseInt(match[1]!) } : null
+ *     }
+ *   }
+ * })
+ *
+ * const graphic = Circle2.to.graphic({ radius: 10 }) // "(10)"
+ * const result3 = Circle2.from.graphic("(10)") // Result<Circle, AdtCodecError>
+ * ```
+ */
+declare function variant$1<Tag$1 extends string, S$1 extends StandardSchemaV1, Codecs extends AdtCodecConstraint<Tag$1, S$1>>(_tag: Tag$1, schema: S$1, codecs: Codecs): AdtVariant<Tag$1, S$1, Codecs>;
+declare function variant$1<Tag$1 extends string, S$1 extends StandardSchemaV1>(_tag: Tag$1, schema: S$1): AdtVariant<Tag$1, S$1>;
+declare namespace adt_d_exports {
+  export { AdtInfer, AdtVariantNames, AdtVariantOf, match, union, variant };
+}
+/**
+ * Re-exported ADT inferred union helper.
+ *
+ * @example
+ * ```ts
+ * import { Adt } from "@nicolastoulemont/std"
+ *
+ * type Example = typeof Adt
+ * ```
+ *
+ * @category Type-level
+ */
+type AdtInfer<T> = AdtInfer$1<T>;
+/**
+ * Re-exported union variant name helper.
+ *
+ * @example
+ * ```ts
+ * import { Adt } from "@nicolastoulemont/std"
+ *
+ * type Example = typeof Adt
+ * ```
+ *
+ * @category Type-level
+ */
+type AdtVariantNames<T> = AdtVariantNames$1<T>;
+/**
+ * Re-exported helper to extract a specific variant from an ADT.
+ *
+ * @example
+ * ```ts
+ * import { Adt } from "@nicolastoulemont/std"
+ *
+ * type Example = typeof Adt
+ * ```
+ *
+ * @category Type-level
+ */
+type AdtVariantOf<T, K$1 extends string> = AdtVariantOf$1<T, K$1>;
+/**
+ * Build an ADT union from named variants.
+ *
+ * @example
+ * ```ts
+ * import { Adt } from "@nicolastoulemont/std"
+ *
+ * const Shape = Adt.union("Shape", {} as never)
+ * // => union helper with tagged constructors
+ * ```
+ *
+ * @category Constructors
+ */
+declare const union: typeof union$1;
+/**
+ * Define one ADT variant with schema-backed validation.
+ *
+ * @example
+ * ```ts
+ * import { Adt } from "@nicolastoulemont/std"
+ *
+ * const Circle = Adt.variant("Circle", {} as never)
+ * // => callable variant constructor
+ * ```
+ *
+ * @category Constructors
+ */
+declare const variant: typeof variant$1;
+/**
+ * Match over ADT variants by discriminator tag.
+ *
+ * @example
+ * ```ts
+ * import { Adt } from "@nicolastoulemont/std"
+ *
+ * const label = Adt.match({ _tag: "Circle", radius: 2 } as const, {
+ *   Circle: (circle) => `r=${circle.radius}` ,
+ * })
+ * // => "r=2"
+ * ```
+ *
+ * @category Pattern Matching
+ */
+declare const match: typeof match$1;
+//#endregion
+export { adt_d_exports as t };
+//# sourceMappingURL=index-DKS1g1oC.d.mts.map

package/dist/index-DKS1g1oC.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DKS1g1oC.d.mts","names":[],"sources":["../src/adt/adt.match.ts","../src/adt/adt.types.ts","../src/adt/adt.union.ts","../src/adt/adt.variant.ts","../src/adt/adt.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;KAOK,gBACG,CAAA,UAAA;EAA4B,SAAA,IAAA,EAAA,MAAA;CAAoB,EAAA,OAAA,CAAA,GAAA,QAAhD,CAAoB,CAAA,MAAA,CAAA,GAAA,CAAA,KAAA,EAAA,OAAA,CAAQ,CAAR,EAAA;EAAqC,SAAA,IAAA,EAAT,CAAS;AAAO,CAAA,CAAA,EAAA,GAAP,OAAO,EAgCxE;;;;;;;;;;;;;;AC3BA;;;;;AAsCA;;;;;;;;AAcA;AAeA;;AAAoE,iBDxCpD,OCwCoD,CAAA,UAAA;EAAZ,SAAA,IAAA,EAAA,MAAA;CAAW,EAAA,OAAA,EAAA,iBDrChD,gBCqCgD,CDrC/B,CCqC+B,EDrC5B,OCqC4B,CAAA,GDrCjB,gBCqCiB,CDrCA,CCqCA,EDrCG,OCqCH,CAAA,CAAA,CAAA,KAAA,EDpC1D,CCoC0D,EAAA,QAAA,EDpC7C,QCoC6C,CAAA,EDpClC,OCoCkC;;;;;;;ADxE/B,KCKxB,kBAAA,GDLwB;EAAoB,SAAA,MAAA,ECMrC,aDNqC,CAAA;IAA5B,SAAA,OAAA,EAAA,MAAA;IAAqC,SAAA,IAAA,CAAA,ECQ7C,aDR6C,CCQ/B,WDR+B,CAAA,GAAA,SAAA;EAAO,CAAA,CAAA;AAgCxE,CAAA;;;;;;ACWuF,KAA3E,kBAA2E,CAAA,cAAA,MAAA,EAAA,YAA1B,gBAA0B,CAAA,GAAN,MAAM,CAAA,MAAA,EAAA;EAc3E,EAAA,EAAA,CAAA,KAAA,EAVI,cAUS,CAVM,GAUN,CAIK,GAdM,aAcN,CAdoB,KAcF,CAAA,EAAA,GAAA,GAAA;EAWpC,IAAA,EAAA,CAAA,KAAA,EAAA,GAAa,EAAA,GAAA,GAAA;CAAW,CAAA;;;;AAMpC;AAAqC,KArBzB,aAAA,GAqByB;EAAgC,SAAA,IAAA,EAAA,eAAA,GAAA,eAAA,GAAA,iBAAA;EAAZ,SAAA,OAAA,EAAA,MAAA;EAAW,SAAA,KAAA,CAAA,EAAA,OAAA;EAW/D,SAAA,gBAAe,CAAA,EA5BU,kBA4BH,CAAA,QAAA,CAAA;AAAA,CAAA;AAe3B;;;;AACoD,KAjCxC,aAiCwC,CAAA,YAjChB,gBAiCgB,CAAA,GAjCI,WAiCJ,CAjCgB,GAiChB,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,OAAA,CAAA;;;;;AAIH,KA/BrC,cA+BqC,CAAA,YA/BZ,gBA+BY,CAAA,GA/BQ,WA+BR,CA/BoB,GA+BpB,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,QAAA,CAAA;;;;;KApB5C,eAoBsF,CAAA,CAAA,CAAA,GApBjE,CAoBiE,SAAA;EAAnC,EAAA,EAAA,CAAA,KAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA;CAAM,GAAA,CAAA,GAAA,KAAA;AAU9D;;;;KAvBK,gBAwB+D,CAAA,CAAA,CAAA,GAxBzC,CAwByC,SAAA;EAAd,IAAA,EAAA,CAAA,KAAA,EAAA,KAAA,EAAA,EAAA,GAAA,GAAA;CAAoB,GAAA,CAAA,GAAA,KAAA;;;;;;;AAK3D,KArBH,SAqBG,CAAA,YArBiB,gBAqBjB,EAAA,MAAA,CAAA,GAAA;EACkB,IAAA,EAAA,CAAA,KAAA,EArBjB,aAqBiB,CArBH,GAqBG,CAAA,EAAA,GArBI,MAqBJ,CAAA,MAAA,EArBmB,aAqBnB,CAAA;CAAf,GAAA,CAnBb,MAmBa,SAnBE,MAmBF,CAAA,MAAA,EAAA,GAAA,CAAA,GAAA,QAAkC,MAjBlC,MAiBkC,GAAA,CAAA,KAAA,EAjBjB,aAiBiB,CAjBH,GAiBG,CAAA,EAAA,GAjBI,MAiBJ,CAjBW,eAiBX,CAjB2B,MAiB3B,CAjBkC,CAiBlC,CAAA,CAAA,EAjBuC,aAiBvC,CAAA,EAAd,GAAA,MAAA,CAAA;;;;AAatC;;;AAGoC,KAvBxB,WAuBwB,CAAA,cAAA,MAAA,EAAA,YAvBkB,gBAuBlB,EAAA,MAAA,CAAA,GAAA;EAAK,IAAA,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAtBd,MAsBc,CAtBP,cAsBO,CAtBQ,GAsBR,CAAA,GAtBa,aAsBb,CAtB2B,KAsB3B,CAAA,EAtBiC,aAsBjC,CAAA;CAAxB,GAAA,CApBZ,MAoBY,SApBG,MAoBH,CAAA,MAAA,EAAA,GAAA,CAAA,GAAA,QAKA,MAvBC,MAuBD,GAAA,CAAA,KAAA,EAtBF,gBAsBE,CAtBe,MAsBf,CAtBsB,CAsBtB,CAAA,CAAA,EAAA,GArBN,MAqBM,CArBC,cAqBD,CArBgB,GAqBhB,CAAA,GArBqB,aAqBrB,CArBmC,KAqBnC,CAAA,EArByC,aAqBzC,CAAA,EAEE,GAAA,MAAA,CAAA;;;;;;AAQmD,KAlB1D,UAkB0D,CAAA,cAAA,MAAA,GAAA,MAAA,EAAA,YAhB1D,gBAgB0D,GAhBvC,gBAgBuC,EAAA,eAfrD,kBAeqD,CAflC,KAekC,EAf7B,GAe6B,CAAA,GAAA,SAAA,GAAA,SAAA,CAAA,GAAA;EAAd;EAAoB,SAAA,QAAA,EAAA,IAAA;EAA/C;EAKiB,SAAA,IAAA,EAf7B,KAe6B;EAAf;EAAkC,SAAA,MAAA,EAb9C,GAa8C;EAAd;EAK1B,SAAA,MAAA,CAAA,EAhBL,MAgBK;EAAG;;;;;EAMX,CAAA,KAAA,EAhBP,aAgBO,CAhBO,GAgBP,CAAA,CAAA,EAhBY,MAgBZ,CAhBmB,cAgBnB,CAhBkC,GAgBlC,CAAA,GAhBuC,aAgBvC,CAhBqD,KAgBrD,CAAA,EAhB2D,kBAgB3D,CAAA;EAKU;;;;EAA2C,EAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAhBvC,cAgBuC,CAhBxB,GAgBwB,CAAA,GAhBnB,aAgBmB,CAhBL,KAgBK,CAAA;EAAf;;;;EAMzC,SAAA,EAAA,EAjBC,SAiBD,CAjBW,GAiBX,EAjBc,MAiBd,CAAA;EAAkC;;;AAahD;AAA2E;EAU3C,SAAA,IAAA,EAlCf,WAkCe,CAlCH,KAkCG,EAlCE,GAkCF,EAlCK,MAkCL,CAAA;EAE9B;;;;EAA8E,MAAA,CAAA,CAAA,EA/BpE,cA+BoE,CA/BrD,GA+BqD,CAAA,GA/BhD,aA+BgD,CA/BlC,KA+BkC,CAAA,EAAA,CAAA,EA/BzB,cA+ByB,CA/BV,GA+BU,CAAA,GA/BL,aA+BK,CA/BS,KA+BT,CAAA,CAAA,EAAA,OAAA;EAAC;AAAA;;;;EAMf,IAAA,CAAA,KAAA,EA/BpD,cA+BoD,CA/BrC,GA+BqC,CAAA,GA/BhC,aA+BgC,CA/BlB,KA+BkB,CAAA,CAAA,EAAA,MAAA;AAOlE,CAAA;;;;;;AAWY,KApCA,aAAA,GAAgB,gBAoChB,GApCmC,UAoCnC,CAAA,MAAA,EAAA,GAAA,EAAA,GAAA,CAAA;;;;KA1BP,gBA8BS,CAAA,UA9BkB,aA8BlB,CAAA,GA5BZ,CA4BY,SA5BF,UA4BE,CAAA,MAAA,EAAA,KAAA,EAAA,EAAA,GAAA,CAAA,GAAA,CAAA,GA5BqC,CA4BrC,SA5B+C,gBA4B/C,GA5BkE,CA4BlE,GAAA,KAAA;;;;KAtBT,aAwBuD,CAAA,UAxB/B,aAwB+B,CAAA,GAxBd,CAwBc,SAxBJ,UAwBI,CAAA,MAAA,EAAA,GAAA,EAAA,KAAA,OAAA,CAAA,GAAA,MAAA,GAAA,SAAA;;;;;;AAAhC,KAjBhB,QAiBgB,CAAA,YAjBG,MAiBH,CAAA,MAAA,EAjBkB,aAiBlB,CAAA,CAAA,GAAA;EAUvB;EAAgD,SAAA,KAAA,EAAA,MAAA;EAAiD;;;EACrF,EAAA,CAAA,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAtBc,aAsBd,CAtB4B,GAsB5B,CAAA;EAAG;AAAA;;;EAON,MAAA,CAAA,CAAA,EAxBF,aAwBE,CAxBY,GAwBZ,CAAA,EAAA,CAAA,EAxBmB,aAwBnB,CAxBiC,GAwBjC,CAAA,CAAA,EAAA,OAAA;EAAsB;;;EAAlB,IAAA,CAAA,KAAA,EApBJ,aAoBI,CApBU,GAoBV,CAAA,CAAA,EAAA,MAAA;CACV,GAAA,QAAC,MAnBK,GAmBL,GAnBS,UAmBT,CAnBoB,CAmBpB,GAAA,MAAA,EAnBgC,gBAmBhC,CAnBiD,GAmBjD,CAnBmD,CAmBnD,CAAA,CAAA,EAnBwD,aAmBxD,CAnBsE,GAmBtE,CAnBwE,CAmBxE,CAAA,CAAA,CAAA,EAoBT;;;;KA7BK,iBA+BU,CAAA,cAAA,MAAA,EAAA,YA/BsC,aA+BtC,CAAA,GA/BuD,cA+BvD,CA/BsE,gBA+BtE,CA/BuF,GA+BvF,CAAA,CAAA,GAAA;EAAT,SAAA,IAAA,EA9BW,KA8BX;CACA;;;;KAzBD,aA0B8C,CAAA,YA1BtB,MA0BsB,CAAA,MAAA,EA1BP,aA0BO,CAAA,CAAA,GAAA,QAAd,MAzBvB,GAyBuB,GAzBnB,iBAyBmB,CAzBD,CAyBC,GAAA,MAAA,EAzBW,GAyBX,CAzBa,CAyBb,CAAA,CAAA,EAA7B,CAAA,MAxBA,GAwBA,CAAA;;AAgBR;;;;;AAYA;;;;;;;;;;;;AAGgB,KAnCJ,UAmCI,CAAA,CAAA,CAAA,GAlCd,CAkCc,SAlCJ,QAkCI,CAAA,KAAA,EAAA,CAAA,GAjCV,QAiCU,CAjCD,aAiCC,CAjCa,CAiCb,CAAA,CAAA,GAhCV,CAgCU,SAhCA,UAgCA,CAAA,KAAA,IAAA,EAAA,KAAA,EAAA,CAAA,GA/BR,QA+BQ,CA/BC,cA+BD,CA/BgB,CA+BhB,CAAA,GA/BqB,aA+BrB,CA/BmC,GA+BnC,CAAA,CAAA,GAAA,KAAA;;;;AC7QhB;;;;;;AAAkG,KD8PtF,iBC9PsF,CAAA,CAAA,CAAA,GD8PjE,CC9PiE,SD8PvD,QC9PuD,CAAA,KAAA,EAAA,CAAA,GAAA,MD8P7B,CC9P6B,GAAA,MAAA,GAAA,KAAA;;;;ACQlG;;;;;;;AAGU,KF+PE,cE/PF,CAAA,CAAA,EAAA,YAAA,MAAA,CAAA,GFgQR,CEhQQ,SFgQE,QEhQF,CAAA,KAAA,EAAA,CAAA,GFiQJ,GEjQI,SAAA,MFiQY,CEjQZ,GFkQF,QElQE,CFkQO,cElQP,CFkQsB,gBElQtB,CFkQuC,CElQvC,CFkQyC,GElQzC,CAAA,CAAA,CAAA,GFkQgD,aElQhD,CFkQ8D,GElQ9D,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;;;;;;;;;;;;;;;AHvBV;;;;;;;;;;;;;;AC3BA;;;;;AAsCA;;;;;;;;AAcA;AAeA;;;;;AAMA;AAAqC,iBClCrB,ODkCqB,CAAA,YClCL,MDkCK,CAAA,MAAA,EClCU,aDkCV,CAAA,CAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EClCiD,GDkCjD,CAAA,EClCqD,QDkCrD,CClC8D,GDkC9D,CAAA;;;;;;;;;;;;;;AD9CrC;;;;;;;;;;;;;;AC3BA;;;;;AAsCA;;;;;;;;AAcA;AAeA;;;;;AAMA;;;;;AAAuG;AAkBlG,iBE5CW,SF4CK,CAAA,cAAO,MAAA,EAAA,YE5C0B,gBF4C1B,EAAA,eE5C2D,kBF4C3D,CE5C8E,KF4C9E,EE5CmF,GF4CnF,CAAA,CAAA,CAAA,IAAA,EE3CpB,KF2CoB,EAAA,MAAA,EE1ClB,GF0CkB,EAAA,MAAA,EEzClB,MFyCkB,CAAA,EExCzB,UFwCyB,CExCd,KFwCc,EExCT,GFwCS,EExCN,MFwCM,CAAA;AAQhB,iBE7CI,SF6CK,CAAA,cAAA,MAAA,EAAA,YE7CiC,gBF6CjC,CAAA,CAAA,IAAA,EE7CyD,KF6CzD,EAAA,MAAA,EE7CsE,GF6CtE,CAAA,EE7C0E,UF6C1E,CE7CqF,KF6CrF,EE7C0F,GF6C1F,CAAA;AAAA;;;AA7DrB;;;;;;;;AAcA;AAeA;;;AAAwD,KG/B5C,QH+B4C,CAAA,CAAA,CAAA,GG/B9B,UH+B8B,CG/BjB,CH+BiB,CAAA;;AAMxD;;;;;AAAuG;AAW5E;AAe3B;;;;AACoD,KGlDxC,eHkDwC,CAAA,CAAA,CAAA,GGlDnB,iBHkDmB,CGlDC,CHkDD,CAAA;;;;;;;;;;;;;AAcxC,KGlDA,YHkDW,CAAA,CAAA,EAAA,YAAA,MAAA,CAAA,GGlDyB,cHkDzB,CGlD0C,CHkD1C,EGlD6C,GHkD7C,CAAA;;;;;;;;;;;;;;AAOU,cG1CpB,KH0CoB,EAAA,OG1Cf,OH0Ce;;;;;;;AAajC;;;;;;;AAUmB,cGlDN,OHkDM,EAAA,OGlDC,SHkDD;;;;;;;;;;;;;;;;AAkBJ,cGnDF,KHmDE,EAAA,OGnDG,OHmDH"}