@omnitronix/rng-client-core 1.0.10 → 1.1.2

package/src/interfaces/metrics.ts

@@ -0,0 +1,38 @@
+export interface Counter<L = Record<string, string | number>> {
+  inc: (_labels?: L, _value?: number) => void;
+}
+
+export interface Histogram<L = Record<string, string | number>> {
+  observe: (_labels: L, _value: number) => void;
+}
+
+export interface Gauge<L = Record<string, string | number>> {
+  set: (_labels: L, _value: number) => void;
+}
+
+interface RngBufferBaseLabels {
+  rng_range: string;
+  engine_type: string;
+}
+
+export interface RngBufferMetricsHandlers {
+  rngBufferCapacity: Gauge<RngBufferBaseLabels>;
+  rngBufferFillLevel: Gauge<RngBufferBaseLabels>;
+  rngBufferFillRatio: Gauge<RngBufferBaseLabels>;
+  rngBufferRefillRequestsTotal: Counter<
+    RngBufferBaseLabels & {
+      reason?: string;
+    }
+  >;
+  rngBufferRefillFailuresTotal: Counter<
+    RngBufferBaseLabels & {
+      reason?: string;
+      error?: string;
+    }
+  >;
+  rngBufferRefillDurationMs: Histogram<RngBufferBaseLabels>;
+  rngBufferStarvationEventsTotal: Counter<RngBufferBaseLabels>;
+  rngBufferLatencyMs: Histogram<RngBufferBaseLabels>;
+}
+
+export type RngClientMetricsHandlers = RngBufferMetricsHandlers;

package/src/metrics/default-metrics-handlers.ts

@@ -0,0 +1,29 @@
+import {
+  Counter,
+  Gauge,
+  Histogram,
+  RngClientMetricsHandlers,
+} from '../interfaces/metrics';
+
+class DummyCounter implements Counter {
+  inc(_labels?: unknown, _value?: number): void {}
+}
+
+class DummyGauge implements Gauge {
+  set(_labels: unknown, _value: number): void {}
+}
+
+class DummyHistogram implements Histogram {
+  observe(_labels: unknown, _value: number): void {}
+}
+
+export const defaultMetricsHandlers: RngClientMetricsHandlers = {
+  rngBufferCapacity: new DummyGauge(),
+  rngBufferFillLevel: new DummyGauge(),
+  rngBufferFillRatio: new DummyGauge(),
+  rngBufferRefillRequestsTotal: new DummyCounter(),
+  rngBufferRefillFailuresTotal: new DummyCounter(),
+  rngBufferRefillDurationMs: new DummyHistogram(),
+  rngBufferStarvationEventsTotal: new DummyCounter(),
+  rngBufferLatencyMs: new DummyHistogram(),
+};

package/src/ring-buffer/interfaces.ts

@@ -0,0 +1,9 @@
+export interface SingleRingBuffer {
+  items: RingBufferValue[];
+  range: { min: number; max: number };
+}
+
+export interface RingBufferValue {
+  value: number;
+  seed: number;
+}

package/src/ring-buffer/ring-buffer.ts

