@nicolastoulemont/std 0.7.1 → 0.8.0

package/dist/{index-DXbYlSnB.d.mts → index-BA0EsFxS.d.mts}

@@ -1,64 +1,7 @@
-import { t as Result } from "./result.types-_xDAei3-.mjs";
+import { t as Result } from "./result.types-BKzChyWY.mjs";
+import { i as Validator, n as Branded$1, r as Unbrand, t as BrandError$1 } from "./brand.types-B3NDX1vo.mjs";
 
-//#region src/brand/brand.types.d.ts
-/**
- * Unique symbol for brand keys to ensure true nominal typing.
- * Using a symbol prevents collision with actual property keys.
- */
-declare const BrandSymbol: unique symbol;
-/**
- * A brand type that adds nominal typing to TypeScript.
- * The brand exists only at the type level - no runtime cost.
- *
- * @template K - The brand key (typically a string literal type)
- */
-type Brand<K extends string> = {
-  readonly [BrandSymbol]: K;
-};
-/**
- * Create a branded type by intersecting a base type with a brand.
- * The resulting type is structurally compatible with T but nominally unique.
- *
- * @template T - The base type to brand
- * @template K - The brand key (string literal)
- *
- * @example
- * ```ts
- * type UserId = Branded<string, "UserId">
- * type OrderId = Branded<string, "OrderId">
- *
- * // UserId and OrderId are incompatible even though both are strings
- * declare const userId: UserId
- * declare const orderId: OrderId
- * userId = orderId // Type error!
- * ```
- */
-type Branded$1<T, K extends string> = T & Brand<K>;
-/**
- * Extract the base type from a branded type.
- * Useful for working with the underlying value.
- *
- * @template B - A branded type
- */
-type Unbrand<B> = B extends Branded$1<infer T, string> ? T : B;
-/**
- * A validation function that checks if a value can be branded.
- * Returns true if the value passes validation, false otherwise.
- *
- * @template T - The base type being validated
- */
-type Validator<T> = (value: T) => boolean;
-/**
- * Error type returned when brand validation fails.
- * Contains the original value and error message for debugging.
- *
- * @template T - The type of the value that failed validation
- */
-type BrandError$1<T = unknown> = {
-  readonly _tag: "BrandError";
-  readonly value: T;
-  readonly message: string;
-};
+//#region src/brand/brand.d.ts
 declare namespace brand_d_exports {
   export { BrandError, Branded, is, make, refine, unsafeMake };
 }
