@kensio/yulin 0.44.0 → 0.47.0

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.d.ts

@@ -0,0 +1,29 @@
+import type { SimDynamoDbKeySchemaElement, SimDynamoDbKeySchemaElementInput } from "../command/table/table.types.js";
+import { SimDynamoDbKeySchemaSubject } from "./sim-dynamodb-key-schema-subject.js";
+/**
+ * The key of one simulated table or one of its secondary indexes.
+ *
+ * A key schema is one HASH element, optionally followed by one RANGE element,
+ * in that order. Anything else is refused here as it is on AWS. The subject is
+ * what the key schema belongs to, so a request carrying several of them is
+ * refused naming the one that was wrong.
+ */
+export declare class SimDynamoDbKeySchema {
+    readonly elements: readonly SimDynamoDbKeySchemaElement[];
+    readonly subject: SimDynamoDbKeySchemaSubject;
+    readonly hashKeyAttributeName: string;
+    readonly rangeKeyAttributeName: string | undefined;
+    private constructor();
+    /**
+     * Read a key schema a CreateTable request carries.
+     *
+     * The subject defaults to the table's own key schema, which is the one a
+     * request always has.
+     */
+    static fromInput(input: readonly SimDynamoDbKeySchemaElementInput[] | undefined, subject?: SimDynamoDbKeySchemaSubject): SimDynamoDbKeySchema;
+    /**
+     * The attributes this key schema names, partition key first.
+     */
+    attributeNames(): readonly string[];
+}
+//# sourceMappingURL=sim-dynamodb-key-schema.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,gCAAgC,EACjC,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;GAOG;AACH,qBAAa,oBAAoB;IAC/B,SAAgB,QAAQ,EAAE,SAAS,2BAA2B,EAAE,CAAC;IACjE,SAAgB,OAAO,EAAE,2BAA2B,CAAC;IACrD,SAAgB,oBAAoB,EAAE,MAAM,CAAC;IAC7C,SAAgB,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAC;IAE1D,OAAO,eAkBN;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,KAAK,EAAE,SAAS,gCAAgC,EAAE,GAAG,SAAS,EAC9D,OAAO,GAAE,2BAAiE,GACzE,oBAAoB,CAoBtB;IAED;;OAEG;IACH,cAAc,IAAI,SAAS,MAAM,EAAE,CAElC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.js

