@the-situation/core 0.5.0-alpha.0

package/dist/errors/index.js

@@ -0,0 +1,45 @@
+/**
+ * Effect-native error hierarchy for The Situation SDK.
+ *
+ * All errors extend `Data.TaggedError` so they work seamlessly with Effect's
+ * typed error channels.
+ *
+ * @module
+ */
+import { Data } from 'effect';
+/**
+ * Input validation failed (e.g., negative variance, invalid address).
+ */
+export class InvalidInputError extends Data.TaggedError('InvalidInputError') {
+}
+/**
+ * Newton-Raphson or other numerical solver did not converge.
+ */
+export class SolverFailedError extends Data.TaggedError('SolverFailedError') {
+}
+/**
+ * Starknet RPC call failed.
+ */
+export class RpcError extends Data.TaggedError('RpcError') {
+}
+/**
+ * Required data was not found or could not be parsed from an RPC response.
+ */
+export class MissingDataError extends Data.TaggedError('MissingDataError') {
+}
+/**
+ * Transaction or contract call execution failed.
+ */
+export class ExecutionError extends Data.TaggedError('ExecutionError') {
+}
+/**
+ * Operation requires a connected account but none is available.
+ */
+export class NotConnectedError extends Data.TaggedError('NotConnectedError') {
+}
+/**
+ * Requested feature or operation is not supported.
+ */
+export class UnsupportedError extends Data.TaggedError('UnsupportedError') {
+}
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAGzE;CAAG;AAEL;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAGzE;CAAG;AAEL;;GAEG;AACH,MAAM,OAAO,QAAS,SAAQ,IAAI,CAAC,WAAW,CAAC,UAAU,CAGvD;CAAG;AAEL;;GAEG;AACH,MAAM,OAAO,gBAAiB,SAAQ,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAGvE;CAAG;AAEL;;GAEG;AACH,MAAM,OAAO,cAAe,SAAQ,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAInE;CAAG;AAEL;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAEzE;CAAG;AAEL;;GAEG;AACH,MAAM,OAAO,gBAAiB,SAAQ,IAAI,CAAC,WAAW,CAAC,kBAAkB,CAEvE;CAAG"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @the-situation/core
+ *
+ * Core types, math primitives, distributions, and Effect error hierarchy.
+ *
+ * @packageDocumentation
+ */
+export { createSQ128x128Raw, isValidSQ128x128Raw, MAX_LIMB, NEG_ONE_RAW, ONE_RAW, type SQ128x128Raw, ZERO_RAW, } from './math/sq128-raw';
+export { EXP_NEG_TABLE, HALF, INV_SQRT_2PI, MAX, MIN, NEG_ONE, ONE, SQ128x128, TWO, ZERO, } from './math/sq128';
+export type { Distribution } from './distributions/distribution';
+export { NormalDistribution, type NormalDistributionRaw } from './distributions/normal-distribution';
+export type { NormalSqrtHintsRaw } from './distributions/normal-sqrt-hints-raw';
+export { ExecutionError, InvalidInputError, MissingDataError, NotConnectedError, RpcError, type SdkError, SolverFailedError, UnsupportedError, } from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,OAAO,EACP,KAAK,YAAY,EACjB,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,GAAG,EACH,GAAG,EACH,OAAO,EACP,GAAG,EACH,SAAS,EACT,GAAG,EACH,IAAI,GACL,MAAM,cAAc,CAAC;AAGtB,YAAY,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAGjE,OAAO,EAAE,kBAAkB,EAAE,KAAK,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AACrG,YAAY,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAGhF,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,KAAK,QAAQ,EACb,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * @the-situation/core
+ *
+ * Core types, math primitives, distributions, and Effect error hierarchy.
+ *
+ * @packageDocumentation
+ */
+// Math primitives
+export { createSQ128x128Raw, isValidSQ128x128Raw, MAX_LIMB, NEG_ONE_RAW, ONE_RAW, ZERO_RAW, } from './math/sq128-raw';
+export { EXP_NEG_TABLE, HALF, INV_SQRT_2PI, MAX, MIN, NEG_ONE, ONE, SQ128x128, TWO, ZERO, } from './math/sq128';
+// Normal distribution
+export { NormalDistribution } from './distributions/normal-distribution';
+// Effect error hierarchy
+export { ExecutionError, InvalidInputError, MissingDataError, NotConnectedError, RpcError, SolverFailedError, UnsupportedError, } from './errors';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,kBAAkB;AAClB,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,OAAO,EAEP,QAAQ,GACT,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,GAAG,EACH,GAAG,EACH,OAAO,EACP,GAAG,EACH,SAAS,EACT,GAAG,EACH,IAAI,GACL,MAAM,cAAc,CAAC;AAKtB,sBAAsB;AACtB,OAAO,EAAE,kBAAkB,EAA8B,MAAM,qCAAqC,CAAC;AAGrG,yBAAyB;AACzB,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EAER,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,UAAU,CAAC"}

