@kontur.candy/tools 2.210.1-cgroupv2.0 → 2.210.1-cgroupv2.1

package/distr/Common/IterableUtils.js

@@ -0,0 +1,288 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IterUtils = void 0;
+exports.concat = concat;
+exports.count = count;
+exports.findLast = findLast;
+exports.iterateEntries = iterateEntries;
+exports.iterateKeys = iterateKeys;
+exports.iterateValues = iterateValues;
+exports.reverseArray = reverseArray;
+exports.toAsyncIterator = toAsyncIterator;
+var _TypingUtils = require("./TypingUtils");
+var _Errors = require("./Errors");
+function* reverseArray(array) {
+  for (let i = array.length - 1; i >= 0; i--) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    yield array[i];
+  }
+}
+function toAsyncIterator(generator) {
+  return AsyncIterator.from(generator());
+}
+function findLast(items, condition) {
+  let result;
+  for (const item of items) {
+    if (condition(item)) {
+      result = item;
+    }
+  }
+  return result;
+}
+function* concat(...iterables) {
+  for (const iterableItem of iterables) {
+    yield* iterableItem;
+  }
+}
+function* iterateValues(obj) {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      yield obj[key];
+    }
+  }
+}
+function* iterateKeys(obj) {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      yield key;
+    }
+  }
+}
+function* iterateEntries(obj) {
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      yield [key, obj[key]];
+    }
+  }
+}
+function count(items) {
+  let result = 0;
+  for (const _item of items) {
+    result++;
+  }
+  return result;
+}
+const EmptySingleElement = Symbol.for("EmptySingleElement");
+const NoValueMarker = Symbol.for("NoValueMarker");
+class IterUtils {
+  static isEmpty(iterable) {
+    for (const _item of iterable) {
+      return false;
+    }
+    return true;
+  }
+  static groupBy(iterable, selectKey) {
+    const result = new Map();
+    for (const item of iterable) {
+      const key = selectKey(item);
+      const keyList = result.get(key);
+      if (keyList == undefined) {
+        result.set(key, [item]);
+      } else {
+        keyList.push(item);
+      }
+    }
+    return result;
+  }
+  static sortBy(items, selector) {
+    const result = [...items];
+    result.sort((aItem, bItem) => {
+      const leftValue = selector(aItem);
+      const rightValue = selector(bItem);
+      if (leftValue === rightValue) {
+        return 0;
+      } else if (leftValue < rightValue) {
+        return -1;
+      } else {
+        return 1;
+      }
+    });
+    return result;
+  }
+  static last(items) {
+    if (Array.isArray(items)) {
+      return items[items.length - 1];
+    }
+    let lastItem;
+    for (const item of items) {
+      lastItem = item;
+    }
+    return lastItem;
+  }
+  static first(items) {
+    if (Array.isArray(items)) {
+      return items[0];
+    }
+    let firstItem;
+    for (const item of items) {
+      firstItem = item;
+      break;
+    }
+    return firstItem;
+  }
+  static single(items, singleAssertMessage) {
+    if (Array.isArray(items)) {
+      var _items$;
+      if (items.length !== 1) {
+        throw new Error(singleAssertMessage !== null && singleAssertMessage !== void 0 ? singleAssertMessage : `Sequence must contain exactly single element, but got ${items.length}`);
+      }
+      return (_items$ = items[0]) !== null && _items$ !== void 0 ? _items$ : (0, _TypingUtils.reject)();
+    } else {
+      let singleElement = EmptySingleElement;
+      for (const item of items) {
+        if (singleElement !== EmptySingleElement) {
+          throw new Error(singleAssertMessage !== null && singleAssertMessage !== void 0 ? singleAssertMessage : `Sequence must contain exactly single element, but got at least 2`);
+        }
+        singleElement = item;
+      }
+      if (singleElement === EmptySingleElement) {
+        throw new Error(singleAssertMessage !== null && singleAssertMessage !== void 0 ? singleAssertMessage : "Sequence must contain exactly single element, but got 0");
+      }
+      return singleElement;
+    }
+  }
+  static *iterateEntries(items) {
+    let index = 0;
+    for (const item of items) {
+      yield [index, item];
+      index++;
+    }
+  }
+  static *skipLast(items, skipCount) {
+    if (skipCount === 0) {
+      yield* items;
+      return;
+    }
+    const prevItems = new Array(skipCount).fill(EmptySingleElement);
+    let resultItem = EmptySingleElement;
+    let currentIndex = 0;
+    for (const item of items) {
+      // @ts-expect-error В общем, строка выше гарантирует длину массива
+      resultItem = prevItems[currentIndex];
+      prevItems[currentIndex] = item;
+      currentIndex = (currentIndex + 1) % skipCount;
+      if (resultItem != EmptySingleElement) {
+        yield resultItem;
+      }
+    }
+  }
+  static minBy(items, compareFunc) {
+    let minValue = NoValueMarker;
+    for (const item of items) {
+      if (minValue === NoValueMarker) {
+        minValue = item;
+      } else if (compareFunc(item, minValue) === -1) {
+        minValue = item;
+      }
+    }
+    if (minValue === NoValueMarker) {
+      throw new _Errors.InvalidArgumentError("items", "Items should be not empty list");
+    }
+    return minValue;
+  }
+  static minByOrUndefined(items, compareFunc) {
+    let minValue = NoValueMarker;
+    for (const item of items) {
+      if (minValue === NoValueMarker) {
+        minValue = item;
+      } else if (compareFunc(item, minValue) === -1) {
+        minValue = item;
+      }
+    }
+    if (minValue === NoValueMarker) {
+      return undefined;
+    }
+    return minValue;
+  }
+  static *range(inStartOrCount, inItemCount) {
+    const start = inItemCount === undefined ? 0 : inStartOrCount;
+    const itemCount = inItemCount === undefined ? inStartOrCount : inItemCount;
+    if (itemCount < 0) {
+      throw new _Errors.InvalidArgumentError("itemCount", "itemCount must be a non negative number");
+    }
+    for (let i = start; i < start + itemCount; i++) {
+      yield i;
+    }
+  }
+
+  /**
+   * @summary Вставляет между элементами массива заданный элемент и возвращает новый массив
+   */
+  static intersperse(items, item) {
+    return this.intersperseFn(items, () => item);
+  }
+
+  /**
+   * @summary Вставляет между элементами массива элемент, создаваемый функцией, и возвращает новый массив
+   */
+  static intersperseFn(items, item) {
+    return items.flatMap((x, index) => index === 0 ? [x] : [item(x, index), x]);
+  }
+  static *zip(...iterables) {
+    const iterators = iterables.map(it => Iterator.from(it));
+    let hasUndoneIterators = true;
+    while (hasUndoneIterators) {
+      const resultEntry = [];
+      hasUndoneIterators = false;
+      for (const [i, iterator] of this.iterateEntries(iterators)) {
+        if (iterator === NoValueMarker) {
+          resultEntry.push(undefined);
+        } else {
+          const resultValue = iterator.next();
+          if (resultValue.done) {
+            resultEntry.push(undefined);
+            iterators[i] = NoValueMarker;
+          } else {
+            resultEntry.push(resultValue.value);
+            hasUndoneIterators = true;
+          }
+        }
+      }
+      if (hasUndoneIterators) {
+        yield resultEntry;
+      }
+    }
+  }
+  static *distinctBy(items, idSelector) {
+    const set = new Set();
+    for (const item of items) {
+      const id = idSelector(item);
+      if (!set.has(id)) {
+        set.add(id);
+        yield item;
+      }
+    }
+  }
+  static reduce(items, reducer, initialValue) {
+    let index = 0;
+    return Iterator.from(items).reduce((acc, item) => reducer(acc, item, index++), initialValue);
+  }
+  static *batch(items, batchSize) {
+    const iterator = Iterator.from(items);
+    const safeBatchSize = batchSize > 0 ? batchSize : 1;
+    let done = false;
+    while (!done) {
+      const batch = [];
+      while (batch.length < safeBatchSize) {
+        const current = iterator.next();
+        if (current.done) {
+          done = true;
+          break;
+        } else {
+          batch.push(current.value);
+        }
+      }
+      if (batch.length > 0) {
+        yield batch;
+      }
+    }
+  }
+}
+exports.IterUtils = IterUtils;
+IterUtils.count = count;
+IterUtils.concat = concat;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_TypingUtils","require","_Errors","reverseArray","array","i","length","toAsyncIterator","generator","AsyncIterator","from","findLast","items","condition","result","item","concat","iterables","iterableItem","iterateValues","obj","key","Object","prototype","hasOwnProperty","call","iterateKeys","iterateEntries","count","_item","EmptySingleElement","Symbol","for","NoValueMarker","IterUtils","isEmpty","iterable","groupBy","selectKey","Map","keyList","get","undefined","set","push","sortBy","selector","sort","aItem","bItem","leftValue","rightValue","last","Array","isArray","lastItem","first","firstItem","single","singleAssertMessage","_items$","Error","reject","singleElement","index","skipLast","skipCount","prevItems","fill","resultItem","currentIndex","minBy","compareFunc","minValue","InvalidArgumentError","minByOrUndefined","range","inStartOrCount","inItemCount","start","itemCount","intersperse","intersperseFn","flatMap","x","zip","iterators","map","it","Iterator","hasUndoneIterators","resultEntry","iterator","resultValue","next","done","value","distinctBy","idSelector","Set","id","has","add","reduce","reducer","initialValue","acc","batch","batchSize","safeBatchSize","current","exports"],"sources":["../../../Common/IterableUtils.ts"],"sourcesContent":["import { MinLengthArray, reject } from \"./TypingUtils\";\nimport { CompareFunc } from \"./Comparers\";\nimport { InvalidArgumentError } from \"./Errors\";\n\nexport function* reverseArray<T>(array: readonly T[]): IterableIterator<T> {\n    for (let i = array.length - 1; i >= 0; i--) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        yield array[i]!;\n    }\n}\n\nexport function toAsyncIterator<T>(generator: () => AsyncGenerator<T>): AsyncIterableIterator<T> {\n    return AsyncIterator.from(generator());\n}\n\nexport function findLast<T>(items: Iterable<T>, condition: (item: T) => boolean): T | undefined {\n    let result: T | undefined;\n    for (const item of items) {\n        if (condition(item)) {\n            result = item;\n        }\n    }\n    return result;\n}\n\nexport function* concat<T>(...iterables: Array<Iterable<T>>): IterableIterator<T> {\n    for (const iterableItem of iterables) {\n        yield* iterableItem;\n    }\n}\n\nexport function* iterateValues<TK extends string | symbol | number, TV>(obj: { [key in TK]: TV }): Iterable<TV> {\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            yield obj[key];\n        }\n    }\n}\n\nexport function iterateKeys<TO>(obj: Readonly<TO>): Iterable<Extract<keyof TO, string>>;\nexport function iterateKeys<TV>(obj: Readonly<{ [key: string]: TV }>): Iterable<string>;\nexport function iterateKeys(obj: Readonly<{}>): Iterable<string>;\nexport function* iterateKeys<TK extends string | symbol | number>(obj: { [key in TK]: unknown }): Iterable<TK> {\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            yield key;\n        }\n    }\n}\n\nexport function iterateEntries<TO>(obj: Readonly<TO>): Iterable<[Extract<keyof TO, string>, TO[keyof TO]]>;\nexport function iterateEntries<TV>(obj: Readonly<{ [key: string]: TV }>): Iterable<[string, TV]>;\nexport function iterateEntries(obj: Readonly<{}>): Iterable<[string, unknown]>;\nexport function* iterateEntries<TV>(obj: Readonly<{ [key: string]: TV }>): Iterable<[string, TV]> {\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            yield [key, obj[key]!];\n        }\n    }\n}\n\nexport function count<T>(items: Iterable<T>): number {\n    let result = 0;\n    for (const _item of items) {\n        result++;\n    }\n    return result;\n}\n\nconst EmptySingleElement = Symbol.for(\"EmptySingleElement\");\nconst NoValueMarker = Symbol.for(\"NoValueMarker\");\n\nexport class IterUtils {\n    public static count = count;\n    public static concat = concat;\n\n    public static isEmpty<T>(iterable: Iterable<T>): boolean {\n        for (const _item of iterable) {\n            return false;\n        }\n        return true;\n    }\n\n    public static groupBy<T, TKey>(iterable: Iterable<T>, selectKey: (item: T) => TKey): Map<TKey, T[]> {\n        const result = new Map<TKey, T[]>();\n        for (const item of iterable) {\n            const key = selectKey(item);\n            const keyList = result.get(key);\n            if (keyList == undefined) {\n                result.set(key, [item]);\n            } else {\n                keyList.push(item);\n            }\n        }\n        return result;\n    }\n\n    public static sortBy<T>(items: Iterable<T>, selector: (item: T) => string | number): T[] {\n        const result = [...items];\n        result.sort((aItem, bItem) => {\n            const leftValue = selector(aItem);\n            const rightValue = selector(bItem);\n            if (leftValue === rightValue) {\n                return 0;\n            } else if (leftValue < rightValue) {\n                return -1;\n            } else {\n                return 1;\n            }\n        });\n        return result;\n    }\n\n    public static last<T>(items: MinLengthArray<T, 1>): T;\n    public static last<T>(items: Iterable<T> | readonly T[]): undefined | T;\n    public static last<T>(items: Iterable<T> | readonly T[]): undefined | T {\n        if (Array.isArray(items)) {\n            return items[items.length - 1];\n        }\n        let lastItem: T | undefined;\n        for (const item of items) {\n            lastItem = item;\n        }\n        return lastItem;\n    }\n\n    public static first<T>(items: [T, ...unknown[]]): T;\n    public static first<T>(items: MinLengthArray<T, 1>): T;\n    public static first<T>(items: Iterable<T> | readonly T[]): undefined | T;\n    public static first<T>(items: Iterable<T> | readonly T[]): undefined | T {\n        if (Array.isArray(items)) {\n            return items[0];\n        }\n        let firstItem: T | undefined;\n        for (const item of items) {\n            firstItem = item;\n            break;\n        }\n        return firstItem;\n    }\n\n    public static single<T>(items: readonly T[] | Iterable<T>, singleAssertMessage?: string): T {\n        if (Array.isArray(items)) {\n            if (items.length !== 1) {\n                throw new Error(\n                    singleAssertMessage ?? `Sequence must contain exactly single element, but got ${items.length}`\n                );\n            }\n            return items[0] ?? reject();\n        } else {\n            let singleElement: T | typeof EmptySingleElement = EmptySingleElement;\n            for (const item of items) {\n                if (singleElement !== EmptySingleElement) {\n                    throw new Error(\n                        singleAssertMessage ?? `Sequence must contain exactly single element, but got at least 2`\n                    );\n                }\n                singleElement = item;\n            }\n            if (singleElement === EmptySingleElement) {\n                throw new Error(singleAssertMessage ?? \"Sequence must contain exactly single element, but got 0\");\n            }\n            return singleElement;\n        }\n    }\n\n    public static *iterateEntries<T>(items: readonly T[] | T[] | Iterable<T>): Iterable<[number, T]> {\n        let index = 0;\n        for (const item of items) {\n            yield [index, item];\n            index++;\n        }\n    }\n\n    public static *skipLast<T>(items: Iterable<T>, skipCount: number): Iterable<T> {\n        if (skipCount === 0) {\n            yield* items;\n            return;\n        }\n        const prevItems: Array<T | typeof EmptySingleElement> = new Array(skipCount).fill(EmptySingleElement);\n        let resultItem: T | typeof EmptySingleElement = EmptySingleElement;\n        let currentIndex = 0;\n        for (const item of items) {\n            // @ts-expect-error В общем, строка выше гарантирует длину массива\n            resultItem = prevItems[currentIndex];\n            prevItems[currentIndex] = item;\n            currentIndex = (currentIndex + 1) % skipCount;\n            if (resultItem != EmptySingleElement) {\n                yield resultItem;\n            }\n        }\n    }\n\n    public static minBy<T>(items: readonly T[] | T[] | Iterable<T>, compareFunc: CompareFunc<T>): T {\n        let minValue: typeof NoValueMarker | T = NoValueMarker;\n        for (const item of items) {\n            if (minValue === NoValueMarker) {\n                minValue = item;\n            } else if (compareFunc(item, minValue) === -1) {\n                minValue = item;\n            }\n        }\n        if (minValue === NoValueMarker) {\n            throw new InvalidArgumentError(\"items\", \"Items should be not empty list\");\n        }\n        return minValue;\n    }\n\n    public static minByOrUndefined<T>(\n        items: readonly T[] | T[] | Iterable<T>,\n        compareFunc: CompareFunc<T>\n    ): T | undefined {\n        let minValue: typeof NoValueMarker | T = NoValueMarker;\n        for (const item of items) {\n            if (minValue === NoValueMarker) {\n                minValue = item;\n            } else if (compareFunc(item, minValue) === -1) {\n                minValue = item;\n            }\n        }\n        if (minValue === NoValueMarker) {\n            return undefined;\n        }\n        return minValue;\n    }\n\n    public static range(itemCount: number): Iterable<number>;\n    public static range(start: number, itemCount: number): Iterable<number>;\n    public static *range(inStartOrCount: number, inItemCount?: number): Iterable<number> {\n        const start = inItemCount === undefined ? 0 : inStartOrCount;\n        const itemCount = inItemCount === undefined ? inStartOrCount : inItemCount;\n        if (itemCount < 0) {\n            throw new InvalidArgumentError(\"itemCount\", \"itemCount must be a non negative number\");\n        }\n        for (let i = start; i < start + itemCount; i++) {\n            yield i;\n        }\n    }\n\n    /**\n     * @summary Вставляет между элементами массива заданный элемент и возвращает новый массив\n     */\n    public static intersperse<TI, TS>(items: TI[], item: TS): Array<TI | TS> {\n        return this.intersperseFn(items, () => item);\n    }\n\n    /**\n     * @summary Вставляет между элементами массива элемент, создаваемый функцией, и возвращает новый массив\n     */\n    public static intersperseFn<TI, TS>(items: TI[], item: (nextItem: TI, index: number) => TS): Array<TI | TS> {\n        return items.flatMap((x, index) => (index === 0 ? [x] : [item(x, index), x]));\n    }\n\n    public static zip<T1, T2>(items1: Iterable<T1>, items2: Iterable<T2>): Iterable<[T1 | undefined, T2 | undefined]>;\n    public static *zip(...iterables: Array<Iterable<unknown>>): Iterable<unknown[]> {\n        const iterators: Array<Iterator<unknown> | typeof NoValueMarker> = iterables.map(it => Iterator.from(it));\n        let hasUndoneIterators = true;\n        while (hasUndoneIterators) {\n            const resultEntry = [];\n            hasUndoneIterators = false;\n            for (const [i, iterator] of this.iterateEntries(iterators)) {\n                if (iterator === NoValueMarker) {\n                    resultEntry.push(undefined);\n                } else {\n                    const resultValue = iterator.next();\n                    if (resultValue.done) {\n                        resultEntry.push(undefined);\n                        iterators[i] = NoValueMarker;\n                    } else {\n                        resultEntry.push(resultValue.value);\n                        hasUndoneIterators = true;\n                    }\n                }\n            }\n            if (hasUndoneIterators) {\n                yield resultEntry;\n            }\n        }\n    }\n\n    public static *distinctBy<T>(items: Iterable<T>, idSelector: (item: T) => string): Iterable<T> {\n        const set = new Set<string>();\n        for (const item of items) {\n            const id = idSelector(item);\n            if (!set.has(id)) {\n                set.add(id);\n                yield item;\n            }\n        }\n    }\n\n    public static reduce<T, U>(\n        items: Iterable<T>,\n        reducer: (accumulator: U, item: T, index: number) => U,\n        initialValue: U\n    ): U {\n        let index = 0;\n        return Iterator.from(items).reduce((acc, item) => reducer(acc, item, index++), initialValue);\n    }\n\n    public static *batch<T>(items: Iterable<T>, batchSize: number): Iterable<Iterable<T>> {\n        const iterator = Iterator.from(items);\n        const safeBatchSize = batchSize > 0 ? batchSize : 1;\n        let done = false;\n        while (!done) {\n            const batch: T[] = [];\n            while (batch.length < safeBatchSize) {\n                const current = iterator.next();\n                if (current.done) {\n                    done = true;\n                    break;\n                } else {\n                    batch.push(current.value);\n                }\n            }\n            if (batch.length > 0) {\n                yield batch;\n            }\n        }\n    }\n}\n"],"mappings":"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","ignoreList":[]}

