@aidc-toolkit/utility 1.0.46 → 1.0.47-beta

package/dist/reg-exp.js

@@ -0,0 +1,55 @@
+import { i18nextUtility } from "./locale/i18n.js";
+/**
+ * Regular expression validator. The regular expression applies to the full string only if constructed as such. For
+ * example, <code>&#x2F;\d&#x2A;&#x2F;</code> (0 or more digits) matches every string, <code>&#x2F;\d+&#x2F;</code> (1
+ * or more digits) matches strings with at least one digit, <code>&#x2F;^\d&#x2A;$&#x2F;</code> matches strings that are
+ * all digits or empty, and <code>&#x2F;^\d+$&#x2F;</code> matches strings that are all digits and not empty.
+ *
+ * Clients of this class are recommended to override the {@linkcode createErrorMessage | createErrorMessage()} method
+ * to create a more suitable error message for their use case.
+ */
+export class RegExpValidator {
+    /**
+     * Regular expression.
+     */
+    #regExp;
+    /**
+     * Constructor.
+     *
+     * @param regExp
+     * Regular expression. See {@link RegExpValidator | class documentation} for notes.
+     */
+    constructor(regExp) {
+        this.#regExp = regExp;
+    }
+    /**
+     * Get the regular expression.
+     */
+    get regExp() {
+        return this.#regExp;
+    }
+    /**
+     * Create an error message for a string. The generic error message is sufficient for many use cases but a more
+     * domain-specific error message, possibly including the pattern itself, is often required.
+     *
+     * @param s
+     * String.
+     *
+     * @returns
+     * Error message.
+     */
+    createErrorMessage(s) {
+        return i18nextUtility.t("RegExpValidator.stringDoesNotMatchPattern", {
+            s
+        });
+    }
+    /**
+     * @inheritDoc
+     */
+    validate(s) {
+        if (!this.#regExp.test(s)) {
+            throw new RangeError(this.createErrorMessage(s));
+        }
+    }
+}
+//# sourceMappingURL=reg-exp.js.map

package/dist/reg-exp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reg-exp.js","sourceRoot":"","sources":["../src/reg-exp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGlD;;;;;;;;GAQG;AACH,MAAM,OAAO,eAAe;IACxB;;OAEG;IACM,OAAO,CAAS;IAEzB;;;;;OAKG;IACH,YAAY,MAAc;QACtB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;IAED;;;;;;;;;OASG;IACO,kBAAkB,CAAC,CAAS;QAClC,OAAO,cAAc,CAAC,CAAC,CAAC,2CAA2C,EAAE;YACjE,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,CAAS;QACd,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,CAAC;IACL,CAAC;CACJ"}

package/dist/sequence.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Sequence. Defines an ascending or descending sequence of big integers implemented as an iterable.
+ */
+export declare class Sequence implements Iterable<bigint> {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param startValue
+     * Start value.
+     *
+     * @param count
+     * Count of values. If count is zero or positive, iteration ascends from start value, otherwise it descends from
+     * start value.
+     */
+    constructor(startValue: number | bigint, count: number);
+    /**
+     * Get the start value (inclusive).
+     */
+    get startValue(): bigint;
+    /**
+     * Get the end value (exclusive).
+     */
+    get endValue(): bigint;
+    /**
+     * Get the count of values.
+     */
+    get count(): number;
+    /**
+     * Get the minimum value (inclusive).
+     */
+    get minimumValue(): bigint;
+    /**
+     * Get the maximum value (inclusive).
+     */
+    get maximumValue(): bigint;
+    /**
+     * Iterable implementation.
+     *
+     * @yields
+     * Next value in sequence.
+     */
+    [Symbol.iterator](): Generator<bigint>;
+}
+//# sourceMappingURL=sequence.d.ts.map

package/dist/sequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../src/sequence.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,QAAS,YAAW,QAAQ,CAAC,MAAM,CAAC;;IA+B7C;;;;;;;;;OASG;gBACS,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM;IAgBtD;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACD,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC;CAK3C"}

package/dist/sequence.js

