fp-pack 0.1.0

package/src/stream/flatMap.ts

@@ -0,0 +1,48 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** flatMap - lazy map + flatten */
+function flatMap<T, R>(fn: (value: T) => Iterable<R>): (iterable: Iterable<T>) => IterableIterator<R>;
+function flatMap<T, R>(
+  fn: (value: T) => Iterable<R> | Promise<Iterable<R>>
+): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => AsyncIterableIterator<R>;
+function flatMap<T, R>(fn: (value: T) => Iterable<R>, iterable: Iterable<T>): IterableIterator<R>;
+function flatMap<T, R>(
+  fn: (value: T) => Iterable<R> | Promise<Iterable<R>>,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): AsyncIterableIterator<R>;
+function flatMap<T, R>(
+  fn: (value: T) => Iterable<R> | Promise<Iterable<R>>,
+  iterable?: AnyIterableInput<PromiseLikeValue<T>>
+): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => flatMap(fn, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      for await (const item of toAsync(iterable)) {
+        const mapped = await fn(item as T);
+        for (const inner of mapped) {
+          yield inner;
+        }
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      for (const item of iterable) {
+        const mapped = fn(item as T) as Iterable<R>;
+        for (const inner of mapped) {
+          yield inner;
+        }
+      }
+    })();
+  }
+
+  throw new TypeError('flatMap: input is not iterable');
+}
+
+export default flatMap;