@@ -0,0 +1,214 @@
+import { RingBufferValue, SingleRingBuffer } from './interfaces';
+import { RngClientCore } from '../core/rng-client-core';
+import { RingStorage, StorageType } from './ring-storage';
+import { RngBufferMetricsHandlers } from '../interfaces/metrics';
+
+export const FILL_UP_BUFFER_DELAY = 5;
+
+export interface RingBufferConfig {
+  size?: number;
+  clientCore: RngClientCore;
+  storageType: StorageType;
+  metrics: RngBufferMetricsHandlers;
+}
+
+export class RingBuffer {
+  private size: number;
+  private maxSize: number;
+  private clientCore: RngClientCore;
+  private storageType: StorageType;
+  private storage: RingStorage;
+  private readonly metrics: RngBufferMetricsHandlers;
+
+  constructor({ size, clientCore, storageType, metrics }: RingBufferConfig) {
+    this.size = size ?? 2000;
+    this.maxSize = this.size * 2;
+    this.clientCore = clientCore;
+    this.storageType = storageType;
+    this.storage = new RingStorage(storageType);
+    this.metrics = metrics;
+  }
+
+  private getRangeKey(min: number, max: number): string {
+    return `${min}-${max}`;
+  }
+
+  private getEngineType(): string {
+    return 'default';
+  }
+
+  async getNumbersByRange(
+    min: number,
+    max: number,
+    count = 1
+  ): Promise<RingBufferValue[] | undefined> {
+    const rangeKey = this.getRangeKey(min, max);
+    let requestStartTime = Date.now();
+
+    const buffer = await this.storage.getBufferByRange(min, max);
+    if (!buffer) {
+      this.metrics.rngBufferStarvationEventsTotal.inc({
+        rng_range: rangeKey,
+        engine_type: this.getEngineType(),
+      });
+
+      const newBuffer = this.createBuffer(min, max);
+      await this.storage.saveBuffer(newBuffer);
+      setTimeout(async () => {
+        requestStartTime = Date.now();
+        await this.fillUpBuffer(newBuffer, 'initial');
+        const latency = Date.now() - requestStartTime;
+        this.metrics.rngBufferLatencyMs.observe(
+          {
+            rng_range: rangeKey,
+            engine_type: this.getEngineType(),
+          },
+          latency
+        );
+      }, FILL_UP_BUFFER_DELAY);
+
+      return undefined;
+    }
+
+    const item = await this.storage.getFromBuffer(buffer, count);
+    if (!item) {
+      this.metrics.rngBufferStarvationEventsTotal.inc({
+        rng_range: rangeKey,
+        engine_type: this.getEngineType(),
+      });
+
+      setTimeout(async () => {
+        requestStartTime = Date.now();
+        await this.fillUpBuffer(buffer, 'starvation');
+        const latency = Date.now() - requestStartTime;
+        this.metrics.rngBufferLatencyMs.observe(
+          {
+            rng_range: rangeKey,
+            engine_type: this.getEngineType(),
+          },
+          latency
+        );
+      }, FILL_UP_BUFFER_DELAY);
+
+      return undefined;
+    }
+
+    setTimeout(async () => {
+      requestStartTime = Date.now();
+      await this.fillUpBuffer(buffer, 'refill');
+      const latency = Date.now() - requestStartTime;
+      this.metrics.rngBufferLatencyMs.observe(
+        {
+          rng_range: rangeKey,
+          engine_type: this.getEngineType(),
+        },
+        latency
+      );
+    }, FILL_UP_BUFFER_DELAY);
+
+    return item;
+  }
+
+  async fillUpBuffer(
+    buffer: SingleRingBuffer,
+    reason: string = 'scheduled'
+  ): Promise<void> {
+    const rangeKey = this.getRangeKey(buffer.range.min, buffer.range.max);
+    const refillStartTime = Date.now();
+
+    this.metrics.rngBufferRefillRequestsTotal.inc({
+      rng_range: rangeKey,
+      engine_type: this.getEngineType(),
+      reason,
+    });
+
+    try {
+      const values = await this.pullNumberByBuffer(buffer);
+      if (values.length === 0 || buffer.items.length >= this.maxSize) {
+        const duration = Date.now() - refillStartTime;
+        this.metrics.rngBufferRefillDurationMs.observe(
+          {
+            rng_range: rangeKey,
+            engine_type: this.getEngineType(),
+          },
+          duration
+        );
+        return;
+      }
+      await this.storage.addItemsToBuffer(buffer, values);
+      this.metrics.rngBufferFillLevel.set(
+        {
+          rng_range: rangeKey,
+          engine_type: this.getEngineType(),
+        },
+        buffer.items.length
+      );
+      this.metrics.rngBufferFillRatio.set(
+        {
+          rng_range: rangeKey,
+          engine_type: this.getEngineType(),
+        },
+        buffer.items.length / this.size
+      );
+
+      const duration = Date.now() - refillStartTime;
+      this.metrics.rngBufferRefillDurationMs.observe(
+        {
+          rng_range: rangeKey,
+          engine_type: this.getEngineType(),
+        },
+        duration
+      );
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      this.metrics.rngBufferRefillFailuresTotal.inc({
+        rng_range: rangeKey,
+        engine_type: this.getEngineType(),
+        reason,
+        error: errorMessage,
+      });
+
+      const duration = Date.now() - refillStartTime;
+      this.metrics.rngBufferRefillDurationMs.observe(
+        {
+          rng_range: rangeKey,
+          engine_type: this.getEngineType(),
+        },
+        duration
+      );
+
+      throw error;
+    }
+  }
+
+  async pullNumberByBuffer(
+    buffer: SingleRingBuffer
+  ): Promise<RingBufferValue[]> {
+    const count = this.size - buffer.items.length;
+    if (count <= 0) {
+      return [];
+    }
+    const values = await this.clientCore.getBatchNumbersWithSeeds({
+      min: buffer.range.min,
+      max: buffer.range.max,
+      count,
+    });
+    return values.result as RingBufferValue[];
+  }
+
+  createBuffer(min: number, max: number): SingleRingBuffer {
+    this.metrics.rngBufferCapacity.set(
+      {
+        rng_range: this.getRangeKey(min, max),
+        engine_type: this.getEngineType(),
+      },
+      this.size
+    );
+
+    return {
+      items: [],
+      range: { min, max },
+    };
+  }
+}

