joist-core 2.3.0 → 2.4.0-next.2

package/build/newTestInstance.d.cts

@@ -0,0 +1,207 @@
+import { ActualFactoryOpts, FactoryExtrasOf, OptsOf } from "./typeMap.cjs";
+import { DeepNew } from "./loading/loadHints.cjs";
+import "./index.cjs";
+import { EntityConstructor, EntityManager, IdOf, MaybeAbstractEntityConstructor } from "./EntityManager.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/newTestInstance.d.ts
+/**
+ * A proxy that allows accessing factory-created entities by their factory id.
+ *
+ * For example, after creating entities with `as` keys:
+ *
+ * ```ts
+ * newAuthor(em, { books: [{ is: "b#1" }, { is: "b#2", prequel: "b#1" }] });
+ * const { b1, b2 } = factories;
+ * ```
+ *
+ * The proxy parses property names like `b1` into `b#1` and looks up the entity
+ * in the most recently used EntityManager.
+ */
+declare const factories: Record<string, any>;
+/**
+ * DeepPartial-esque type specific to our `newTestInstance` factory.
+ *
+ * Specifically (vs using DeepPartial directly) this:
+ *
+ * 1. Adds a `use` tag of `Entity | Entity[]` that will be checked for existing
+ * entities before creating new ones (i.e. "if `newTestInstance` needs a `Book`,
+ * use the one in `use` instead of making a new one).
+ *
+ * 2. Works specifically against the constructor/entity opts fields.
+ */
+type FactoryOpts<T extends Entity> = DeepPartialOpts<T> & {
+  is?: string;
+  use?: Entity | Entity[];
+  useFactoryDefaults?: boolean | "none";
+  useExistingCheck?: boolean;
+  useLogging?: boolean;
+} & { [K in keyof FactoryExtrasOf<T>]?: FactoryExtrasOf<T>[K]; };
+declare const testDate: Date;
+declare const testPlainDate: import("temporal-spec").Temporal.PlainDate | undefined;
+declare const testPlainDateTime: import("temporal-spec").Temporal.PlainDateTime | undefined;
+declare const testZonedDateTime: import("temporal-spec").Temporal.ZonedDateTime | undefined;
+/**
+ * Creates a test instance of `T`.
+ *
+ * If the factory code passes factoryOpts.useExisting, they can "intercept" the `em.create`
+ * to try and resolve "already created" / singleton instances. The `useExisting` callback is
+ * useful b/c the `opts` will be the "resolved-to-entity" opts, and not the raw "maybe object
+ * literal, maybe object instance" opts that tests pass into the factory.
+ */
+declare function newTestInstance<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>,
+/** The test's test-specific override opts. */
+testOpts?: FactoryOpts<T>,
+/** The factory file's default opts. */
+factoryOpts?: FactoryOpts<T> & {
+  useExisting?: (opts: OptsOf<T>, existing: DeepNew<T>) => boolean;
+}): DeepNew<T>;
+/**
+ * A marker value for later replacement with the test instance's "unique-ish" index.
+ *
+ * This is meant to just be a helpful identifier in fields like entity names/descriptions for
+ * debugging purposes.
+ */
+declare const testIndex: number;
+/**
+ * A marker value for the default `newTestInstance` behavior.
+ *
+ * Useful for passing arguments to `newTestInstance` where you sometimes want to
+ * provide a specific value, and other times ask for the "pick a default" behavior
+ * (i.e. you don't want to pass `undefined` b/c that means explicitly "leave this
+ * key unset").
+ *
+ * Note that this is a function so that we can infer the return type as basically
+ * `any` without really using `any` (which would disable type-checking in the rest
+ * of the expression).
+ */
+declare function defaultValue<T>(): T;
+/**
+ * A marker value to never set a field, even if it's required.
+ *
+ * The factories treat `{ author: undefined }` as "still set the author", because of how easy
+ * it is for destructuring/restructuring opts to implicitly set `undefined` values.
+ *
+ * If you want to force a field to not be set, you can use `{ author: noValue() }`.
+ */
+declare function noValue<T>(): T;
+/**
+ * A marker value to accept values only if explicitly created-or-passed within the current,
+ * unique "branch" of a factory call.
+ *
+ * This is useful for "diamond-shape" entity models like:
+ *
+ * ```
+ *  ParentGroup <-- ParentItem
+ *      |              |
+ *   ChildGroup  <-- ChildItem
+ * ```
+ *
+ * Where it's important that the `ChildItem -> ParentItem -> ParentGroup` path matches
+ * the `ChildItem -> ChildGroup -> ParentGroup` path.
+ *
+ * This can be hard to achieve in normal factory behavior, i.e. for a call like:
+ *
+ * ```ts
+ * const c = newChild(em, {
+ *   groups: [
+ *     { childItems: [{}, {}] },
+ *     { childItems: [{}, {}] },
+ *   ],
+ * });
+ * ```
+ *
+ * The first `ChildGroup` will create a new `ParentGroup` that is used by everything, which
+ * is not our intent, as both `ChildGroup`s, and all four `ParentItem`s, will live in a single
+ * `ParentGroup`.
+ *
+ * An initial idea is to pass `parentGroup: {}` in the factories, because that turns off "reusing
+ * existing instances", but for this problem the `{}` approach is "too good" at creating new
+ * instances, b/c the above diamond pattern will be disconnected.
+ *
+ * So `branchValue` provides a middle ground, where _usually_ it will be a new entity, unless
+ * it was explicitly created within the same "branch" of a factory call.
+ */
+declare function maybeBranchValue<T>(opts?: ActualFactoryOpts<T>): T;
+/**
+ * Allows a factory to declare that an optional relation should be filled in with an
+ * "obvious default", or a new entity if one doesn't exist.
+ *
+ * This "obvious default or new entity" is what Joist already does for _required_ relations,
+ * and so `maybeNew` lets the factory tell Joist to apply the same behavior to an optional
+ * field.
+ *
+ * I.e.:
+ *
+ * ```typescript
+ * export function newAuthor(em: Entity, opts: FactoryOpts<Author>) {
+ *   return newTestInstance(em, Author, {
+ *     // this always make a new publisher, unless explicitly overridden by the test,
+ *     // i.e. when each author really needs "their own" publisher.
+ *     publisher: {},
+ *     // this will make a new publisher but first looks for "good defaults" in the
+ *     // test, i.e. an already-created publisher. This is the default behavior of
+ *     // required fields ("look for a good default"), and `maybeNew` lets you tell
+ *     // Joist to invoke that same "maybe new" behavior for an optional field.
+ *     publisher: maybeNew<Publisher>({}),
+ *     ...opts,
+ *   });
+ * }
+ * ```
+ */
+declare function maybeNew<T extends Entity>(opts?: ActualFactoryOpts<T>): FactoryEntityOpt<T>;
+/**
+ * Similar to `maybeNew` in behaviour/use but with enhancements to support polymorphic fields:
+ * 1) Allows you to specify which entity type to create, if it is found a new one is needed
+ * 2) Allows you to prioritize which existing entities to select
+ *
+ * For example below, we are specifying that an Author should be created if needed (and optionally it's default opts
+ * in the `ifNewOpts` field), and also that the priority order for choosing existing entities is Author, Book, and then Publisher.
+ * Note since BookReview is excluded from `existingSearchOrder`, an existing BookReview will never be chosen.
+ *
+ * ```typescript
+ * export function newComment(em: EntityManager, opts: FactoryOpts<Comment> = {}): New<Comment> {
+ *   return newTestInstance(em, Comment, {
+ *     parent: maybeNewPoly<CommentParent, Author>(
+ *       Author, {
+ *         ifNewOpts: { firstName: "optional"},
+ *         existingSearchOrder: [Author, Book, Publisher]
+ *       }),
+ *     ...opts,
+ *   });
+ * }
+ * ```
+ */
+declare function maybeNewPoly<T extends Entity, NewT extends T = T>(ifNewCstr: EntityConstructor<NewT>, opts?: {
+  ifNewOpts?: ActualFactoryOpts<NewT>;
+  existingSearchOrder?: MaybeAbstractEntityConstructor<T>[];
+}): FactoryEntityOpt<NewT>;
+/**
+ * Returns a unique-ish test index for putting in `name` fields.
+ *
+ * Note that `testIndex` is easier to just include in a string, because it doesn't require passing
+ * the `EntityManger` and `type`. But if a factory really wants the test index as a number, they can
+ * call this method.
+ *
+ * Despite the name, these are 1-based, i.e. the first `Author` is `a1`.
+ */
+declare function getTestIndex<T extends Entity>(em: EntityManager, type: MaybeAbstractEntityConstructor<T>): number;
+type DefinedOr<T> = T | undefined | null;
+type DeepPartialOpts<T extends Entity> = AllowRelationsOrPartials<OptsOf<T>>;
+/** What a factory can accept for a given entity. */
+type FactoryEntityOpt<T extends Entity> = T | IdOf<T> | (ActualFactoryOpts<T> & {
+  useFactoryDefaults?: boolean | "none";
+});
+type AllowRelationsOrPartials<T> = { [P in keyof T]?: T[P] extends DefinedOr<infer U> ? U extends Array<infer V> ? V extends Entity ? Array<FactoryEntityOpt<V>> : T[P] : U extends Entity ? FactoryEntityOpt<U> : T[P] : T[P]; };
+type UseMapSource = "testOpts" | "useOpt" | "sameBranch" | "diffBranch";
+/** Enables factory logging for all factories. */
+declare function setFactoryLogging(enabled: boolean): void;
+/** Marker for tests setting derived values during test setup. */
+declare class FactoryInitialValue {
+  readonly value: any;
+  constructor(value: any);
+}
+declare function isFactoryCreation(entity: Entity): boolean;
+declare function resetFactoryCreated(): void;
+//#endregion
+export { FactoryEntityOpt, FactoryInitialValue, FactoryOpts, UseMapSource, defaultValue, factories, getTestIndex, isFactoryCreation, maybeBranchValue, maybeNew, maybeNewPoly, newTestInstance, noValue, resetFactoryCreated, setFactoryLogging, testDate, testIndex, testPlainDate, testPlainDateTime, testZonedDateTime };
+//# sourceMappingURL=newTestInstance.d.cts.map