package/src/stream/flatten.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import flatten from './flatten';
+import toArray from './toArray';
+
+describe('stream flatten', () => {
+  it('flattens sync iterables', () => {
+    const result = Array.from(flatten([[1, 2], [3]]));
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  it('flattens async inputs', async () => {
+    const result = await toArray(
+      flatten(Promise.resolve([[1, 2], [3]]))
+    );
+    expect(result).toEqual([1, 2, 3]);
+  });
+});

package/src/stream/flatten.ts

@@ -0,0 +1,33 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { awaitValue, isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** flatten - lazily flatten iterable of iterables */
+function flatten<T>(iterable: Iterable<Iterable<T>>): IterableIterator<T>;
+function flatten<T>(iterable: AnyIterableInput<PromiseLikeValue<Iterable<T>>>): AsyncIterableIterator<T>;
+function flatten<T>(iterable: AnyIterableInput<PromiseLikeValue<Iterable<T>>>): any {
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      for await (const inner of toAsync(iterable)) {
+        const resolved = await awaitValue(inner as PromiseLikeValue<Iterable<T>>);
+        for (const item of resolved) {
+          yield item as T;
+        }
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      for (const inner of iterable as Iterable<Iterable<T>>) {
+        for (const item of inner) {
+          yield item as T;
+        }
+      }
+    })();
+  }
+
+  throw new TypeError('flatten: input is not iterable');
+}
+
+export default flatten;

package/src/stream/flattenDeep.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import flattenDeep from './flattenDeep';
+import toArray from './toArray';
+
+describe('stream flattenDeep', () => {
+  it('flattens sync iterables deeply', () => {
+    const result = Array.from(flattenDeep([1, [2, [3, 4], 5], [[6]]]));
+    expect(result).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  it('flattens async inputs deeply', async () => {
+    const result = await toArray(
+      flattenDeep(Promise.resolve([1, [2, [3]], [[4]]]))
+    );
+    expect(result).toEqual([1, 2, 3, 4]);
+  });
+});

package/src/stream/flattenDeep.ts

@@ -0,0 +1,41 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { awaitValue, isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** flattenDeep - lazily flatten nested iterables */
+function flattenDeep<T>(iterable: Iterable<unknown>): IterableIterator<T>;
+function flattenDeep<T>(iterable: AnyIterableInput<PromiseLikeValue<unknown>>): AsyncIterableIterator<T>;
+function flattenDeep<T>(iterable: AnyIterableInput<PromiseLikeValue<unknown>>): any {
+  const walkSync = function* (value: unknown): IterableIterator<T> {
+    if (isIterable(value)) {
+      for (const item of value as Iterable<unknown>) {
+        yield* walkSync(item);
+      }
+      return;
+    }
+    yield value as T;
+  };
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      for await (const item of toAsync(iterable)) {
+        const resolved = await awaitValue(item as PromiseLikeValue<unknown>);
+        for (const inner of walkSync(resolved)) {
+          yield inner as T;
+        }
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      for (const item of iterable as Iterable<unknown>) {
+        yield* walkSync(item);
+      }
+    })();
+  }
+
+  throw new TypeError('flattenDeep: input is not iterable');
+}
+
+export default flattenDeep;

package/src/stream/index.ts

@@ -0,0 +1,23 @@
+export { default as append } from './append';
+export { default as chunk } from './chunk';
+export { default as concat } from './concat';
+export { default as drop } from './drop';
+export { default as dropWhile } from './dropWhile';
+export { default as every } from './every';
+export { default as filter } from './filter';
+export { default as find } from './find';
+export { default as flatMap } from './flatMap';
+export { default as flatten } from './flatten';
+export { default as flattenDeep } from './flattenDeep';
+export { default as map } from './map';
+export { default as prepend } from './prepend';
+export { default as range } from './range';
+export { default as reduce } from './reduce';
+export { default as scan } from './scan';
+export { default as some } from './some';
+export { default as take } from './take';
+export { default as takeWhile } from './takeWhile';
+export { default as toArray } from './toArray';
+export { default as toAsync } from './toAsync';
+export { default as zip } from './zip';
+export { default as zipWith } from './zipWith';

package/src/stream/map.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import map from './map';
+import toArray from './toArray';
+
+describe('stream map', () => {
+  it('maps sync iterables', () => {
+    expect(Array.from(map((n: number) => n * 2, [1, 2, 3]))).toEqual([2, 4, 6]);
+  });
+
+  it('supports data-last usage', () => {
+    const mapper = map((n: number) => n + 1);
+    expect(Array.from(mapper([1, 2]))).toEqual([2, 3]);
+  });
+
+  it('maps async inputs', async () => {
+    const result = await toArray(map(async (n: number) => n * 3, Promise.resolve([1, 2])));
+    expect(result).toEqual([3, 6]);
+  });
+});

package/src/stream/map.ts

@@ -0,0 +1,39 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** map - lazy map over iterables */
+function map<T, R>(fn: (value: T) => R): (iterable: Iterable<T>) => IterableIterator<R>;
+function map<T, R>(
+  fn: (value: T) => R | Promise<R>
+): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => AsyncIterableIterator<R>;
+function map<T, R>(fn: (value: T) => R, iterable: Iterable<T>): IterableIterator<R>;
+function map<T, R>(
+  fn: (value: T) => R | Promise<R>,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): AsyncIterableIterator<R>;
+function map<T, R>(fn: (value: T) => R | Promise<R>, iterable?: AnyIterableInput<PromiseLikeValue<T>>): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => map(fn, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      for await (const item of toAsync(iterable)) {
+        yield await fn(item as T);
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      for (const item of iterable) {
+        yield fn(item as T) as R;
+      }
+    })();
+  }
+
+  throw new TypeError('map: input is not iterable');
+}
+
+export default map;

package/src/stream/pipeAsync.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import pipeAsync from '../implement/async/pipeAsync';
+import chunk from './chunk';
+import toArray from './toArray';
+import toAsync from './toAsync';
+
+describe('stream pipeAsync integration', () => {
+  it('pipes sync input through chunk/toArray', async () => {
+    const result = await pipeAsync(chunk(2), toArray)([1, 2, 3, 4]);
+    expect(result).toEqual([[1, 2], [3, 4]]);
+  });
+
+  it('pipes promise input through chunk/toArray', async () => {
+    const result = await pipeAsync(chunk(2), toArray)(Promise.resolve([1, 2, 3, 4]));
+    expect(result).toEqual([[1, 2], [3, 4]]);
+  });
+
+  it('pipes async values via toAsync', async () => {
+    const result = await pipeAsync(toAsync, chunk(2), toArray)([
+      Promise.resolve(1),
+      Promise.resolve(2),
+      Promise.resolve(3),
+      Promise.resolve(4),
+    ]);
+    expect(result).toEqual([[1, 2], [3, 4]]);
+  });
+});