@@ -71,8 +14,6 @@ declare namespace brand_d_exports {
  *
  * type Example = typeof Brand
  * ```
- *
- * @category Type-level
  */
 type Branded<T, K extends string> = Branded$1<T, K>;
 /**
@@ -84,8 +25,6 @@ type Branded<T, K extends string> = Branded$1<T, K>;
  *
  * type Example = typeof Brand
  * ```
- *
- * @category Type-level
  */
 type BrandError<T> = BrandError$1<T>;
 /**
@@ -108,8 +47,6 @@ type BrandError<T> = BrandError$1<T>;
  * const userId = Brand.make<UserId>(raw)
  * // => brand-preserving cast
  * ```
- *
- * @category Utilities
  */
 declare const make: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
 /**
@@ -129,8 +66,6 @@ declare const make: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B
  * const userId = Brand.unsafeMake<UserId>(raw)
  * // => unchecked brand cast
  * ```
- *
- * @category Utilities
  */
 declare const unsafeMake: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
 /**
@@ -151,8 +86,6 @@ declare const unsafeMake: <B extends Branded<unknown, string>>(value: Unbrand<B>
  * const valid = isUserId("user_123")
  * // => true
  * ```
- *
- * @category Utilities
  */
 declare const is: <T, K extends string>(validator: Validator<T>) => ((value: T) => value is Branded<T, K>);
 /**
@@ -172,13 +105,11 @@ declare const is: <T, K extends string>(validator: Validator<T>) => ((value: T)
  *
  * type UserId = Brand.Branded<string, "UserId">
  * const toUserId = Brand.refine<UserId>((value) => value.startsWith("user_"), "Invalid user id")
- * const parsed = toUserId("user_123" as UserId)
+ * const parsed = toUserId("user_123")
  * // => { _tag: "Ok", value: "user_123" }
  * ```
- *
- * @category Utilities
  */
 declare const refine: <B extends Branded<unknown, string>>(validator: Validator<Unbrand<B>>, errorMessage?: string | ((value: Unbrand<B>) => string)) => ((value: Unbrand<B>) => Result<B, BrandError<Unbrand<B>>>);
 //#endregion
 export { brand_d_exports as t };
-//# sourceMappingURL=index-DXbYlSnB.d.mts.map
+//# sourceMappingURL=index-BA0EsFxS.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BA0EsFxS.d.mts","names":[],"sources":["../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;KA4CY,+BAA+B,UAAY,GAAG;AAA1D;;;;;AAYA;AAyBA;;;;AAA6E,KAzBjE,UAyBiE,CAAA,CAAA,CAAA,GAzBjD,YAyBiD,CAzBlC,CAyBkC,CAAA;;AAsB7E;;;;;;AAuBA;;;;;;;;AAyBA;;;;;;AAEmC,cAxEtB,IAwEsB,EAAA,CAAA,UAxEJ,OAwEI,CAAA,OAAA,EAAA,MAAA,CAAA,CAAA,CAAA,KAAA,EAxE6B,OAwE7B,CAxEqC,CAwErC,CAAA,EAAA,GAxE0C,CAwE1C;;;;;;;;;;;;;;;;;;;cAlDtB,uBAAwB,iCAAiC,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;cAuBtE,qCAAsC,UAAU,gBAAc,eAAe,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;cAyBxF,mBAAoB,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}

package/dist/{index-UzMbg1dh.d.mts → index-BqJ1GWAF.d.mts}

@@ -1,4 +1,4 @@
-import { a as OptionFilter, c as OptionMatch, d as OptionUnwrapOr, f as OptionUnwrapOrElse, i as OptionAll, l as OptionOrElse, n as NoSuchElementError$1, o as OptionFlatMap, r as Option$1, s as OptionMap, t as FromTryReturn, u as OptionTap } from "./option.types-qPevEZQd.mjs";
+import { a as OptionFilter, c as OptionMatch, d as OptionUnwrapOr, f as OptionUnwrapOrElse, i as OptionAll, l as OptionOrElse, n as NoSuchElementError$1, o as OptionFlatMap, r as Option$1, s as OptionMap, t as FromTryReturn, u as OptionTap } from "./option.types-D9hrKcfa.mjs";
 
 //#region src/option/option.d.ts
 declare namespace option_d_exports {
@@ -14,8 +14,6 @@ declare namespace option_d_exports {
  * const error = new Option.NoSuchElementError()
  * // => error.name === "NoSuchElementError"
  * ```
- *
- * @category Re-exports
  */
 declare const NoSuchElementError: typeof NoSuchElementError$1;
 /**
@@ -27,8 +25,6 @@ declare const NoSuchElementError: typeof NoSuchElementError$1;
  *
  * type Example = Option.NoSuchElementError
  * ```
- *
- * @category Re-exports
  */
 type NoSuchElementError = InstanceType<typeof NoSuchElementError$1>;
 /**
@@ -40,8 +36,6 @@ type NoSuchElementError = InstanceType<typeof NoSuchElementError$1>;
  *
  * type Example = Option.Option<unknown>
  * ```
- *
- * @category Re-exports
  */
 type Option<T> = Option$1<T>;
 /**
@@ -57,8 +51,6 @@ type Option<T> = Option$1<T>;
  * const value = Option.some(42)
  * // => { _tag: "Some", value: 42 }
  * ```
- *
- * @category Constructors
  */
 declare const some: <T>(value: T) => Option$1<T>;
 /**
@@ -73,8 +65,6 @@ declare const some: <T>(value: T) => Option$1<T>;
  * const value = Option.none<number>()
  * // => { _tag: "None" }
  * ```
- *
- * @category Constructors
  */
 declare const none: <T = never>() => Option$1<T>;
 /**
@@ -90,8 +80,6 @@ declare const none: <T = never>() => Option$1<T>;
  * const value = Option.isSome(Option.some(1))
  * // => true
  * ```
- *
- * @category Guards
  */
 declare const isSome: <T>(option: Option$1<T>) => option is Extract<Option$1<T>, {
   _tag: "Some";
@@ -106,8 +94,6 @@ declare const isSome: <T>(option: Option$1<T>) => option is Extract<Option$1<T>,
  * const value = Option.isNone(Option.none())
  * // => true
  * ```
- *
- * @category Guards
  */
 declare const isNone: <T>(option: Option$1<T>) => option is Extract<Option$1<T>, {
   _tag: "None";
@@ -120,12 +106,12 @@ declare const isNone: <T>(option: Option$1<T>) => option is Extract<Option$1<T>,
  * - Data-first: `map(option, fn)`
  * - Data-last: `pipe(option, map(fn))`
  *
- * Supports both sync and async functions:
- * - Sync fn: returns Option<U>
- * - Async fn: returns Promise<Option<U>>
+ * Supports both sync and async callbacks:
+ * - Sync fn: returns U
+ * - Async fn: returns Promise<U>
  *
- * @param fn - Function to transform the value
- * @returns A function that takes an Option and returns a new Option
+ * @param fn - Function that transforms the contained value
+ * @returns The mapped Option in data-first form, or a function that maps an Option in data-last form
  *
  * @example
  * ```ts
@@ -138,8 +124,6 @@ declare const isNone: <T>(option: Option$1<T>) => option is Extract<Option$1<T>,
  * const dataLast = Option.map((n: number) => n + 1)(input)
  * // => { _tag: "Some", value: 3 }
  * ```
- *
- * @category Mapping
  */
 declare const map: OptionMap;
 /**
@@ -155,7 +139,7 @@ declare const map: OptionMap;
  * - Async fn: returns Promise<Option<U>>
  *
  * @param fn - Function that takes a value and returns an Option (or Promise<Option>)
- * @returns A function that takes an Option and returns a new Option
+ * @returns The resulting Option in data-first form, or a function that flatMaps an Option in data-last form
  *
  * @example
  * ```ts
@@ -168,8 +152,6 @@ declare const map: OptionMap;
  * const dataLast = Option.flatMap((n: number) => Option.some(n + 1))(input)
  * // => { _tag: "Some", value: 3 }
  * ```
- *
- * @category Sequencing
  */
 declare const flatMap: OptionFlatMap;
 /**
@@ -181,12 +163,12 @@ declare const flatMap: OptionFlatMap;
  * - Data-first: `tap(option, fn)`
  * - Data-last: `pipe(option, tap(fn))`
  *
- * Supports both sync and async functions:
- * - Sync fn: returns Option<T>
- * - Async fn: returns Promise<Option<T>>
+ * Supports both sync and async side effects:
+ * - Sync fn: returns any value (ignored)
+ * - Async fn: returns Promise<unknown>
  *
  * @param fn - Function to call with the value (return value is ignored)
- * @returns A function that takes an Option and returns the same Option
+ * @returns The original Option in data-first form, or a function that taps an Option in data-last form
  *
  * @example
  * ```ts
@@ -204,8 +186,6 @@ declare const flatMap: OptionFlatMap;
  * })(input)
  * // => { _tag: "Some", value: 2 }
  * ```
- *
- * @category Sequencing
  */
 declare const tap: OptionTap;
 /**
@@ -216,12 +196,12 @@ declare const tap: OptionTap;
  * - Data-first: `orElse(option, fn)`
  * - Data-last: `pipe(option, orElse(fn))`
  *
- * Supports both sync and async functions:
- * - Sync fn: returns Option<T | U>
- * - Async fn: returns Promise<Option<T | U>>
+ * Supports both sync and async fallback functions:
+ * - Sync fn: returns Option<U>
+ * - Async fn: returns Promise<Option<U>>
  *
  * @param fn - Function that returns an alternative Option
- * @returns A function that takes an Option and returns a new Option
+ * @returns The original or fallback Option in data-first form, or a function that recovers from none in data-last form
  *
  * @example
  * ```ts
@@ -234,8 +214,6 @@ declare const tap: OptionTap;
  * const dataLast = Option.orElse(() => Option.some(0))(input)
  * // => { _tag: "Some", value: 0 }
  * ```
- *
- * @category Combining
  */
 declare const orElse: OptionOrElse;
 /**
@@ -248,7 +226,7 @@ declare const orElse: OptionOrElse;
  * - Data-last: `pipe(option, filter(predicate))`
  *
  * @param predicate - Function that returns true to keep the value
- * @returns A function that takes an Option and returns a new Option
+ * @returns The filtered Option in data-first form, or a function that filters an Option in data-last form
  *
  * @example
  * ```ts
@@ -261,8 +239,6 @@ declare const orElse: OptionOrElse;
  * const dataLast = Option.filter((n: number) => n > 0)(input)
  * // => { _tag: "Some", value: 3 }
  * ```
- *
- * @category Filtering
  */
 declare const filter: OptionFilter;
 /**
@@ -282,8 +258,6 @@ declare const filter: OptionFilter;
  * const combined = Option.all([Option.some(1), Option.some(2)] as const)
  * // => { _tag: "Some", value: [1, 2] }
  * ```
- *
- * @category Combining
  */
 declare const all: OptionAll;
 /**
@@ -296,7 +270,7 @@ declare const all: OptionAll;
  * Uses NoInfer to prevent type inference from the default value.
  *
  * @param defaultValue - Value to return if the Option is none
- * @returns A function that takes an Option and returns the value or default
+ * @returns The unwrapped value in data-first form, or a function that unwraps an Option with a default in data-last form
  *
  * @example
  * ```ts
@@ -309,8 +283,6 @@ declare const all: OptionAll;
  * const dataLast = Option.unwrapOr(0)(input)
  * // => 0
  * ```
- *
- * @category Getters
  */
 declare const unwrapOr: OptionUnwrapOr;
 /**
@@ -321,7 +293,7 @@ declare const unwrapOr: OptionUnwrapOr;
  * - Data-last: `pipe(option, unwrapOrElse(fn))`
  *
  * @param fn - Function to compute a value
- * @returns A function that takes an Option and returns the value or computed value
+ * @returns The unwrapped value in data-first form, or a function that unwraps an Option lazily in data-last form
  *
  * @example
  * ```ts
@@ -334,8 +306,6 @@ declare const unwrapOr: OptionUnwrapOr;
  * const dataLast = Option.unwrapOrElse(() => 0)(input)
  * // => 0
  * ```
- *
- * @category Getters
  */
 declare const unwrapOrElse: OptionUnwrapOrElse;
 /**
@@ -346,7 +316,7 @@ declare const unwrapOrElse: OptionUnwrapOrElse;
  * - Data-last: `pipe(option, match({ Some: ..., None: ... }))`
  *
  * @param handlers - Object with `Some` and `None` handlers
- * @returns A function that takes an Option and returns the handler result
+ * @returns The handler result in data-first form, or a function that matches an Option in data-last form
  *
  * @example
  * ```ts
@@ -365,8 +335,6 @@ declare const unwrapOrElse: OptionUnwrapOrElse;
  * })(input)
  * // => "some:2"
  * ```
- *
- * @category Pattern Matching
  */
 declare const match: OptionMatch;
 /**
@@ -379,8 +347,6 @@ declare const match: OptionMatch;
  * const value = Option.fromNullable("Ada")
  * // => { _tag: "Some", value: "Ada" }
  * ```
- *
- * @category Conversions
  */
 declare const fromNullable: <T>(value: T) => Option$1<NonNullable<T>>;
 /**
@@ -406,10 +372,8 @@ declare const fromNullable: <T>(value: T) => Option$1<NonNullable<T>>;
  * const parsed = Option.fromTry(() => Number.parseInt("42", 10))
  * // => { _tag: "Some", value: 42 }
  * ```
- *
- * @category Conversions
  */
 declare const fromTry: <T>(fn: () => T) => FromTryReturn<T>;
 //#endregion
 export { option_d_exports as t };
-//# sourceMappingURL=index-UzMbg1dh.d.mts.map
+//# sourceMappingURL=index-BqJ1GWAF.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BqJ1GWAF.d.mts","names":[],"sources":["../src/option/option.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;cA0Da,2BAAkB;;;;;;;;;;AAA/B;AAYY,KAAA,kBAAA,GAAqB,YAAoB,CAAA,OAAA,oBAAR,CAAA;AAY7C;AAsBA;;;;;AA4BA;AAgCA;;;AAA+E,KAlFnE,MAkFmE,CAAA,CAAA,CAAA,GAlFvD,QAkFuD,CAlF5C,CAkF4C,CAAA;;;;AAc/E;;;;;;;AAmCA;AAsCA;AAsCA;AAsCA;AA4Ba,cA3PA,IA8PX,EAHmB,CAAA,CAAA,CAAA,CAAA,KAAA,EA3PU,CA8P7B,EAAA,GA9PiC,QA8PjC,CA9P4C,CA8P5C,CAAA;AAyBF;AAgDA;AA2BA;AAiCA;AAyCA;;;;;;AA2BA;;;AAAyC,cA3a5B,IA2a4B,EAAA,CAAA,IAAA,KAAA,CAAA,GAAA,GA3aN,QA2aM,CA3aK,CA2aL,CAAA;;;;;;;;;;;;;;;cA3Y5B,oBAAqB,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;;;;;;cAclE,oBAAqB,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmClE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA4BR,QAAQ;;;;;;;;;;;;;;;;;;;cA4BR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;cAgDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;cA2BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCd,OAAO;;;;;;;;;;;;cAyCP,yBAA0B,MAAI,SAAW,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;cA2BrD,uBAAwB,MAAI,cAAc"}

package/dist/index-BsPOcZk9.d.mts

@@ -0,0 +1,96 @@
+import { n as Branded } from "./brand.types-B3NDX1vo.mjs";
+import { n as TaggedErrorFactory } from "./index-UINIHFuh.mjs";
+import { t as Result } from "./index-CIvNgjsx.mjs";
+
+//#region src/duration/duration.d.ts
+declare namespace duration_d_exports {
+  export { Duration, DurationInvalidInputError, DurationInvalidValueError, DurationParseError, Input, InputError, ParseError, StringInput, Unit, days, from, hours, millis, minutes, parse, seconds, toMillis, weeks };
+}
+/**
+ * Millisecond-backed branded duration type.
+ */
+type Duration = Branded<number, "Duration">;
+/**
+ * Supported textual duration units.
+ */
+type Unit = "milli" | "millis" | "second" | "seconds" | "minute" | "minutes" | "hour" | "hours" | "day" | "days" | "week" | "weeks";
+/**
+ * String input for durations.
+ */
+type StringInput = `${number} ${Unit}`;
+/**
+ * Accepted duration input shapes.
+ */
+type Input = Duration | number | StringInput;
+declare const DurationParseError_base: TaggedErrorFactory<"DurationParseError">;
+/**
+ * Tagged parse error for invalid duration strings.
+ */
+declare class DurationParseError extends DurationParseError_base<{
+  input: string;
+  message: string;
+}> {}
+declare const DurationInvalidValueError_base: TaggedErrorFactory<"DurationInvalidValueError">;
+/**
+ * Tagged error for invalid numeric duration values.
+ */
+declare class DurationInvalidValueError extends DurationInvalidValueError_base<{
+  input: number;
+  message: string;
+}> {}
+declare const DurationInvalidInputError_base: TaggedErrorFactory<"DurationInvalidInputError">;
+/**
+ * Tagged error for invalid duration input values outside supported shapes.
+ */
+declare class DurationInvalidInputError extends DurationInvalidInputError_base<{
+  input: Input;
+  message: string;
+  cause?: DurationParseError | DurationInvalidValueError;
+}> {}
+/**
+ * Re-exported parse error type.
+ */
+type ParseError = DurationParseError;
+/**
+ * Re-exported duration input error union.
+ */
+type InputError = DurationInvalidInputError | DurationParseError | DurationInvalidValueError;
+/**
+ * Create a duration from milliseconds.
+ */
+declare const millis: (value: number) => Duration;
+/**
+ * Create a duration from seconds.
+ */
+declare const seconds: (value: number) => Duration;
+/**
+ * Create a duration from minutes.
+ */
+declare const minutes: (value: number) => Duration;
+/**
+ * Create a duration from hours.
+ */
+declare const hours: (value: number) => Duration;
+/**
+ * Create a duration from days.
+ */
+declare const days: (value: number) => Duration;
+/**
+ * Create a duration from weeks.
+ */
+declare const weeks: (value: number) => Duration;
+/**
+ * Convert a duration to raw milliseconds.
+ */
+declare const toMillis: (duration: Duration) => number;
+/**
+ * Parse a duration string.
+ */
+declare const parse: (input: string) => Result<Duration, DurationParseError>;
+/**
+ * Normalize supported duration inputs to a branded duration.
+ */
+declare const from: (input: Input) => Result<Duration, InputError>;
+//#endregion
+export { InputError as n, duration_d_exports as r, Input as t };
+//# sourceMappingURL=index-BsPOcZk9.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BsPOcZk9.d.mts","names":[],"sources":["../src/duration/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KA4BY,QAAA,GAAW;;;;KAKX,IAAA;;;;KAiBA,WAAA,gBAA2B;;;;KAK3B,KAAA,GAAQ,oBAAoB;cAAW,yBAAA;;;;cAKtC,kBAAA,SAA2B;;;AAhCxC,CAAA,CAAA,CAAA;AAsBA,cAaK,8BAbsC,EAatC,kBAbsC,CAAA,2BAAA,CAAA;AAK3C;AAAmD;AAKnD;AAGK,cAKQ,yBAAA,SAAkC,8BAL1C,CAAA;EAKQ,KAAA,EAAA,MAAA;EAGR,OAAA,EAAA,MAAA;AAKL,CAAA,CAAA,CAAA;cALK,8BAQK,EARL,kBAQK,CAAA,2BAAA,CAAA;;;;AAME,cATC,yBAAA,SAAkC,8BASJ,CAAA;EAK/B,KAAA,EAbH,KAaG;EAAa,OAAA,EAAA,MAAA;EAA4B,KAAA,CAAA,EAX3C,kBAW2C,GAXtB,yBAWsB;CAAqB,CAAA,CAAA;AAwB1E;AAKA;AAKA;AAKa,KA5CD,UAAA,GAAa,kBA4CkD;AAK3E;AAKA;AAKA;AAiCa,KAvFD,UAAA,GAAa,yBAkHxB,GAlHoD,kBAkHpD,GAlHyE,yBAkHzE;;;;AA3BkD,cA/DtC,MA+DsC,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA/DZ,QA+DY;AAgCnD;;;AAA4D,cA1F/C,OA0F+C,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA1FpB,QA0FoB;;;;cArF/C,4BAA2B;;;;cAK3B,0BAAyB;;;;cAKzB,yBAAwB;;;;cAKxB,0BAAyB;;;;cAKzB,qBAAsB;;;;cAiCtB,0BAAyB,OAAc,UAAU;;;;cAgCjD,cAAe,UAAQ,OAAc,UAAU"}