package/dist/math/sq128-raw.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Raw representation of SQ128x128 fixed-point numbers.
+ *
+ * This module provides the low-level data structure that matches the Cairo
+ * `SQ128x128Raw` struct used for serialization/deserialization with Starknet.
+ *
+ * ## Representation
+ *
+ * A 256-bit signed magnitude number stored as four 64-bit limbs:
+ * - magnitude = limb3 * 2^192 + limb2 * 2^128 + limb1 * 2^64 + limb0
+ * - sign is stored separately in `neg` flag
+ *
+ * ## Constraints
+ *
+ * - All limbs: [0, 2^64 - 1]
+ * - neg: true for negative, false for non-negative
+ *
+ * @module
+ */
+/** Maximum value for all limbs (2^64 - 1) */
+export declare const MAX_LIMB: bigint;
+/**
+ * Raw DTO for SQ128x128 serialization to/from Starknet.
+ *
+ * This is intentionally "dumb data" - no arithmetic operations.
+ * Use `SQ128x128` class for computations.
+ */
+export interface SQ128x128Raw {
+    /** Lowest 64 bits of magnitude */
+    readonly limb0: bigint;
+    /** Second 64 bits of magnitude */
+    readonly limb1: bigint;
+    /** Third 64 bits of magnitude */
+    readonly limb2: bigint;
+    /** Highest 64 bits of magnitude */
+    readonly limb3: bigint;
+    /** Sign flag: true = negative, false = non-negative */
+    readonly neg: boolean;
+}
+/**
+ * Validates whether a raw value has valid limb ranges.
+ *
+ * @param raw - The raw value to validate
+ * @returns true if all limbs are within valid ranges
+ */
+export declare function isValidSQ128x128Raw(raw: SQ128x128Raw): boolean;
+/**
+ * Creates a validated SQ128x128Raw.
+ *
+ * @param limb0 - Lowest 64 bits
+ * @param limb1 - Second 64 bits
+ * @param limb2 - Third 64 bits
+ * @param limb3 - Highest 64 bits
+ * @param neg - Sign flag
+ * @returns The raw value if valid, null otherwise
+ */
+export declare function createSQ128x128Raw(limb0: bigint, limb1: bigint, limb2: bigint, limb3: bigint, neg: boolean): SQ128x128Raw | null;
+/** Zero (0.0) in raw representation */
+export declare const ZERO_RAW: SQ128x128Raw;
+/**
+ * One (1.0) in raw representation.
+ *
+ * 1.0 = 2^128 / 2^128, so the magnitude is exactly 2^128.
+ * In limbs: limb3 = 0, limb2 = 1, limb1 = 0, limb0 = 0
+ */
+export declare const ONE_RAW: SQ128x128Raw;
+/** Negative one (-1.0) in raw representation */
+export declare const NEG_ONE_RAW: SQ128x128Raw;
+//# sourceMappingURL=sq128-raw.d.ts.map

package/dist/math/sq128-raw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sq128-raw.d.ts","sourceRoot":"","sources":["../../src/math/sq128-raw.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,6CAA6C;AAC7C,eAAO,MAAM,QAAQ,EAAE,MAAyB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAW9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,OAAO,GACX,YAAY,GAAG,IAAI,CAGrB;AAMD,uCAAuC;AACvC,eAAO,MAAM,QAAQ,EAAE,YAMtB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,YAMrB,CAAC;AAEF,gDAAgD;AAChD,eAAO,MAAM,WAAW,EAAE,YAMzB,CAAC"}

package/dist/math/sq128-raw.js