@@ -0,0 +1,53 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { readSimDynamoDbKeySchemaElement } from "./sim-dynamodb-key-schema-element.js";
+import { SimDynamoDbKeySchemaSubject } from "./sim-dynamodb-key-schema-subject.js";
+/**
+ * The key of one simulated table or one of its secondary indexes.
+ *
+ * A key schema is one HASH element, optionally followed by one RANGE element,
+ * in that order. Anything else is refused here as it is on AWS. The subject is
+ * what the key schema belongs to, so a request carrying several of them is
+ * refused naming the one that was wrong.
+ */
+export class SimDynamoDbKeySchema {
+    elements;
+    subject;
+    hashKeyAttributeName;
+    rangeKeyAttributeName;
+    constructor(elements, subject) {
+        const [hashKey, rangeKey] = elements;
+        assertDefined(hashKey, "DynamoDB HASH key schema element");
+        const hashKeyName = hashKey.AttributeName;
+        if (rangeKey?.AttributeName === hashKeyName) {
+            throw subject.refuse(`the HASH and RANGE elements both name the attribute ${hashKeyName}`);
+        }
+        this.elements = elements;
+        this.subject = subject;
+        this.hashKeyAttributeName = hashKey.AttributeName;
+        this.rangeKeyAttributeName = rangeKey?.AttributeName;
+    }
+    /**
+     * Read a key schema a CreateTable request carries.
+     *
+     * The subject defaults to the table's own key schema, which is the one a
+     * request always has.
+     */
+    static fromInput(input, subject = SimDynamoDbKeySchemaSubject.table()) {
+        if (input === undefined || input.length === 0) {
+            throw new SimDynamoDbValidationException(`A KeySchema with a HASH key element is required${subject.owner}`);
+        }
+        if (input.length > 2) {
+            throw subject.refuse(`a key schema holds a HASH element and at most one RANGE element, ` +
+                `but ${input.length.toString()} elements were given`);
+        }
+        return new this(input.map((element, index) => readSimDynamoDbKeySchemaElement(element, index, subject)), subject);
+    }
+    /**
+     * The attributes this key schema names, partition key first.
+     */
+    attributeNames() {
+        return this.elements.map((element) => element.AttributeName);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-key-schema.js.map

package/dist/service/dynamodb/table/sim-dynamodb-key-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-schema.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-key-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAKpE,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;;;;;;GAOG;AACH,MAAM,OAAO,oBAAoB;IACf,QAAQ,CAAyC;IACjD,OAAO,CAA8B;IACrC,oBAAoB,CAAS;IAC7B,qBAAqB,CAAqB;IAE1D,YACE,QAAgD,EAChD,OAAoC;QAEpC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC;QACrC,aAAa,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC;QAC3D,MAAM,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;QAE1C,IAAI,QAAQ,EAAE,aAAa,KAAK,WAAW,EAAE,CAAC;YAC5C,MAAM,OAAO,CAAC,MAAM,CAClB,uDAAuD,WAAW,EAAE,CACrE,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC;QAClD,IAAI,CAAC,qBAAqB,GAAG,QAAQ,EAAE,aAAa,CAAC;IACvD,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,SAAS,CACd,KAA8D,EAC9D,OAAO,GAAgC,2BAA2B,CAAC,KAAK,EAAE;QAE1E,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,MAAM,IAAI,8BAA8B,CACtC,kDAAkD,OAAO,CAAC,KAAK,EAAE,CAClE,CAAC;QACJ,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,OAAO,CAAC,MAAM,CAClB,mEAAmE;gBACjE,OAAO,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,sBAAsB,CACvD,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,IAAI,CACb,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAC3B,+BAA+B,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,CACzD,EACD,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/D,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The hash of a marshalled partition key value.
+ *
+ * Two things read this. A scan walks partition key values in hash order, which
+ * is an order that is stable within a process and is not the sorted one. A
+ * parallel scan puts a partition key value in a segment by the same hash, so
+ * every item sharing a partition key lands in the same segment.
+ *
+ * Real DynamoDB hashes the partition key to decide which physical partition an
+ * item lives on, and both of those follow from that. The hash itself is not
+ * DynamoDB's, which is unpublished, so the segment an item lands in here is not
+ * the segment it lands in on AWS. What matches is the shape: whole item
+ * collections move together, and segments come out uneven.
+ */
+export declare function simDynamoDbPartitionKeyHash(partitionKey: string): number;
+//# sourceMappingURL=sim-dynamodb-partition-key-hash.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-partition-key-hash.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-partition-key-hash.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAOxE"}

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.js

@@ -0,0 +1,23 @@
+/**
+ * The offset basis and prime of 32 bit FNV-1a.
+ */
+const offsetBasis = 2_166_136_261;
+const prime = 16_777_619;
+/**
+ * The hash of a marshalled partition key value.
+ *
+ * Two things read this. A scan walks partition key values in hash order, which
+ * is an order that is stable within a process and is not the sorted one. A
+ * parallel scan puts a partition key value in a segment by the same hash, so
+ * every item sharing a partition key lands in the same segment.
+ *
+ * Real DynamoDB hashes the partition key to decide which physical partition an
+ * item lives on, and both of those follow from that. The hash itself is not
+ * DynamoDB's, which is unpublished, so the segment an item lands in here is not
+ * the segment it lands in on AWS. What matches is the shape: whole item
+ * collections move together, and segments come out uneven.
+ */
+export function simDynamoDbPartitionKeyHash(partitionKey) {
+    return (Buffer.from(partitionKey, "utf8").reduce((hash, byte) => Math.imul(hash ^ byte, prime), offsetBasis) >>> 0);
+}
+//# sourceMappingURL=sim-dynamodb-partition-key-hash.js.map

package/dist/service/dynamodb/table/sim-dynamodb-partition-key-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-partition-key-hash.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-partition-key-hash.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,GAAG,aAAa,CAAC;AAClC,MAAM,KAAK,GAAG,UAAU,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,2BAA2B,CAAC,YAAoB;IAC9D,OAAO,CACL,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,MAAM,CACtC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,KAAK,CAAC,EAC7C,WAAW,CACZ,KAAK,CAAC,CACR,CAAC;AACJ,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.d.ts

@@ -0,0 +1,16 @@
+import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+/**
+ * The primary key of a stored item, as the attribute values a pagination token
+ * carries.
+ *
+ * `LastEvaluatedKey` is the primary key of the item a walk stopped on, and the
+ * `ExclusiveStartKey` of the next request is the same thing read back, so it is
+ * written here once for whatever hands out a page.
+ *
+ * Every item in a table carries its key attributes. A write that left one out
+ * was refused, so the value is there by the time an item is stored.
+ */
+export declare function simDynamoDbPrimaryKeyAttributes(item: SimDynamoDbItem, keySchema: SimDynamoDbKeySchema): Record<string, SimDynamoDbAttributeValue>;
+//# sourceMappingURL=sim-dynamodb-primary-key.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-primary-key.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-primary-key.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,oBAAoB,GAC9B,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAU3C"}

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.js

@@ -0,0 +1,21 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { writeSimDynamoDbValue } from "../item/sim-dynamodb-value-writer.js";
+/**
+ * The primary key of a stored item, as the attribute values a pagination token
+ * carries.
+ *
+ * `LastEvaluatedKey` is the primary key of the item a walk stopped on, and the
+ * `ExclusiveStartKey` of the next request is the same thing read back, so it is
+ * written here once for whatever hands out a page.
+ *
+ * Every item in a table carries its key attributes. A write that left one out
+ * was refused, so the value is there by the time an item is stored.
+ */
+export function simDynamoDbPrimaryKeyAttributes(item, keySchema) {
+    return Object.fromEntries(keySchema.attributeNames().map((attributeName) => {
+        const value = item.attribute(attributeName);
+        assertDefined(value, `key attribute ${attributeName} of a stored item`);
+        return [attributeName, writeSimDynamoDbValue(value)];
+    }));
+}
+//# sourceMappingURL=sim-dynamodb-primary-key.js.map

package/dist/service/dynamodb/table/sim-dynamodb-primary-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-primary-key.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-primary-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAGpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAG7E;;;;;;;;;;GAUG;AACH,MAAM,UAAU,+BAA+B,CAC7C,IAAqB,EACrB,SAA+B;IAE/B,OAAO,MAAM,CAAC,WAAW,CACvB,SAAS,CAAC,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,EAAE;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAE5C,aAAa,CAAC,KAAK,EAAE,iBAAiB,aAAa,mBAAmB,CAAC,CAAC;QAExE,OAAO,CAAC,aAAa,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;IACvD,CAAC,CAAC,CACH,CAAC;AACJ,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-read-view.d.ts

@@ -0,0 +1,76 @@
+import type { SimDynamoDbAttributeValue } from "../command/item/item.types.js";
+import type { SimDynamoDbKeyCondition } from "../expression/key-condition/sim-dynamodb-key-condition.js";
+import type { SimDynamoDbDocumentPath } from "../expression/sim-dynamodb-document-path.js";
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbAttributeDefinitions } from "./sim-dynamodb-attribute-definitions.js";
+import type { SimDynamoDbItemCollection } from "./sim-dynamodb-item-collection.js";
+import type { SimDynamoDbKeySchema } from "./sim-dynamodb-key-schema.js";
+import type { SimDynamoDbTableScan } from "./sim-dynamodb-table-scan.js";
+/**
+ * What a Query or a Scan reads: a table, or one of its secondary indexes.
+ *
+ * The two answer the same questions and answer them differently, which is the
+ * whole of what `IndexName` does to a read. A table view holds every item and
+ * every attribute of it. An index view holds the items carrying the index key,
+ * keyed by that key, and only the attributes the index projects.
+ *
+ * A view is built per read rather than kept, since an index is derived when it
+ * is looked at rather than maintained on the write path.
+ */
+export interface SimDynamoDbReadView {
+    /**
+     * How a refusal names what is being read.
+     */
+    readonly description: string;
+    /**
+     * The key a read of this walks by, which for an index is its own.
+     */
+    readonly keySchema: SimDynamoDbKeySchema;
+    /**
+     * The types the key attributes were declared with, which the table owns
+     * whichever view uses them.
+     */
+    readonly attributeDefinitions: SimDynamoDbAttributeDefinitions;
+    /**
+     * The items one key condition names, in sort key order.
+     */
+    itemCollection(keyCondition: SimDynamoDbKeyCondition): SimDynamoDbItemCollection;
+    /**
+     * Every item this view holds, in the order a Scan reads them.
+     */
+    scan(): SimDynamoDbTableScan;
+    /**
+     * Refuse an `ExclusiveStartKey` this view could not have handed out.
+     */
+    assertStartKey(key: SimDynamoDbItem): void;
+    /**
+     * The key attributes a pagination token carries for this view.
+     */
+    tokenKey(item: SimDynamoDbItem): Record<string, SimDynamoDbAttributeValue>;
+    /**
+     * Cut an item down to what this view carries.
+     */
+    project(item: SimDynamoDbItem): SimDynamoDbItem;
+    /**
+     * Refuse a read asking for whole items where this view holds part of them.
+     */
+    assertCarriesWholeItem(): void;
+    /**
+     * Refuse an expression naming an attribute this view does not carry.
+     *
+     * A path into an attribute an index does not project would match nothing
+     * here, which reads as a collection that happens to be empty. Real DynamoDB
+     * refuses it, so this does too rather than answering with a page that means
+     * something else.
+     */
+    assertCarriesPaths(paths: readonly SimDynamoDbDocumentPath[]): void;
+    /**
+     * Refuse a strongly consistent read this view cannot answer.
+     *
+     * Only a global secondary index refuses one. It is maintained asynchronously
+     * on AWS, so it cannot answer a strongly consistent read whatever the
+     * simulation does. A table and a local secondary index both can.
+     */
+    assertConsistentRead(): void;
+}
+//# sourceMappingURL=sim-dynamodb-read-view.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-read-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-read-view.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-read-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2DAA2D,CAAC;AACzG,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAC;AAC3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,yCAAyC,CAAC;AAC/F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE;;;;;;;;;;GAUG;AACH,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IAEzC;;;OAGG;IACH,QAAQ,CAAC,oBAAoB,EAAE,+BAA+B,CAAC;IAE/D;;OAEG;IACH,cAAc,CACZ,YAAY,EAAE,uBAAuB,GACpC,yBAAyB,CAAC;IAE7B;;OAEG;IACH,IAAI,IAAI,oBAAoB,CAAC;IAE7B;;OAEG;IACH,cAAc,CAAC,GAAG,EAAE,eAAe,GAAG,IAAI,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;IAE3E;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC;IAEhD;;OAEG;IACH,sBAAsB,IAAI,IAAI,CAAC;IAE/B;;;;;;;OAOG;IACH,kBAAkB,CAAC,KAAK,EAAE,SAAS,uBAAuB,EAAE,GAAG,IAAI,CAAC;IAEpE;;;;;;OAMG;IACH,oBAAoB,IAAI,IAAI,CAAC;CAC9B"}

package/dist/service/dynamodb/table/sim-dynamodb-read-view.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-dynamodb-read-view.js.map

package/dist/service/dynamodb/table/sim-dynamodb-read-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-read-view.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-read-view.ts"],"names":[],"mappings":""}

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.d.ts

@@ -0,0 +1,46 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbScanSegment } from "./sim-dynamodb-scan-segment.js";
+import type { SimDynamoDbSortKeyOrder } from "./sim-dynamodb-sort-key-order.js";
+interface SimDynamoDbScanPositionProperties {
+    readonly item: SimDynamoDbItem;
+    readonly partitionKey: string;
+    readonly sortKeyOrder: SimDynamoDbSortKeyOrder;
+}
+/**
+ * Where one item sits in the order a scan walks a table in.
+ *
+ * The order is by the hash of the partition key first, then by sort key inside
+ * one partition key value. That gives two things a scan needs. Items under one
+ * partition key come back together and ascending, as they do on AWS. Partition
+ * key values come back in an order that is not the sorted one, so a test cannot
+ * quietly come to depend on a global ordering that real DynamoDB does not give.
+ *
+ * The order has to be a total order all the same, otherwise an
+ * `ExclusiveStartKey` could not say where to resume from. Partition key values
+ * that hash alike are ordered by their marshalled bytes to settle that.
+ *
+ * A position is also worked out for the Key a request resumes after, which is
+ * why it is built from a key and a sort key order rather than read off a stored
+ * item: the item the token names may since have been deleted.
+ */
+export declare class SimDynamoDbScanPosition {
+    readonly item: SimDynamoDbItem;
+    private readonly partitionKey;
+    private readonly hash;
+    private readonly sortKeyOrder;
+    constructor(properties: SimDynamoDbScanPositionProperties);
+    /**
+     * Whether a parallel scan segment holds this item.
+     */
+    inSegment(segment: SimDynamoDbScanSegment): boolean;
+    /**
+     * Order this position against another position in the same table.
+     */
+    compareTo(other: SimDynamoDbScanPosition): number;
+    /**
+     * Order two partition key values, by their hash and then by their bytes.
+     */
+    private comparePartitions;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-scan-position.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-position.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-position.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAEhF,UAAU,iCAAiC;IACzC,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,uBAAuB,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,uBAAuB;IAClC,SAAgB,IAAI,EAAE,eAAe,CAAC;IAEtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0B;IAEvD,YAAY,UAAU,EAAE,iCAAiC,EAKxD;IAED;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAElD;IAED;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAQhD;IAED;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAU1B"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.js

@@ -0,0 +1,57 @@
+import { compareSimDynamoDbBytes } from "../item/sim-dynamodb-value-order.js";
+import { simDynamoDbPartitionKeyHash } from "./sim-dynamodb-partition-key-hash.js";
+/**
+ * Where one item sits in the order a scan walks a table in.
+ *
+ * The order is by the hash of the partition key first, then by sort key inside
+ * one partition key value. That gives two things a scan needs. Items under one
+ * partition key come back together and ascending, as they do on AWS. Partition
+ * key values come back in an order that is not the sorted one, so a test cannot
+ * quietly come to depend on a global ordering that real DynamoDB does not give.
+ *
+ * The order has to be a total order all the same, otherwise an
+ * `ExclusiveStartKey` could not say where to resume from. Partition key values
+ * that hash alike are ordered by their marshalled bytes to settle that.
+ *
+ * A position is also worked out for the Key a request resumes after, which is
+ * why it is built from a key and a sort key order rather than read off a stored
+ * item: the item the token names may since have been deleted.
+ */
+export class SimDynamoDbScanPosition {
+    item;
+    partitionKey;
+    hash;
+    sortKeyOrder;
+    constructor(properties) {
+        this.item = properties.item;
+        this.partitionKey = properties.partitionKey;
+        this.hash = simDynamoDbPartitionKeyHash(properties.partitionKey);
+        this.sortKeyOrder = properties.sortKeyOrder;
+    }
+    /**
+     * Whether a parallel scan segment holds this item.
+     */
+    inSegment(segment) {
+        return segment.holds(this.partitionKey);
+    }
+    /**
+     * Order this position against another position in the same table.
+     */
+    compareTo(other) {
+        const partitions = this.comparePartitions(other);
+        if (partitions !== 0) {
+            return partitions;
+        }
+        return this.sortKeyOrder.compareItems(this.item, other.item);
+    }
+    /**
+     * Order two partition key values, by their hash and then by their bytes.
+     */
+    comparePartitions(other) {
+        if (this.hash !== other.hash) {
+            return this.hash - other.hash;
+        }
+        return compareSimDynamoDbBytes(Buffer.from(this.partitionKey, "utf8"), Buffer.from(other.partitionKey, "utf8"));
+    }
+}
+//# sourceMappingURL=sim-dynamodb-scan-position.js.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-position.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-position.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAUnF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,uBAAuB;IAClB,IAAI,CAAkB;IAErB,YAAY,CAAS;IACrB,IAAI,CAAS;IACb,YAAY,CAA0B;IAEvD,YAAY,UAA6C;QACvD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;QAC5C,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;QACjE,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,OAA+B;QACvC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAA8B;QACtC,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;QAEjD,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACrB,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,KAA8B;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAChC,CAAC;QAED,OAAO,uBAAuB,CAC5B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,EACtC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CACxC,CAAC;IACJ,CAAC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.d.ts

@@ -0,0 +1,37 @@
+interface SimDynamoDbScanSegmentProperties {
+    readonly index: number;
+    readonly totalSegments: number;
+}
+/**
+ * One segment of a parallel scan.
+ *
+ * A segment is a share of the table's partition key values rather than a share
+ * of its items. Every item under one partition key belongs to one segment, so a
+ * segment holds whole item collections, and two segments of the same table can
+ * hold very different numbers of items. A segment holding nothing at all is
+ * ordinary rather than a failure.
+ *
+ * There is no concurrency to gain here, since a simulated scan walks a map in
+ * memory. What a segment models is the caller's side of a parallel scan: code
+ * that divides a table between workers can be run against a simulated table.
+ */
+export declare class SimDynamoDbScanSegment {
+    /** The zero based number of this segment. */
+    readonly index: number;
+    /** How many segments the table is divided into. */
+    readonly totalSegments: number;
+    constructor(properties: SimDynamoDbScanSegmentProperties);
+    /**
+     * The whole table as one segment, which is what a sequential scan reads.
+     */
+    static whole(): SimDynamoDbScanSegment;
+    /**
+     * Whether this segment holds the items under a marshalled partition key.
+     *
+     * A `TotalSegments` of 1 holds everything, which is what makes a parallel
+     * scan of one segment the same read as a sequential scan.
+     */
+    holds(partitionKey: string): boolean;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-scan-segment.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-segment.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-segment.ts"],"names":[],"mappings":"AAQA,UAAU,gCAAgC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAsB;IACjC,6CAA6C;IAC7C,SAAgB,KAAK,EAAE,MAAM,CAAC;IAE9B,mDAAmD;IACnD,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,YAAY,UAAU,EAAE,gCAAgC,EAMvD;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,IAAI,sBAAsB,CAErC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAKnC;CACF"}

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.js

@@ -0,0 +1,69 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { simDynamoDbPartitionKeyHash } from "./sim-dynamodb-partition-key-hash.js";
+/**
+ * The most segments a parallel scan can be divided into, as on AWS.
+ */
+const greatestTotalSegments = 1_000_000;
+/**
+ * One segment of a parallel scan.
+ *
+ * A segment is a share of the table's partition key values rather than a share
+ * of its items. Every item under one partition key belongs to one segment, so a
+ * segment holds whole item collections, and two segments of the same table can
+ * hold very different numbers of items. A segment holding nothing at all is
+ * ordinary rather than a failure.
+ *
+ * There is no concurrency to gain here, since a simulated scan walks a map in
+ * memory. What a segment models is the caller's side of a parallel scan: code
+ * that divides a table between workers can be run against a simulated table.
+ */
+export class SimDynamoDbScanSegment {
+    /** The zero based number of this segment. */
+    index;
+    /** How many segments the table is divided into. */
+    totalSegments;
+    constructor(properties) {
+        assertTotalSegments(properties.totalSegments);
+        assertIndex(properties.index, properties.totalSegments);
+        this.index = properties.index;
+        this.totalSegments = properties.totalSegments;
+    }
+    /**
+     * The whole table as one segment, which is what a sequential scan reads.
+     */
+    static whole() {
+        return new this({ index: 0, totalSegments: 1 });
+    }
+    /**
+     * Whether this segment holds the items under a marshalled partition key.
+     *
+     * A `TotalSegments` of 1 holds everything, which is what makes a parallel
+     * scan of one segment the same read as a sequential scan.
+     */
+    holds(partitionKey) {
+        return (simDynamoDbPartitionKeyHash(partitionKey) % this.totalSegments ===
+            this.index);
+    }
+}
+/**
+ * Refuse a `TotalSegments` outside the range a parallel scan takes.
+ */
+function assertTotalSegments(totalSegments) {
+    if (!Number.isSafeInteger(totalSegments) ||
+        totalSegments < 1 ||
+        totalSegments > greatestTotalSegments) {
+        throw new SimDynamoDbValidationException(`TotalSegments ${totalSegments.toString()} is invalid. It is a whole ` +
+            `number between 1 and ${greatestTotalSegments.toString()}.`);
+    }
+}
+/**
+ * Refuse a `Segment` that names no segment of the division asked for.
+ */
+function assertIndex(index, totalSegments) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= totalSegments) {
+        throw new SimDynamoDbValidationException(`Segment ${index.toString()} is invalid. It is zero based, so it is a ` +
+            `whole number between 0 and ${(totalSegments - 1).toString()} for a ` +
+            `TotalSegments of ${totalSegments.toString()}.`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-scan-segment.js.map

package/dist/service/dynamodb/table/sim-dynamodb-scan-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-scan-segment.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-scan-segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAEnF;;GAEG;AACH,MAAM,qBAAqB,GAAG,SAAS,CAAC;AAOxC;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,sBAAsB;IACjC,6CAA6C;IAC7B,KAAK,CAAS;IAE9B,mDAAmD;IACnC,aAAa,CAAS;IAEtC,YAAY,UAA4C;QACtD,mBAAmB,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAC9C,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC;QAExD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK;QACV,OAAO,IAAI,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,CAAC,CAAC;IAClD,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAoB;QACxB,OAAO,CACL,2BAA2B,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,aAAa;YAC9D,IAAI,CAAC,KAAK,CACX,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAC,aAAqB;IAChD,IACE,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC;QACpC,aAAa,GAAG,CAAC;QACjB,aAAa,GAAG,qBAAqB,EACrC,CAAC;QACD,MAAM,IAAI,8BAA8B,CACtC,iBAAiB,aAAa,CAAC,QAAQ,EAAE,6BAA6B;YACpE,wBAAwB,qBAAqB,CAAC,QAAQ,EAAE,GAAG,CAC9D,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,KAAa,EAAE,aAAqB;IACvD,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,aAAa,EAAE,CAAC;QACxE,MAAM,IAAI,8BAA8B,CACtC,WAAW,KAAK,CAAC,QAAQ,EAAE,4CAA4C;YACrE,8BAA8B,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,SAAS;YACrE,oBAAoB,aAAa,CAAC,QAAQ,EAAE,GAAG,CAClD,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/dynamodb/table/sim-dynamodb-sort-key-compare.d.ts

@@ -0,0 +1,30 @@
+import type { SimDynamoDbItem } from "../item/sim-dynamodb-item.js";
+import type { SimDynamoDbValue } from "../item/sim-dynamodb-value.js";
+import type { SimDynamoDbItemKey } from "./sim-dynamodb-item-key.js";
+/**
+ * The sort key a stored item holds.
+ *
+ * Every item of a collection carries the key attributes it is walked by. A
+ * write that left a table key attribute out was refused, and an index holds
+ * only the items carrying the whole of its key, so the value is there either
+ * way.
+ */
+export declare function simDynamoDbSortKeyValue(item: SimDynamoDbItem, attributeName: string): SimDynamoDbValue;
+/**
+ * Order two items by their sort keys.
+ *
+ * Two items of one collection always order: every key attribute is checked
+ * against its declared type on the way in, so no collection holds two sort keys
+ * of different types.
+ */
+export declare function compareSimDynamoDbSortKeys(first: SimDynamoDbItem, second: SimDynamoDbItem, attributeName: string): number;
+/**
+ * Separate two items their sort keys did not, by the key that identifies them.
+ *
+ * The marshalled key is compared as UTF-8 bytes, which is the order the rest of
+ * the simulation compares text in. Nothing depends on which of two items comes
+ * first, only that the answer is the same every time, since an
+ * `ExclusiveStartKey` could not resume a walk otherwise.
+ */
+export declare function compareSimDynamoDbItemIdentities(first: SimDynamoDbItem, second: SimDynamoDbItem, identity: SimDynamoDbItemKey): number;
+//# sourceMappingURL=sim-dynamodb-sort-key-compare.d.ts.map

package/dist/service/dynamodb/table/sim-dynamodb-sort-key-compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-sort-key-compare.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-sort-key-compare.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAKpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,eAAe,EACrB,aAAa,EAAE,MAAM,GACpB,gBAAgB,CAMlB;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,eAAe,EACvB,aAAa,EAAE,MAAM,GACpB,MAAM,CASR;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,CAKR"}

package/dist/service/dynamodb/table/sim-dynamodb-sort-key-compare.js

@@ -0,0 +1,39 @@
+import { assertDefined } from "../../../util/type-guard/defined.js";
+import { compareSimDynamoDbBytes, compareSimDynamoDbValues, } from "../item/sim-dynamodb-value-order.js";
+/**
+ * The sort key a stored item holds.
+ *
+ * Every item of a collection carries the key attributes it is walked by. A
+ * write that left a table key attribute out was refused, and an index holds
+ * only the items carrying the whole of its key, so the value is there either
+ * way.
+ */
+export function simDynamoDbSortKeyValue(item, attributeName) {
+    const value = item.attribute(attributeName);
+    assertDefined(value, `sort key ${attributeName} of a stored item`);
+    return value;
+}
+/**
+ * Order two items by their sort keys.
+ *
+ * Two items of one collection always order: every key attribute is checked
+ * against its declared type on the way in, so no collection holds two sort keys
+ * of different types.
+ */
+export function compareSimDynamoDbSortKeys(first, second, attributeName) {
+    const order = compareSimDynamoDbValues(simDynamoDbSortKeyValue(first, attributeName), simDynamoDbSortKeyValue(second, attributeName));
+    assertDefined(order, `order of two ${attributeName} sort keys`);
+    return order;
+}
+/**
+ * Separate two items their sort keys did not, by the key that identifies them.
+ *
+ * The marshalled key is compared as UTF-8 bytes, which is the order the rest of
+ * the simulation compares text in. Nothing depends on which of two items comes
+ * first, only that the answer is the same every time, since an
+ * `ExclusiveStartKey` could not resume a walk otherwise.
+ */
+export function compareSimDynamoDbItemIdentities(first, second, identity) {
+    return compareSimDynamoDbBytes(Buffer.from(identity.of(first), "utf8"), Buffer.from(identity.of(second), "utf8"));
+}
+//# sourceMappingURL=sim-dynamodb-sort-key-compare.js.map

package/dist/service/dynamodb/table/sim-dynamodb-sort-key-compare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-sort-key-compare.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/table/sim-dynamodb-sort-key-compare.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,qCAAqC,CAAC;AAI7C;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAqB,EACrB,aAAqB;IAErB,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IAE5C,aAAa,CAAC,KAAK,EAAE,YAAY,aAAa,mBAAmB,CAAC,CAAC;IAEnE,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAsB,EACtB,MAAuB,EACvB,aAAqB;IAErB,MAAM,KAAK,GAAG,wBAAwB,CACpC,uBAAuB,CAAC,KAAK,EAAE,aAAa,CAAC,EAC7C,uBAAuB,CAAC,MAAM,EAAE,aAAa,CAAC,CAC/C,CAAC;IAEF,aAAa,CAAC,KAAK,EAAE,gBAAgB,aAAa,YAAY,CAAC,CAAC;IAEhE,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gCAAgC,CAC9C,KAAsB,EACtB,MAAuB,EACvB,QAA4B;IAE5B,OAAO,uBAAuB,CAC5B,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,EACvC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CACzC,CAAC;AACJ,CAAC"}