Init

node_modules/sweet-collections/dist/set/LfuSet.d.ts

@@ -0,0 +1,15 @@
+export declare class LfuSet<T> implements Set<T> {
+    private readonly map;
+    constructor(limit: number);
+    has(value: T): boolean;
+    add(value: T): this;
+    delete(value: T): boolean;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    clear(): void;
+    [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(cb: (value: T, key: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/set/LfuSet.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LfuSet = void 0;
+const map_1 = require("../map");
+class LfuSet {
+    constructor(limit) {
+        this.map = new map_1.LfuMap(limit);
+    }
+    has(value) {
+        return this.map.has(value);
+    }
+    add(value) {
+        this.map.set(value, value);
+        return this;
+    }
+    delete(value) {
+        return this.map.delete(value);
+    }
+    keys() {
+        return this.map.keys();
+    }
+    values() {
+        return this.map.values();
+    }
+    entries() {
+        return this.map.entries();
+    }
+    clear() {
+        this.map.clear();
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(cb, thisArg) {
+        this.map.forEach((item) => cb.call(thisArg, item, item, this));
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+exports.LfuSet = LfuSet;

node_modules/sweet-collections/dist/set/LruSet.d.ts

@@ -0,0 +1,15 @@
+export declare class LruSet<T> implements Set<T> {
+    private readonly map;
+    constructor(limit: number);
+    has(value: T): boolean;
+    add(value: T): this;
+    delete(value: T): boolean;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    clear(): void;
+    [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(cb: (value: T, key: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/set/LruSet.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LruSet = void 0;
+const map_1 = require("../map");
+class LruSet {
+    constructor(limit) {
+        this.map = new map_1.LruMap(limit);
+    }
+    has(value) {
+        return this.map.has(value);
+    }
+    add(value) {
+        this.map.set(value, value);
+        return this;
+    }
+    delete(value) {
+        return this.map.delete(value);
+    }
+    keys() {
+        return this.map.keys();
+    }
+    values() {
+        return this.map.values();
+    }
+    entries() {
+        return this.map.entries();
+    }
+    clear() {
+        this.map.clear();
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(cb, thisArg) {
+        this.map.forEach((item) => cb.call(thisArg, item, item, this));
+    }
+    get size() {
+        return this.map.size;
+    }
+}
+exports.LruSet = LruSet;

node_modules/sweet-collections/dist/set/SortedSet.d.ts

@@ -0,0 +1,15 @@
+export declare class SortedSet<T> implements Set<T> {
+    private array;
+    constructor(comparator: (a: T, b: T) => number);
+    has(value: T): boolean;
+    add(...values: T[]): this;
+    delete(value: T): boolean;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    entries(): IterableIterator<[T, T]>;
+    clear(): void;
+    readonly [Symbol.toStringTag]: string;
+    [Symbol.iterator](): IterableIterator<T>;
+    forEach(cb: (value: T, key: T, set: Set<T>) => void, thisArg?: any): void;
+    get size(): number;
+}

node_modules/sweet-collections/dist/set/SortedSet.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SortedSet = void 0;
+const array_1 = require("../array");
+class SortedSet {
+    constructor(comparator) {
+        this.array = new array_1.SortedArray(comparator, true);
+    }
+    has(value) {
+        return this.array.includes(value);
+    }
+    add(...values) {
+        this.array.push(...values);
+        return this;
+    }
+    delete(value) {
+        return this.array.delete(value);
+    }
+    keys() {
+        return this.array.toArray()[Symbol.iterator]();
+    }
+    values() {
+        return this.array.toArray()[Symbol.iterator]();
+    }
+    entries() {
+        return this.array
+            .toArray()
+            .map((value) => [value, value])[Symbol.iterator]();
+    }
+    clear() {
+        this.array.clear();
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    forEach(cb, thisArg) {
+        this.array.toArray().forEach((item) => cb.call(thisArg, item, item, this));
+    }
+    get size() {
+        return this.array.length;
+    }
+}
+exports.SortedSet = SortedSet;

node_modules/sweet-collections/dist/set/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LruSet';
+export * from './LfuSet';
+export * from './SortedSet';

node_modules/sweet-collections/dist/set/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LruSet"), exports);
+__exportStar(require("./LfuSet"), exports);
+__exportStar(require("./SortedSet"), exports);