package/src/stream/prepend.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import prepend from './prepend';
+import toArray from './toArray';
+
+describe('stream prepend', () => {
+  it('prepends sync iterables', () => {
+    const result = Array.from(prepend(0, [1, 2]));
+    expect(result).toEqual([0, 1, 2]);
+  });
+
+  it('supports data-last usage', () => {
+    const addHead = prepend(-1);
+    expect(Array.from(addHead([1, 2]))).toEqual([-1, 1, 2]);
+  });
+
+  it('prepends async inputs', async () => {
+    const result = await toArray(prepend(Promise.resolve(0), Promise.resolve([1, 2])));
+    expect(result).toEqual([0, 1, 2]);
+  });
+});

package/src/stream/prepend.ts

@@ -0,0 +1,39 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { awaitValue, isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** prepend - lazily prepend a value to the start */
+function prepend<T>(value: T): (iterable: Iterable<T>) => IterableIterator<T>;
+function prepend<T>(value: PromiseLikeValue<T>): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => AsyncIterableIterator<T>;
+function prepend<T>(value: T, iterable: Iterable<T>): IterableIterator<T>;
+function prepend<T>(
+  value: PromiseLikeValue<T>,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): AsyncIterableIterator<T>;
+function prepend<T>(value: PromiseLikeValue<T>, iterable?: AnyIterableInput<PromiseLikeValue<T>>): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => prepend(value, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      yield await awaitValue(value);
+      for await (const item of toAsync(iterable)) {
+        yield item as T;
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      yield value as T;
+      for (const item of iterable) {
+        yield item as T;
+      }
+    })();
+  }
+
+  throw new TypeError('prepend: input is not iterable');
+}
+
+export default prepend;

package/src/stream/range.test.ts

@@ -0,0 +1,16 @@
+import { describe, it, expect } from 'vitest';
+import range from './range';
+
+describe('stream range', () => {
+  it('creates an ascending range excluding end', () => {
+    expect(Array.from(range(0, 4))).toEqual([0, 1, 2, 3]);
+  });
+
+  it('creates a descending range excluding end', () => {
+    expect(Array.from(range(4, 0))).toEqual([4, 3, 2, 1]);
+  });
+
+  it('returns empty when start equals end', () => {
+    expect(Array.from(range(2, 2))).toEqual([]);
+  });
+});

package/src/stream/range.ts

@@ -0,0 +1,20 @@
+/** range - lazily generate a numeric range (end excluded) */
+function range(start: number, end: number): IterableIterator<number> {
+  if (!Number.isFinite(start) || !Number.isFinite(end)) {
+    return (function* () {})();
+  }
+
+  if (start === end) {
+    return (function* () {})();
+  }
+
+  const step = start < end ? 1 : -1;
+
+  return (function* () {
+    for (let value = start; step > 0 ? value < end : value > end; value += step) {
+      yield value;
+    }
+  })();
+}
+
+export default range;

package/src/stream/reduce.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import reduce from './reduce';
+
+describe('stream reduce', () => {
+  it('reduces sync iterables', () => {
+    expect(reduce((acc: number, n: number) => acc + n, 0, [1, 2, 3])).toBe(6);
+  });
+
+  it('supports data-last usage', () => {
+    const sum = reduce((acc: number, n: number) => acc + n, 0);
+    expect(sum([4, 5])).toBe(9);
+  });
+
+  it('reduces async inputs', async () => {
+    const result = await reduce(async (acc: number, n: number) => acc + n, 0, Promise.resolve([2, 4]));
+    expect(result).toBe(6);
+  });
+});

package/src/stream/reduce.ts

