@lagless/misc 0.0.33

package/dist/lib/now.d.ts

@@ -0,0 +1,2 @@
+export declare const now: () => number;
+//# sourceMappingURL=now.d.ts.map

package/dist/lib/now.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"now.d.ts","sourceRoot":"","sources":["../../src/lib/now.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,GAAG,EAAE,MAAM,MAMd,CAAC"}

package/dist/lib/now.js

@@ -0,0 +1,6 @@
+export const now = typeof globalThis.performance?.now === 'function'
+    ? globalThis.performance.now.bind(globalThis.performance)
+    : (() => {
+        const { performance } = require('node:perf_hooks');
+        return performance.now.bind(performance);
+    })();

package/dist/lib/phase-nudger.d.ts

@@ -0,0 +1,27 @@
+export declare class PhaseNudger {
+    private readonly _frameLength;
+    private readonly _maxNudgePerFrame;
+    private _phaseDebtMs;
+    private _isActive;
+    constructor(_frameLength: number, _maxNudgePerFrame: number);
+    get isActive(): boolean;
+    get currentDebtMs(): number;
+    /**
+     * Activates the nudger. Call this when ClockSync becomes ready.
+     */
+    activate(): void;
+    /**
+     * Call on every server tick hint (after ClockSync is ready).
+     */
+    onServerTickHint(serverTick: number, localTick: number): void;
+    /**
+     * Resets debt to zero. Use when doing hard time sync.
+     */
+    reset(): void;
+    /**
+     * Drain a small portion of phase debt each frame.
+     * @returns milliseconds to add to accumulatedTime
+     */
+    drain(): number;
+}
+//# sourceMappingURL=phase-nudger.d.ts.map

package/dist/lib/phase-nudger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-nudger.d.ts","sourceRoot":"","sources":["../../src/lib/phase-nudger.ts"],"names":[],"mappings":"AAMA,qBAAa,WAAW;IAKpB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IALpC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,SAAS,CAAS;gBAGP,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM;IAG5C,IAAW,QAAQ,IAAI,OAAO,CAE7B;IAED,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED;;OAEG;IACI,QAAQ,IAAI,IAAI;IAKvB;;OAEG;IACI,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAyBpE;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;OAGG;IACI,KAAK,IAAI,MAAM;CA6BvB"}

package/dist/lib/phase-nudger.js

@@ -0,0 +1,84 @@
+import { createLogger } from './logger.js';
+const log = createLogger('PhaseNudger');
+const LARGE_DEBT_THRESHOLD_MS = 50;
+const MAX_SINGLE_CORRECTION_MS = 5_000;
+export class PhaseNudger {
+    _frameLength;
+    _maxNudgePerFrame;
+    _phaseDebtMs = 0;
+    _isActive = false;
+    constructor(_frameLength, _maxNudgePerFrame) {
+        this._frameLength = _frameLength;
+        this._maxNudgePerFrame = _maxNudgePerFrame;
+    }
+    get isActive() {
+        return this._isActive;
+    }
+    get currentDebtMs() {
+        return this._phaseDebtMs;
+    }
+    /**
+     * Activates the nudger. Call this when ClockSync becomes ready.
+     */
+    activate() {
+        this._isActive = true;
+        log.info('Activated');
+    }
+    /**
+     * Call on every server tick hint (after ClockSync is ready).
+     */
+    onServerTickHint(serverTick, localTick) {
+        if (!this._isActive) {
+            return;
+        }
+        const dTicks = (serverTick - localTick) | 0;
+        const correctionMs = dTicks * this._frameLength;
+        // Reject unreasonably large corrections (likely bad data)
+        if (Math.abs(correctionMs) > MAX_SINGLE_CORRECTION_MS) {
+            log.warn(`Rejected large correction: ${correctionMs.toFixed(0)}ms (${dTicks} ticks)`);
+            return;
+        }
+        // Accumulate (not replace) - smooth out fluctuations
+        // Using weighted accumulation to prevent oscillation
+        const weight = 0.3;
+        this._phaseDebtMs = this._phaseDebtMs * (1 - weight) + correctionMs * weight;
+        // console.log(
+        //   `[PhaseNudger] Hint: ${dTicks} ticks, ` +
+        //   `debt: ${this._phaseDebtMs.toFixed(1)}ms`
+        // );
+    }
+    /**
+     * Resets debt to zero. Use when doing hard time sync.
+     */
+    reset() {
+        this._phaseDebtMs = 0;
+    }
+    /**
+     * Drain a small portion of phase debt each frame.
+     * @returns milliseconds to add to accumulatedTime
+     */
+    drain() {
+        if (!this._isActive || this._phaseDebtMs === 0) {
+            return 0;
+        }
+        const absDebt = Math.abs(this._phaseDebtMs);
+        // For large debt: drain faster but still limited
+        // For small debt: drain slowly for smoothness
+        let drainAmount;
+        if (absDebt >= LARGE_DEBT_THRESHOLD_MS) {
+            // Drain up to 50% of large debt per frame, but not more than frameLength
+            drainAmount = Math.min(absDebt * 0.5, this._frameLength);
+        }
+        else {
+            // Drain small amounts gradually
+            drainAmount = Math.min(absDebt, this._maxNudgePerFrame);
+        }
+        drainAmount *= Math.sign(this._phaseDebtMs);
+        this._phaseDebtMs -= drainAmount;
+        // Snap to zero if very small
+        if (Math.abs(this._phaseDebtMs) < 0.1) {
+            this._phaseDebtMs = 0;
+        }
+        return drainAmount;
+    }
+}

