@lde/search-typesense 0.28.0 → 0.29.1

package/dist/blue-green-rebuild.d.ts

@@ -19,11 +19,14 @@ export type BlueGreenRebuildOptions = RebuildOptions;
  *   creates the versioned collection (`${name}_<timestamp>`) with the schema
  *   derived from the {@link SearchType}.
  * - `write` streams documents into the fresh collection, batched across write
- *   calls, each stamped with its `source` (the dataset IRI).
+ *   calls, each recording the dataset it came from ({@link openDocuments}).
  * - `flush` on a **failed** dataset, and `reset` (the pipeline’s dump-fallback
- *   discard), roll that dataset’s documents back out of the not-yet-live
- *   collection by `source`, so a swap never ships a half-processed dataset;
- *   a successful flush leaves the streamed documents in place.
+ *   discard), roll that dataset back out of the not-yet-live collection, so a
+ *   swap never ships a half-processed dataset; a successful flush leaves the
+ *   streamed documents in place. On a canonically keyed collection the
+ *   rollback drops the failed dataset’s *membership*, so a document another
+ *   dataset also contributed stays – with a reference from that dataset that
+ *   still resolves.
  * - `commit` imports the remainder, atomically repoints the `name` alias to
  *   the new collection, drops the collection it superseded, and releases the
  *   lock. Until commit, the live alias never points at a partial build.
