SYMBOL INDEX (142 symbols across 27 files)

FILE: lib/array.js
  constant DEFAULT_OPTIONS (line 36) | const DEFAULT_OPTIONS = { min: 5, percent: 0.7 };
  constant REDUCE_EMPTY_ARR (line 151) | const REDUCE_EMPTY_ARR =
  constant REDUCE_RIGHT_EMPTY_ARR (line 201) | const REDUCE_RIGHT_EMPTY_ARR =

FILE: lib/async-iterator.js
  class AsyncIterator (line 19) | class AsyncIterator {
    method constructor (line 20) | constructor(base) {
    method next (line 28) | async next() {
    method count (line 32) | async count() {
    method each (line 40) | async each(fn, thisArg) {
    method forEach (line 44) | async forEach(fn, thisArg) {
    method parallel (line 50) | async parallel(fn, thisArg) {
    method every (line 58) | async every(predicate, thisArg) {
    method find (line 66) | async find(predicate, thisArg) {
    method includes (line 76) | async includes(element) {
    method reduce (line 85) | async reduce(reducer, initialValue) {
    method some (line 104) | async some(predicate, thisArg) {
    method someCount (line 113) | async someCount(predicate, count, thisArg) {
    method collectTo (line 123) | async collectTo(CollectionClass) {
    method collectWith (line 128) | async collectWith(obj, collector) {
    method join (line 132) | async join(sep = ',', prefix = '', suffix = '') {
    method toArray (line 144) | async toArray() {
    method map (line 152) | map(mapper, thisArg) {
    method filter (line 156) | filter(predicate, thisArg) {
    method flat (line 160) | flat(depth = 1) {
    method flatMap (line 164) | flatMap(mapper, thisArg) {
    method zip (line 168) | zip(...iterators) {
    method chain (line 172) | chain(...iterators) {
    method take (line 176) | take(amount) {
    method takeWhile (line 180) | takeWhile(predicate, thisArg) {
    method skip (line 184) | skip(amount) {
    method throttle (line 191) | throttle(percent, min) {
    method enumerate (line 195) | enumerate() {
  method [Symbol.asyncIterator] (line 24) | [Symbol.asyncIterator]() {
  class MapIterator (line 200) | class MapIterator extends AsyncIterator {
    method constructor (line 201) | constructor(base, mapper, thisArg) {
    method next (line 207) | async next() {
  class FilterIterator (line 216) | class FilterIterator extends AsyncIterator {
    method constructor (line 217) | constructor(base, predicate, thisArg) {
    method next (line 223) | async next() {
  class FlatIterator (line 233) | class FlatIterator extends AsyncIterator {
    method constructor (line 234) | constructor(base, depth) {
    method next (line 241) | async next() {
  class FlatMapIterator (line 268) | class FlatMapIterator extends AsyncIterator {
    method constructor (line 269) | constructor(base, mapper, thisArg) {
    method next (line 276) | async next() {
  class TakeIterator (line 301) | class TakeIterator extends AsyncIterator {
    method constructor (line 302) | constructor(base, amount) {
    method next (line 308) | async next() {
  class TakeWhileIterator (line 317) | class TakeWhileIterator extends AsyncIterator {
    method constructor (line 318) | constructor(base, predicate, thisArg) {
    method next (line 325) | async next() {
  class ZipIterator (line 335) | class ZipIterator extends AsyncIterator {
    method constructor (line 336) | constructor(base, iterators) {
    method next (line 341) | async next() {
  class ChainIterator (line 362) | class ChainIterator extends AsyncIterator {
    method constructor (line 363) | constructor(base, iterators) {
    method next (line 369) | async next() {
  class EnumerateIterator (line 383) | class EnumerateIterator extends AsyncIterator {
    method constructor (line 384) | constructor(base) {
    method next (line 389) | async next() {
  class ThrottleIterator (line 398) | class ThrottleIterator extends AsyncIterator {
    method constructor (line 399) | constructor(base, percent = 0.7, min = 5) {
    method next (line 410) | async next() {

FILE: lib/collector.class.js
  constant UNEXPECTED_KEY (line 14) | const UNEXPECTED_KEY = 'Metasync: unexpected key: ';
  constant COLLECT_TIMEOUT (line 15) | const COLLECT_TIMEOUT = 'Metasync: Collector timed out';
  constant COLLECT_CANCELED (line 16) | const COLLECT_CANCELED = 'Metasync: Collector cancelled';
  class Collector (line 18) | class Collector {
    method constructor (line 21) | constructor(expected) {
    method collect (line 33) | collect(key, err, value) {
    method pick (line 56) | pick(key, value) {
    method fail (line 61) | fail(key, err) {
    method take (line 66) | take(key, fn, ...args) {
    method timeout (line 73) | timeout(msec) {
    method done (line 87) | done(callback) {
    method finalize (line 92) | finalize(key, err, data) {
    method distinct (line 105) | distinct(value = true) {
    method cancel (line 110) | cancel(err) {
    method then (line 116) | then(fulfilled, rejected) {

FILE: lib/collector.functor.js
  constant TYPE_ERROR (line 3) | const TYPE_ERROR = 'Metasync: Collect unexpected type';
  constant COLLECT_TIMEOUT (line 4) | const COLLECT_TIMEOUT = 'Metasync: Collector timed out';

FILE: lib/collector.js
  constant UNEXPECTED_KEY (line 5) | const UNEXPECTED_KEY = 'Metasync: unexpected key: ';
  constant COLLECT_TIMEOUT (line 6) | const COLLECT_TIMEOUT = 'Metasync: Collector timed out';
  constant COLLECT_CANCELED (line 7) | const COLLECT_CANCELED = 'Metasync: Collector cancelled';
  function Collector (line 11) | function Collector(expected) {

FILE: lib/collector.prototype.js
  function Collector (line 8) | function Collector() {}
  constant COLLECT_TIMEOUT (line 10) | const COLLECT_TIMEOUT = 'Metasync: Collector timed out';

FILE: lib/composition.js
  function Composition (line 3) | function Composition() {}
  constant COMPOSE_CANCELED (line 5) | const COMPOSE_CANCELED = 'Metasync: asynchronous composition canceled';
  constant COMPOSE_TIMEOUT (line 6) | const COMPOSE_TIMEOUT = 'Metasync: asynchronous composition timed out';

FILE: lib/do.js
  function Do (line 3) | function Do() {}

FILE: lib/memoize.js
  function Memoized (line 3) | function Memoized() {}

FILE: lib/queue.js
  function Queue (line 5) | function Queue(concurrency) {
  constant QUEUE_TIMEOUT (line 27) | const QUEUE_TIMEOUT = 'Metasync: Queue timed out';

FILE: lib/throttle.js
  constant FN_TIMEOUT (line 53) | const FN_TIMEOUT = 'Metasync: asynchronous function timed out';

FILE: metasync.d.ts
  type Callback (line 1) | type Callback<T = unknown> = (err: Error | null, data?: T) => void;
  type AsyncFunction (line 2) | type AsyncFunction<T = unknown, R = unknown> = (
  type AsyncFunctionNoData (line 6) | type AsyncFunctionNoData<R = unknown> = (callback: Callback<R>) => void;
  type FlowFunction (line 7) | type FlowFunction = AsyncFunction | AsyncFunctionNoData | Flow;
  type Flow (line 9) | type Flow = FlowFunction[];
  type Composition (line 11) | interface Composition {
  class Composition (line 45) | class Composition {
  type AsyncMapOptions (line 71) | interface AsyncMapOptions {
  type Collector (line 151) | interface Collector {
  class Collector (line 183) | class Collector {
  type Do (line 220) | interface Do {
  type MemoizedEvents (line 270) | interface MemoizedEvents {
  type Memoized (line 279) | interface Memoized extends Function {
  class Memoized (line 304) | class Memoized {
  type Pool (line 308) | interface Pool {
  type Queue (line 321) | interface Queue {
  class Queue (line 365) | class Queue {
  type AsyncIteratorResult (line 387) | interface AsyncIteratorResult<T> {
  type AsyncIterator (line 392) | interface AsyncIterator<T = unknown> {
  class AsyncIterator (line 472) | class AsyncIterator<T = unknown> {

FILE: test/compose.js
  constant AC1 (line 86) | const AC1 = 'async functions composition cancel before start';
  constant AC2 (line 120) | const AC2 = 'async functions composition cancel in the middle';

FILE: test/examples.js
  constant ASYNC_TIMEOUT (line 7) | const ASYNC_TIMEOUT = 200;

FILE: test/fp.fmap.js
  constant FP1 (line 44) | const FP1 = 'Getting error with no second argument execution';

FILE: tests/fixtures/iterator.js
  method fn (line 110) | fn(value) {
  method mapper (line 163) | mapper(value) {
  method predicate (line 188) | predicate(value) {
  method mapper (line 244) | mapper(item) {
  method predicate (line 314) | predicate(value) {
  method predicate (line 336) | predicate(value) {
  method predicate (line 363) | predicate(value) {
  method predicate (line 387) | predicate(value) {

FILE: tests/fixtures/throttle.js
  constant ARRAY_SIZE (line 10) | const ARRAY_SIZE = 1000;
  constant TIMER_TIME (line 11) | const TIMER_TIME = 10;
  constant ITEM_TIME (line 12) | const ITEM_TIME = 1;
  constant EXPECTED_PERCENT (line 13) | const EXPECTED_PERCENT = 0.7;

FILE: tests/load/collect.class.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/collect.functor.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/collect.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/collect.prototype.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/parallel.collect.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/parallel.compose.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/parallel.promise.js
  constant COUNT (line 3) | const COUNT = 1000000;

FILE: tests/load/poolify.array.js
  constant COUNT (line 3) | const COUNT = 10000;
  constant GETS (line 4) | const GETS = 300;

FILE: tests/load/poolify.opt.js
  constant COUNT (line 3) | const COUNT = 10000;
  constant GETS (line 4) | const GETS = 300;

FILE: tests/load/poolify.symbol.js
  constant COUNT (line 3) | const COUNT = 10000;
  constant GETS (line 4) | const GETS = 300;