package/dist/lib/ring-buffer.d.ts

@@ -0,0 +1,11 @@
+export declare class RingBuffer<T> {
+    protected readonly _buffer: T[];
+    protected readonly _size: number;
+    private _pos;
+    constructor(size: number);
+    add(item: T): number;
+    get(atIdx: number): T | undefined;
+    [Symbol.iterator](): ArrayIterator<T>;
+    clear(): void;
+}
+//# sourceMappingURL=ring-buffer.d.ts.map

package/dist/lib/ring-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ring-buffer.d.ts","sourceRoot":"","sources":["../../src/lib/ring-buffer.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAU,CAAC,CAAC;IACvB,SAAS,CAAC,QAAQ,CAAC,OAAO,MAAgB;IAC1C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACjC,OAAO,CAAC,IAAI,CAAK;gBAEL,IAAI,EAAE,MAAM;IAOjB,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM;IAQpB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAIjC,CAAC,MAAM,CAAC,QAAQ,CAAC;IAIjB,KAAK,IAAI,IAAI;CAIrB"}

package/dist/lib/ring-buffer.js

@@ -0,0 +1,27 @@
+export class RingBuffer {
+    _buffer = new Array;
+    _size;
+    _pos = 0;
+    constructor(size) {
+        if (size < 0) {
+            throw new RangeError('The size does not allow negative values.');
+        }
+        this._size = size;
+    }
+    add(item) {
+        const insertAtIdx = this._pos;
+        this._buffer[insertAtIdx] = item;
+        this._pos = (insertAtIdx + 1) % this._size;
+        return insertAtIdx;
+    }
+    get(atIdx) {
+        return this._buffer[atIdx];
+    }
+    [Symbol.iterator]() {
+        return this._buffer[Symbol.iterator]();
+    }
+    clear() {
+        this._buffer.length = 0;
+        this._pos = 0;
+    }
+}

package/dist/lib/simulation-clock.d.ts

@@ -0,0 +1,18 @@
+import { PhaseNudger } from './phase-nudger.js';
+export declare class SimulationClock {
+    private _startedTime;
+    private _accumulatedTime;
+    readonly phaseNudger: PhaseNudger;
+    constructor(frameLength: number, maxNudgePerFrame: number);
+    get startedTime(): number;
+    get accumulatedTime(): number;
+    getElapsedTime: () => number;
+    start(): void;
+    update(dt: number): void;
+    /**
+     * Jump accumulated time to a specific value.
+     * Used for late-join to sync with server tick.
+     */
+    setAccumulatedTime(ms: number): void;
+}
+//# sourceMappingURL=simulation-clock.d.ts.map

package/dist/lib/simulation-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulation-clock.d.ts","sourceRoot":"","sources":["../../src/lib/simulation-clock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,qBAAa,eAAe;IAC1B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,gBAAgB,CAAK;IAE7B,SAAgB,WAAW,EAAE,WAAW,CAAC;gBAGvC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM;IAK1B,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,eAAe,IAAI,MAAM,CAEnC;IAEM,cAAc,QAAO,MAAM,CAKjC;IAEM,KAAK,IAAI,IAAI;IAQb,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI/B;;;OAGG;IACI,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;CAI5C"}

package/dist/lib/simulation-clock.js