@@ -0,0 +1,47 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** reduce - fold values into an accumulator */
+function reduce<T, R>(fn: (acc: R, value: T) => R, initial: R): (iterable: Iterable<T>) => R;
+function reduce<T, R>(
+  fn: (acc: R, value: T) => R | Promise<R>,
+  initial: R
+): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => Promise<R>;
+function reduce<T, R>(fn: (acc: R, value: T) => R, initial: R, iterable: Iterable<T>): R;
+function reduce<T, R>(
+  fn: (acc: R, value: T) => R | Promise<R>,
+  initial: R,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): Promise<R>;
+function reduce<T, R>(
+  fn: (acc: R, value: T) => R | Promise<R>,
+  initial: R,
+  iterable?: AnyIterableInput<PromiseLikeValue<T>>
+) {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => reduce(fn, initial, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async () => {
+      let acc = initial;
+      for await (const item of toAsync(iterable)) {
+        acc = await fn(acc, item as T);
+      }
+      return acc;
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    let acc = initial;
+    for (const item of iterable) {
+      acc = fn(acc, item as T) as R;
+    }
+    return acc;
+  }
+
+  throw new TypeError('reduce: input is not iterable');
+}
+
+export default reduce;

package/src/stream/scan.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import scan from './scan';
+import toArray from './toArray';
+
+describe('stream scan', () => {
+  it('scans sync iterables', () => {
+    const result = Array.from(scan((acc: number, n: number) => acc + n, 0, [1, 2, 3]));
+    expect(result).toEqual([1, 3, 6]);
+  });
+
+  it('supports data-last usage', () => {
+    const runningSum = scan((acc: number, n: number) => acc + n, 0);
+    expect(Array.from(runningSum([2, 2]))).toEqual([2, 4]);
+  });
+
+  it('scans async inputs', async () => {
+    const result = await toArray(
+      scan(async (acc: number, n: number) => acc + n, 0, Promise.resolve([1, 2]))
+    );
+    expect(result).toEqual([1, 3]);
+  });
+});

package/src/stream/scan.ts

@@ -0,0 +1,49 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** scan - fold values and emit each accumulated value */
+function scan<T, R>(fn: (acc: R, value: T) => R, initial: R): (iterable: Iterable<T>) => IterableIterator<R>;
+function scan<T, R>(
+  fn: (acc: R, value: T) => R | Promise<R>,
+  initial: R
+): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => AsyncIterableIterator<R>;
+function scan<T, R>(fn: (acc: R, value: T) => R, initial: R, iterable: Iterable<T>): IterableIterator<R>;
+function scan<T, R>(
+  fn: (acc: R, value: T) => R | Promise<R>,
+  initial: R,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): AsyncIterableIterator<R>;
+function scan<T, R>(
+  fn: (acc: R, value: T) => R | Promise<R>,
+  initial: R,
+  iterable?: AnyIterableInput<PromiseLikeValue<T>>
+): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => scan(fn, initial, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      let acc = initial;
+      for await (const item of toAsync(iterable)) {
+        acc = await fn(acc, item as T);
+        yield acc;
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      let acc = initial;
+      for (const item of iterable) {
+        acc = fn(acc, item as T) as R;
+        yield acc;
+      }
+    })();
+  }
+
+  throw new TypeError('scan: input is not iterable');
+}
+
+export default scan;

package/src/stream/some.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import some from './some';
+
+describe('stream some', () => {
+  it('checks sync iterables', () => {
+    expect(some((n: number) => n > 2, [1, 2, 3])).toBe(true);
+    expect(some((n: number) => n > 5, [1, 2, 3])).toBe(false);
+  });
+
+  it('supports data-last usage', () => {
+    const hasEven = some((n: number) => n % 2 === 0);
+    expect(hasEven([1, 3, 5])).toBe(false);
+  });
+
+  it('checks async inputs', async () => {
+    const result = await some(async (n: number) => n === 2, Promise.resolve([1, 2, 3]));
+    expect(result).toBe(true);
+  });
+});

package/src/stream/some.ts