@@ -0,0 +1,96 @@
+/**
+ * Sequence. Defines an ascending or descending sequence of big integers implemented as an iterable.
+ */
+export class Sequence {
+    /**
+     * Start value (inclusive).
+     */
+    #startValue;
+    /**
+     * End value (exclusive).
+     */
+    #endValue;
+    /**
+     * Count of values.
+     */
+    #count;
+    /**
+     * Delta to the next value; equal to the sign of the count.
+     */
+    #nextDelta;
+    /**
+     * Minimum value (inclusive).
+     */
+    #minimumValue;
+    /**
+     * Maximum value (inclusive).
+     */
+    #maximumValue;
+    /**
+     * Constructor.
+     *
+     * @param startValue
+     * Start value.
+     *
+     * @param count
+     * Count of values. If count is zero or positive, iteration ascends from start value, otherwise it descends from
+     * start value.
+     */
+    constructor(startValue, count) {
+        this.#startValue = BigInt(startValue);
+        this.#endValue = this.#startValue + BigInt(count);
+        this.#count = count;
+        if (count >= 0) {
+            this.#nextDelta = 1n;
+            this.#minimumValue = this.#startValue;
+            this.#maximumValue = this.#endValue - 1n;
+        }
+        else {
+            this.#nextDelta = -1n;
+            this.#minimumValue = this.#endValue + 1n;
+            this.#maximumValue = this.#startValue;
+        }
+    }
+    /**
+     * Get the start value (inclusive).
+     */
+    get startValue() {
+        return this.#startValue;
+    }
+    /**
+     * Get the end value (exclusive).
+     */
+    get endValue() {
+        return this.#endValue;
+    }
+    /**
+     * Get the count of values.
+     */
+    get count() {
+        return this.#count;
+    }
+    /**
+     * Get the minimum value (inclusive).
+     */
+    get minimumValue() {
+        return this.#minimumValue;
+    }
+    /**
+     * Get the maximum value (inclusive).
+     */
+    get maximumValue() {
+        return this.#maximumValue;
+    }
+    /**
+     * Iterable implementation.
+     *
+     * @yields
+     * Next value in sequence.
+     */
+    *[Symbol.iterator]() {
+        for (let value = this.#startValue; value !== this.#endValue; value += this.#nextDelta) {
+            yield value;
+        }
+    }
+}
+//# sourceMappingURL=sequence.js.map

package/dist/sequence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.js","sourceRoot":"","sources":["../src/sequence.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,QAAQ;IACjB;;OAEG;IACM,WAAW,CAAS;IAE7B;;OAEG;IACM,SAAS,CAAS;IAE3B;;OAEG;IACM,MAAM,CAAS;IAExB;;OAEG;IACM,UAAU,CAAW;IAE9B;;OAEG;IACM,aAAa,CAAS;IAE/B;;OAEG;IACM,aAAa,CAAS;IAE/B;;;;;;;;;OASG;IACH,YAAY,UAA2B,EAAE,KAAa;QAClD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QACtC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAClD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QAEpB,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACb,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;YACrB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC;YACtC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;QAC7C,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;YACzC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC;QAC1C,CAAC;IACL,CAAC;IAED;;OAEG;IACH,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACH,CAAE,CAAC,MAAM,CAAC,QAAQ,CAAC;QACf,KAAK,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,KAAK,KAAK,IAAI,CAAC,SAAS,EAAE,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpF,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC;CACJ"}

package/dist/string.d.ts

@@ -0,0 +1,25 @@
+/**
+ * String validation interface. To ensure signature compatibility in implementing classes, string validation is
+ * controlled by validation interfaces specific to each validator type.
+ */
+export interface StringValidation {
+}
+/**
+ * String validator interface.
+ *
+ * @template TStringValidation
+ * String validation type.
+ */
+export interface StringValidator<TStringValidation extends StringValidation = StringValidation> {
+    /**
+     * Validate a string and throw an error if validation fails.
+     *
+     * @param s
+     * String.
+     *
+     * @param validation
+     * String validation parameters.
+     */
+    validate: (s: string, validation?: TStringValidation) => void;
+}
+//# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,gBAAgB;CAChC;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe,CAAC,iBAAiB,SAAS,gBAAgB,GAAG,gBAAgB;IAC1F;;;;;;;;OAQG;IACH,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACjE"}

package/dist/string.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=string.js.map

package/dist/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":""}

package/dist/transformer.d.ts

