data-structure-typed 0.9.16 → 1.12.9

package/dist/data-structures/matrix/vector2d.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector2D = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var Vector2D = /** @class */ (function () {
     function Vector2D(x, y, w // needed for matrix multiplication
     ) {
@@ -13,7 +17,8 @@ var Vector2D = /** @class */ (function () {
     }
     Object.defineProperty(Vector2D.prototype, "isZero", {
         /**
-         * Set x and y both to zero
+         * The function checks if the x and y values of a point are both zero.
+         * @returns A boolean value indicating whether both the x and y properties of the object are equal to 0.
          */
         get: function () {
             return this.x === 0 && this.y === 0;
@@ -23,7 +28,8 @@ var Vector2D = /** @class */ (function () {
     });
     Object.defineProperty(Vector2D.prototype, "length", {
         /**
-         * The length / magnitude of the vector
+         * The above function calculates the length of a vector using the Pythagorean theorem.
+         * @returns The length of a vector, calculated using the Pythagorean theorem.
          */
         get: function () {
             return Math.sqrt((this.x * this.x) + (this.y * this.y));
@@ -33,7 +39,8 @@ var Vector2D = /** @class */ (function () {
     });
     Object.defineProperty(Vector2D.prototype, "lengthSq", {
         /**
-         * The squared length of the vector
+         * The function calculates the square of the length of a vector.
+         * @returns The method is returning the sum of the squares of the x and y values.
          */
         get: function () {
             return (this.x * this.x) + (this.y * this.y);
@@ -43,7 +50,9 @@ var Vector2D = /** @class */ (function () {
     });
     Object.defineProperty(Vector2D.prototype, "rounded", {
         /**
-         * Return the vector with rounded values
+         * The "rounded" function returns a new Vector2D object with the x and y values rounded to the nearest whole number.
+         * @returns The method is returning a new instance of the Vector2D class with the x and y values rounded to the nearest
+         * whole number.
          */
         get: function () {
             return new Vector2D(Math.round(this.x), Math.round(this.y));
@@ -51,24 +60,87 @@ var Vector2D = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * The function "add" takes two Vector2D objects as parameters and returns a new Vector2D object with the sum of their
+     * x and y components.
+     * @param {Vector2D} vector1 - The parameter `vector1` is an instance of the `Vector2D` class. It represents a
+     * 2-dimensional vector with an `x` and `y` component.
+     * @param {Vector2D} vector2 - The parameter "vector2" is of type Vector2D. It represents a 2-dimensional vector with
+     * an x and y component.
+     * @returns The method is returning a new instance of the Vector2D class with the x and y components of the two input
+     * vectors added together.
+     */
     Vector2D.add = function (vector1, vector2) {
         return new Vector2D(vector1.x + vector2.x, vector1.y + vector2.y);
     };
+    /**
+     * The subtract function takes two Vector2D objects as parameters and returns a new Vector2D object with the x and y
+     * components subtracted.
+     * @param {Vector2D} vector1 - The parameter `vector1` is an instance of the `Vector2D` class, representing a
+     * 2-dimensional vector. It has properties `x` and `y` which represent the x and y components of the vector
+     * respectively.
+     * @param {Vector2D} vector2 - The parameter "vector2" is a Vector2D object. It represents the second vector that you
+     * want to subtract from the first vector.
+     * @returns The method is returning a new Vector2D object with the x and y components subtracted from vector1 and
+     * vector2.
+     */
     Vector2D.subtract = function (vector1, vector2) {
         return new Vector2D(vector1.x - vector2.x, vector1.y - vector2.y);
     };
+    /**
+     * The function subtracts a given value from the x and y components of a Vector2D object and returns a new Vector2D
+     * object.
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D, which represents a 2-dimensional vector with
+     * x and y components.
+     * @param {number} value - The "value" parameter is a number that will be subtracted from both the x and y components
+     * of the "vector" parameter.
+     * @returns A new Vector2D object with the x and y values subtracted by the given value.
+     */
     Vector2D.subtractValue = function (vector, value) {
         return new Vector2D(vector.x - value, vector.y - value);
     };
+    /**
+     * The function multiplies a Vector2D object by a given value.
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D, which represents a 2-dimensional vector with
+     * x and y components.
+     * @param {number} value - The "value" parameter is a number that represents the value by which the x and y components
+     * of the vector will be multiplied.
+     * @returns A new Vector2D object with the x and y values multiplied by the given value.
+     */
     Vector2D.multiply = function (vector, value) {
         return new Vector2D(vector.x * value, vector.y * value);
     };
+    /**
+     * The function divides the x and y components of a Vector2D by a given value and returns a new Vector2D.
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D, which represents a 2-dimensional vector with
+     * x and y components.
+     * @param {number} value - The value parameter is a number that will be used to divide the x and y components of the
+     * vector.
+     * @returns A new instance of the Vector2D class with the x and y values divided by the given value.
+     */
     Vector2D.divide = function (vector, value) {
         return new Vector2D(vector.x / value, vector.y / value);
     };
+    /**
+     * The function checks if two Vector2D objects are equal by comparing their x and y values.
+     * @param {Vector2D} vector1 - The parameter `vector1` is of type `Vector2D`, which represents a 2-dimensional vector.
+     * It has two properties: `x` and `y`, which represent the x and y components of the vector, respectively.
+     * @param {Vector2D} vector2 - The parameter "vector2" is of type Vector2D.
+     * @returns a boolean value, which indicates whether the two input vectors are equal or not.
+     */
     Vector2D.equals = function (vector1, vector2) {
         return vector1.x === vector2.x && vector1.y === vector2.y;
     };
+    /**
+     * The function checks if two Vector2D objects are equal within a specified rounding factor.
+     * @param {Vector2D} vector1 - The first vector to compare.
+     * @param {Vector2D} vector2 - The parameter "vector2" is a Vector2D object, which represents a 2-dimensional vector.
+     * It is used as one of the inputs for the "equalsRounded" function.
+     * @param [roundingFactor=12] - The roundingFactor parameter is used to determine the threshold for considering two
+     * vectors as equal. If the absolute difference in the x and y components of the vectors is less than the
+     * roundingFactor, the vectors are considered equal.
+     * @returns a boolean value.
+     */
     Vector2D.equalsRounded = function (vector1, vector2, roundingFactor) {
         if (roundingFactor === void 0) { roundingFactor = 12; }
         var vector = Vector2D.abs(Vector2D.subtract(vector1, vector2));
@@ -78,7 +150,10 @@ var Vector2D = /** @class */ (function () {
         return false;
     };
     /**
-     * Normalizes the vector if it matches a certain condition
+     * The normalize function takes a vector as input and returns a normalized version of the vector.Normalizes the vector if it matches a certain condition
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D.
+     * @returns the normalized vector if its length is greater than a very small value (epsilon), otherwise it returns the
+     * original vector.
      */
     Vector2D.normalize = function (vector) {
         var length = vector.length;
@@ -88,7 +163,12 @@ var Vector2D = /** @class */ (function () {
         return vector;
     };
     /**
-     * Adjusts x and y so that the length of the vector does not exceed max
+     * The function truncates a vector to a maximum length if it exceeds that length.Adjusts x and y so that the length of the vector does not exceed max
+     * @param {Vector2D} vector - A 2D vector represented by the Vector2D class.
+     * @param {number} max - The `max` parameter is a number that represents the maximum length that the `vector` should
+     * have.
+     * @returns either the original vector or a truncated version of the vector, depending on whether the length of the
+     * vector is greater than the maximum value specified.
      */
     Vector2D.truncate = function (vector, max) {
         if (vector.length > max) {
@@ -97,22 +177,39 @@ var Vector2D = /** @class */ (function () {
         return vector;
     };
     /**
-     * The vector that is perpendicular to this one
+     * The function returns a new Vector2D object that is perpendicular to the input vector.The vector that is perpendicular to this one
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D.
+     * @returns A new Vector2D object is being returned.
      */
     Vector2D.perp = function (vector) {
         return new Vector2D(-vector.y, vector.x);
     };
     /**
-     * returns the vector that is the reverse of this vector
+     * The reverse function takes a Vector2D object and returns a new Vector2D object with the negated x and y values.
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D, which represents a 2-dimensional vector. It
+     * has two properties: "x" and "y", which represent the x and y components of the vector, respectively.
+     * @returns A new Vector2D object with the negated x and y values of the input vector. Returns the vector that is the reverse of this vector
      */
     Vector2D.reverse = function (vector) {
         return new Vector2D(-vector.x, -vector.y);
     };
+    /**
+     * The function takes a Vector2D object as input and returns a new Vector2D object with the absolute values of its x
+     * and y components.
+     * @param {Vector2D} vector - The parameter "vector" is of type Vector2D, which represents a 2-dimensional vector. It
+     * has two properties: "x" and "y", which represent the x and y components of the vector, respectively.
+     * @returns The method is returning a new Vector2D object with the absolute values of the x and y components of the
+     * input vector.
+     */
     Vector2D.abs = function (vector) {
         return new Vector2D(Math.abs(vector.x), Math.abs(vector.y));
     };
     /**
-     * The dot product of v1 and v2
+     * The dot function calculates the dot product of two 2D vectors.The dot product of v1 and v2
+     * @param {Vector2D} vector1 - The parameter `vector1` represents a 2D vector with its x and y components.
+     * @param {Vector2D} vector2 - The "vector2" parameter is a Vector2D object. It represents a two-dimensional vector
+     * with an x and y component.
+     * @returns The dot product of the two input vectors.
      */
     Vector2D.dot = function (vector1, vector2) {
         return (vector1.x * vector2.x) + (vector1.y * vector2.y);
@@ -132,7 +229,14 @@ var Vector2D = /** @class */ (function () {
     //     return vectors.map(vector => Matrix2D.multiplyByVector(transformation, vector))
     // }
     /**
-     * The distance between this and the vector
+     * The function calculates the distance between two points in a two-dimensional space.
+     * @param {Vector2D} vector1 - The parameter `vector1` represents the first vector in 2D space, while `vector2`
+     * represents the second vector. Each vector has an `x` and `y` component, which represent their respective coordinates
+     * in the 2D space.
+     * @param {Vector2D} vector2 - The `vector2` parameter represents the second vector in the calculation of distance. It
+     * is an instance of the `Vector2D` class, which typically has properties `x` and `y` representing the coordinates of
+     * the vector in a 2D space.
+     * @returns The distance between vector1 and vector2.
      */
     Vector2D.distance = function (vector1, vector2) {
         var ySeparation = vector2.y - vector1.y;
@@ -140,7 +244,12 @@ var Vector2D = /** @class */ (function () {
         return Math.sqrt((ySeparation * ySeparation) + (xSeparation * xSeparation));
     };
     /**
-     * The distance between this and the vector squared
+     * The function calculates the squared distance between two 2D vectors.
+     * @param {Vector2D} vector1 - The parameter `vector1` represents the first vector, which is an instance of the
+     * `Vector2D` class. It contains the x and y coordinates of the vector.
+     * @param {Vector2D} vector2 - The `vector2` parameter represents the second vector in a two-dimensional space. It has
+     * properties `x` and `y` which represent the coordinates of the vector.
+     * @returns the square of the distance between the two input vectors.
      */
     Vector2D.distanceSq = function (vector1, vector2) {
         var ySeparation = vector2.y - vector1.y;
@@ -148,8 +257,13 @@ var Vector2D = /** @class */ (function () {
         return (ySeparation * ySeparation) + (xSeparation * xSeparation);
     };
     /**
-     * Returns positive if v2 is clockwise of this vector, negative if counterclockwise
+     * The sign function determines the sign of the cross product between two 2D vectors.
      * (assuming the Y axis is pointing down, X axis to right like a Window app)
+     * @param {Vector2D} vector1 - The parameter `vector1` is of type `Vector2D`, which represents a 2-dimensional vector.
+     * It likely has properties `x` and `y` representing the x and y components of the vector, respectively.
+     * @param {Vector2D} vector2 - The above code defines a function called "sign" that takes two parameters: vector1 and
+     * vector2. Both vector1 and vector2 are of type Vector2D.
+     * @returns either -1 or 1. Returns positive if v2 is clockwise of this vector, negative if counterclockwise
      */
     Vector2D.sign = function (vector1, vector2) {
         if (vector1.y * vector2.x > vector1.x * vector2.y) {
@@ -158,21 +272,31 @@ var Vector2D = /** @class */ (function () {
         return 1;
     };
     /**
-     * Returns the angle between origin and the given vector in radians
-     * @param vector
+     * The function calculates the angle between a given vector and the negative y-axis.
+     * @param {Vector2D} vector - The "vector" parameter is an instance of the Vector2D class, which represents a
+     * 2-dimensional vector. It has two properties: "x" and "y", which represent the x and y components of the vector,
+     * respectively.
+     * @returns the angle between the given vector and the vector (0, -1) in radians.Returns the angle between origin and the given vector in radians
      */
     Vector2D.angle = function (vector) {
         var origin = new Vector2D(0, -1);
         var radian = Math.acos(Vector2D.dot(vector, origin) / (vector.length * origin.length));
         return Vector2D.sign(vector, origin) === 1 ? ((Math.PI * 2) - radian) : radian;
     };
+    /**
+     * The function "random" generates a random Vector2D object with x and y values within the specified range.
+     * @param {number} maxX - The maxX parameter represents the maximum value for the x-coordinate of the random vector.
+     * @param {number} maxY - The `maxY` parameter represents the maximum value for the y-coordinate of the generated
+     * random vector.
+     * @returns a new instance of the Vector2D class with random x and y values.
+     */
     Vector2D.random = function (maxX, maxY) {
         var randX = Math.floor(Math.random() * maxX - (maxX / 2));
         var randY = Math.floor(Math.random() * maxY - (maxY / 2));
         return new Vector2D(randX, randY);
     };
     /**
-     * Check wether both x and y are zero
+     * The function sets the values of x and y to zero.
      */
     Vector2D.prototype.zero = function () {
         this.x = 0;

package/dist/data-structures/priority-queue/max-priority-queue.d.ts

@@ -1,5 +1,13 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../types';
 export declare class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
     constructor(options?: PriorityQueueOptions<T>);
 }

package/dist/data-structures/priority-queue/max-priority-queue.js

@@ -16,9 +16,17 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var priority_queue_1 = require("./priority-queue");
 var MaxPriorityQueue = /** @class */ (function (_super) {
     __extends(MaxPriorityQueue, _super);
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
     function MaxPriorityQueue(options) {
         return _super.call(this, {
             nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {

package/dist/data-structures/priority-queue/min-priority-queue.d.ts

@@ -1,5 +1,13 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../types';
 export declare class MinPriorityQueue<T = number> extends PriorityQueue<T> {
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
     constructor(options?: PriorityQueueOptions<T>);
 }

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -16,9 +16,17 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var priority_queue_1 = require("./priority-queue");
 var MinPriorityQueue = /** @class */ (function (_super) {
     __extends(MinPriorityQueue, _super);
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
     function MinPriorityQueue(options) {
         return _super.call(this, {
             nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -1,30 +1,160 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../types';
 export declare class PriorityQueue<T = number> {
     protected nodes: T[];
+    /**
+     * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
+     * function.
+     * @param options - The `options` parameter is an object that contains the following properties:
+     */
     constructor(options: PriorityQueueOptions<T>);
     get size(): number;
+    /**
+     * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
+     * @param options - The "options" parameter is an object that contains the configuration options for the PriorityQueue.
+     * It can include properties such as "comparator" which specifies the comparison function used to order the elements in
+     * the priority queue, and "initialValues" which is an array of initial values to be added to the priority
+     * @returns a new instance of the PriorityQueue class after performing the heapify operation on it.
+     */
     static heapify<T>(options: PriorityQueueOptions<T>): PriorityQueue<T>;
+    /**
+     * The function checks if a priority queue is valid by creating a new priority queue with a fix option and then calling
+     * the isValid method.
+     * @param options - An object containing options for creating a priority queue. The options object should have the
+     * following properties:
+     * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
+     */
     static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
+    /**
+     * The "offer" function adds a node to the heap and ensures that the heap property is maintained.
+     * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node
+     * that needs to be added to the heap.
+     */
     offer(node: T): void;
+    /**
+     * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
+     * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
+     * Otherwise, it returns `null`.
+     */
     peek(): T | null;
+    /**
+     * The `poll` function removes and returns the top element from a heap data structure.
+     * @returns The `poll()` method returns a value of type `T` or `null`.
+     */
     poll(): T | null;
+    /**
+     * The `leaf` function returns the last element in the `nodes` array or `null` if the array is empty.
+     * @returns The method `leaf()` is returning the last element (`T`) in the `nodes` array if it exists. If the array is
+     * empty or the last element is `null`, then it returns `null`.
+     */
     leaf(): T | null;
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value indicating whether the
+     * object is empty or not.
+     * @returns The method `isEmpty()` is returning a boolean value indicating whether the size of the object is equal to
+     * 0.
+     */
     isEmpty(): boolean;
+    /**
+     * The clear function clears the nodes array.
+     */
     clear(): void;
+    /**
+     * The toArray function returns an array containing all the elements in the nodes property.
+     * @returns An array of type T, which is the elements of the nodes property.
+     */
     toArray(): T[];
+    /**
+     * The `clone` function returns a new instance of the `PriorityQueue` class with the same nodes and comparator as the
+     * original instance.
+     * @returns The `clone()` method is returning a new instance of the `PriorityQueue` class with the same `nodes` and
+     * `comparator` properties as the original instance.
+     */
     clone(): PriorityQueue<T>;
+    /**
+     * The `isValid` function recursively checks if a binary tree satisfies a certain condition.
+     * @returns The function `isValid()` returns a boolean value.
+     */
     isValid(): boolean;
+    /**
+     * The function sorts the elements in a data structure and returns them in ascending order.
+     * @returns The `sort()` function is returning an array of type `T[]`.
+     */
     sort(): T[];
+    /**
+     * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
+     * based on the specified traversal order.
+     * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
+     * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
+     * @returns an array of type `(T | null)[]`.
+     */
     DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[];
     protected readonly _comparator: PriorityQueueComparator<T>;
+    /**
+     * The function compares two numbers using a custom comparator function.
+     * @param {number} a - The parameter "a" is a number that represents the index of a node in an array.
+     * @param {number} b - The parameter "b" is a number.
+     * @returns the result of the comparison between the elements at indices `a` and `b` in the `nodes` array. The
+     * comparison is done using the `_comparator` function, and if the result is greater than 0, `true` is returned,
+     * indicating that the element at index `a` is greater than the element at index `b`.
+     */
     protected _compare(a: number, b: number): boolean;
+    /**
+     * The function swaps two elements in an array.
+     * @param {number} a - The parameter "a" is a number that represents the index of an element in an array.
+     * @param {number} b - The parameter "b" is a number.
+     */
     protected _swap(a: number, b: number): void;
+    /**
+     * The function checks if a given index is valid within an array.
+     * @param {number} index - The parameter "index" is of type number and represents the index value that needs to be
+     * checked for validity.
+     * @returns A boolean value indicating whether the given index is valid or not.
+     */
     protected _isValidIndex(index: number): boolean;
+    /**
+     * The function returns the index of the parent node given the index of a child node in a binary tree.
+     * @param {number} child - The "child" parameter is a number representing the index of a child node in a binary tree.
+     * @returns the parent of the given child node.
+     */
     protected _getParent(child: number): number;
+    /**
+     * The function returns the index of the left child node in a binary tree given the index of its parent node.
+     * @param {number} parent - The parameter "parent" is a number that represents the index of a node in a binary tree.
+     * @returns the left child of a given parent node in a binary tree.
+     */
     protected _getLeft(parent: number): number;
+    /**
+     * The function returns the index of the right child node in a binary tree given the index of its parent node.
+     * @param {number} parent - The parameter "parent" is a number that represents the index of a node in a binary tree.
+     * @returns the right child of a given parent node in a binary tree.
+     */
     protected _getRight(parent: number): number;
+    /**
+     * The function returns the index of the smallest child node of a given parent node.
+     * @param {number} parent - The parent parameter is a number that represents the index of the parent node in a binary
+     * tree.
+     * @returns the minimum value between the parent node and its left and right child nodes.
+     */
     protected _getComparedChild(parent: number): number;
+    /**
+     * The function `_heapifyUp` is used to maintain the heap property by moving an element up the heap until it is in the
+     * correct position.
+     * @param {number} start - The start parameter is the index of the element that needs to be moved up in the heap.
+     */
     protected _heapifyUp(start: number): void;
+    /**
+     * The function performs a heapify operation by comparing and swapping elements in a binary heap.
+     * @param {number} start - The start parameter is the index of the element in the heap from where the heapifyDown
+     * operation should start.
+     */
     protected _heapifyDown(start: number): void;
+    /**
+     * The _fix function performs a heapify operation on the elements of the heap starting from the middle and moving
+     * towards the root.
+     */
     protected _fix(): void;
 }