package/src/ring-buffer/ring-storage-memory.ts

@@ -0,0 +1,48 @@
+import { RingBufferValue, SingleRingBuffer } from './interfaces';
+
+export class RingStorageMemory {
+  private storage: { [key: string]: SingleRingBuffer };
+
+  constructor() {
+    this.storage = {};
+  }
+
+  getBufferName(min: number, max: number): string {
+    return `${min}-${max}`;
+  }
+
+  async saveBuffer(buffer: SingleRingBuffer): Promise<void> {
+    this.storage[this.getBufferName(buffer.range.min, buffer.range.max)] =
+      buffer;
+  }
+
+  async getBuffer(name: string): Promise<SingleRingBuffer> {
+    return this.storage[name];
+  }
+
+  async getFromBuffer(
+    name: string,
+    count = 1
+  ): Promise<RingBufferValue[] | undefined> {
+    const buffer = await this.getBuffer(name);
+    if (!buffer) {
+      return undefined;
+    }
+    if (buffer.items.length < count) {
+      return undefined;
+    }
+    const items = buffer.items.splice(0, count);
+    if (items.length === 0) {
+      return undefined;
+    }
+    return items;
+  }
+
+  async addItemsToBuffer(
+    buffer: SingleRingBuffer,
+    items: RingBufferValue[]
+  ): Promise<void> {
+    buffer.items.push(...items);
+    await this.saveBuffer(buffer);
+  }
+}

package/src/ring-buffer/ring-storage.ts

@@ -0,0 +1,59 @@
+import { RingBufferValue, SingleRingBuffer } from './interfaces';
+import { RingStorageMemory } from './ring-storage-memory';
+
+export enum StorageType {
+  IN_MEMORY = 'in_memory',
+  REDIS = 'redis',
+}
+
+export class RingStorage {
+  private storage: RingStorageMemory;
+  constructor(private readonly storageType: StorageType) {
+    this.storage = new RingStorageMemory();
+  }
+
+  async getFromBuffer(
+    buffer: SingleRingBuffer,
+    count = 1
+  ): Promise<RingBufferValue[] | undefined> {
+    if (this.storageType === StorageType.IN_MEMORY) {
+      return this.storage.getFromBuffer(
+        this.storage.getBufferName(buffer.range.min, buffer.range.max),
+        count
+      );
+    }
+    return undefined;
+  }
+
+  async saveBuffer(buffer: SingleRingBuffer): Promise<void> {
+    if (this.storageType === StorageType.IN_MEMORY) {
+      this.storage.saveBuffer(buffer);
+    }
+  }
+
+  async getBufferByRange(
+    min: number,
+    max: number
+  ): Promise<SingleRingBuffer | undefined> {
+    if (this.storageType === StorageType.IN_MEMORY) {
+      return this.storage.getBuffer(this.storage.getBufferName(min, max));
+    }
+    return undefined;
+  }
+
+  async getBuffer(name: string): Promise<SingleRingBuffer | undefined> {
+    if (this.storageType === StorageType.IN_MEMORY) {
+      return this.storage.getBuffer(name);
+    }
+    return undefined;
+  }
+
+  async addItemsToBuffer(
+    buffer: SingleRingBuffer,
+    items: RingBufferValue[]
+  ): Promise<void> {
+    if (this.storageType === StorageType.IN_MEMORY) {
+      this.storage.addItemsToBuffer(buffer, items);
+    }
+  }
+}