@@ -50,10 +53,6 @@ export declare class BlueGreenRebuild<TDocument extends {
      */
     readonly collectionName: string;
     private readonly resolved;
-    /** The column this collection carries its documents’ dataset IRI in: the
-     *  type’s declared dataset field, or the private `source` when it declares
-     *  none. Both the stamp and the per-dataset rollback filter read it. */
-    private readonly sourceField;
     constructor(client: Client, searchType: SearchType, options?: BlueGreenRebuildOptions);
     openRun(context: RunContext): Promise<RunWriter<TDocument>>;
     /** The collection an alias currently points at, or `undefined` if unset. */

package/dist/blue-green-rebuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blue-green-rebuild.d.ts","sourceRoot":"","sources":["../src/blue-green-rebuild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AAUvB,OAAO,EAML,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAE9B;;yDAEyD;AACzD,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,gBAAgB,CAC3B,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAiB1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAjB7B;;;;;;;OAOG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD;;4EAEwE;IACxE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;gBAGlB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACvC,OAAO,GAAE,uBAA4B;IAajC,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAwHjE,4EAA4E;YAC9D,WAAW;CAW1B"}
+{"version":3,"file":"blue-green-rebuild.d.ts","sourceRoot":"","sources":["../src/blue-green-rebuild.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAEV,UAAU,EACV,SAAS,EACT,MAAM,EACP,MAAM,eAAe,CAAC;AASvB,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAE9B;;yDAEyD;AACzD,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,gBAAgB,CAC3B,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAChC,YAAW,MAAM,CAAC,SAAS,CAAC;IAa1B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAb7B;;;;;;;OAOG;IACH,SAAgB,cAAc,EAAE,MAAM,CAAC;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;gBAG/B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACvC,OAAO,GAAE,uBAA4B;IAUjC,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;IAsGjE,4EAA4E;YAC9D,WAAW;CAW1B"}

package/dist/blue-green-rebuild.js

@@ -1,8 +1,7 @@
 import { buildCollectionDefinition } from './collection-definition.js';
-import { BatchImporter } from './import.js';
 import { httpStatus, openLockedRun, releaseLock } from './lock.js';
-import { SOURCE_FIELD, provenanceField, sourceDocumentsFilter, } from './sweep.js';
-import { assertNoReservedFields, assertSweepableProvenanceField, deleteByFilter, resolveRebuildOptions, stampDocuments, } from './rebuild-support.js';
+import { assertWritableType, openDocuments, withBookkeeping, } from './documents.js';
+import { resolveRebuildOptions, } from './rebuild-support.js';
 /**
  * Blue/green Rebuild (build a fresh index alongside the live one, then swap to
  * it atomically) as a transactional `Writer`: each run builds the search
@@ -16,11 +15,14 @@ import { assertNoReservedFields, assertSweepableProvenanceField, deleteByFilter,
  *   creates the versioned collection (`${name}_<timestamp>`) with the schema
  *   derived from the {@link SearchType}.
  * - `write` streams documents into the fresh collection, batched across write
- *   calls, each stamped with its `source` (the dataset IRI).
+ *   calls, each recording the dataset it came from ({@link openDocuments}).
  * - `flush` on a **failed** dataset, and `reset` (the pipeline’s dump-fallback
- *   discard), roll that dataset’s documents back out of the not-yet-live
- *   collection by `source`, so a swap never ships a half-processed dataset;
- *   a successful flush leaves the streamed documents in place.
+ *   discard), roll that dataset back out of the not-yet-live collection, so a
+ *   swap never ships a half-processed dataset; a successful flush leaves the
+ *   streamed documents in place. On a canonically keyed collection the
+ *   rollback drops the failed dataset’s *membership*, so a document another
+ *   dataset also contributed stays – with a reference from that dataset that
+ *   still resolves.
  * - `commit` imports the remainder, atomically repoints the `name` alias to
  *   the new collection, drops the collection it superseded, and releases the
  *   lock. Until commit, the live alias never points at a partial build.
@@ -45,19 +47,12 @@ export class BlueGreenRebuild {
      */
     collectionName;
     resolved;
-    /** The column this collection carries its documents’ dataset IRI in: the
-     *  type’s declared dataset field, or the private `source` when it declares
-     *  none. Both the stamp and the per-dataset rollback filter read it. */
-    sourceField;
     constructor(client, searchType, options = {}) {
         this.client = client;
         this.searchType = searchType;
-        // `source` is stamped on every document for per-dataset rollback.
-        assertNoReservedFields(searchType, [SOURCE_FIELD]);
-        // Rollback filters by a known dataset IRI rather than enumerating the
-        // indexed ones, so a declared field need not be facetable here.
-        assertSweepableProvenanceField(searchType, { requireFacetable: false });
-        this.sourceField = provenanceField(searchType);
+        // Rollback drops a known dataset rather than enumerating the indexed ones,
+        // so a declared dataset field need not be facetable here.
+        assertWritableType(searchType, { requireFacetable: false });
         this.resolved = resolveRebuildOptions(searchType, options);
         this.collectionName =
             this.resolved.definitionOptions.collectionNameFor(searchType);
@@ -65,7 +60,6 @@ export class BlueGreenRebuild {
     async openRun(context) {
         const { batchSize, lockTtlMs, definitionOptions } = this.resolved;
         const name = this.collectionName;
-        const sourceField = this.sourceField;
         return openLockedRun(this.client, name, lockTtlMs, async () => {
             // Create the fresh (blue) collection up front, so a failure surfaces
             // before any dataset is processed. startedAt orders the versioned names;
@@ -87,30 +81,22 @@ export class BlueGreenRebuild {
                 ...definitionOptions,
                 collectionNameFor: versioned,
             });
-            await this.client.collections().create({
-                ...definition,
-                // The private `source` only when the type declares no dataset field of
-                // its own; a declared one is already in the definition and carries the
-                // same IRI.
-                fields: [
-                    ...(definition.fields ?? []),
-                    ...(sourceField === SOURCE_FIELD
-                        ? [{ name: SOURCE_FIELD, type: 'string' }]
-                        : []),
-                ],
+            await this.client
+                .collections()
+                .create(withBookkeeping(definition, this.searchType));
+            const documents = openDocuments(this.client, collection, {
+                searchType: this.searchType,
+                runId: context.runId,
+                startedAt: context.startedAt,
+                batchSize,
             });
-            const importer = new BatchImporter(this.client, collection, batchSize);
-            // Drop a dataset’s streamed documents back out of the not-yet-live
-            // collection (a failed dataset, or a reset before the dump re-run). Any
-            // still buffered must land first, so the delete filter sees them.
-            const rollback = async (dataset) => {
-                await importer.flush();
-                await deleteByFilter(this.client, collection, sourceDocumentsFilter(sourceField, dataset.iri.toString()));
-            };
+            // Roll a dataset back out of the not-yet-live collection (a failed
+            // dataset, or a reset before the dump re-run). On a keyed collection
+            // that drops its membership rather than the documents themselves, so a
+            // dataset that succeeded keeps the ones it also contributed.
+            const rollback = async (dataset) => documents.dropAll(dataset);
             return {
-                write: async (dataset, documents) => importer.add(stampDocuments(documents, {
-                    [sourceField]: dataset.iri.toString(),
-                })),
+                write: async (dataset, items) => documents.add(dataset, items),
                 flush: async (dataset, outcome) => {
                     // A successful dataset keeps its streamed documents (they go live at
                     // the swap); a failed one is rolled back so the swap never ships it.
@@ -120,7 +106,7 @@ export class BlueGreenRebuild {
                 },
                 reset: async (dataset) => rollback(dataset),
                 commit: async () => {
-                    await importer.flush();
+                    await documents.flush();
                     // The alias swap is the commit point: once it lands the new
                     // collection is live. Everything after it is best-effort cleanup that
                     // must NOT fail the commit – a post-swap rejection would otherwise

package/dist/collection-definition.js

@@ -145,7 +145,11 @@ function typesenseFields(searchType, field, defaultLocale, defaultSortingField,
     const nested = nestedTypeOf(searchType, field, schema);
     if (nested !== undefined) {
         return [
-            ...nestedFields(field.name, field, nested, schema, defaultLocale),
+            ...nestedFields(field.name, field, nested, schema, defaultLocale, false, 
+            // The declaring type is already on the path, exactly as the frame and
+            // the extraction seed theirs, so a lookup back to it is cut at the
+            // same depth here as it is there.
+            new Set([searchType.name])),
             ...identityCompanionFields(field, schema),
         ];
     }
@@ -287,10 +291,30 @@ function nestedFields(prefix, reference, nestedType, schema, defaultLocale, with
         }
         const deeper = nestedTypeOfNestedField(field, schema);
         if (deeper !== undefined && walked.has(deeper.name)) {
-            // The cycle stops here, and so does the frame – nothing will ever be
-            // stored under this field, so nothing is declared for it. Falling
-            // through would declare it as a LEAF, whose scalar type is not what a
-            // nested object would be stored as.
+            // The cycle stops here, and so does the frame – but a value is still
+            // stored: the extraction falls back to the target's key hop, and the
+            // projection writes the referent as an `{id}` object beside its identity
+            // leaf. So the BOUNDARY is declared and only the descent stops. Falling
+            // through instead would declare the field as a LEAF, whose scalar type
+            // is not what a nested object is stored as.
+            const boundary = nestedFieldName(prefix, field.name);
+            const boundaryArray = flattensToArray || field.array === true;
+            children.push({
+                name: boundary,
+                type: boundaryArray ? 'object[]' : 'object',
+                // Nothing under it is indexed – the key is a stored value, and the
+                // leaf a filter welds on sits beside the object, not inside it.
+                index: false,
+                optional: true,
+            }, {
+                // Always a Root Type, so always identified: `searchSchema` rejects
+                // inline cycles, so the only way to arrive at a type already on the
+                // path is a `local` lookup, whose target declares a class.
+                name: nestedFieldName(boundary, 'id'),
+                type: boundaryArray ? 'string[]' : 'string',
+                index: false,
+                optional: true,
+            }, ...nestedIdentityFields(prefix, field, schema));
             continue;
         }
         if (deeper !== undefined) {

package/dist/documents.d.ts

@@ -0,0 +1,147 @@
+import type { Client, CollectionCreateSchema } from 'typesense';
+import type { CollectionFieldSchema } from 'typesense/lib/Typesense/Collection.js';
+import type { Dataset } from '@lde/dataset';
+import type { SearchSchema, SearchType } from '@lde/search';
+/**
+ * Default ceiling on the distinct datasets a collection may hold before the
+ * membership sweep refuses to guess. The sweep needs the complete set to spot
+ * the ones that left, so a truncated facet would silently miss deletions.
+ */
+export declare const DEFAULT_MAX_SWEEPABLE_SOURCES = 10000;
+/** What {@link openDocuments} needs to know about the run it serves. */
+export interface RunDocumentsOptions {
+    /** The type whose collection this is; its `key` chooses the regime. */
+    readonly searchType: SearchType;
+    /** The run’s id, stamped on documents of a single-dataset collection. */
+    readonly runId: string;
+    /** The run’s ISO 8601 start, the ordered stamp a keyed collection records –
+     *  see {@link openDocuments}. */
+    readonly startedAt: string;
+    /** Documents per Typesense import request. */
+    readonly batchSize: number;
+    /** Most distinct datasets {@link RunDocuments.dropUnselected} may enumerate
+     *  before it throws rather than risk missing one that left. */
+    readonly maxSweepableSources?: number;
+}
+/**
+ * One run’s writes into one collection, plus the four questions a writer can
+ * ask about what should leave it. Every one is phrased about *datasets*, never
+ * about filters or fields: which column carries membership, whether a document
+ * is owned or shared, and what a deletion physically is, are this module’s.
+ *
+ * The one ordering rule a caller must hold: {@link add} buffers, so anything
+ * that drops documents needs the buffer landed first. Each `drop` does that
+ * itself; a caller only needs {@link flush} before it finishes the run.
+ */
+export interface RunDocuments<TDocument extends {
+    id: string;
+}> {
+    /** Write a dataset’s documents, batched. */
+    add(dataset: Dataset, documents: AsyncIterable<TDocument>): Promise<void>;
+    /** Land whatever is still buffered. */
+    flush(): Promise<void>;
+    /**
+     * Drop what this dataset had and this run did not rewrite – the sweep after
+     * a dataset succeeds. A document another dataset still references survives,
+     * having lost only this one’s membership.
+     */
+    dropUnwritten(dataset: Dataset): Promise<void>;
+    /**
+     * Drop only what this run wrote for the dataset, keeping its earlier
+     * documents – the pipeline’s dump-fallback discard.
+     */
+    dropWrittenThisRun(dataset: Dataset): Promise<void>;
+    /** Drop everything this dataset contributed, whenever it was written. */
+    dropAll(dataset: Dataset): Promise<void>;
+    /**
+     * Drop what belongs to datasets outside the run’s selection: the registry
+     * membership sweep. Enumerating what the collection holds is this module’s
+     * business, and so is refusing to sweep when it cannot see all of it.
+     *
+     * @param selectedDatasets Every dataset IRI the run’s selector produced,
+     *   including datasets skipped as unchanged – selection is membership.
+     */
+    dropUnselected(selectedDatasets: Iterable<string>): Promise<void>;
+}
+/**
+ * Open a run’s documents on a collection.
+ *
+ * Two regimes, chosen once from the type and never surfaced again:
+ *
+ * - a type with no {@link RootType.key} keys every document on its own node
+ *   IRI, so a document belongs to exactly one dataset. It is stamped with that
+ *   dataset and the run id, and a drop is a delete.
+ * - a **canonically keyed** type keys documents on an identifier several
+ *   datasets can share – two datasets referencing the same GeoNames place
+ *   produce one document. Membership is therefore a set: a write **adds** the
+ *   dataset to `referenced_by`, a drop **removes** it, and the document is
+ *   deleted when the last referring dataset goes. That is what stops one
+ *   dataset’s sweep from deleting what another still points at, without any
+ *   special case for a dataset skipped as unchanged – its membership simply
+ *   stays, untouched by anyone else’s sweep.
+ *
+ * The run is recorded on a keyed collection as `Date.parse(startedAt)` rather
+ * than as the run id, because *this dataset did not write it this run* has to
+ * be asked of one element of a nested array, and Typesense correlates a
+ * comparison within an element but **not** a negation – `run:<thisRun`
+ * correlates, `run:!=thisRun` silently answers at document level and sweeps
+ * nothing. See `test/membership-filters.integration.test.ts`, where both are
+ * pinned against the engine.
+ */
+export declare function openDocuments<TDocument extends {
+    id: string;
+}>(client: Client, collection: string, options: RunDocumentsOptions): RunDocuments<TDocument>;
+/**
+ * The collection definition plus the bookkeeping a writer keeps on it: the
+ * private membership columns, and the nesting a keyed collection’s
+ * `referenced_by` needs enabled.
+ *
+ * A single-dataset collection carries `source` only when the type declares no
+ * dataset field of its own; when it does, that field already holds the same
+ * IRI ({@link provenanceFieldOf}) and a second column would be the same value
+ * twice, free to drift.
+ */
+export declare function withBookkeeping(definition: CollectionCreateSchema, searchType: SearchType): CollectionCreateSchema;
+/**
+ * Reject a {@link SearchType} whose declaration cannot carry this module’s
+ * bookkeeping, at writer construction – so it fails before a run touches the
+ * index rather than at the sweep, after the writes.
+ *
+ * A **canonically keyed** type may not declare a field over the dataset. Such a
+ * field asks *which dataset is this document’s*, and a document several
+ * datasets share has no answer: it would hold whichever wrote last, and a user
+ * filtering by one of the others would silently miss it.
+ *
+ * A single-dataset type declaring one makes it the collection’s provenance
+ * column, so it has to answer that question the way the private `source` did:
+ * not `array` (Typesense reads `field:=[a,b]` over a `string[]` as *contains
+ * any*, so a departed dataset would take every document merely mentioning it);
+ * no `transform` (the sweep matches the stored value against the run’s raw
+ * dataset IRIs); and `facetable` on its own name where the writer enumerates
+ * the indexed datasets by faceting it – a reference inheriting a facet policy
+ * facets a companion holding only the admitted keys, so enumerating through it
+ * would miss every dataset the policy excludes.
+ *
+ * @param requireFacetable Whether this writer enumerates the indexed datasets
+ *   ({@link RunDocuments.dropUnselected}); a writer that only ever filters by a
+ *   known IRI does not need the column facetable.
+ */
+export declare function assertWritableType(searchType: SearchType, options: {
+    readonly requireFacetable: boolean;
+    readonly schema?: SearchSchema;
+}): void;
+/**
+ * Fail an EXISTING collection that predates its type being canonically keyed,
+ * naming the two steps that fix it.
+ *
+ * The field cannot be added: nesting is a create-time collection setting, and
+ * even where it could be it would be **empty** on every document already
+ * indexed. Membership is only written by a dataset that reprocesses, and
+ * skip-unchanged means most do not – so those documents would match no
+ * dataset, never be retracted and never be collected, while looking perfectly
+ * healthy. Dropping the collection alone has the same hole: a rebuilt
+ * collection is repopulated only by datasets that changed, so the pipeline
+ * version has to rotate with it to force every dataset through.
+ */
+export declare function assertBookkeepingPresent(searchType: SearchType, existing: readonly CollectionFieldSchema[], collection: string): void;
+//# sourceMappingURL=documents.d.ts.map

package/dist/documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../src/documents.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAY,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAmCtE;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,QAAS,CAAC;AAEpD,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;qCACiC;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;mEAC+D;IAC/D,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE;IAC5D,4CAA4C;IAC5C,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,uCAAuC;IACvC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C;;;OAGG;IACH,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,yEAAyE;IACzE,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACzC;;;;;;;OAOG;IACH,cAAc,CAAC,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,SAAS,SAAS;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EAC5D,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC3B,YAAY,CAAC,SAAS,CAAC,CAIzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,sBAAsB,EAClC,UAAU,EAAE,UAAU,GACrB,sBAAsB,CA4BxB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE;IACP,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC;CAChC,GACA,IAAI,CAoDN;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,qBAAqB,EAAE,EAC1C,UAAU,EAAE,MAAM,GACjB,IAAI,CAWN"}