package/distr/Common/IterableUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IterableUtils.js","names":["_TypingUtils","require","_Errors","reverseArray","array","i","length","toAsyncIterator","generator","AsyncIterator","from","findLast","items","condition","result","item","concat","iterables","iterableItem","iterateValues","obj","key","Object","prototype","hasOwnProperty","call","iterateKeys","iterateEntries","count","_item","EmptySingleElement","Symbol","for","NoValueMarker","IterUtils","isEmpty","iterable","groupBy","selectKey","Map","keyList","get","undefined","set","push","sortBy","selector","sort","aItem","bItem","leftValue","rightValue","last","Array","isArray","lastItem","first","firstItem","single","singleAssertMessage","_items$","Error","reject","singleElement","index","skipLast","skipCount","prevItems","fill","resultItem","currentIndex","minBy","compareFunc","minValue","InvalidArgumentError","minByOrUndefined","range","inStartOrCount","inItemCount","start","itemCount","intersperse","intersperseFn","flatMap","x","zip","iterators","map","it","Iterator","hasUndoneIterators","resultEntry","iterator","resultValue","next","done","value","distinctBy","idSelector","Set","id","has","add","reduce","reducer","initialValue","acc","batch","batchSize","safeBatchSize","current","exports"],"sources":["../../../Common/IterableUtils.ts"],"sourcesContent":["import { MinLengthArray, reject } from \"./TypingUtils\";\nimport { CompareFunc } from \"./Comparers\";\nimport { InvalidArgumentError } from \"./Errors\";\n\nexport function* reverseArray<T>(array: readonly T[]): IterableIterator<T> {\n    for (let i = array.length - 1; i >= 0; i--) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        yield array[i]!;\n    }\n}\n\nexport function toAsyncIterator<T>(generator: () => AsyncGenerator<T>): AsyncIterableIterator<T> {\n    return AsyncIterator.from(generator());\n}\n\nexport function findLast<T>(items: Iterable<T>, condition: (item: T) => boolean): T | undefined {\n    let result: T | undefined;\n    for (const item of items) {\n        if (condition(item)) {\n            result = item;\n        }\n    }\n    return result;\n}\n\nexport function* concat<T>(...iterables: Array<Iterable<T>>): IterableIterator<T> {\n    for (const iterableItem of iterables) {\n        yield* iterableItem;\n    }\n}\n\nexport function* iterateValues<TK extends string | symbol | number, TV>(obj: { [key in TK]: TV }): Iterable<TV> {\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            yield obj[key];\n        }\n    }\n}\n\nexport function iterateKeys<TO>(obj: Readonly<TO>): Iterable<Extract<keyof TO, string>>;\nexport function iterateKeys<TV>(obj: Readonly<{ [key: string]: TV }>): Iterable<string>;\nexport function iterateKeys(obj: Readonly<{}>): Iterable<string>;\nexport function* iterateKeys<TK extends string | symbol | number>(obj: { [key in TK]: unknown }): Iterable<TK> {\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            yield key;\n        }\n    }\n}\n\nexport function iterateEntries<TO>(obj: Readonly<TO>): Iterable<[Extract<keyof TO, string>, TO[keyof TO]]>;\nexport function iterateEntries<TV>(obj: Readonly<{ [key: string]: TV }>): Iterable<[string, TV]>;\nexport function iterateEntries(obj: Readonly<{}>): Iterable<[string, unknown]>;\nexport function* iterateEntries<TV>(obj: Readonly<{ [key: string]: TV }>): Iterable<[string, TV]> {\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            yield [key, obj[key]!];\n        }\n    }\n}\n\nexport function count<T>(items: Iterable<T>): number {\n    let result = 0;\n    for (const _item of items) {\n        result++;\n    }\n    return result;\n}\n\nconst EmptySingleElement = Symbol.for(\"EmptySingleElement\");\nconst NoValueMarker = Symbol.for(\"NoValueMarker\");\n\nexport class IterUtils {\n    public static count = count;\n    public static concat = concat;\n\n    public static isEmpty<T>(iterable: Iterable<T>): boolean {\n        for (const _item of iterable) {\n            return false;\n        }\n        return true;\n    }\n\n    public static groupBy<T, TKey>(iterable: Iterable<T>, selectKey: (item: T) => TKey): Map<TKey, T[]> {\n        const result = new Map<TKey, T[]>();\n        for (const item of iterable) {\n            const key = selectKey(item);\n            const keyList = result.get(key);\n            if (keyList == undefined) {\n                result.set(key, [item]);\n            } else {\n                keyList.push(item);\n            }\n        }\n        return result;\n    }\n\n    public static sortBy<T>(items: Iterable<T>, selector: (item: T) => string | number): T[] {\n        const result = [...items];\n        result.sort((aItem, bItem) => {\n            const leftValue = selector(aItem);\n            const rightValue = selector(bItem);\n            if (leftValue === rightValue) {\n                return 0;\n            } else if (leftValue < rightValue) {\n                return -1;\n            } else {\n                return 1;\n            }\n        });\n        return result;\n    }\n\n    public static last<T>(items: MinLengthArray<T, 1>): T;\n    public static last<T>(items: Iterable<T> | readonly T[]): undefined | T;\n    public static last<T>(items: Iterable<T> | readonly T[]): undefined | T {\n        if (Array.isArray(items)) {\n            return items[items.length - 1];\n        }\n        let lastItem: T | undefined;\n        for (const item of items) {\n            lastItem = item;\n        }\n        return lastItem;\n    }\n\n    public static first<T>(items: [T, ...unknown[]]): T;\n    public static first<T>(items: MinLengthArray<T, 1>): T;\n    public static first<T>(items: Iterable<T> | readonly T[]): undefined | T;\n    public static first<T>(items: Iterable<T> | readonly T[]): undefined | T {\n        if (Array.isArray(items)) {\n            return items[0];\n        }\n        let firstItem: T | undefined;\n        for (const item of items) {\n            firstItem = item;\n            break;\n        }\n        return firstItem;\n    }\n\n    public static single<T>(items: readonly T[] | Iterable<T>, singleAssertMessage?: string): T {\n        if (Array.isArray(items)) {\n            if (items.length !== 1) {\n                throw new Error(\n                    singleAssertMessage ?? `Sequence must contain exactly single element, but got ${items.length}`\n                );\n            }\n            return items[0] ?? reject();\n        } else {\n            let singleElement: T | typeof EmptySingleElement = EmptySingleElement;\n            for (const item of items) {\n                if (singleElement !== EmptySingleElement) {\n                    throw new Error(\n                        singleAssertMessage ?? `Sequence must contain exactly single element, but got at least 2`\n                    );\n                }\n                singleElement = item;\n            }\n            if (singleElement === EmptySingleElement) {\n                throw new Error(singleAssertMessage ?? \"Sequence must contain exactly single element, but got 0\");\n            }\n            return singleElement;\n        }\n    }\n\n    public static *iterateEntries<T>(items: readonly T[] | T[] | Iterable<T>): Iterable<[number, T]> {\n        let index = 0;\n        for (const item of items) {\n            yield [index, item];\n            index++;\n        }\n    }\n\n    public static *skipLast<T>(items: Iterable<T>, skipCount: number): Iterable<T> {\n        if (skipCount === 0) {\n            yield* items;\n            return;\n        }\n        const prevItems: Array<T | typeof EmptySingleElement> = new Array(skipCount).fill(EmptySingleElement);\n        let resultItem: T | typeof EmptySingleElement = EmptySingleElement;\n        let currentIndex = 0;\n        for (const item of items) {\n            // @ts-expect-error В общем, строка выше гарантирует длину массива\n            resultItem = prevItems[currentIndex];\n            prevItems[currentIndex] = item;\n            currentIndex = (currentIndex + 1) % skipCount;\n            if (resultItem != EmptySingleElement) {\n                yield resultItem;\n            }\n        }\n    }\n\n    public static minBy<T>(items: readonly T[] | T[] | Iterable<T>, compareFunc: CompareFunc<T>): T {\n        let minValue: typeof NoValueMarker | T = NoValueMarker;\n        for (const item of items) {\n            if (minValue === NoValueMarker) {\n                minValue = item;\n            } else if (compareFunc(item, minValue) === -1) {\n                minValue = item;\n            }\n        }\n        if (minValue === NoValueMarker) {\n            throw new InvalidArgumentError(\"items\", \"Items should be not empty list\");\n        }\n        return minValue;\n    }\n\n    public static minByOrUndefined<T>(\n        items: readonly T[] | T[] | Iterable<T>,\n        compareFunc: CompareFunc<T>\n    ): T | undefined {\n        let minValue: typeof NoValueMarker | T = NoValueMarker;\n        for (const item of items) {\n            if (minValue === NoValueMarker) {\n                minValue = item;\n            } else if (compareFunc(item, minValue) === -1) {\n                minValue = item;\n            }\n        }\n        if (minValue === NoValueMarker) {\n            return undefined;\n        }\n        return minValue;\n    }\n\n    public static range(itemCount: number): Iterable<number>;\n    public static range(start: number, itemCount: number): Iterable<number>;\n    public static *range(inStartOrCount: number, inItemCount?: number): Iterable<number> {\n        const start = inItemCount === undefined ? 0 : inStartOrCount;\n        const itemCount = inItemCount === undefined ? inStartOrCount : inItemCount;\n        if (itemCount < 0) {\n            throw new InvalidArgumentError(\"itemCount\", \"itemCount must be a non negative number\");\n        }\n        for (let i = start; i < start + itemCount; i++) {\n            yield i;\n        }\n    }\n\n    /**\n     * @summary Вставляет между элементами массива заданный элемент и возвращает новый массив\n     */\n    public static intersperse<TI, TS>(items: TI[], item: TS): Array<TI | TS> {\n        return this.intersperseFn(items, () => item);\n    }\n\n    /**\n     * @summary Вставляет между элементами массива элемент, создаваемый функцией, и возвращает новый массив\n     */\n    public static intersperseFn<TI, TS>(items: TI[], item: (nextItem: TI, index: number) => TS): Array<TI | TS> {\n        return items.flatMap((x, index) => (index === 0 ? [x] : [item(x, index), x]));\n    }\n\n    public static zip<T1, T2>(items1: Iterable<T1>, items2: Iterable<T2>): Iterable<[T1 | undefined, T2 | undefined]>;\n    public static *zip(...iterables: Array<Iterable<unknown>>): Iterable<unknown[]> {\n        const iterators: Array<Iterator<unknown> | typeof NoValueMarker> = iterables.map(it => Iterator.from(it));\n        let hasUndoneIterators = true;\n        while (hasUndoneIterators) {\n            const resultEntry = [];\n            hasUndoneIterators = false;\n            for (const [i, iterator] of this.iterateEntries(iterators)) {\n                if (iterator === NoValueMarker) {\n                    resultEntry.push(undefined);\n                } else {\n                    const resultValue = iterator.next();\n                    if (resultValue.done) {\n                        resultEntry.push(undefined);\n                        iterators[i] = NoValueMarker;\n                    } else {\n                        resultEntry.push(resultValue.value);\n                        hasUndoneIterators = true;\n                    }\n                }\n            }\n            if (hasUndoneIterators) {\n                yield resultEntry;\n            }\n        }\n    }\n\n    public static *distinctBy<T>(items: Iterable<T>, idSelector: (item: T) => string): Iterable<T> {\n        const set = new Set<string>();\n        for (const item of items) {\n            const id = idSelector(item);\n            if (!set.has(id)) {\n                set.add(id);\n                yield item;\n            }\n        }\n    }\n\n    public static reduce<T, U>(\n        items: Iterable<T>,\n        reducer: (accumulator: U, item: T, index: number) => U,\n        initialValue: U\n    ): U {\n        let index = 0;\n        return Iterator.from(items).reduce((acc, item) => reducer(acc, item, index++), initialValue);\n    }\n\n    public static *batch<T>(items: Iterable<T>, batchSize: number): Iterable<Iterable<T>> {\n        const iterator = Iterator.from(items);\n        const safeBatchSize = batchSize > 0 ? batchSize : 1;\n        let done = false;\n        while (!done) {\n            const batch: T[] = [];\n            while (batch.length < safeBatchSize) {\n                const current = iterator.next();\n                if (current.done) {\n                    done = true;\n                    break;\n                } else {\n                    batch.push(current.value);\n                }\n            }\n            if (batch.length > 0) {\n                yield batch;\n            }\n        }\n    }\n}\n"],"mappings":"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","ignoreList":[]}