package/src/rng-client.ts

@@ -0,0 +1,190 @@
+import { RngClientCore } from './core/rng-client-core';
+import { RngClientConfig } from './interfaces/client-interfaces';
+import { StorageType } from './ring-buffer/ring-storage';
+import {
+  RngSingleResponse,
+  RngBatchResponse,
+  RngSingleRequest,
+  RngBatchRequest,
+  RngSingleFloatRequest,
+  RngBatchFloatRequest,
+} from './http/http-client.types';
+import { RingBuffer } from './ring-buffer/ring-buffer';
+import { defaultMetricsHandlers } from './metrics/default-metrics-handlers';
+
+/**
+ * RNG Client - High-level API for client-side random number generation
+ *
+ * This is the main entry point for client-side RNG operations.
+ * It provides a simple interface for generating random numbers
+ * via HTTP communication with the RNG service.
+ */
+export class RngClient {
+  private readonly clientCore: RngClientCore;
+  private readonly ringBuffer: RingBuffer;
+
+  constructor(config: RngClientConfig) {
+    this.clientCore = new RngClientCore(config);
+    this.ringBuffer = new RingBuffer({
+      size: config.poolingSize || 2000,
+      clientCore: this.clientCore,
+      storageType: config.storageType || StorageType.IN_MEMORY,
+      metrics: {
+        ...defaultMetricsHandlers,
+        ...config.metrics?.handlers,
+      },
+    });
+  }
+
+  /**
+   * Get a single random number
+   * @param min Minimum value (inclusive)
+   * @param max Maximum value (inclusive)
+   * @param seed Optional seed for deterministic generation
+   * @returns Random integer result
+   */
+  async getSingleNumber(
+    min: number,
+    max: number,
+    seed?: number
+  ): Promise<{ value: number; seed: number }> {
+    const data: RngSingleRequest = {
+      min,
+      max,
+    };
+    if (seed) {
+      data.seed = seed;
+    } else {
+      const item = await this.ringBuffer.getNumbersByRange(min, max, 1);
+      if (item && item.length > 0) {
+        return { value: item[0].value, seed: item[0].seed };
+      }
+    }
+    const response = await this.clientCore.getSingleNumber(data);
+    return { value: response.result, seed: response.seed };
+  }
+
+  /**
+   * Get a batch of random numbers
+   * @param min Minimum value (inclusive)
+   * @param max Maximum value (inclusive)
+   * @param count Number of values to generate
+   * @param seed Optional seed for deterministic generation
+   * @returns Batch of random integers
+   */
+  async getBatchNumbers(
+    min: number,
+    max: number,
+    count: number,
+    seed?: number
+  ): Promise<number[]> {
+    const data: RngBatchRequest = {
+      min,
+      max,
+      count,
+    };
+    if (seed) {
+      data.seed = seed;
+    }
+    const response = await this.clientCore.getBatchNumbers(data);
+
+    return response.result;
+  }
+
+  /**
+   * Get a batch of random numbers with seeds
+   * @param min Minimum value (inclusive)
+   * @param max Maximum value (inclusive)
+   * @param count Number of values to generate
+   * @param seed Optional seed for deterministic generation
+   * @returns Batch of random integers
+   */
+  async getBatchNumbersWithSeeds(
+    min: number,
+    max: number,
+    count: number,
+    seed?: number
+  ): Promise<{ value: number; seed: number }[]> {
+    const data: RngBatchRequest = {
+      min,
+      max,
+      count,
+    };
+    if (seed) {
+      data.seed = seed;
+    } else {
+      const item = await this.ringBuffer.getNumbersByRange(min, max, count);
+      if (item && item.length > 0) {
+        return item;
+      }
+    }
+    const response = await this.clientCore.getBatchNumbersWithSeeds(data);
+
+    return response.result.map((item) => ({
+      value: item.value,
+      seed: item.seed,
+    }));
+  }
+
+  /**
+   * Get a single random float
+   * @param seed Optional seed for deterministic generation
+   * @returns Random float result
+   */
+  async getSingleFloat(seed?: number): Promise<RngSingleResponse> {
+    const data: RngSingleFloatRequest = {};
+    if (seed) {
+      data.seed = seed;
+    }
+    return this.clientCore.getSingleFloat(data);
+  }
+
+  /**
+   * Get a batch of random floats
+   * @param count Number of values to generate
+   * @param seed Optional seed for deterministic generation
+   * @returns Batch of random floats
+   */
+  async getBatchFloats(
+    count: number,
+    seed?: number
+  ): Promise<RngBatchResponse> {
+    const data: RngBatchFloatRequest = { count };
+    if (seed) {
+      data.seed = seed;
+    }
+    return this.clientCore.getBatchFloats(data);
+  }
+
+  /**
+   * Get a random number
+   * @param min Minimum value (inclusive)
+   * @param max Maximum value (inclusive)
+   * @param seed Optional seed for deterministic generation
+   * @returns Random integer result
+   */
+  async getRandomNumber(
+    min: number,
+    max: number,
+    seed?: number
+  ): Promise<RngSingleResponse> {
+    const data: RngSingleRequest = { min, max };
+    if (seed) {
+      data.seed = seed;
+    }
+    return this.clientCore.getRandomNumber(data);
+  }
+
+  /**
+   * Get a random float
+   * @param seed Optional seed for deterministic generation
+   * @returns Random float result
+   */
+  async getRandomFloat(seed?: number): Promise<RngSingleResponse> {
+    const data: RngSingleFloatRequest = {};
+    if (seed) {
+      data.seed = seed;
+    }
+    return this.clientCore.getRandomFloat(data);
+  }
+}