@@ -0,0 +1,84 @@
+/**
+ * Raw representation of SQ128x128 fixed-point numbers.
+ *
+ * This module provides the low-level data structure that matches the Cairo
+ * `SQ128x128Raw` struct used for serialization/deserialization with Starknet.
+ *
+ * ## Representation
+ *
+ * A 256-bit signed magnitude number stored as four 64-bit limbs:
+ * - magnitude = limb3 * 2^192 + limb2 * 2^128 + limb1 * 2^64 + limb0
+ * - sign is stored separately in `neg` flag
+ *
+ * ## Constraints
+ *
+ * - All limbs: [0, 2^64 - 1]
+ * - neg: true for negative, false for non-negative
+ *
+ * @module
+ */
+/** Maximum value for all limbs (2^64 - 1) */
+export const MAX_LIMB = (1n << 64n) - 1n;
+/**
+ * Validates whether a raw value has valid limb ranges.
+ *
+ * @param raw - The raw value to validate
+ * @returns true if all limbs are within valid ranges
+ */
+export function isValidSQ128x128Raw(raw) {
+    return (raw.limb0 >= 0n &&
+        raw.limb0 <= MAX_LIMB &&
+        raw.limb1 >= 0n &&
+        raw.limb1 <= MAX_LIMB &&
+        raw.limb2 >= 0n &&
+        raw.limb2 <= MAX_LIMB &&
+        raw.limb3 >= 0n &&
+        raw.limb3 <= MAX_LIMB);
+}
+/**
+ * Creates a validated SQ128x128Raw.
+ *
+ * @param limb0 - Lowest 64 bits
+ * @param limb1 - Second 64 bits
+ * @param limb2 - Third 64 bits
+ * @param limb3 - Highest 64 bits
+ * @param neg - Sign flag
+ * @returns The raw value if valid, null otherwise
+ */
+export function createSQ128x128Raw(limb0, limb1, limb2, limb3, neg) {
+    const raw = { limb0, limb1, limb2, limb3, neg };
+    return isValidSQ128x128Raw(raw) ? raw : null;
+}
+// ============================================================================
+// Constants
+// ============================================================================
+/** Zero (0.0) in raw representation */
+export const ZERO_RAW = {
+    limb0: 0n,
+    limb1: 0n,
+    limb2: 0n,
+    limb3: 0n,
+    neg: false,
+};
+/**
+ * One (1.0) in raw representation.
+ *
+ * 1.0 = 2^128 / 2^128, so the magnitude is exactly 2^128.
+ * In limbs: limb3 = 0, limb2 = 1, limb1 = 0, limb0 = 0
+ */
+export const ONE_RAW = {
+    limb0: 0n,
+    limb1: 0n,
+    limb2: 1n,
+    limb3: 0n,
+    neg: false,
+};
+/** Negative one (-1.0) in raw representation */
+export const NEG_ONE_RAW = {
+    limb0: 0n,
+    limb1: 0n,
+    limb2: 1n,
+    limb3: 0n,
+    neg: true,
+};
+//# sourceMappingURL=sq128-raw.js.map

package/dist/math/sq128-raw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sq128-raw.js","sourceRoot":"","sources":["../../src/math/sq128-raw.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,6CAA6C;AAC7C,MAAM,CAAC,MAAM,QAAQ,GAAW,CAAC,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;AAqBjD;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAiB;IACnD,OAAO,CACL,GAAG,CAAC,KAAK,IAAI,EAAE;QACf,GAAG,CAAC,KAAK,IAAI,QAAQ;QACrB,GAAG,CAAC,KAAK,IAAI,EAAE;QACf,GAAG,CAAC,KAAK,IAAI,QAAQ;QACrB,GAAG,CAAC,KAAK,IAAI,EAAE;QACf,GAAG,CAAC,KAAK,IAAI,QAAQ;QACrB,GAAG,CAAC,KAAK,IAAI,EAAE;QACf,GAAG,CAAC,KAAK,IAAI,QAAQ,CACtB,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAAa,EACb,KAAa,EACb,KAAa,EACb,KAAa,EACb,GAAY;IAEZ,MAAM,GAAG,GAAiB,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;IAC9D,OAAO,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/C,CAAC;AAED,+EAA+E;AAC/E,YAAY;AACZ,+EAA+E;AAE/E,uCAAuC;AACvC,MAAM,CAAC,MAAM,QAAQ,GAAiB;IACpC,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,GAAG,EAAE,KAAK;CACX,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAiB;IACnC,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,GAAG,EAAE,KAAK;CACX,CAAC;AAEF,gDAAgD;AAChD,MAAM,CAAC,MAAM,WAAW,GAAiB;IACvC,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,EAAE;IACT,GAAG,EAAE,IAAI;CACV,CAAC"}

package/dist/math/sq128.d.ts