@@ -0,0 +1,40 @@
+import { now } from './now.js';
+import { PhaseNudger } from './phase-nudger.js';
+export class SimulationClock {
+    _startedTime = 0;
+    _accumulatedTime = 0;
+    phaseNudger;
+    constructor(frameLength, maxNudgePerFrame) {
+        this.phaseNudger = new PhaseNudger(frameLength, maxNudgePerFrame);
+    }
+    get startedTime() {
+        return this._startedTime;
+    }
+    get accumulatedTime() {
+        return this._accumulatedTime;
+    }
+    getElapsedTime = () => {
+        if (this._startedTime === 0) {
+            throw new Error('SimulationClock has not been started yet.');
+        }
+        return now() - this._startedTime;
+    };
+    start() {
+        if (this._startedTime !== 0) {
+            throw new Error('SimulationClock has already been started.');
+        }
+        this._startedTime = now();
+        this._accumulatedTime = 0;
+    }
+    update(dt) {
+        this._accumulatedTime += dt + this.phaseNudger.drain();
+    }
+    /**
+     * Jump accumulated time to a specific value.
+     * Used for late-join to sync with server tick.
+     */
+    setAccumulatedTime(ms) {
+        this._accumulatedTime = ms;
+        this.phaseNudger.reset();
+    }
+}

package/dist/lib/snapshot-history.d.ts

@@ -0,0 +1,18 @@
+export declare class SnapshotHistory<T> {
+    private readonly _maxSize;
+    private readonly _ticks;
+    private readonly _snapshots;
+    private _head;
+    private _count;
+    private _lastTick;
+    constructor(maxSize: number);
+    set(tick: number, snapshot: T): void;
+    getNearest(tick: number): T;
+    /**
+     * Remove all snapshots with tick >= given tick.
+     * After this call you can safely write new snapshots starting from that tick.
+     */
+    rollback(tick: number): void;
+    private indexAt;
+}
+//# sourceMappingURL=snapshot-history.d.ts.map

package/dist/lib/snapshot-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-history.d.ts","sourceRoot":"","sources":["../../src/lib/snapshot-history.ts"],"names":[],"mappings":"AAAA,qBAAa,eAAe,CAAC,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAG/C,OAAO,CAAC,KAAK,CAAK;IAElB,OAAO,CAAC,MAAM,CAAK;IAEnB,OAAO,CAAC,SAAS,CAAa;gBAElB,OAAO,EAAE,MAAM;IAUpB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI;IAkCpC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC;IAuClC;;;OAGG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAkCnC,OAAO,CAAC,OAAO;CAKhB"}

package/dist/lib/snapshot-history.js