package/build/newTestInstance.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newTestInstance.d.cts","names":[],"sources":["../src/newTestInstance.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsDa,WAAW;;;;;;;;;;;;KAyBZ,YAAY,UAAU,UAAU,gBAAgB;EAC1D;EACA,MAAM,SAAS;EACf;EACA;EACA;OAIC,WAAW,gBAAgB,MAAM,gBAAgB,GAAG;cAK1C,UAAQ;cAER,uCAAa,SAAA;cACb,2CAAiB,SAAA;cACjB,2CAAiB,SAAA;;;;;;;;;iBAYd,gBAAgB,UAAU,QACxC,IAAI,eACJ,MAAM,kBAAkB,IAExB;;AAAA,WAAU,YAAY,IAEtB;;AAAA,cAAa,YAAY;EACvB,eAAe,MAAM,OAAO,IAAI,UAAU,QAAQ;IAEnD,QAAQ;;;;;;;cAqYE;;;;;;;;;;;;;iBAmBG,aAAa,MAAM;;;;;;;;;iBAYnB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCd,iBAAiB,GAAG,OAAO,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BlD,SAAS,UAAU,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBA2B1E,aAAa,UAAU,QAAQ,aAAa,IAAI,GAC9D,WAAW,kBAAkB,OAC7B;EACE,YAAY,kBAAkB;EAC9B,sBAAsB,+BAA+B;IAEtD,iBAAiB;;;;;;;;;;iBAqBJ,aAAa,UAAU,QAAQ,IAAI,eAAe,MAAM,+BAA+B;KAiDlG,UAAU,KAAK;KAEf,gBAAgB,UAAU,UAAU,yBAAyB,OAAO;;KAG7D,iBAAiB,UAAU,UACnC,IAKA,KAAK,MACJ,kBAAkB;EAAO;;KAEzB,yBAAyB,QAC3B,WAAW,KAAK,EAAE,WAAW,gBAAgB,KAC1C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,iBAAiB,MACvB,EAAE,KACJ,UAAU,SACR,iBAAiB,KACjB,EAAE,KACN,EAAE;KAUI;;iBA8II,kBAAkB;;cAKrB;WACiB;EAA5B,YAA4B;;iBAGd,kBAAkB,QAAQ;iBAI1B"}