package/src/rng.proto

@@ -0,0 +1,102 @@
+syntax = "proto3";
+
+package rng;
+
+service RngService {
+  rpc Single (SingleRequest) returns (SingleResponse);
+  rpc SingleBatch (BatchRequest) returns (BatchResponse);
+  rpc SingleBatchWithSeeds (BatchRequest) returns (BatchWithSeedsResponse);
+  rpc Float (FloatRequest) returns (FloatResponse);
+  rpc FloatBatch (BatchFloatRequest) returns (BatchFloatResponse);
+  rpc FloatBatchWithSeeds (BatchFloatRequest) returns (BatchFloatWithSeedsResponse);
+}
+
+message SingleRequest {
+  int32 min = 1;
+  int32 max = 2;
+  optional string sessionId = 3;
+  optional int32 seed = 4;
+}
+
+message SingleResponse {
+  string id = 1;
+  int32 seed = 2;
+  int32 result = 3;
+  int32 min = 4;
+  int32 max = 5;
+  string createdAt = 6;
+  optional string sessionId = 7;
+}
+
+message FloatRequest {
+  optional string sessionId = 1;
+  optional int32 seed = 2;
+}
+
+message FloatResponse {
+  string id = 1;
+  int32 seed = 2;
+  double result = 3;
+  string createdAt = 4;
+  optional string sessionId = 5;
+}
+
+message BatchFloatRequest {
+  int32 count = 1;
+  optional string sessionId = 2;
+  optional int32 seed = 3;
+}
+
+message BatchFloatResponse {
+  string id = 1;
+  int32 seed = 2;
+  repeated double result = 3;
+  string createdAt = 4;
+  optional string sessionId = 5;
+}
+
+message BatchFloatWithSeedsResponse {
+  string id = 1;
+  int32 seed = 2;
+  repeated BatchFloatItem result = 3;
+  string createdAt = 4;
+  optional string sessionId = 5;
+}
+
+message BatchFloatItem {
+  double value = 1;
+  int32 seed = 2;
+}
+
+message BatchRequest {
+  int32 min = 1;
+  int32 max = 2;
+  int32 count = 3;
+  optional string sessionId = 4;
+  optional int32 seed = 5;
+}
+
+message BatchResponse {
+  string id = 1;
+  int32 seed = 2;
+  repeated int32 result = 3;
+  int32 min = 4;
+  int32 max = 5;
+  string createdAt = 6;
+  optional string sessionId = 7;
+}
+
+message BatchWithSeedsResponse {
+  string id = 1;
+  int32 seed = 2;
+  repeated BatchItem result = 3;
+  int32 min = 4;
+  int32 max = 5;
+  string createdAt = 6;
+  optional string sessionId = 7;
+}
+
+message BatchItem {
+  int32 value = 1;
+  uint64 seed = 2;
+}