@@ -0,0 +1,121 @@
+export class SnapshotHistory {
+    _maxSize;
+    _ticks;
+    _snapshots;
+    // Index of the oldest element in the ring buffer
+    _head = 0;
+    // Number of stored elements (<= maxSize)
+    _count = 0;
+    // Last inserted tick (to enforce monotonicity)
+    _lastTick = -Infinity;
+    constructor(maxSize) {
+        if (!Number.isInteger(maxSize) || maxSize <= 0) {
+            throw new Error('maxSize must be a positive integer');
+        }
+        this._maxSize = maxSize;
+        this._ticks = new Array(maxSize);
+        this._snapshots = new Array(maxSize);
+    }
+    set(tick, snapshot) {
+        // Enforce non-decreasing ticks for fast structure
+        if (tick < this._lastTick) {
+            throw new Error('Ticks must be non-decreasing. Call rollback() before writing older ticks.');
+        }
+        // If tick is the same as last one - just overwrite the last snapshot
+        if (tick === this._lastTick && this._count > 0) {
+            const lastLogicalIndex = this._count - 1;
+            const lastPhysicalIndex = this.indexAt(lastLogicalIndex);
+            this._ticks[lastPhysicalIndex] = tick;
+            this._snapshots[lastPhysicalIndex] = snapshot;
+            return;
+        }
+        this._lastTick = tick;
+        // Choose physical index where we will write new snapshot
+        let idx;
+        if (this._count < this._maxSize) {
+            // There is still free space: append after the last element
+            idx = this.indexAt(this._count);
+            this._count++;
+        }
+        else {
+            // Buffer is full: overwrite the oldest element (at head)
+            idx = this._head;
+            // Move head forward
+            this._head = (this._head + 1) % this._maxSize;
+        }
+        this._ticks[idx] = tick;
+        this._snapshots[idx] = snapshot;
+    }
+    getNearest(tick) {
+        if (this._count === 0) {
+            throw new Error('History is empty');
+        }
+        // Smallest tick (oldest snapshot)
+        const firstTick = this._ticks[this.indexAt(0)];
+        if (tick <= firstTick) {
+            // No snapshot with tick < requested tick
+            throw new Error('No snapshot with tick less than requested');
+        }
+        // Standard binary search for the greatest tick < requested tick
+        let left = 0;
+        let right = this._count - 1;
+        let resultLogicalIndex = -1;
+        while (left <= right) {
+            const mid = (left + right) >>> 1; // floor((left + right) / 2)
+            const midTick = this._ticks[this.indexAt(mid)];
+            if (midTick < tick) {
+                // Candidate: move right to find a closer one
+                resultLogicalIndex = mid;
+                left = mid + 1;
+            }
+            else {
+                // midTick >= tick, we need smaller ticks
+                right = mid - 1;
+            }
+        }
+        if (resultLogicalIndex === -1) {
+            throw new Error('No snapshot with tick less than requested');
+        }
+        const idx = this.indexAt(resultLogicalIndex);
+        return this._snapshots[idx];
+    }
+    /**
+     * Remove all snapshots with tick >= given tick.
+     * After this call you can safely write new snapshots starting from that tick.
+     */
+    rollback(tick) {
+        if (this._count === 0) {
+            this._lastTick = -Infinity;
+            return;
+        }
+        // Find first logical index where tick >= given one
+        let left = 0;
+        let right = this._count - 1;
+        let firstToDrop = this._count; // default: nothing to drop
+        while (left <= right) {
+            const mid = (left + right) >>> 1;
+            const midTick = this._ticks[this.indexAt(mid)];
+            if (midTick >= tick) {
+                firstToDrop = mid;
+                right = mid - 1;
+            }
+            else {
+                left = mid + 1;
+            }
+        }
+        // Keep elements [0, firstToDrop)
+        this._count = firstToDrop;
+        if (this._count === 0) {
+            this._lastTick = -Infinity;
+        }
+        else {
+            this._lastTick = this._ticks[this.indexAt(this._count - 1)];
+        }
+    }
+    // Convert logical index [0..count) to physical index in ring buffer
+    indexAt(logicalIndex) {
+        // logicalIndex 0 corresponds to head
+        const idx = this._head + logicalIndex;
+        return idx >= this._maxSize ? idx - this._maxSize : idx;
+    }
+}

package/dist/lib/transform2d-utils.d.ts

@@ -0,0 +1,30 @@
+interface Transform2dCursorLike {
+    positionX: number;
+    positionY: number;
+    rotation: number;
+    prevPositionX: number;
+    prevPositionY: number;
+    prevRotation: number;
+}
+export declare const interpolateTransform2dToRef: (prevPositionX: number, prevPositionY: number, positionX: number, positionY: number, prevRotation: number, rotation: number, interpolationFactor: number, ref: {
+    x: number;
+    y: number;
+    rotation: number;
+}, teleportThresholdSquared?: number) => void;
+export declare const interpolateTransform2d: (prevPositionX: number, prevPositionY: number, positionX: number, positionY: number, prevRotation: number, rotation: number, interpolationFactor: number) => {
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+};
+export declare const interpolateTransform2dCursor: (cursor: Transform2dCursorLike, interpolationFactor: number) => {
+    readonly x: number;
+    readonly y: number;
+    readonly rotation: number;
+};
+export declare const interpolateTransform2dCursorToRef: (cursor: Transform2dCursorLike, interpolationFactor: number, ref: {
+    x: number;
+    y: number;
+    rotation: number;
+}) => void;
+export {};
+//# sourceMappingURL=transform2d-utils.d.ts.map

package/dist/lib/transform2d-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform2d-utils.d.ts","sourceRoot":"","sources":["../../src/lib/transform2d-utils.ts"],"names":[],"mappings":"AAMA,UAAU,qBAAqB;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,2BAA2B,GACtC,eAAe,MAAM,EACrB,eAAe,MAAM,EACrB,WAAW,MAAM,EACjB,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,UAAU,MAAM,EAChB,qBAAqB,MAAM,EAC3B,KAAK;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC/C,iCAAkD,KACjD,IAcF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,eAAe,MAAM,EACrB,eAAe,MAAM,EACrB,WAAW,MAAM,EACjB,WAAW,MAAM,EACjB,cAAc,MAAM,EACpB,UAAU,MAAM,EAChB,qBAAqB,MAAM,KAC1B;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAarE,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,QAAQ,qBAAqB,EAC7B,qBAAqB,MAAM,KAC1B;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAUrE,CAAA;AAED,eAAO,MAAM,iCAAiC,GAC5C,QAAQ,qBAAqB,EAC7B,qBAAqB,MAAM,EAC3B,KAAK;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,KAC9C,IAWF,CAAA"}