@@ -0,0 +1,46 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** some - check any value matches */
+function some<T>(predicate: (value: T) => boolean): (iterable: Iterable<T>) => boolean;
+function some<T>(
+  predicate: (value: T) => boolean | Promise<boolean>
+): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => Promise<boolean>;
+function some<T>(predicate: (value: T) => boolean, iterable: Iterable<T>): boolean;
+function some<T>(
+  predicate: (value: T) => boolean | Promise<boolean>,
+  iterable: AnyIterableInput<PromiseLikeValue<T>>
+): Promise<boolean>;
+function some<T>(
+  predicate: (value: T) => boolean | Promise<boolean>,
+  iterable?: AnyIterableInput<PromiseLikeValue<T>>
+): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => some(predicate, next);
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async () => {
+      for await (const item of toAsync(iterable)) {
+        if (await predicate(item as T)) {
+          return true;
+        }
+      }
+      return false;
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    for (const item of iterable) {
+      if (predicate(item as T)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  throw new TypeError('some: input is not iterable');
+}
+
+export default some;

package/src/stream/take.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import take from './take';
+import toArray from './toArray';
+
+describe('stream take', () => {
+  it('takes from sync iterables', () => {
+    expect(Array.from(take(2, [1, 2, 3]))).toEqual([1, 2]);
+  });
+
+  it('supports data-last usage', () => {
+    const takeTwo = take(2);
+    expect(Array.from(takeTwo([4, 5, 6]))).toEqual([4, 5]);
+  });
+
+  it('takes from async inputs', async () => {
+    const result = await toArray(take(2, Promise.resolve([7, 8, 9])));
+    expect(result).toEqual([7, 8]);
+  });
+});

package/src/stream/take.ts

@@ -0,0 +1,51 @@
+import type { AnyIterableInput, PromiseLikeValue } from './utils';
+import { isAsyncInput, isIterable } from './utils';
+import toAsync from './toAsync';
+
+/** take - lazily take first n values */
+function take<T>(count: number): (iterable: Iterable<T>) => IterableIterator<T>;
+function take<T>(count: number): (iterable: AnyIterableInput<PromiseLikeValue<T>>) => AsyncIterableIterator<T>;
+function take<T>(count: number, iterable: Iterable<T>): IterableIterator<T>;
+function take<T>(count: number, iterable: AnyIterableInput<PromiseLikeValue<T>>): AsyncIterableIterator<T>;
+function take<T>(count: number, iterable?: AnyIterableInput<PromiseLikeValue<T>>): any {
+  if (iterable === undefined) {
+    return (next: AnyIterableInput<PromiseLikeValue<T>>) => take(count, next);
+  }
+
+  const limit = Math.floor(count);
+  if (!Number.isFinite(limit) || limit <= 0) {
+    return isAsyncInput(iterable)
+      ? (async function* () {})()
+      : (function* () {})();
+  }
+
+  if (isAsyncInput(iterable)) {
+    return (async function* () {
+      let taken = 0;
+      for await (const item of toAsync(iterable)) {
+        yield item as T;
+        taken += 1;
+        if (taken >= limit) {
+          break;
+        }
+      }
+    })();
+  }
+
+  if (isIterable(iterable)) {
+    return (function* () {
+      let taken = 0;
+      for (const item of iterable) {
+        yield item as T;
+        taken += 1;
+        if (taken >= limit) {
+          break;
+        }
+      }
+    })();
+  }
+
+  throw new TypeError('take: input is not iterable');
+}
+
+export default take;

package/src/stream/takeWhile.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import takeWhile from './takeWhile';
+import toArray from './toArray';
+
+describe('stream takeWhile', () => {
+  it('takes while predicate holds (sync)', () => {
+    const result = Array.from(takeWhile((n: number) => n < 3, [1, 2, 3, 1]));
+    expect(result).toEqual([1, 2]);
+  });
+
+  it('supports data-last usage', () => {
+    const takeSmall = takeWhile((n: number) => n <= 2);
+    expect(Array.from(takeSmall([2, 2, 3]))).toEqual([2, 2]);
+  });
+
+  it('takes while predicate holds (async)', async () => {
+    const result = await toArray(takeWhile(async (n: number) => n < 3, Promise.resolve([1, 2, 3, 1])));
+    expect(result).toEqual([1, 2]);
+  });
+});