package/dist/core/rng-client-core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rng-client-core.d.ts","sourceRoot":"","sources":["../../src/core/rng-client-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAIlE,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;gBAEnC,MAAM,EAAE,eAAe;IAUtB,eAAe,CAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,CAAC;IAIhB,eAAe,CAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,iBAAiB,CAAC;IAIhB,cAAc,CACzB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;IAMhB,cAAc,CACzB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;IAMhB,cAAc,CACzB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,gBAAgB,CAAC;IAIf,eAAe,CAC1B,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,gBAAgB,CAAC;IAIf,wBAAwB,CACnC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,yBAAyB,CAAC;IAIxB,sBAAsB,CACjC,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,yBAAyB,CAAC;CAGtC"}

package/dist/core/rng-client-core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rng-client-core.js","sourceRoot":"","sources":["../../src/core/rng-client-core.ts"],"names":[],"mappings":";;;AAEA,6DAAwD;AACxD,6DAAwD;AAWxD,MAAa,aAAa;IAIxB,YAAY,MAAuB;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QAErB,IAAI,MAAM,CAAC,YAAY,KAAK,MAAM,EAAE,CAAC;YACnC,IAAI,CAAC,SAAS,GAAG,IAAI,+BAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACrD,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,SAAS,GAAG,IAAI,+BAAa,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,OAAyB;QAEzB,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACjD,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,OAAyB;QAEzB,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACjD,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,OAA8B;QAE9B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAE9D,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,OAA8B;QAE9B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAE9D,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,cAAc,CACzB,OAA6B;QAE7B,OAAO,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAChD,CAAC;IAEM,KAAK,CAAC,eAAe,CAC1B,IAAqB;QAErB,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAEM,KAAK,CAAC,wBAAwB,CACnC,OAAwB;QAExB,OAAO,IAAI,CAAC,SAAS,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC;IAC1D,CAAC;IAEM,KAAK,CAAC,sBAAsB,CACjC,OAA8B;QAE9B,OAAO,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;CACF;AAjED,sCAiEC"}

package/dist/errors/rng-errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rng-errors.d.ts","sourceRoot":"","sources":["../../src/errors/rng-errors.ts"],"names":[],"mappings":"AAEA,qBAAa,eAAgB,SAAQ,KAAK;aAGtB,IAAI,EAAE,MAAM;aACZ,aAAa,CAAC,EAAE,OAAO;gBAFvC,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,qBAAa,kBAAmB,SAAQ,eAAe;gBAEnD,OAAO,GAAE,MAA2C,EACpD,aAAa,CAAC,EAAE,OAAO;CAK1B;AAED,qBAAa,mBAAoB,SAAQ,KAAK;aAG1B,aAAa,CAAC,EAAE,OAAO;gBADvC,OAAO,GAAE,MAA2C,EACpC,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,qBAAa,gBAAiB,SAAQ,KAAK;aAGvB,UAAU,EAAE,MAAM;aAClB,aAAa,CAAC,EAAE,OAAO;gBAFvC,OAAO,EAAE,MAAM,EACC,UAAU,EAAE,MAAM,EAClB,aAAa,CAAC,EAAE,OAAO,YAAA;CAK1C;AAED,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,KAAK,CA+CP"}