package/build/newTestInstance.d.mts

@@ -0,0 +1,207 @@
+import { ActualFactoryOpts, FactoryExtrasOf, OptsOf } from "./typeMap.mjs";
+import { DeepNew } from "./loading/loadHints.mjs";
+import "./index.mjs";
+import { EntityConstructor, EntityManager, IdOf, MaybeAbstractEntityConstructor } from "./EntityManager.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/newTestInstance.d.ts
+/**
+ * A proxy that allows accessing factory-created entities by their factory id.
+ *
+ * For example, after creating entities with `as` keys:
+ *
+ * ```ts
+ * newAuthor(em, { books: [{ is: "b#1" }, { is: "b#2", prequel: "b#1" }] });
+ * const { b1, b2 } = factories;
+ * ```
+ *
+ * The proxy parses property names like `b1` into `b#1` and looks up the entity
+ * in the most recently used EntityManager.
+ */
+declare const factories: Record<string, any>;
+/**
+ * DeepPartial-esque type specific to our `newTestInstance` factory.
+ *
+ * Specifically (vs using DeepPartial directly) this:
+ *
+ * 1. Adds a `use` tag of `Entity | Entity[]` that will be checked for existing
+ * entities before creating new ones (i.e. "if `newTestInstance` needs a `Book`,
+ * use the one in `use` instead of making a new one).
+ *
+ * 2. Works specifically against the constructor/entity opts fields.
+ */
+type FactoryOpts<T extends Entity> = DeepPartialOpts<T> & {
+  is?: string;
+  use?: Entity | Entity[];
+  useFactoryDefaults?: boolean | "none";
+  useExistingCheck?: boolean;
+  useLogging?: boolean;
+} & { [K in keyof FactoryExtrasOf<T>]?: FactoryExtrasOf<T>[K]; };
+declare const testDate: Date;
+declare const testPlainDate: import("temporal-spec").Temporal.PlainDate | undefined;
+declare const testPlainDateTime: import("temporal-spec").Temporal.PlainDateTime | undefined;
+declare const testZonedDateTime: import("temporal-spec").Temporal.ZonedDateTime | undefined;
+/**
+ * Creates a test instance of `T`.
+ *
+ * If the factory code passes factoryOpts.useExisting, they can "intercept" the `em.create`
+ * to try and resolve "already created" / singleton instances. The `useExisting` callback is
+ * useful b/c the `opts` will be the "resolved-to-entity" opts, and not the raw "maybe object
+ * literal, maybe object instance" opts that tests pass into the factory.
+ */
+declare function newTestInstance<T extends Entity>(em: EntityManager, cstr: EntityConstructor<T>,
+/** The test's test-specific override opts. */
+testOpts?: FactoryOpts<T>,
+/** The factory file's default opts. */
+factoryOpts?: FactoryOpts<T> & {
+  useExisting?: (opts: OptsOf<T>, existing: DeepNew<T>) => boolean;
+}): DeepNew<T>;
+/**
+ * A marker value for later replacement with the test instance's "unique-ish" index.
+ *
+ * This is meant to just be a helpful identifier in fields like entity names/descriptions for
+ * debugging purposes.
+ */
+declare const testIndex: number;
+/**
+ * A marker value for the default `newTestInstance` behavior.
+ *
+ * Useful for passing arguments to `newTestInstance` where you sometimes want to
+ * provide a specific value, and other times ask for the "pick a default" behavior
+ * (i.e. you don't want to pass `undefined` b/c that means explicitly "leave this
+ * key unset").
+ *
+ * Note that this is a function so that we can infer the return type as basically
+ * `any` without really using `any` (which would disable type-checking in the rest
+ * of the expression).
+ */
+declare function defaultValue<T>(): T;
+/**
+ * A marker value to never set a field, even if it's required.
+ *
+ * The factories treat `{ author: undefined }` as "still set the author", because of how easy
+ * it is for destructuring/restructuring opts to implicitly set `undefined` values.
+ *
+ * If you want to force a field to not be set, you can use `{ author: noValue() }`.
+ */
+declare function noValue<T>(): T;
+/**
+ * A marker value to accept values only if explicitly created-or-passed within the current,
+ * unique "branch" of a factory call.
+ *
+ * This is useful for "diamond-shape" entity models like:
+ *
+ * ```
+ *  ParentGroup <-- ParentItem
+ *      |              |
+ *   ChildGroup  <-- ChildItem
+ * ```
+ *
+ * Where it's important that the `ChildItem -> ParentItem -> ParentGroup` path matches
+ * the `ChildItem -> ChildGroup -> ParentGroup` path.
+ *
+ * This can be hard to achieve in normal factory behavior, i.e. for a call like:
+ *
+ * ```ts
+ * const c = newChild(em, {
+ *   groups: [
+ *     { childItems: [{}, {}] },
+ *     { childItems: [{}, {}] },
+ *   ],
+ * });
+ * ```
+ *
+ * The first `ChildGroup` will create a new `ParentGroup` that is used by everything, which
+ * is not our intent, as both `ChildGroup`s, and all four `ParentItem`s, will live in a single
+ * `ParentGroup`.
+ *
+ * An initial idea is to pass `parentGroup: {}` in the factories, because that turns off "reusing
+ * existing instances", but for this problem the `{}` approach is "too good" at creating new
+ * instances, b/c the above diamond pattern will be disconnected.
+ *
+ * So `branchValue` provides a middle ground, where _usually_ it will be a new entity, unless
+ * it was explicitly created within the same "branch" of a factory call.
+ */
+declare function maybeBranchValue<T>(opts?: ActualFactoryOpts<T>): T;
+/**
+ * Allows a factory to declare that an optional relation should be filled in with an
+ * "obvious default", or a new entity if one doesn't exist.
+ *
+ * This "obvious default or new entity" is what Joist already does for _required_ relations,
+ * and so `maybeNew` lets the factory tell Joist to apply the same behavior to an optional
+ * field.
+ *
+ * I.e.:
+ *
+ * ```typescript
+ * export function newAuthor(em: Entity, opts: FactoryOpts<Author>) {
+ *   return newTestInstance(em, Author, {
+ *     // this always make a new publisher, unless explicitly overridden by the test,
+ *     // i.e. when each author really needs "their own" publisher.
+ *     publisher: {},
+ *     // this will make a new publisher but first looks for "good defaults" in the
+ *     // test, i.e. an already-created publisher. This is the default behavior of
+ *     // required fields ("look for a good default"), and `maybeNew` lets you tell
+ *     // Joist to invoke that same "maybe new" behavior for an optional field.
+ *     publisher: maybeNew<Publisher>({}),
+ *     ...opts,
+ *   });
+ * }
+ * ```
+ */
+declare function maybeNew<T extends Entity>(opts?: ActualFactoryOpts<T>): FactoryEntityOpt<T>;
+/**
+ * Similar to `maybeNew` in behaviour/use but with enhancements to support polymorphic fields:
+ * 1) Allows you to specify which entity type to create, if it is found a new one is needed
+ * 2) Allows you to prioritize which existing entities to select
+ *
+ * For example below, we are specifying that an Author should be created if needed (and optionally it's default opts
+ * in the `ifNewOpts` field), and also that the priority order for choosing existing entities is Author, Book, and then Publisher.
+ * Note since BookReview is excluded from `existingSearchOrder`, an existing BookReview will never be chosen.
+ *
+ * ```typescript
+ * export function newComment(em: EntityManager, opts: FactoryOpts<Comment> = {}): New<Comment> {
+ *   return newTestInstance(em, Comment, {
+ *     parent: maybeNewPoly<CommentParent, Author>(
+ *       Author, {
+ *         ifNewOpts: { firstName: "optional"},
+ *         existingSearchOrder: [Author, Book, Publisher]
+ *       }),
+ *     ...opts,
+ *   });
+ * }
+ * ```
+ */
+declare function maybeNewPoly<T extends Entity, NewT extends T = T>(ifNewCstr: EntityConstructor<NewT>, opts?: {
+  ifNewOpts?: ActualFactoryOpts<NewT>;
+  existingSearchOrder?: MaybeAbstractEntityConstructor<T>[];
+}): FactoryEntityOpt<NewT>;
+/**
+ * Returns a unique-ish test index for putting in `name` fields.
+ *
+ * Note that `testIndex` is easier to just include in a string, because it doesn't require passing
+ * the `EntityManger` and `type`. But if a factory really wants the test index as a number, they can
+ * call this method.
+ *
+ * Despite the name, these are 1-based, i.e. the first `Author` is `a1`.
+ */
+declare function getTestIndex<T extends Entity>(em: EntityManager, type: MaybeAbstractEntityConstructor<T>): number;
+type DefinedOr<T> = T | undefined | null;
+type DeepPartialOpts<T extends Entity> = AllowRelationsOrPartials<OptsOf<T>>;
+/** What a factory can accept for a given entity. */
+type FactoryEntityOpt<T extends Entity> = T | IdOf<T> | (ActualFactoryOpts<T> & {
+  useFactoryDefaults?: boolean | "none";
+});
+type AllowRelationsOrPartials<T> = { [P in keyof T]?: T[P] extends DefinedOr<infer U> ? U extends Array<infer V> ? V extends Entity ? Array<FactoryEntityOpt<V>> : T[P] : U extends Entity ? FactoryEntityOpt<U> : T[P] : T[P]; };
+type UseMapSource = "testOpts" | "useOpt" | "sameBranch" | "diffBranch";
+/** Enables factory logging for all factories. */
+declare function setFactoryLogging(enabled: boolean): void;
+/** Marker for tests setting derived values during test setup. */
+declare class FactoryInitialValue {
+  readonly value: any;
+  constructor(value: any);
+}
+declare function isFactoryCreation(entity: Entity): boolean;
+declare function resetFactoryCreated(): void;
+//#endregion
+export { FactoryEntityOpt, FactoryInitialValue, FactoryOpts, UseMapSource, defaultValue, factories, getTestIndex, isFactoryCreation, maybeBranchValue, maybeNew, maybeNewPoly, newTestInstance, noValue, resetFactoryCreated, setFactoryLogging, testDate, testIndex, testPlainDate, testPlainDateTime, testZonedDateTime };
+//# sourceMappingURL=newTestInstance.d.mts.map