@@ -0,0 +1,191 @@
+import { type IndexedCallback } from "./iterable-utility.js";
+/**
+ * Transformer that transforms values in a numeric domain to values in a range equal to the domain or to another range
+ * defined by a callback function. In other words, the domain determines valid input values and, without a callback, the
+ * range of valid output values.
+ *
+ * The concept is similar to {@link https://en.wikipedia.org/wiki/Format-preserving_encryption | format-preserving
+ * encryption}, where input values within a specified domain (e.g., {@link
+ * https://en.wikipedia.org/wiki/Payment_card_number | payment card numbers} ranging from 8-19 digits) are transformed
+ * into values in the same domain, typically for storage in a database where the data type and length are already fixed
+ * and exfiltration of the data can have significant repercussions.
+ *
+ * Two subclasses are supported directly by this class: {@linkcode IdentityTransformer} (which operates based on a
+ * domain only) and {@linkcode EncryptionTransformer} (which operates based on a domain and a tweak). If an application
+ * is expected to make repeated use of a transformer with the same domain and (optional) tweak and can't manage the
+ * transformer object, an in-memory cache is available via the {@linkcode get | get()} method. Properties in {@linkcode
+ * IdentityTransformer} and {@linkcode EncryptionTransformer} are read-only once constructed, so there is no issue with
+ * their shared use.
+ */
+export declare abstract class Transformer {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param domain
+     * Domain.
+     */
+    constructor(domain: number | bigint);
+    /**
+     * Get a transformer, constructing it if necessary. The type returned is {@linkcode IdentityTransformer} if tweak is
+     * undefined, {@linkcode EncryptionTransformer} if tweak is defined. Note that although an {@linkcode
+     * EncryptionTransformer} with a zero tweak operates as an {@linkcode IdentityTransformer}, {@linkcode
+     * EncryptionTransformer} is still the type returned if a zero tweak is explicitly specified.
+     *
+     * @param domain
+     * Domain.
+     *
+     * @param tweak
+     * Tweak.
+     *
+     * @returns
+     * Transformer.
+     */
+    static get(domain: number | bigint, tweak?: number | bigint): Transformer;
+    /**
+     * Get the domain.
+     */
+    get domain(): bigint;
+    /**
+     * Do the work of transforming a value forward.
+     *
+     * @param value
+     * Value.
+     *
+     * @returns
+     * Transformed value.
+     */
+    protected abstract doForward(value: bigint): bigint;
+    /**
+     * Transform a value forward.
+     *
+     * @param value
+     * Value.
+     *
+     * @returns
+     * Transformed value.
+     */
+    forward(value: number | bigint): bigint;
+    /**
+     * Transform a value forward and apply another transformation.
+     *
+     * @template TOutput
+     * Transformer callback output type.
+     *
+     * @param value
+     * Value.
+     *
+     * @param transformerCallback
+     * Called with interim transformed value to transform it to its final value.
+     *
+     * @returns
+     * Transformed value.
+     */
+    forward<TOutput>(value: number | bigint, transformerCallback: IndexedCallback<bigint, TOutput>): TOutput;
+    /**
+     * Transform values forward.
+     *
+     * @param values
+     * Values. If this is an instance of {@linkcode Sequence}, the minimum and maximum values are validated prior to
+     * transformation. Otherwise, the individual values are validated at the time of each transformation.
+     *
+     * @returns
+     * Transformed values.
+     */
+    forward(values: Iterable<number | bigint>): Iterable<bigint>;
+    /**
+     * Transform values forward and apply another transformation to each.
+     *
+     * @template TOutput
+     * Transformer callback output type.
+     *
+     * @param values
+     * Values. If this is an instance of {@linkcode Sequence}, the minimum and maximum values are validated prior to
+     * transformation. Otherwise, the individual values are validated at the time of each transformation.
+     *
+     * @param transformerCallback
+     * Called with each interim transformed value to transform it to its final value.
+     *
+     * @returns
+     * Transformed values.
+     */
+    forward<TOutput>(values: Iterable<number | bigint>, transformerCallback: IndexedCallback<bigint, TOutput>): Iterable<TOutput>;
+    forward<TInput extends number | bigint | Iterable<number | bigint>>(valueOrValues: TInput extends Iterable<number | bigint> ? TInput : number | bigint): TInput extends Iterable<number | bigint> ? Iterable<bigint> : bigint;
+    forward<TInput extends number | bigint | Iterable<number | bigint>, TOutput>(valueOrValues: TInput extends Iterable<number | bigint> ? TInput : number | bigint, transformerCallback: IndexedCallback<bigint, TOutput>): TInput extends Iterable<number | bigint> ? Iterable<TOutput> : TOutput;
+    /**
+     * Do the work of transforming a value in reverse.
+     *
+     * @param transformedValue
+     * Transformed value.
+     *
+     * @returns
+     * Value.
+     */
+    protected abstract doReverse(transformedValue: bigint): bigint;
+    /**
+     * Transform a value in reverse.
+     *
+     * @param transformedValue
+     * Transformed value.
+     *
+     * @returns
+     * Value.
+     */
+    reverse(transformedValue: number | bigint): bigint;
+}
+/**
+ * Identity transformer. Values are transformed to themselves.
+ */
+export declare class IdentityTransformer extends Transformer {
+    /**
+     * @inheritDoc
+     */
+    protected doForward(value: bigint): bigint;
+    /**
+     * @inheritDoc
+     */
+    protected doReverse(transformedValue: bigint): bigint;
+}
+/**
+ * Encryption transformer. Values are transformed using repeated shuffle and xor operations, similar to those found in
+ * many cryptography algorithms, particularly AES. While sufficient for obfuscation of numeric sequences (e.g., serial
+ * number generation, below), if true format-preserving encryption is required, a more robust algorithm such as {@link
+ * https://doi.org/10.6028/NIST.SP.800-38Gr1.2pd | FF1} is recommended. Furthermore, no work has been done to mitigate
+ * {@link https://timing.attacks.cr.yp.to/index.html | timing attacks} for key detection.
+ *
+ * The purpose of the encryption transformer is to generate pseudo-random values in a deterministic manner to obscure
+ * the sequence of values generated over time. A typical example is for serial number generation, where knowledge of the
+ * sequence can infer production volumes (e.g., serial number 1000 implies that at least 1,000 units have been
+ * manufactured) or can be used in counterfeiting (e.g., a counterfeiter can generate serial numbers 1001, 1002, ...
+ * with reasonable confidence that they would be valid if queried).
+ *
+ * The domain and the tweak together determine the encryption key, which in turn determines the number of rounds of
+ * shuffle and xor operations. The minimum number of rounds is 4, except where the domain is less than or equal to 256,
+ * which results in single-byte operations. To ensure that the operations are effective for single-byte domains, the
+ * number of rounds is 1 and only the xor operation is applied (shuffling a single byte is an identity operation).
+ *
+ * Another exception is when there is a tweak value of 0; this results in identity operations where the output value is
+ * identical to the input value, as no shuffle or xor takes place.
+ */
+export declare class EncryptionTransformer extends Transformer {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param domain
+     * Domain.
+     *
+     * @param tweak
+     * Tweak.
+     */
+    constructor(domain: number | bigint, tweak: number | bigint);
+    /**
+     * @inheritDoc
+     */
+    protected doForward(value: bigint): bigint;
+    /**
+     * @inheritDoc
+     */
+    protected doReverse(transformedValue: bigint): bigint;
+}
+//# sourceMappingURL=transformer.d.ts.map

package/dist/transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.d.ts","sourceRoot":"","sources":["../src/transformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAe,MAAM,uBAAuB,CAAC;AAI1E;;;;;;;;;;;;;;;;;GAiBG;AACH,8BAAsB,WAAW;;IAW7B;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,GAAG,MAAM;IAUnC;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW;IAsBzE;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAuBD;;;;;;;;OAQG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAsCnD;;;;;;;;OAQG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAEvC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,mBAAmB,EAAE,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAExG;;;;;;;;;OASG;IACH,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC;IAE5D;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,mBAAmB,EAAE,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC;IAG7H,OAAO,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,aAAa,EAAE,MAAM,SAAS,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,SAAS,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM;IAG7N,OAAO,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,mBAAmB,EAAE,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,SAAS,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO;IA8B/R;;;;;;;;OAQG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM;IAE9D;;;;;;;;OAQG;IACH,OAAO,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;CAOrD;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IAChD;;OAEG;cACgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAInD;;OAEG;cACgB,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM;CAGjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;;IA6ClD;;;;;;;;OAQG;gBACS,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAuM3D;;OAEG;cACgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAiBnD;;OAEG;cACgB,SAAS,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM;CAgBjE"}