Добавлена ДБ

node_modules/fast-check/lib/stream/LazyIterableIterator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLazy = makeLazy;
+class LazyIterableIterator {
+    constructor(producer) {
+        this.producer = producer;
+    }
+    [Symbol.iterator]() {
+        if (this.it === undefined) {
+            this.it = this.producer();
+        }
+        return this.it;
+    }
+    next() {
+        if (this.it === undefined) {
+            this.it = this.producer();
+        }
+        return this.it.next();
+    }
+}
+function makeLazy(producer) {
+    return new LazyIterableIterator(producer);
+}

node_modules/fast-check/lib/stream/Stream.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stream = void 0;
+exports.stream = stream;
+const StreamHelpers_1 = require("./StreamHelpers");
+const safeSymbolIterator = Symbol.iterator;
+class Stream {
+    static nil() {
+        return new Stream((0, StreamHelpers_1.nilHelper)());
+    }
+    static of(...elements) {
+        return new Stream(elements[safeSymbolIterator]());
+    }
+    constructor(g) {
+        this.g = g;
+    }
+    next() {
+        return this.g.next();
+    }
+    [Symbol.iterator]() {
+        return this.g;
+    }
+    map(f) {
+        return new Stream((0, StreamHelpers_1.mapHelper)(this.g, f));
+    }
+    flatMap(f) {
+        return new Stream((0, StreamHelpers_1.flatMapHelper)(this.g, f));
+    }
+    dropWhile(f) {
+        let foundEligible = false;
+        function* helper(v) {
+            if (foundEligible || !f(v)) {
+                foundEligible = true;
+                yield v;
+            }
+        }
+        return this.flatMap(helper);
+    }
+    drop(n) {
+        if (n <= 0) {
+            return this;
+        }
+        let idx = 0;
+        function helper() {
+            return idx++ < n;
+        }
+        return this.dropWhile(helper);
+    }
+    takeWhile(f) {
+        return new Stream((0, StreamHelpers_1.takeWhileHelper)(this.g, f));
+    }
+    take(n) {
+        return new Stream((0, StreamHelpers_1.takeNHelper)(this.g, n));
+    }
+    filter(f) {
+        return new Stream((0, StreamHelpers_1.filterHelper)(this.g, f));
+    }
+    every(f) {
+        for (const v of this.g) {
+            if (!f(v)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    has(f) {
+        for (const v of this.g) {
+            if (f(v)) {
+                return [true, v];
+            }
+        }
+        return [false, null];
+    }
+    join(...others) {
+        return new Stream((0, StreamHelpers_1.joinHelper)(this.g, others));
+    }
+    getNthOrLast(nth) {
+        let remaining = nth;
+        let last = null;
+        for (const v of this.g) {
+            if (remaining-- === 0)
+                return v;
+            last = v;
+        }
+        return last;
+    }
+}
+exports.Stream = Stream;
+function stream(g) {
+    return new Stream(g);
+}

node_modules/fast-check/lib/stream/StreamHelpers.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nilHelper = nilHelper;
+exports.mapHelper = mapHelper;
+exports.flatMapHelper = flatMapHelper;
+exports.filterHelper = filterHelper;
+exports.takeNHelper = takeNHelper;
+exports.takeWhileHelper = takeWhileHelper;
+exports.joinHelper = joinHelper;
+class Nil {
+    [Symbol.iterator]() {
+        return this;
+    }
+    next(value) {
+        return { value, done: true };
+    }
+}
+Nil.nil = new Nil();
+function nilHelper() {
+    return Nil.nil;
+}
+function* mapHelper(g, f) {
+    for (const v of g) {
+        yield f(v);
+    }
+}
+function* flatMapHelper(g, f) {
+    for (const v of g) {
+        yield* f(v);
+    }
+}
+function* filterHelper(g, f) {
+    for (const v of g) {
+        if (f(v)) {
+            yield v;
+        }
+    }
+}
+function* takeNHelper(g, n) {
+    for (let i = 0; i < n; ++i) {
+        const cur = g.next();
+        if (cur.done) {
+            break;
+        }
+        yield cur.value;
+    }
+}
+function* takeWhileHelper(g, f) {
+    let cur = g.next();
+    while (!cur.done && f(cur.value)) {
+        yield cur.value;
+        cur = g.next();
+    }
+}
+function* joinHelper(g, others) {
+    for (let cur = g.next(); !cur.done; cur = g.next()) {
+        yield cur.value;
+    }
+    for (const s of others) {
+        for (let cur = s.next(); !cur.done; cur = s.next()) {
+            yield cur.value;
+        }
+    }
+}