@kensio/yulin 0.44.0 → 0.45.0

package/dist/service/dynamodb/item/sim-dynamodb-number-order.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compare the digits of two numbers, ignoring their signs.
+ *
+ * Both are in plain decimal notation with no leading zeros, so a longer whole
+ * part is a bigger number and two whole parts of the same length compare
+ * character by character. The fractions are then padded to the same length so
+ * `0.5` and `0.45` compare by their digits rather than by how many there are.
+ */
+export declare function compareSimDynamoDbMagnitudes(first: string, second: string): number;
+//# sourceMappingURL=sim-dynamodb-number-order.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-number-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-order.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-order.ts"],"names":[],"mappings":"AAeA;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,MAAM,CAkBR"}

package/dist/service/dynamodb/item/sim-dynamodb-number-order.js

@@ -0,0 +1,33 @@
+/**
+ * Compare two runs of digits of the same length.
+ */
+function compareDigits(first, second) {
+    if (first < second) {
+        return -1;
+    }
+    if (first > second) {
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Compare the digits of two numbers, ignoring their signs.
+ *
+ * Both are in plain decimal notation with no leading zeros, so a longer whole
+ * part is a bigger number and two whole parts of the same length compare
+ * character by character. The fractions are then padded to the same length so
+ * `0.5` and `0.45` compare by their digits rather than by how many there are.
+ */
+export function compareSimDynamoDbMagnitudes(first, second) {
+    const [firstWhole = "", firstFraction = ""] = first.split(".");
+    const [secondWhole = "", secondFraction = ""] = second.split(".");
+    if (firstWhole.length !== secondWhole.length) {
+        return firstWhole.length - secondWhole.length;
+    }
+    if (firstWhole !== secondWhole) {
+        return compareDigits(firstWhole, secondWhole);
+    }
+    const width = Math.max(firstFraction.length, secondFraction.length);
+    return compareDigits(firstFraction.padEnd(width, "0"), secondFraction.padEnd(width, "0"));
+}
+//# sourceMappingURL=sim-dynamodb-number-order.js.map

package/dist/service/dynamodb/item/sim-dynamodb-number-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-order.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-order.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,SAAS,aAAa,CAAC,KAAa,EAAE,MAAc;IAClD,IAAI,KAAK,GAAG,MAAM,EAAE,CAAC;QACnB,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;IAED,IAAI,KAAK,GAAG,MAAM,EAAE,CAAC;QACnB,OAAO,CAAC,CAAC;IACX,CAAC;IAED,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,KAAa,EACb,MAAc;IAEd,MAAM,CAAC,UAAU,GAAG,EAAE,EAAE,aAAa,GAAG,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC/D,MAAM,CAAC,WAAW,GAAG,EAAE,EAAE,cAAc,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAElE,IAAI,UAAU,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;QAC7C,OAAO,UAAU,CAAC,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;IAChD,CAAC;IAED,IAAI,UAAU,KAAK,WAAW,EAAE,CAAC;QAC/B,OAAO,aAAa,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAChD,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC;IAEpE,OAAO,aAAa,CAClB,aAAa,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,EAChC,cAAc,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAClC,CAAC;AACJ,CAAC"}

package/dist/service/dynamodb/item/sim-dynamodb-number-range.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Refuse a number outside the range real DynamoDB stores.
+ *
+ * How wide a number can be and how big it can get are limits of the store
+ * rather than of how a number is written, so they are checked here rather than
+ * beside the parsing.
+ */
+export declare function assertSimDynamoDbNumberInRange(value: string, significand: string, scale: number): void;
+//# sourceMappingURL=sim-dynamodb-number-range.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-number-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-range.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-range.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,IAAI,CAsBN"}

package/dist/service/dynamodb/item/sim-dynamodb-number-range.js

@@ -0,0 +1,27 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+const greatestSignificantDigits = 38;
+const greatestAdjustedExponent = 125;
+const leastAdjustedExponent = -130;
+/**
+ * Refuse a number outside the range real DynamoDB stores.
+ *
+ * How wide a number can be and how big it can get are limits of the store
+ * rather than of how a number is written, so they are checked here rather than
+ * beside the parsing.
+ */
+export function assertSimDynamoDbNumberInRange(value, significand, scale) {
+    if (significand.length > greatestSignificantDigits) {
+        throw new SimDynamoDbValidationException(`Number ${value} has ${significand.length.toString()} significant ` +
+            `digits, and DynamoDB numbers carry ${greatestSignificantDigits.toString()}`);
+    }
+    // The exponent the number has when written as one digit, a point and the
+    // rest, which is how DynamoDB documents its range.
+    const adjustedExponent = scale + significand.length - 1;
+    if (adjustedExponent > greatestAdjustedExponent ||
+        adjustedExponent < leastAdjustedExponent) {
+        throw new SimDynamoDbValidationException(`Number ${value} is outside the range DynamoDB stores, which is ` +
+            `1E-130 to 9.9999999999999999999999999999999999999E+125 and its ` +
+            `negative mirror`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-number-range.js.map

package/dist/service/dynamodb/item/sim-dynamodb-number-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-range.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-range.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E,MAAM,yBAAyB,GAAG,EAAE,CAAC;AACrC,MAAM,wBAAwB,GAAG,GAAG,CAAC;AACrC,MAAM,qBAAqB,GAAG,CAAC,GAAG,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,UAAU,8BAA8B,CAC5C,KAAa,EACb,WAAmB,EACnB,KAAa;IAEb,IAAI,WAAW,CAAC,MAAM,GAAG,yBAAyB,EAAE,CAAC;QACnD,MAAM,IAAI,8BAA8B,CACtC,UAAU,KAAK,QAAQ,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,eAAe;YACjE,sCAAsC,yBAAyB,CAAC,QAAQ,EAAE,EAAE,CAC/E,CAAC;IACJ,CAAC;IAED,yEAAyE;IACzE,mDAAmD;IACnD,MAAM,gBAAgB,GAAG,KAAK,GAAG,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;IAExD,IACE,gBAAgB,GAAG,wBAAwB;QAC3C,gBAAgB,GAAG,qBAAqB,EACxC,CAAC;QACD,MAAM,IAAI,8BAA8B,CACtC,UAAU,KAAK,kDAAkD;YAC/D,iEAAiE;YACjE,iBAAiB,CACpB,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/dynamodb/item/sim-dynamodb-number-sum.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Add one DynamoDB number to another, or take it away.
+ *
+ * The two are added as whole digits at their common scale, so nothing goes
+ * through a JavaScript number on the way. Adding 1 to 9007199254740993 answers
+ * 9007199254740994 here, where a double would answer 9007199254740992.
+ *
+ * The answer comes back as text, so whatever reads it applies the same range
+ * and precision checks a number a request wrote goes through.
+ */
+export declare function sumSimDynamoDbNumberTexts(one: string, other: string, direction: 1 | -1): string;
+//# sourceMappingURL=sim-dynamodb-number-sum.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-number-sum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-sum.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-sum.ts"],"names":[],"mappings":"AA8BA;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,CAAC,GAAG,CAAC,CAAC,GAChB,MAAM,CAYR"}

package/dist/service/dynamodb/item/sim-dynamodb-number-sum.js

@@ -0,0 +1,50 @@
+import { simDynamoDbPlainDecimal } from "./sim-dynamodb-number-text.js";
+/**
+ * Read the plain decimal text a normalised number holds.
+ */
+function scaledDigitsOf(text) {
+    const [whole = "", fraction = ""] = text.split(".");
+    return { digits: BigInt(whole + fraction), scale: -fraction.length };
+}
+/**
+ * The digits this number has when written at a scale it is no coarser than.
+ */
+function digitsAt(number, scale) {
+    return number.digits * 10n ** BigInt(number.scale - scale);
+}
+/**
+ * Add one DynamoDB number to another, or take it away.
+ *
+ * The two are added as whole digits at their common scale, so nothing goes
+ * through a JavaScript number on the way. Adding 1 to 9007199254740993 answers
+ * 9007199254740994 here, where a double would answer 9007199254740992.
+ *
+ * The answer comes back as text, so whatever reads it applies the same range
+ * and precision checks a number a request wrote goes through.
+ */
+export function sumSimDynamoDbNumberTexts(one, other, direction) {
+    const augend = scaledDigitsOf(one);
+    const addend = scaledDigitsOf(other);
+    const scale = Math.min(augend.scale, addend.scale);
+    const total = digitsAt(augend, scale) + BigInt(direction) * digitsAt(addend, scale);
+    return simDynamoDbPlainDecimal(signOf(total), magnitudeOf(total).toString(), scale);
+}
+/**
+ * The sign a total is written with.
+ */
+function signOf(total) {
+    if (total < 0n) {
+        return "-";
+    }
+    return "";
+}
+/**
+ * A total without the sign in front of it.
+ */
+function magnitudeOf(total) {
+    if (total < 0n) {
+        return -total;
+    }
+    return total;
+}
+//# sourceMappingURL=sim-dynamodb-number-sum.js.map

package/dist/service/dynamodb/item/sim-dynamodb-number-sum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-sum.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-sum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAcxE;;GAEG;AACH,SAAS,cAAc,CAAC,IAAY;IAClC,MAAM,CAAC,KAAK,GAAG,EAAE,EAAE,QAAQ,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,GAAG,QAAQ,CAAC,EAAE,KAAK,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;AACvE,CAAC;AAED;;GAEG;AACH,SAAS,QAAQ,CAAC,MAAoB,EAAE,KAAa;IACnD,OAAO,MAAM,CAAC,MAAM,GAAG,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;AAC7D,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,yBAAyB,CACvC,GAAW,EACX,KAAa,EACb,SAAiB;IAEjB,MAAM,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;IACnC,MAAM,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACnD,MAAM,KAAK,GACT,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAExE,OAAO,uBAAuB,CAC5B,MAAM,CAAC,KAAK,CAAC,EACb,WAAW,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAC7B,KAAK,CACN,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,MAAM,CAAC,KAAa;IAC3B,IAAI,KAAK,GAAG,EAAE,EAAE,CAAC;QACf,OAAO,GAAG,CAAC;IACb,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAAC,KAAa;IAChC,IAAI,KAAK,GAAG,EAAE,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC;IAChB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/service/dynamodb/item/sim-dynamodb-number-text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Render a number in plain decimal notation.
+ *
+ * Every number DynamoDB takes fits in plain notation: the widest is 126 digits
+ * before the point and the smallest 130 zeros after it, so nothing here needs
+ * an exponent to stay readable.
+ *
+ * Both the number a request wrote and the number arithmetic worked out are
+ * written this way, so the same value reads back the same however it was
+ * arrived at.
+ */
+export declare function simDynamoDbPlainDecimal(sign: string, digits: string, scale: number): string;
+//# sourceMappingURL=sim-dynamodb-number-text.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-number-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-text.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAYR"}

package/dist/service/dynamodb/item/sim-dynamodb-number-text.js

@@ -0,0 +1,22 @@
+/**
+ * Render a number in plain decimal notation.
+ *
+ * Every number DynamoDB takes fits in plain notation: the widest is 126 digits
+ * before the point and the smallest 130 zeros after it, so nothing here needs
+ * an exponent to stay readable.
+ *
+ * Both the number a request wrote and the number arithmetic worked out are
+ * written this way, so the same value reads back the same however it was
+ * arrived at.
+ */
+export function simDynamoDbPlainDecimal(sign, digits, scale) {
+    if (scale >= 0) {
+        return sign + digits + "0".repeat(scale);
+    }
+    const pointPosition = digits.length + scale;
+    if (pointPosition > 0) {
+        return `${sign + digits.slice(0, pointPosition)}.${digits.slice(pointPosition)}`;
+    }
+    return `${sign}0.${"0".repeat(-pointPosition)}${digits}`;
+}
+//# sourceMappingURL=sim-dynamodb-number-text.js.map

package/dist/service/dynamodb/item/sim-dynamodb-number-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number-text.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number-text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY,EACZ,MAAc,EACd,KAAa;IAEb,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACf,OAAO,IAAI,GAAG,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC;IAE5C,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;QACtB,OAAO,GAAG,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;IACnF,CAAC;IAED,OAAO,GAAG,IAAI,KAAK,GAAG,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,GAAG,MAAM,EAAE,CAAC;AAC3D,CAAC"}

package/dist/service/dynamodb/item/sim-dynamodb-number.d.ts

@@ -0,0 +1,66 @@
+/**
+ * One DynamoDB number.
+ *
+ * DynamoDB numbers carry up to 38 significant digits, where a JavaScript
+ * number carries about 15, so the digits are kept as text and never converted.
+ * An identifier, a monetary amount or a large counter comes back exactly as it
+ * was written.
+ *
+ * The text is normalised: leading and trailing zeros are trimmed, and an
+ * exponent is worked back into plain notation. Two numbers written differently
+ * for the same value normalise to the same text, which is what makes a number
+ * set compare by value.
+ */
+export declare class SimDynamoDbNumber {
+    readonly text: string;
+    readonly significantDigits: number;
+    private constructor();
+    /**
+     * Read a number from the text a request carries.
+     */
+    static of(value: string): SimDynamoDbNumber;
+    /**
+     * Build a number from its digits and the power of ten they are scaled by.
+     */
+    private static ofDigits;
+    /**
+     * Compare this number with another, as DynamoDB orders numbers.
+     *
+     * The digits are compared rather than converted, so two numbers past what a
+     * JavaScript number holds still order by what they say. Converting them
+     * would round both to the same value and call them equal.
+     */
+    compareTo(other: SimDynamoDbNumber): number;
+    /**
+     * This number with another added to it.
+     *
+     * The digits are added rather than converted, so a total past what a
+     * JavaScript number holds is exact. A total outside the range DynamoDB
+     * stores is refused the same way one a request wrote would be.
+     */
+    plus(other: SimDynamoDbNumber): SimDynamoDbNumber;
+    /**
+     * This number with another taken away from it.
+     */
+    minus(other: SimDynamoDbNumber): SimDynamoDbNumber;
+    /**
+     * The bytes this number counts towards the item size.
+     *
+     * Real DynamoDB counts a number as about one byte per two significant digits,
+     * plus one.
+     */
+    get sizeInBytes(): number;
+    /**
+     * Whether this number is below zero.
+     */
+    private get negative();
+    /**
+     * Which way round this number goes against one of the other sign.
+     */
+    private signOrder;
+    /**
+     * The digits of this number, without the sign in front of them.
+     */
+    private withoutSign;
+}
+//# sourceMappingURL=sim-dynamodb-number.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB;IAC5B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,iBAAiB,EAAE,MAAM,CAAC;IAE1C,OAAO,eAGN;IAED;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAoB1C;IAED;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ;IAuBvB;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAe1C;IAED;;;;;;OAMG;IACH,IAAI,CAAC,KAAK,EAAE,iBAAiB,GAAG,iBAAiB,CAIhD;IAED;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,iBAAiB,CAIjD;IAED;;;;;OAKG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,OAAO,KAAK,QAAQ,GAEnB;IAED;;OAEG;IACH,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,OAAO,CAAC,WAAW;CAGpB"}

package/dist/service/dynamodb/item/sim-dynamodb-number.js

@@ -0,0 +1,125 @@
+import { SimDynamoDbValidationException } from "../error/dynamodb.error.js";
+import { compareSimDynamoDbMagnitudes } from "./sim-dynamodb-number-order.js";
+import { assertSimDynamoDbNumberInRange } from "./sim-dynamodb-number-range.js";
+import { sumSimDynamoDbNumberTexts } from "./sim-dynamodb-number-sum.js";
+import { simDynamoDbPlainDecimal } from "./sim-dynamodb-number-text.js";
+/**
+ * A number as DynamoDB takes it on the wire: digits, an optional fraction, and
+ * an optional exponent. It arrives as a string and never as a JavaScript
+ * number, which is the whole point of holding it this way.
+ */
+// Each part consumes a distinct character, so a value that fails to match
+// backtracks a digit at a time rather than combinatorially.
+// eslint-disable-next-line security/detect-unsafe-regex -- no nested quantifier.
+const numberPattern = /^(-?)(\d+)(?:\.(\d+))?(?:[Ee]([+-]?\d+))?$/;
+/**
+ * One DynamoDB number.
+ *
+ * DynamoDB numbers carry up to 38 significant digits, where a JavaScript
+ * number carries about 15, so the digits are kept as text and never converted.
+ * An identifier, a monetary amount or a large counter comes back exactly as it
+ * was written.
+ *
+ * The text is normalised: leading and trailing zeros are trimmed, and an
+ * exponent is worked back into plain notation. Two numbers written differently
+ * for the same value normalise to the same text, which is what makes a number
+ * set compare by value.
+ */
+export class SimDynamoDbNumber {
+    text;
+    significantDigits;
+    constructor(text, significantDigits) {
+        this.text = text;
+        this.significantDigits = significantDigits;
+    }
+    /**
+     * Read a number from the text a request carries.
+     */
+    static of(value) {
+        const match = numberPattern.exec(value);
+        if (match === null) {
+            throw new SimDynamoDbValidationException(`The parameter cannot be converted to a numeric value: ${value}`);
+        }
+        const [, sign = "", integerDigits = "", fractionDigits = "", exponent = "0",] = match;
+        const digits = integerDigits + fractionDigits;
+        const scale = Number(exponent) - fractionDigits.length;
+        return this.ofDigits(value, sign, digits, scale);
+    }
+    /**
+     * Build a number from its digits and the power of ten they are scaled by.
+     */
+    static ofDigits(value, sign, digits, scale) {
+        const withoutLeadingZeros = digits.replace(/^0+/, "");
+        if (withoutLeadingZeros === "") {
+            return new this("0", 1);
+        }
+        const significand = withoutLeadingZeros.replace(/0+$/, "");
+        const trailingZeros = withoutLeadingZeros.length - significand.length;
+        assertSimDynamoDbNumberInRange(value, significand, scale + trailingZeros);
+        return new this(simDynamoDbPlainDecimal(sign, significand, scale + trailingZeros), significand.length);
+    }
+    /**
+     * Compare this number with another, as DynamoDB orders numbers.
+     *
+     * The digits are compared rather than converted, so two numbers past what a
+     * JavaScript number holds still order by what they say. Converting them
+     * would round both to the same value and call them equal.
+     */
+    compareTo(other) {
+        if (this.negative !== other.negative) {
+            return this.signOrder();
+        }
+        const magnitude = compareSimDynamoDbMagnitudes(this.withoutSign(), other.withoutSign());
+        if (this.negative) {
+            return -magnitude;
+        }
+        return magnitude;
+    }
+    /**
+     * This number with another added to it.
+     *
+     * The digits are added rather than converted, so a total past what a
+     * JavaScript number holds is exact. A total outside the range DynamoDB
+     * stores is refused the same way one a request wrote would be.
+     */
+    plus(other) {
+        return SimDynamoDbNumber.of(sumSimDynamoDbNumberTexts(this.text, other.text, 1));
+    }
+    /**
+     * This number with another taken away from it.
+     */
+    minus(other) {
+        return SimDynamoDbNumber.of(sumSimDynamoDbNumberTexts(this.text, other.text, -1));
+    }
+    /**
+     * The bytes this number counts towards the item size.
+     *
+     * Real DynamoDB counts a number as about one byte per two significant digits,
+     * plus one.
+     */
+    get sizeInBytes() {
+        return Math.ceil(this.significantDigits / 2) + 1;
+    }
+    /**
+     * Whether this number is below zero.
+     */
+    get negative() {
+        return this.text.startsWith("-");
+    }
+    /**
+     * Which way round this number goes against one of the other sign.
+     */
+    signOrder() {
+        if (this.negative) {
+            return -1;
+        }
+        return 1;
+    }
+    /**
+     * The digits of this number, without the sign in front of them.
+     */
+    withoutSign() {
+        return this.text.replace("-", "");
+    }
+}
+//# sourceMappingURL=sim-dynamodb-number.js.map

package/dist/service/dynamodb/item/sim-dynamodb-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-number.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-number.ts"],"names":[],"mappings":"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"}

package/dist/service/dynamodb/item/sim-dynamodb-set-members.d.ts

@@ -0,0 +1,55 @@
+import type { SimDynamoDbNumber } from "./sim-dynamodb-number.js";
+import type { SimDynamoDbBinarySetValue, SimDynamoDbNumberSetValue, SimDynamoDbStringSetValue, SimDynamoDbValue } from "./sim-dynamodb-value.js";
+/**
+ * A stored value that is one of the three set kinds.
+ */
+export type SimDynamoDbSetValue = SimDynamoDbStringSetValue | SimDynamoDbNumberSetValue | SimDynamoDbBinarySetValue;
+/**
+ * Two sets of the same kind, and the members each of them holds.
+ *
+ * Set arithmetic only makes sense between two sets of one kind, so the pair is
+ * made once and carries its members already narrowed. That is what lets the
+ * arithmetic below hold no doubt about what it is working on.
+ */
+export type SimDynamoDbSetPair = {
+    readonly kind: "SS";
+    readonly stored: readonly string[];
+    readonly other: readonly string[];
+} | {
+    readonly kind: "NS";
+    readonly stored: readonly SimDynamoDbNumber[];
+    readonly other: readonly SimDynamoDbNumber[];
+} | {
+    readonly kind: "BS";
+    readonly stored: readonly Uint8Array[];
+    readonly other: readonly Uint8Array[];
+};
+/**
+ * Whether a stored value is a set.
+ */
+export declare function isSimDynamoDbSet(value: SimDynamoDbValue): value is SimDynamoDbSetValue;
+/**
+ * Pair two sets up, or answer with nothing when they are not the same kind.
+ *
+ * Real DynamoDB refuses to add a string set to a number set, so nothing here
+ * has to decide what that would mean.
+ */
+export declare function simDynamoDbMatchingSets(stored: SimDynamoDbSetValue, other: SimDynamoDbSetValue): SimDynamoDbSetPair | undefined;
+/**
+ * One set with the members of another added to it.
+ *
+ * Membership goes by value rather than by identity, so a member the set already
+ * holds is not added twice. The members it had keep the order they arrived in
+ * and the new ones follow, which is as good an order as any for a set real
+ * DynamoDB holds unordered.
+ */
+export declare function simDynamoDbSetUnion(pair: SimDynamoDbSetPair): SimDynamoDbSetValue;
+/**
+ * One set with the members of another taken out of it, or nothing when that
+ * leaves no members at all.
+ *
+ * DynamoDB has no empty set, so a subtraction that empties one takes the
+ * attribute away with it.
+ */
+export declare function simDynamoDbSetDifference(pair: SimDynamoDbSetPair): SimDynamoDbSetValue | undefined;
+//# sourceMappingURL=sim-dynamodb-set-members.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-set-members.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-set-members.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-set-members.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B,yBAAyB,GACzB,yBAAyB,GACzB,yBAAyB,CAAC;AAE9B;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IACE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC9C,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;CACvC,CAAC;AAON;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,gBAAgB,GACtB,KAAK,IAAI,mBAAmB,CAE9B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,mBAAmB,GACzB,kBAAkB,GAAG,SAAS,CAchC;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,kBAAkB,GACvB,mBAAmB,CAarB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,kBAAkB,GACvB,mBAAmB,GAAG,SAAS,CAQjC"}

package/dist/service/dynamodb/item/sim-dynamodb-set-members.js

@@ -0,0 +1,118 @@
+import { simDynamoDbBinaryText } from "./sim-dynamodb-binary.js";
+/**
+ * The descriptors a set arrives under.
+ */
+const kindsOfSet = new Set(["SS", "NS", "BS"]);
+/**
+ * Whether a stored value is a set.
+ */
+export function isSimDynamoDbSet(value) {
+    return kindsOfSet.has(value.kind);
+}
+/**
+ * Pair two sets up, or answer with nothing when they are not the same kind.
+ *
+ * Real DynamoDB refuses to add a string set to a number set, so nothing here
+ * has to decide what that would mean.
+ */
+export function simDynamoDbMatchingSets(stored, other) {
+    if (stored.kind === "SS" && other.kind === "SS") {
+        return { kind: "SS", stored: stored.texts, other: other.texts };
+    }
+    if (stored.kind === "NS" && other.kind === "NS") {
+        return { kind: "NS", stored: stored.numbers, other: other.numbers };
+    }
+    if (stored.kind === "BS" && other.kind === "BS") {
+        return { kind: "BS", stored: stored.bytes, other: other.bytes };
+    }
+    return undefined;
+}
+/**
+ * One set with the members of another added to it.
+ *
+ * Membership goes by value rather than by identity, so a member the set already
+ * holds is not added twice. The members it had keep the order they arrived in
+ * and the new ones follow, which is as good an order as any for a set real
+ * DynamoDB holds unordered.
+ */
+export function simDynamoDbSetUnion(pair) {
+    if (pair.kind === "SS") {
+        return { kind: "SS", texts: united(pair.stored, pair.other, textKey) };
+    }
+    if (pair.kind === "NS") {
+        return { kind: "NS", numbers: united(pair.stored, pair.other, numberKey) };
+    }
+    return {
+        kind: "BS",
+        bytes: united(pair.stored, pair.other, simDynamoDbBinaryText),
+    };
+}
+/**
+ * One set with the members of another taken out of it, or nothing when that
+ * leaves no members at all.
+ *
+ * DynamoDB has no empty set, so a subtraction that empties one takes the
+ * attribute away with it.
+ */
+export function simDynamoDbSetDifference(pair) {
+    const kept = remaining(pair);
+    if (memberCount(kept) === 0) {
+        return undefined;
+    }
+    return kept;
+}
+/**
+ * The set left when one set's members are taken out of another's.
+ */
+function remaining(pair) {
+    if (pair.kind === "SS") {
+        return { kind: "SS", texts: without(pair.stored, pair.other, textKey) };
+    }
+    if (pair.kind === "NS") {
+        return { kind: "NS", numbers: without(pair.stored, pair.other, numberKey) };
+    }
+    return {
+        kind: "BS",
+        bytes: without(pair.stored, pair.other, simDynamoDbBinaryText),
+    };
+}
+/**
+ * How many members a set holds.
+ */
+function memberCount(value) {
+    if (value.kind === "SS") {
+        return value.texts.length;
+    }
+    if (value.kind === "NS") {
+        return value.numbers.length;
+    }
+    return value.bytes.length;
+}
+/**
+ * The members of one set, and the members of another it did not already hold.
+ */
+function united(stored, other, keyOf) {
+    const held = new Set(stored.map((member) => keyOf(member)));
+    return [...stored, ...other.filter((member) => !held.has(keyOf(member)))];
+}
+/**
+ * The members of one set that another does not hold.
+ */
+function without(stored, other, keyOf) {
+    const taken = new Set(other.map((member) => keyOf(member)));
+    return stored.filter((member) => !taken.has(keyOf(member)));
+}
+/**
+ * A string member keys by itself.
+ */
+function textKey(text) {
+    return text;
+}
+/**
+ * A number member keys by its normalised digits, so `1` and `1.0` are one
+ * member.
+ */
+function numberKey(number) {
+    return number.text;
+}
+//# sourceMappingURL=sim-dynamodb-set-members.js.map

package/dist/service/dynamodb/item/sim-dynamodb-set-members.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-set-members.js","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-set-members.ts"],"names":[],"mappings":"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"}

package/dist/service/dynamodb/item/sim-dynamodb-value-comparison.d.ts

@@ -0,0 +1,14 @@
+import type { SimDynamoDbValue } from "./sim-dynamodb-value.js";
+/**
+ * Whether two stored values are the same value.
+ *
+ * Every type can be compared for equality, unlike ordering. Two values of
+ * different types are never equal, which is what makes `=` between them false
+ * rather than an error.
+ *
+ * A set is equal to another set holding the same members, whatever order they
+ * arrived in, because a set has no order. A list is equal only to a list
+ * holding the same elements in the same order, because a list does.
+ */
+export declare function simDynamoDbValuesEqual(first: SimDynamoDbValue, second: SimDynamoDbValue): boolean;
+//# sourceMappingURL=sim-dynamodb-value-comparison.d.ts.map

package/dist/service/dynamodb/item/sim-dynamodb-value-comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-value-comparison.d.ts","sourceRoot":"","sources":["../../../../src/service/dynamodb/item/sim-dynamodb-value-comparison.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAMT"}