max-priority-queue-typed 2.5.0 → 2.5.2

package/dist/types/data-structures/matrix/matrix.d.ts

@@ -153,6 +153,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Get and set individual cells
    *  const m = new Matrix([
@@ -193,6 +217,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Modify individual cells
    *  const m = Matrix.zeros(2, 2);
@@ -225,6 +273,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Basic matrix arithmetic
    *  const a = new Matrix([
@@ -266,6 +338,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Element-wise subtraction
    *  const a = Matrix.from([[5, 6], [7, 8]]);
@@ -290,6 +386,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Matrix multiplication for transformations
    *  // 2x3 matrix * 3x2 matrix = 2x2 matrix
@@ -329,6 +449,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Matrix transpose (square matrix)
    *  const m = new Matrix([
@@ -364,6 +508,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Compute the inverse of a 2x2 matrix
    *  const m = Matrix.from([[4, 7], [2, 6]]);
@@ -392,6 +560,30 @@ export declare class Matrix {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Dot product of two matrices
    *  const a = Matrix.from([[1, 2], [3, 4]]);

package/dist/types/data-structures/queue/deque.d.ts

@@ -177,6 +177,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Deque peek at both ends
    *  const deque = new Deque<number>([10, 20, 30, 40, 50]);
@@ -208,6 +232,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Peek at the back element
    *  const dq = new Deque<string>(['a', 'b', 'c']);
@@ -242,6 +290,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // basic Deque creation and push/pop operations
    *  // Create a simple Deque with initial values
@@ -277,6 +349,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove from the back
    *  const dq = new Deque<number>([1, 2, 3]);
@@ -299,6 +395,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove from the front
    *  const dq = new Deque<number>([1, 2, 3]);
@@ -322,6 +442,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Deque shift and unshift operations
    *  const deque = new Deque<number>([20, 30, 40]);
@@ -366,6 +510,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Check if empty
    *  const dq = new Deque();
@@ -385,6 +553,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove all elements
    *  const dq = new Deque<number>([1, 2, 3]);
@@ -405,6 +597,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Access by index
    *  const dq = new Deque<string>(['a', 'b', 'c']);
@@ -474,6 +690,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Remove element
    *  const dq = new Deque<number>([1, 2, 3]);
@@ -510,6 +750,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Deque for...of iteration and reverse
    *  const deque = new Deque<string>(['A', 'B', 'C', 'D']);
@@ -564,6 +828,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Reclaim memory
    *  const dq = new Deque<number>([1, 2, 3, 4, 5]);
@@ -587,6 +875,30 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Create independent copy
    *  const dq = new Deque<number>([1, 2, 3]);
@@ -611,13 +923,37 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Filter elements
    *  const dq = new Deque<number>([1, 2, 3, 4]);
    *     const result = dq.filter(x => x > 2);
    *     console.log(result.length); // 2;
      */
-    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): this;
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;
     /**
      * Map elements into a new deque of the same element type.
      * @remarks Time O(N), Space O(N)
@@ -625,7 +961,7 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @param [thisArg] - Value for `this` inside the callback.
      * @returns A new deque with mapped values.
      */
-    mapSame(callback: ElementCallback<E, R, E>, thisArg?: any): this;
+    mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;
     /**
      * Map elements into a new deque (possibly different element type).
      * @remarks Time O(N), Space O(N)
@@ -643,13 +979,37 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      
      
      
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
+     
       * @example
    * // Transform elements
    *  const dq = new Deque<number>([1, 2, 3]);
    *     const result = dq.map(x => x * 10);
    *     console.log(result.toArray()); // [10, 20, 30];
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: IterableElementBaseOptions<EM, RM>, thisArg?: any): Deque<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: IterableElementBaseOptions<EM, RM>, thisArg?: unknown): Deque<EM, RM>;
     /**
      * (Protected) Set the internal bucket size.
      * @remarks Time O(1), Space O(1)
@@ -696,7 +1056,7 @@ export declare class Deque<E = any, R = any> extends LinearBase<E, R> {
      * @param [options] - Options forwarded to the constructor.
      * @returns A like-kind Deque instance.
      */
-    protected _createLike<T = E, RR = R>(elements?: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR>, options?: DequeOptions<T, RR>): any;
+    protected _createLike<T = E, RR = R>(elements?: IterableWithSizeOrLength<T> | IterableWithSizeOrLength<RR>, options?: DequeOptions<T, RR>): Deque<T, RR>;
     /**
      * (Protected) Iterate elements from back to front.
      * @remarks Time O(N), Space O(1)