@@ -0,0 +1,191 @@
+/**
+ * SQ128x128 fixed-point number type.
+ *
+ * An immutable fixed-point number with 128 bits of integer precision
+ * and 128 bits of fractional precision.
+ *
+ * ## Range
+ * - Minimum: -2^128 ≈ -3.4×10³⁸
+ * - Maximum: 2^128 - 2^-128 ≈ 3.4×10³⁸
+ *
+ * ## Design
+ * - Immutable: all operations return new instances
+ * - Safe: operations return null on overflow/underflow
+ * - Compatible: toRaw()/fromRaw() for Starknet serialization
+ *
+ * @module
+ */
+import { type SQ128x128Raw } from './sq128-raw';
+/**
+ * An immutable signed Q128.128 fixed-point number.
+ */
+export declare class SQ128x128 {
+    private readonly magnitude;
+    private readonly negative;
+    private constructor();
+    /**
+     * Creates an SQ128x128 from a JavaScript number.
+     *
+     * @param value - The number to convert
+     * @returns The SQ128x128 value, or null if overflow/invalid
+     */
+    static fromNumber(value: number): SQ128x128 | null;
+    /**
+     * Creates an SQ128x128 from a bigint integer value.
+     *
+     * @param value - The integer to convert
+     * @returns The SQ128x128 value, or null if overflow
+     */
+    static fromBigInt(value: bigint): SQ128x128 | null;
+    /**
+     * Creates an SQ128x128 from a raw representation.
+     *
+     * @param raw - The raw limb representation
+     * @returns The SQ128x128 value, or null if invalid
+     */
+    static fromRaw(raw: SQ128x128Raw): SQ128x128 | null;
+    /**
+     * Converts to a raw representation for Starknet serialization.
+     */
+    toRaw(): SQ128x128Raw;
+    /**
+     * Converts to a JavaScript number.
+     *
+     * Note: May lose precision for very large or very small values.
+     */
+    toNumber(): number;
+    /**
+     * Returns the underlying scaled magnitude as a bigint.
+     */
+    toScaledBigInt(): bigint;
+    /**
+     * Tests equality with another SQ128x128.
+     */
+    eq(other: SQ128x128): boolean;
+    /**
+     * Tests if this value is less than another.
+     */
+    lt(other: SQ128x128): boolean;
+    /**
+     * Tests if this value is greater than another.
+     */
+    gt(other: SQ128x128): boolean;
+    /**
+     * Tests if this value is less than or equal to another.
+     */
+    lte(other: SQ128x128): boolean;
+    /**
+     * Tests if this value is greater than or equal to another.
+     */
+    gte(other: SQ128x128): boolean;
+    /**
+     * Returns true if this value is zero.
+     */
+    isZero(): boolean;
+    /**
+     * Returns true if this value is negative.
+     */
+    isNegative(): boolean;
+    /**
+     * Returns true if this value is positive (greater than zero).
+     */
+    isPositive(): boolean;
+    /**
+     * Adds another SQ128x128 to this value.
+     *
+     * @returns The sum, or null on overflow
+     */
+    add(other: SQ128x128): SQ128x128 | null;
+    /**
+     * Subtracts another SQ128x128 from this value.
+     *
+     * @returns The difference, or null on overflow
+     */
+    sub(other: SQ128x128): SQ128x128 | null;
+    /**
+     * Multiplies by another SQ128x128.
+     *
+     * @returns The product (rounded toward zero), or null on overflow
+     */
+    mul(other: SQ128x128): SQ128x128 | null;
+    /**
+     * Divides by another SQ128x128.
+     *
+     * @returns The quotient (rounded toward zero), or null on division by zero/overflow
+     */
+    div(other: SQ128x128): SQ128x128 | null;
+    /**
+     * Returns the negation of this value.
+     *
+     * @returns The negated value, or null if negating MIN would overflow
+     */
+    neg(): SQ128x128 | null;
+    /**
+     * Returns the absolute value.
+     */
+    abs(): SQ128x128;
+    /**
+     * Computes the square of this value (x * x).
+     *
+     * More efficient than mul(this) as we can skip sign computation.
+     *
+     * @returns The squared value, or null on overflow
+     */
+    pow2(): SQ128x128 | null;
+    /**
+     * Computes the floor (integer part) of the absolute value.
+     *
+     * @returns The integer part as a number
+     */
+    floor(): number;
+    /**
+     * Computes the fractional part (value - floor).
+     *
+     * @returns The fractional part as SQ128x128
+     */
+    frac(): SQ128x128;
+    /**
+     * Computes exp(-|self|) for this value.
+     *
+     * Uses range reduction: exp(-u) = exp(-k) * exp(-(u mod 1))
+     * where k = floor(u) and the fractional part uses Taylor series.
+     *
+     * @returns The exponential value, or null if computation fails
+     */
+    expNeg(): SQ128x128 | null;
+    /**
+     * Computes exp(-x²/2) for this value.
+     *
+     * This is a common operation in normal distribution computations.
+     *
+     * @returns The exponential value, or null if computation fails
+     */
+    expNegHalfSquared(): SQ128x128 | null;
+}
+/** Zero (0.0) */
+export declare const ZERO: SQ128x128;
+/** Half (0.5) */
+export declare const HALF: SQ128x128;
+/** Two (2.0) */
+export declare const TWO: SQ128x128;
+/** One (1.0) */
+export declare const ONE: SQ128x128;
+/** Negative one (-1.0) */
+export declare const NEG_ONE: SQ128x128;
+/** Minimum value - practical limit for testing (using bigint for precision) */
+export declare const MIN: SQ128x128;
+/** Maximum value - practical limit for testing (using bigint for precision) */
+export declare const MAX: SQ128x128;
+/**
+ * 1/√(2π) ≈ 0.3989422804014327
+ *
+ * This constant is used in normal distribution PDF computation.
+ */
+export declare const INV_SQRT_2PI: SQ128x128;
+/**
+ * Precomputed exp(-k) lookup table for k = 0..10.
+ *
+ * For k > 10, exp(-k) < 2e-5, effectively zero for our precision.
+ */
+export declare const EXP_NEG_TABLE: SQ128x128[];
+//# sourceMappingURL=sq128.d.ts.map