package/dist/lib/transform2d-utils.js

@@ -0,0 +1,28 @@
+import { MathOps } from '@lagless/math';
+const INTERPOLATION_RESULT_BUFFER = { x: 0, y: 0, rotation: 0 };
+const BASE_TELEPORT_THRESHOLD = 300;
+export const interpolateTransform2dToRef = (prevPositionX, prevPositionY, positionX, positionY, prevRotation, rotation, interpolationFactor, ref, teleportThresholdSquared = BASE_TELEPORT_THRESHOLD) => {
+    const dx = positionX - prevPositionX;
+    const dy = positionY - prevPositionY;
+    const distanceSquared = dx * dx + dy * dy;
+    if (distanceSquared >= teleportThresholdSquared * teleportThresholdSquared) {
+        ref.x = positionX;
+        ref.y = positionY;
+        ref.rotation = -rotation;
+    }
+    else {
+        ref.x = prevPositionX + dx * interpolationFactor;
+        ref.y = -(prevPositionY + dy * interpolationFactor);
+        ref.rotation = -MathOps.lerpAngle(prevRotation, rotation, interpolationFactor);
+    }
+};
+export const interpolateTransform2d = (prevPositionX, prevPositionY, positionX, positionY, prevRotation, rotation, interpolationFactor) => {
+    interpolateTransform2dToRef(prevPositionX, prevPositionY, positionX, positionY, prevRotation, rotation, interpolationFactor, INTERPOLATION_RESULT_BUFFER);
+    return INTERPOLATION_RESULT_BUFFER;
+};
+export const interpolateTransform2dCursor = (cursor, interpolationFactor) => {
+    return interpolateTransform2d(cursor.prevPositionX, cursor.prevPositionY, cursor.positionX, cursor.positionY, cursor.prevRotation, cursor.rotation, interpolationFactor);
+};
+export const interpolateTransform2dCursorToRef = (cursor, interpolationFactor, ref) => {
+    interpolateTransform2dToRef(cursor.prevPositionX, cursor.prevPositionY, cursor.positionX, cursor.positionY, cursor.prevRotation, cursor.rotation, interpolationFactor, ref);
+};

package/dist/lib/uuid.d.ts

@@ -0,0 +1,33 @@
+export declare class UUID {
+    private readonly _bytes;
+    private _stringCache;
+    private constructor();
+    /**
+     * Generate a standard random (v4) UUID.
+     */
+    static generate(): UUID;
+    /**
+     * Generate a "Masked" UUID.
+     *
+     * It looks like a standard v4 UUID, but the last 4 bytes (32 bits)
+     * are a checksum of the first 12 bytes.
+     *
+     * Entropy: 90 bits (vs 122 in standard v4).
+     * False positive rate: 1 in ~4.3 billion.
+     */
+    static generateMasked(): UUID;
+    /**
+     * Check if a Uint8Array (16 bytes) represents a Masked UUID.
+     */
+    static isMaskedUint8(bytes: Uint8Array): boolean;
+    /**
+     * Check if a UUID string is a Masked UUID.
+     * Returns false if string is invalid or not masked.
+     */
+    static isMaskedString(uuidStr: string): boolean;
+    static fromString(uuidStr: string): UUID;
+    static fromUint8(uuidUint8: Uint8Array): UUID;
+    asString(): string;
+    asUint8(): Uint8Array;
+}
+//# sourceMappingURL=uuid.d.ts.map

package/dist/lib/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../src/lib/uuid.ts"],"names":[],"mappings":"AAqHA,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAa;IACpC,OAAO,CAAC,YAAY,CAAuB;IAE3C,OAAO;IAIP;;OAEG;WACW,QAAQ,IAAI,IAAI;IAY9B;;;;;;;;OAQG;WACW,cAAc,IAAI,IAAI;IAoBpC;;OAEG;WACW,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAavD;;;OAGG;WACW,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;WAWxC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;WAKjC,SAAS,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI;IAQ7C,QAAQ,IAAI,MAAM;IAOlB,OAAO,IAAI,UAAU;CAG7B"}