@gabrielrufino/cube 2.0.8 → 2.0.10

package/README.md

@@ -44,7 +44,3 @@ const cube = require('@gabrielrufino/cube')
 * [Min Heap](./docs/MinHeap.md)
 * [Max Heap](./docs/MaxHeap.md)
 * [Graph](./docs/Graph.md)
-
----
-
-<small>Black Tech By [Gabriel Rufino](https://github.com/gabrielrufino) 🖤</small>

package/dist/Array/IArray.d.ts

@@ -1,9 +1,9 @@
 interface IArray<T> {
-    insertInLastPosition(_element: T): T;
-    insertInFirstPosition(_element: T): T;
-    insertInPosition(_position: number, _element: T): T;
-    removeFromLastPosition(): T | undefined;
-    removeFromFirstPosition(): T | undefined;
-    removeFromPosition(_position: number): T | undefined;
+    insertInLastPosition: (_element: T) => T;
+    insertInFirstPosition: (_element: T) => T;
+    insertInPosition: (_position: number, _element: T) => T;
+    removeFromLastPosition: () => T | undefined;
+    removeFromFirstPosition: () => T | undefined;
+    removeFromPosition: (_position: number) => T | undefined;
 }
 export default IArray;

package/dist/Array/index.d.ts

@@ -1,5 +1,5 @@
+import type IArray from './IArray';
 import DataStructure from '../DataStructure';
-import IArray from './IArray';
 export default class Array<T = number> extends DataStructure<T> implements IArray<T> {
     constructor(...inputs: Readonly<T[]>);
     insertInLastPosition(element: T): T;

package/dist/BinarySearchTree/IBinarySearchTree.d.ts

@@ -1,14 +1,14 @@
-import IBinarySearchTreeData from './IBinarySearchTreeData';
+import type IBinarySearchTreeData from './IBinarySearchTreeData';
 interface IBinarySearchTree<T> {
     get data(): IBinarySearchTreeData<T>;
     get size(): number;
     get min(): T | null;
     get max(): T | null;
-    insert(_value: T): T;
-    walkInOrder(_callback: (_value: T) => any): void;
-    walkPreOrder(_callback: (_value: T) => any): void;
-    walkPostOrder(_callback: (_value: T) => any): void;
-    search(_value: T): boolean;
-    remove(_value: T): T | null;
+    insert: (_value: T) => T;
+    walkInOrder: (_callback: (_value: T) => any) => void;
+    walkPreOrder: (_callback: (_value: T) => any) => void;
+    walkPostOrder: (_callback: (_value: T) => any) => void;
+    search: (_value: T) => boolean;
+    remove: (_value: T) => T | null;
 }
 export default IBinarySearchTree;

package/dist/BinarySearchTree/IBinarySearchTreeData.d.ts

@@ -1,4 +1,4 @@
-import BinarySearchTreeNode from './BinarySearchTreeNode';
+import type BinarySearchTreeNode from './BinarySearchTreeNode';
 interface IBinarySearchTreeData<T> {
     left: BinarySearchTreeNode<T> | null;
     value: T | null;

package/dist/BinarySearchTree/index.d.ts

@@ -1,6 +1,6 @@
-import IBinarySearchNodeOptions from './IBinarySearchNodeOptions';
-import IBinarySearchTree from './IBinarySearchTree';
-import IBinarySearchTreeData from './IBinarySearchTreeData';
+import type IBinarySearchNodeOptions from './IBinarySearchNodeOptions';
+import type IBinarySearchTree from './IBinarySearchTree';
+import type IBinarySearchTreeData from './IBinarySearchTreeData';
 export default class BinarySearchTree<T = number> implements IBinarySearchTree<T> {
     private _root;
     private _size;

package/dist/BinarySearchTree/index.js

@@ -99,6 +99,7 @@ var BinarySearchTree = /** @class */ (function () {
         return Boolean(current);
     };
     BinarySearchTree.prototype.remove = function (value) {
+        var _a;
         var current = this._root;
         var path = [];
         while (current && current.value !== value) {
@@ -114,7 +115,7 @@ var BinarySearchTree = /** @class */ (function () {
         var found = __assign({}, current);
         var parent = path
             .slice(0, path.length - 1)
-            .reduce(function (accumulator, current) { return accumulator && accumulator[current]; }, this._root);
+            .reduce(function (accumulator, current) { return accumulator[current]; }, this._root);
         var child = path[path.length - 1];
         if ((current === null || current === void 0 ? void 0 : current.left) && current.right && parent) {
             var head = current.right;
@@ -136,7 +137,7 @@ var BinarySearchTree = /** @class */ (function () {
             parent[child] = null;
             this._size -= 1;
         }
-        return found.value || null;
+        return (_a = found.value) !== null && _a !== void 0 ? _a : null;
     };
     BinarySearchTree.prototype._lessThanOrEqualTo = function (value1, value2) {
         if (value1 <= value2) {

package/dist/Deck/IDeck.d.ts

@@ -1,9 +1,9 @@
 interface IDeck<T> {
-    addFront(_element: T): T;
-    addBack(_element: T): T;
-    removeFront(): T | undefined;
-    removeBack(): T | undefined;
-    peekFront(): T | undefined;
-    peekBack(): T | undefined;
+    addFront: (_element: T) => T;
+    addBack: (_element: T) => T;
+    removeFront: () => T | undefined;
+    removeBack: () => T | undefined;
+    peekFront: () => T | undefined;
+    peekBack: () => T | undefined;
 }
 export default IDeck;

package/dist/Deck/index.d.ts

@@ -1,5 +1,5 @@
+import type IDeck from './IDeck';
 import DataStructure from '../DataStructure';
-import IDeck from './IDeck';
 export default class Deck<T = number> extends DataStructure<T> implements IDeck<T> {
     constructor(...inputs: Readonly<T[]>);
     addFront(element: T): T;

package/dist/Dictionary/IDictionary.d.ts

@@ -1,4 +1,4 @@
-import IDictionaryData from './IDictionaryData';
+import type IDictionaryData from './IDictionaryData';
 interface IDictionary<T> {
     get data(): IDictionaryData<T>;
     get size(): number;
@@ -6,11 +6,11 @@ interface IDictionary<T> {
     get keys(): string[];
     get values(): T[];
     get pairs(): [string, T][];
-    set(_key: string, _value: T): [string, T];
-    remove(_key: string): [string, T] | null;
-    hasKey(_key: string): boolean;
-    get(_key: string): T | null;
-    clear(): IDictionaryData<T>;
-    forEach(_func: (_key: string, _value: T) => any): void;
+    set: (_key: string, _value: T) => [string, T];
+    remove: (_key: string) => [string, T] | null;
+    hasKey: (_key: string) => boolean;
+    get: (_key: string) => T | null;
+    clear: () => IDictionaryData<T>;
+    forEach: (_func: (_key: string, _value: T) => any) => void;
 }
 export default IDictionary;

package/dist/Dictionary/index.d.ts

@@ -1,5 +1,5 @@
-import IDictionary from './IDictionary';
-import IDictionaryData from './IDictionaryData';
+import type IDictionary from './IDictionary';
+import type IDictionaryData from './IDictionaryData';
 export default class Dictionary<T = number> implements IDictionary<T> {
     private _data;
     constructor(inputs?: Readonly<{

package/dist/DoublyLinkedList/IDoublyLinkedList.d.ts

@@ -6,11 +6,11 @@ export interface IDoublyLinkedListItem<T> {
 interface IDoublyLinkedList<T> {
     get data(): IDoublyLinkedListItem<T>[];
     get size(): number;
-    push(_element: T): T;
-    getFromPosition(_position: number): IDoublyLinkedListItem<T> | undefined;
-    positionOf(_element: T): number | undefined;
-    insertInPosition(_element: T, _position: number): T | undefined;
-    remove(_element: T): T | undefined;
-    removeFromPosition(_position: number): T | undefined;
+    push: (_element: T) => T;
+    getFromPosition: (_position: number) => IDoublyLinkedListItem<T> | undefined;
+    positionOf: (_element: T) => number | undefined;
+    insertInPosition: (_element: T, _position: number) => T | undefined;
+    remove: (_element: T) => T | undefined;
+    removeFromPosition: (_position: number) => T | undefined;
 }
 export default IDoublyLinkedList;

package/dist/DoublyLinkedList/index.d.ts

@@ -1,4 +1,5 @@
-import IDoublyLinkedList, { IDoublyLinkedListItem } from './IDoublyLinkedList';
+import type { IDoublyLinkedListItem } from './IDoublyLinkedList';
+import type IDoublyLinkedList from './IDoublyLinkedList';
 export default class DoublyLinkedList<T = number> implements IDoublyLinkedList<T> {
     private _head;
     private _tail;

package/dist/Graph/GraphSearchNodeStates.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-unused-vars */
 var GraphSearchNodeStates;
 (function (GraphSearchNodeStates) {
     GraphSearchNodeStates[GraphSearchNodeStates["UNEXPLORED"] = 0] = "UNEXPLORED";

package/dist/Graph/IGraph.d.ts

@@ -6,10 +6,10 @@ interface IGraph {
     get size(): number;
     get nodes(): string[];
     get edges(): [string, string][];
-    insert(_node: string): string | null;
-    connect(_node1: string, _node2: string): [string, string];
-    breadthFirstSearch(_startNode: string, _callback: (_node: string) => void): void;
-    getDistancesFrom(_node: string): {
+    insert: (_node: string) => string | null;
+    connect: (_node1: string, _node2: string) => [string, string];
+    breadthFirstSearch: (_startNode: string, _callback: (_node: string) => void) => void;
+    getDistancesFrom: (_node: string) => {
         [key: string]: number;
     };
 }

package/dist/Graph/index.d.ts

@@ -1,6 +1,6 @@
-import IGraph from './IGraph';
-import IGraphOptions from './IGraphOptions';
-import { Edge } from './Edge';
+import type { Edge } from './Edge';
+import type IGraph from './IGraph';
+import type IGraphOptions from './IGraphOptions';
 export default class Graph implements IGraph {
     private readonly _isDirected;
     private readonly _data;

package/dist/Graph/index.js

@@ -23,11 +23,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var GraphNodeNotFoundError_1 = __importDefault(require("./GraphNodeNotFoundError"));
-var GraphSearchNodeStates_1 = __importDefault(require("./GraphSearchNodeStates"));
 var Dictionary_1 = __importDefault(require("../Dictionary"));
 var Queue_1 = __importDefault(require("../Queue"));
 var Set_1 = __importDefault(require("../Set"));
+var GraphNodeNotFoundError_1 = __importDefault(require("./GraphNodeNotFoundError"));
+var GraphSearchNodeStates_1 = __importDefault(require("./GraphSearchNodeStates"));
 var Graph = /** @class */ (function () {
     function Graph(_a) {
         var _b = _a === void 0 ? {} : _a, _c = _b.inputs, inputs = _c === void 0 ? {} : _c, _d = _b.isDirected, isDirected = _d === void 0 ? false : _d;

package/dist/HashTable/IHashTable.d.ts

@@ -1,10 +1,10 @@
-import IHashTableData from './IHashTableData';
+import type IHashTableData from './IHashTableData';
 interface IHashTable<T> {
     get data(): IHashTableData<T>;
     get size(): number;
     get maxSize(): number;
-    put(_key: string, _value: T): T;
-    get(_key: string): T | null;
-    remove(_key: string): T | null;
+    put: (_key: string, _value: T) => T;
+    get: (_key: string) => T | null;
+    remove: (_key: string) => T | null;
 }
 export default IHashTable;

package/dist/HashTable/index.d.ts

@@ -1,13 +1,13 @@
-import IHashTable from './IHashTable';
-import IHashTableData from './IHashTableData';
-import IHashTableInputs from './IHashTableInputs';
-import IHashTableOptions from './IHashTableOptions';
+import type IHashTable from './IHashTable';
+import type IHashTableData from './IHashTableData';
+import type IHashTableInputs from './IHashTableInputs';
+import type IHashTableOptions from './IHashTableOptions';
 export default class HashTable<T = number> implements IHashTable<T> {
+    readonly maxSize: number;
     private _data;
     constructor(inputs?: Readonly<IHashTableInputs<T>>, { maxSize }?: IHashTableOptions);
     get data(): IHashTableData<T>;
     get size(): number;
-    get maxSize(): number;
     put(key: string, value: T): T;
     get(key: string): T | null;
     remove(key: string): T | null;

package/dist/HashTable/index.js

@@ -15,7 +15,8 @@ var HashTable = /** @class */ (function () {
     function HashTable(inputs, _a) {
         if (inputs === void 0) { inputs = {}; }
         var _b = _a === void 0 ? {} : _a, _c = _b.maxSize, maxSize = _c === void 0 ? 100 : _c;
-        this._data = new Array(maxSize);
+        this._data = [];
+        this.maxSize = maxSize;
         for (var _i = 0, _d = Object.entries(inputs); _i < _d.length; _i++) {
             var _e = _d[_i], key = _e[0], value = _e[1];
             this.put(key, value);
@@ -40,13 +41,6 @@ var HashTable = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(HashTable.prototype, "maxSize", {
-        get: function () {
-            return this._data.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
     HashTable.prototype.put = function (key, value) {
         var position = this._hashCode(key);
         this._data[position] = value;

package/dist/HashTableLinearProbing/HashTableLinearProbingElement.js

@@ -1,6 +1,4 @@
 "use strict";
-/* eslint-disable no-unused-vars */
-/* eslint-disable no-useless-constructor */
 Object.defineProperty(exports, "__esModule", { value: true });
 var HashTableLinearProbingElement = /** @class */ (function () {
     function HashTableLinearProbingElement(key, value) {

package/dist/HashTableLinearProbing/IHashTableLinearProbing.d.ts

@@ -1,9 +1,9 @@
-import IHashTableLinearProbingData from './IHashTableLinearProbingData';
+import type IHashTableLinearProbingData from './IHashTableLinearProbingData';
 interface IHashTableLinearProbing<T> {
     get data(): IHashTableLinearProbingData<T>;
     get size(): number;
-    put(_key: string, _value: T): T | null;
-    get(_key: string): T | null;
-    remove(_key: string): T | null;
+    put: (_key: string, _value: T) => T | null;
+    get: (_key: string) => T | null;
+    remove: (_key: string) => T | null;
 }
 export default IHashTableLinearProbing;

package/dist/HashTableLinearProbing/IHashTableLinearProbingData.d.ts

@@ -1,4 +1,4 @@
-import HashTableLinearProbingElement from './HashTableLinearProbingElement';
+import type HashTableLinearProbingElement from './HashTableLinearProbingElement';
 interface IHashTableLinearProbingData<T> {
     [index: number]: HashTableLinearProbingElement<T>;
 }

package/dist/HashTableLinearProbing/index.d.ts

@@ -1,7 +1,7 @@
+import type IHashTableLinearProbing from './IHashTableLinearProbing';
+import type IHashTableLinearProbingInputs from './IHashTableLinearProbingInputs';
+import type IHashTableLinearProbingOptions from './IHashTableLinearProbingOptions';
 import HashTableLinearProbingElement from './HashTableLinearProbingElement';
-import IHashTableLinearProbing from './IHashTableLinearProbing';
-import IHashTableLinearProbingInputs from './IHashTableLinearProbingInputs';
-import IHashTableLinearProbingOptions from './IHashTableLinearProbingOptions';
 export default class HashTableLinearProbing<T = number> implements IHashTableLinearProbing<T> {
     private _maxSize;
     private _data;

package/dist/HashTableSeparateChaining/HashTableSeparateChainingElement.js

@@ -1,6 +1,4 @@
 "use strict";
-/* eslint-disable no-useless-constructor */
-/* eslint-disable no-unused-vars */
 Object.defineProperty(exports, "__esModule", { value: true });
 var HashTableSeparateChainingElement = /** @class */ (function () {
     function HashTableSeparateChainingElement(key, value) {

package/dist/HashTableSeparateChaining/IHashTableSeparateChaining.d.ts

@@ -1,11 +1,11 @@
-import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
-import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
+import type HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
+import type IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
 interface IHashTableSeparateChaining<T> {
     get data(): IHashTableSeparateChainingData<T>;
     get size(): number;
     get maxSize(): number;
-    put(_key: string, _value: T): T;
-    get(_key: string): HashTableSeparateChainingElement<T> | null;
-    remove(_key: string): HashTableSeparateChainingElement<T> | null;
+    put: (_key: string, _value: T) => T;
+    get: (_key: string) => HashTableSeparateChainingElement<T> | null;
+    remove: (_key: string) => HashTableSeparateChainingElement<T> | null;
 }
 export default IHashTableSeparateChaining;

package/dist/HashTableSeparateChaining/IHashTableSeparateChainingData.d.ts

@@ -1,4 +1,4 @@
-import LinkedList from '../LinkedList';
+import type LinkedList from '../LinkedList';
 interface IHashTableSeparateChainingData<T> {
     [key: number]: LinkedList<T>;
 }

package/dist/HashTableSeparateChaining/index.d.ts

@@ -1,15 +1,15 @@
+import type IHashTableSeparateChaining from './IHashTableSeparateChaining';
+import type IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
+import type IHashTableSeparateChainingInputs from './IHashTableSeparateChainingInputs';
 import HashTableSeparateChainingElement from './HashTableSeparateChainingElement';
-import IHashTableSeparateChaining from './IHashTableSeparateChaining';
-import IHashTableSeparateChainingData from './IHashTableSeparateChainingData';
-import IHashTableSeparateChainingInputs from './IHashTableSeparateChainingInputs';
 export default class HashTableSeparateChaining<T = number> implements IHashTableSeparateChaining<T> {
     private _data;
+    readonly maxSize: number;
     constructor(inputs?: Readonly<IHashTableSeparateChainingInputs<T>>, { maxSize }?: {
         maxSize: number;
     });
     get data(): IHashTableSeparateChainingData<T>;
     get size(): number;
-    get maxSize(): number;
     put(key: string, value: T): T;
     get(key: string): HashTableSeparateChainingElement<T> | null;
     remove(key: string): HashTableSeparateChainingElement<T> | null;

package/dist/HashTableSeparateChaining/index.js

@@ -14,13 +14,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var HashTableSeparateChainingElement_1 = __importDefault(require("./HashTableSeparateChainingElement"));
 var LinkedList_1 = __importDefault(require("../LinkedList"));
+var HashTableSeparateChainingElement_1 = __importDefault(require("./HashTableSeparateChainingElement"));
 var HashTableSeparateChaining = /** @class */ (function () {
     function HashTableSeparateChaining(inputs, _a) {
         if (inputs === void 0) { inputs = {}; }
         var _b = _a === void 0 ? { maxSize: 100 } : _a, maxSize = _b.maxSize;
-        this._data = new Array(maxSize);
+        this._data = [];
+        this.maxSize = maxSize;
         for (var _i = 0, _c = Object.entries(inputs); _i < _c.length; _i++) {
             var _d = _c[_i], key = _d[0], value = _d[1];
             this.put(key, value);
@@ -45,13 +46,6 @@ var HashTableSeparateChaining = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(HashTableSeparateChaining.prototype, "maxSize", {
-        get: function () {
-            return this._data.length;
-        },
-        enumerable: false,
-        configurable: true
-    });
     HashTableSeparateChaining.prototype.put = function (key, value) {
         var linkedList = this._getLinkedListByKey(key);
         var element = new HashTableSeparateChainingElement_1.default(key, value);

package/dist/LinkedList/ILinkedList.d.ts

@@ -1,13 +1,13 @@
-import ILinkedListItem from './ILinkedListItem';
+import type ILinkedListItem from './ILinkedListItem';
 interface ILinkedList<T> {
     get data(): ILinkedListItem<T>[];
     get size(): number;
     get isEmpty(): boolean;
-    push(_element: T): T;
-    getFromPosition(_position: number): ILinkedListItem<T> | null;
-    positionOf(_element: T): number | undefined;
-    insertInPosition(_element: T, _position: number): T | undefined;
-    remove(_element: T): T | null;
-    removeFromPosition(_position: number): T | null;
+    push: (_element: T) => T;
+    getFromPosition: (_position: number) => ILinkedListItem<T> | null;
+    positionOf: (_element: T) => number | undefined;
+    insertInPosition: (_element: T, _position: number) => T | undefined;
+    remove: (_element: T) => T | null;
+    removeFromPosition: (_position: number) => T | null;
 }
 export default ILinkedList;

package/dist/LinkedList/index.d.ts

@@ -1,5 +1,5 @@
-import ILinkedList from './ILinkedList';
-import ILinkedListItem from './ILinkedListItem';
+import type ILinkedList from './ILinkedList';
+import type ILinkedListItem from './ILinkedListItem';
 export default class LinkedList<T = number> implements ILinkedList<T> {
     private readonly _FIRST_POSITION;
     private _head;

package/dist/LinkedList/index.js

@@ -94,7 +94,7 @@ var LinkedList = /** @class */ (function () {
         }
         else {
             var before = this._getNodeFromPosition(position - 1);
-            var after = (before && before.next) || null;
+            var after = (before === null || before === void 0 ? void 0 : before.next) || null;
             if (before) {
                 before.next = node;
             }

package/dist/MaxHeap/IMaxHeap.d.ts

@@ -3,7 +3,7 @@ interface IMaxHeap<T> {
     get size(): number;
     get isEmpty(): boolean;
     get max(): T | null;
-    insert(_value: T): T;
-    extract(): T | null;
+    insert: (_value: T) => T;
+    extract: () => T | null;
 }
 export default IMaxHeap;

package/dist/MaxHeap/index.d.ts

@@ -1,5 +1,5 @@
-import IMaxHeap from './IMaxHeap';
-import IMaxHeapOptions from './IMaxHeapOptions';
+import type IMaxHeap from './IMaxHeap';
+import type IMaxHeapOptions from './IMaxHeapOptions';
 export default class MaxHeap<T = number> implements IMaxHeap<T> {
     private _data;
     constructor({ greaterThanOrEqualTo, inputs }?: IMaxHeapOptions<T>);

package/dist/MinHeap/IMinHeap.d.ts

@@ -3,7 +3,7 @@ interface IMinHeap<T> {
     get size(): number;
     get isEmpty(): boolean;
     get min(): T | null;
-    insert(_value: T): T;
-    extract(): T | null;
+    insert: (_value: T) => T;
+    extract: () => T | null;
 }
 export default IMinHeap;

package/dist/MinHeap/index.d.ts

@@ -1,5 +1,5 @@
-import IMinHeap from './IMinHeap';
-import IMinHeapOptions from './IMinHeapOptions';
+import type IMinHeap from './IMinHeap';
+import type IMinHeapOptions from './IMinHeapOptions';
 export default class MinHeap<T = number> implements IMinHeap<T> {
     private _data;
     constructor({ lessThanOrEqualTo, inputs }?: IMinHeapOptions<T>);

package/dist/Queue/IQueue.d.ts

@@ -1,8 +1,8 @@
 interface IQueue<T> {
-    enqueue(_element: T): T;
-    dequeue(): T | undefined;
-    peek(): T | undefined;
-    clear(): void;
+    enqueue: (_element: T) => T;
+    dequeue: () => T | undefined;
+    peek: () => T | undefined;
+    clear: () => void;
     get isEmpty(): boolean;
 }
 export default IQueue;

package/dist/Queue/index.d.ts

@@ -1,5 +1,5 @@
+import type IQueue from './IQueue';
 import DataStructure from '../DataStructure';
-import IQueue from './IQueue';
 export default class Queue<T = number> extends DataStructure<T> implements IQueue<T> {
     constructor(...inputs: Readonly<T[]>);
     get isEmpty(): boolean;

package/dist/Set/ISet.d.ts

@@ -1,15 +1,15 @@
-import Set from './';
+import type Set from './';
 interface ISet<T> {
     get data(): T[];
     get size(): number;
-    has(_elemet: T): boolean;
-    add(_element: T): T | null;
-    delete(_element: T): T | null;
-    clear(_element: T): T[];
-    union(_set: Set<T>): Set<T>;
-    intersection(_set: Set<T>): Set<T>;
-    difference(_set: Set<T>): Set<T>;
-    isSubsetOf(_set: Set<T>): boolean;
-    contains(_set: Set<T>): boolean;
+    has: (_elemet: T) => boolean;
+    add: (_element: T) => T | null;
+    delete: (_element: T) => T | null;
+    clear: (_element: T) => T[];
+    union: (_set: Set<T>) => Set<T>;
+    intersection: (_set: Set<T>) => Set<T>;
+    difference: (_set: Set<T>) => Set<T>;
+    isSubsetOf: (_set: Set<T>) => boolean;
+    contains: (_set: Set<T>) => boolean;
 }
 export default ISet;

package/dist/Set/index.d.ts

@@ -1,4 +1,4 @@
-import ISet from './ISet';
+import type ISet from './ISet';
 export default class Set<T = number> implements ISet<T> {
     private _data;
     constructor(...inputs: Readonly<T[]>);

package/dist/Stack/IStack.d.ts

@@ -1,8 +1,8 @@
 interface IStack<T> {
-    push(_element: T): T;
-    pop(): T | undefined;
-    peek(): T | undefined;
-    clear(): void;
+    push: (_element: T) => T;
+    pop: () => T | undefined;
+    peek: () => T | undefined;
+    clear: () => void;
     get isEmpty(): boolean;
 }
 export default IStack;

package/dist/Stack/index.d.ts

@@ -1,5 +1,5 @@
+import type IStack from './IStack';
 import DataStructure from '../DataStructure';
-import IStack from './IStack';
 export default class Stack<T = number> extends DataStructure<T> implements IStack<T> {
     constructor(...inputs: Readonly<T[]>);
     push(element: T): T;

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import antfu from '@antfu/eslint-config'
+
+export default antfu()

package/package.json

@@ -1,44 +1,43 @@
 {
   "name": "@gabrielrufino/cube",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "Data structures made in Typescript",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "build:watch": "npm run build -- --watch",
-    "lint": "eslint src/**/*.ts",
-    "test": "vitest run",
-    "test:cov": "npm t -- --coverage",
-    "test:mutation": "npx stryker run",
-    "test:watch": "vitest"
-  },
+  "author": "Gabriel Rufino <contato@gabrielrufino.com>",
+  "license": "UNLICENSED",
+  "funding": "https://github.com/sponsors/gabrielrufino",
+  "homepage": "https://github.com/gabrielrufino/cube#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/gabrielrufino/cube.git"
   },
+  "bugs": {
+    "url": "https://github.com/gabrielrufino/cube/issues"
+  },
   "keywords": [
     "Data",
     "Structures"
   ],
-  "author": "Gabriel Rufino <contato@gabrielrufino.com>",
-  "funding": "https://github.com/sponsors/gabrielrufino",
-  "license": "UNLICENSED",
-  "bugs": {
-    "url": "https://github.com/gabrielrufino/cube/issues"
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "npm run build -- --watch",
+    "lint": "eslint",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "vitest run",
+    "test:cov": "npm t -- --coverage",
+    "test:mutation": "npx stryker run",
+    "test:watch": "vitest"
   },
-  "homepage": "https://github.com/gabrielrufino/cube#readme",
   "devDependencies": {
-    "@commitlint/cli": "^19.8.0",
-    "@commitlint/config-conventional": "^19.8.0",
-    "@faker-js/faker": "^8.4.1",
+    "@antfu/eslint-config": "^4.13.0",
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@faker-js/faker": "^9.7.0",
     "@stryker-mutator/vitest-runner": "^8.7.1",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
-    "@vitest/coverage-v8": "^3.0.8",
-    "eslint": "^8.57.1",
-    "eslint-config-xo": "^0.43.1",
+    "@vitest/coverage-v8": "^3.1.3",
+    "eslint": "^9.26.0",
     "husky": "^9.1.7",
-    "typescript": "^5.8.2",
+    "typescript": "^5.8.3",
     "vitest": "^3.0.4"
   }
 }

package/stryker.config.json

@@ -14,4 +14,4 @@
   "htmlReporter": {
     "baseDir": ".stryker-reports"
   }
-}
+}