package/dist/math/sq128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sq128.d.ts","sourceRoot":"","sources":["../../src/math/sq128.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAKL,KAAK,YAAY,EAElB,MAAM,aAAa,CAAC;AA8BrB;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IAEnC,OAAO;IAKP;;;;;OAKG;WACW,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAiCzD;;;;;OAKG;WACW,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAYzD;;;;;OAKG;WACW,OAAO,CAAC,GAAG,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI;IAS1D;;OAEG;IACI,KAAK,IAAI,YAAY;IAK5B;;;;OAIG;IACI,QAAQ,IAAI,MAAM;IAKzB;;OAEG;IACI,cAAc,IAAI,MAAM;IAQ/B;;OAEG;IACI,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAIpC;;OAEG;IACI,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAUpC;;OAEG;IACI,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAIpC;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAIrC;;OAEG;IACI,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO;IAQrC;;OAEG;IACI,MAAM,IAAI,OAAO;IAIxB;;OAEG;IACI,UAAU,IAAI,OAAO;IAI5B;;OAEG;IACI,UAAU,IAAI,OAAO;IAQ5B;;;;OAIG;IACI,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAe9C;;;;OAIG;IACI,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAe9C;;;;OAIG;IACI,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAa9C;;;;OAIG;IACI,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI;IAgB9C;;;;OAIG;IACI,GAAG,IAAI,SAAS,GAAG,IAAI;IAO9B;;OAEG;IACI,GAAG,IAAI,SAAS;IAIvB;;;;;;OAMG;IACI,IAAI,IAAI,SAAS,GAAG,IAAI;IAY/B;;;;OAIG;IACI,KAAK,IAAI,MAAM;IAMtB;;;;OAIG;IACI,IAAI,IAAI,SAAS;IAOxB;;;;;;;OAOG;IACI,MAAM,IAAI,SAAS,GAAG,IAAI;IAkCjC;;;;;;OAMG;IACI,iBAAiB,IAAI,SAAS,GAAG,IAAI;CAc7C;AAMD,iBAAiB;AACjB,eAAO,MAAM,IAAI,EAAE,SAAoD,CAAC;AAExE,iBAAiB;AACjB,eAAO,MAAM,IAAI,EAAE,SAMJ,CAAC;AAEhB,gBAAgB;AAChB,eAAO,MAAM,GAAG,EAAE,SAMH,CAAC;AAEhB,gBAAgB;AAChB,eAAO,MAAM,GAAG,EAAE,SAAmD,CAAC;AAEtE,0BAA0B;AAC1B,eAAO,MAAM,OAAO,EAAE,SAAuD,CAAC;AAE9E,+EAA+E;AAC/E,eAAO,MAAM,GAAG,EAAE,SAA2D,CAAC;AAE9E,+EAA+E;AAC/E,eAAO,MAAM,GAAG,EAAE,SAA+D,CAAC;AAMlF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,SAMZ,CAAC;AAEhB;;;;GAIG;AACH,eAAO,MAAM,aAAa,EAAE,SAAS,EAmFpC,CAAC"}