package/build/newTestInstance.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newTestInstance.d.mts","names":[],"sources":["../src/newTestInstance.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsDa,WAAW;;;;;;;;;;;;KAyBZ,YAAY,UAAU,UAAU,gBAAgB;EAC1D;EACA,MAAM,SAAS;EACf;EACA;EACA;OAIC,WAAW,gBAAgB,MAAM,gBAAgB,GAAG;cAK1C,UAAQ;cAER,uCAAa,SAAA;cACb,2CAAiB,SAAA;cACjB,2CAAiB,SAAA;;;;;;;;;iBAYd,gBAAgB,UAAU,QACxC,IAAI,eACJ,MAAM,kBAAkB,IAExB;;AAAA,WAAU,YAAY,IAEtB;;AAAA,cAAa,YAAY;EACvB,eAAe,MAAM,OAAO,IAAI,UAAU,QAAQ;IAEnD,QAAQ;;;;;;;cAqYE;;;;;;;;;;;;;iBAmBG,aAAa,MAAM;;;;;;;;;iBAYnB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCd,iBAAiB,GAAG,OAAO,kBAAkB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BlD,SAAS,UAAU,QAAQ,OAAO,kBAAkB,KAAK,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;iBA2B1E,aAAa,UAAU,QAAQ,aAAa,IAAI,GAC9D,WAAW,kBAAkB,OAC7B;EACE,YAAY,kBAAkB;EAC9B,sBAAsB,+BAA+B;IAEtD,iBAAiB;;;;;;;;;;iBAqBJ,aAAa,UAAU,QAAQ,IAAI,eAAe,MAAM,+BAA+B;KAiDlG,UAAU,KAAK;KAEf,gBAAgB,UAAU,UAAU,yBAAyB,OAAO;;KAG7D,iBAAiB,UAAU,UACnC,IAKA,KAAK,MACJ,kBAAkB;EAAO;;KAEzB,yBAAyB,QAC3B,WAAW,KAAK,EAAE,WAAW,gBAAgB,KAC1C,UAAU,YAAY,KACpB,UAAU,SACR,MAAM,iBAAiB,MACvB,EAAE,KACJ,UAAU,SACR,iBAAiB,KACjB,EAAE,KACN,EAAE;KAUI;;iBA8II,kBAAkB;;cAKrB;WACiB;EAA5B,YAA4B;;iBAGd,kBAAkB,QAAQ;iBAI1B"}