@anion155/proposal-iterator-helpers 0.1.0

package/lib/base.js

@@ -0,0 +1,10 @@
+export function polyfill(condition, polyfill) {
+    if (!condition)
+        polyfill();
+}
+export function polyfillProperty(value, key, descriptor) {
+    if (!(key in value)) {
+        const { writable = true, enumerable = true, configurable = true } = descriptor;
+        Object.defineProperty(value, key, { ...descriptor, writable, enumerable, configurable });
+    }
+}

package/lib/global-iterator.js

@@ -0,0 +1,5 @@
+import { polyfillProperty } from "./base";
+import { IteratorConstructor } from "./iterator-constructor";
+polyfillProperty(globalThis, "Iterator", {
+    value: IteratorConstructor,
+});

package/lib/global.js

@@ -0,0 +1,2 @@
+import "./global-iterator";
+import "./index";

package/lib/index.js

@@ -0,0 +1,14 @@
+import "./iterator-from";
+import "./iterator-prototype-drop";
+import "./iterator-prototype-every";
+import "./iterator-prototype-filter";
+import "./iterator-prototype-find";
+import "./iterator-prototype-flat-map";
+import "./iterator-prototype-for-each";
+import "./iterator-prototype-map";
+import "./iterator-prototype-reduce";
+import "./iterator-prototype-some";
+import "./iterator-prototype-take";
+import "./iterator-prototype-to-array";
+export * from "./iterator-constructor";
+export * from "./iterator-prototype";

package/lib/iterator-constructor.js

@@ -0,0 +1,15 @@
+import { polyfill, polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+import { isIteratorInstance } from "./utils";
+polyfill("constructor" in IteratorPrototype, () => {
+    const IteratorConstructor = function Iterator() {
+        if (!isIteratorInstance(this))
+            throw new TypeError("Constructor Iterator requires 'new'");
+        if (Object.getPrototypeOf(this) === IteratorPrototype)
+            throw new TypeError("Abstract class Iterator not directly constructable");
+        return this;
+    };
+    IteratorConstructor.prototype = IteratorPrototype;
+    polyfillProperty(IteratorPrototype, "constructor", { value: IteratorConstructor, enumerable: false });
+});
+export const IteratorConstructor = IteratorPrototype.constructor;

package/lib/iterator-from.js

@@ -0,0 +1,45 @@
+import { polyfillProperty } from "./base";
+import { IteratorConstructor } from "./iterator-constructor";
+import { IteratorPrototype } from "./iterator-prototype";
+import { isIterable, isIteratorInstance } from "./utils";
+const doneKey = Symbol.for("proxy-iterator-done");
+const targetKey = Symbol.for("proxy-iterator-target");
+function ProxyIterator(target) {
+    this[doneKey] = false;
+    polyfillProperty(this, targetKey, { value: target, writable: false });
+}
+ProxyIterator.prototype = Object.create(IteratorPrototype, {
+    next: {
+        value: function proxyNext(value) {
+            if (this[doneKey])
+                return { done: true, value: undefined };
+            return this[targetKey].next(value);
+        },
+    },
+    return: {
+        value: function proxyReturn(value) {
+            this[doneKey] = true;
+            if (!this[targetKey].return)
+                return { value, done: true };
+            return this[targetKey].return?.(value);
+        },
+    },
+    throw: {
+        value: function proxyThrow(error) {
+            this[doneKey] = true;
+            if (!this[targetKey].throw)
+                throw error;
+            return this[targetKey].throw(error);
+        },
+    },
+});
+polyfillProperty(IteratorConstructor, "from", {
+    value: function from(it) {
+        if (isIteratorInstance(it))
+            return it;
+        const iterator = isIterable(it) ? it[Symbol.iterator]() : it;
+        if (isIteratorInstance(iterator))
+            return iterator;
+        return Reflect.construct(ProxyIterator, [iterator]);
+    },
+});

package/lib/iterator-prototype-drop.js

@@ -0,0 +1,15 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "drop", {
+    value: function* drop(limit) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return result.value;
+            if (index >= limit)
+                yield result.value;
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-every.js

@@ -0,0 +1,17 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "every", {
+    value: function every(predicate) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return true;
+            if (!predicate(result.value, index)) {
+                this.return?.(undefined);
+                return false;
+            }
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-filter.js

@@ -0,0 +1,16 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "filter", {
+    value: function* filter(predicate) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return result.value;
+            if (predicate(result.value, index)) {
+                yield result.value;
+            }
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-find.js

@@ -0,0 +1,17 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "find", {
+    value: function find(predicate) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return undefined;
+            if (predicate(result.value, index)) {
+                this.return?.(undefined);
+                return result.value;
+            }
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-flat-map.js

@@ -0,0 +1,15 @@
+import { polyfillProperty } from "./base";
+import { IteratorConstructor } from "./iterator-constructor";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "flatMap", {
+    value: function* flatMap(project) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return result.value;
+            yield* IteratorConstructor.from(project(result.value, index));
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-for-each.js

@@ -0,0 +1,14 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "forEach", {
+    value: function forEach(callback) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return;
+            callback(result.value, index);
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-map.js

@@ -0,0 +1,14 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "map", {
+    value: function* map(project) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return result.value;
+            yield project(result.value, index);
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-reduce.js

@@ -0,0 +1,21 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "reduce", {
+    value: function reduce(reducer, ...args) {
+        let index = 0;
+        let aggregation = args[0];
+        let initiated = args.length > 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return aggregation;
+            if (!initiated && args.length === 0) {
+                aggregation = result.value;
+                initiated = true;
+                continue;
+            }
+            aggregation = reducer(aggregation, result.value, index);
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-some.js

@@ -0,0 +1,17 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "some", {
+    value: function some(predicate) {
+        let index = 0;
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return false;
+            if (predicate(result.value, index)) {
+                this.return?.(undefined);
+                return true;
+            }
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-take.js

@@ -0,0 +1,17 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "take", {
+    value: function* take(limit) {
+        let index = 0;
+        while (true) {
+            if (index >= limit) {
+                return this.return?.(undefined).value;
+            }
+            const result = this.next();
+            if (result.done)
+                return result.value;
+            yield result.value;
+            index += 1;
+        }
+    },
+});

package/lib/iterator-prototype-to-array.js

@@ -0,0 +1,13 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+polyfillProperty(IteratorPrototype, "toArray", {
+    value: function toArray() {
+        const items = [];
+        while (true) {
+            const result = this.next();
+            if (result.done)
+                return items;
+            items.push(result.value);
+        }
+    },
+});

package/lib/iterator-prototype.js

@@ -0,0 +1,12 @@
+import { polyfillProperty } from "./base";
+export const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));
+polyfillProperty(IteratorPrototype, Symbol.toStringTag, {
+    value: "Iterator",
+    writable: false,
+    enumerable: false,
+});
+polyfillProperty(IteratorPrototype, Symbol.iterator, {
+    value: function iterator() {
+        return this;
+    },
+});

package/lib/utils.js

@@ -0,0 +1,7 @@
+import { IteratorPrototype } from "./iterator-prototype";
+export function isIteratorInstance(value) {
+    return Object.prototype.isPrototypeOf.call(IteratorPrototype, value);
+}
+export function isIterable(value) {
+    return Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@anion155/proposal-iterator-helpers",
+  "version": "0.1.0",
+  "description": "Polyfills implementing the Iterator Helpers proposal for ECMAScript.",
+  "keywords": [
+    "iterator",
+    "iterable",
+    "helpers",
+    "ecmascript",
+    "proposal",
+    "polyfill"
+  ],
+  "author": {
+    "name": "anion155",
+    "url": "https://github.com/anion155"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anion155/monorepo.git",
+    "directory": "packages/proposal-iterator-helpers"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./global-iterator": "./src/global-iterator.ts",
+    "./global": "./src/global.ts",
+    ".": "./src/index.ts",
+    "./iterator-constructor": "./src/iterator-constructor.ts",
+    "./iterator-from": "./src/iterator-from.ts",
+    "./iterator-prototype-drop": "./src/iterator-prototype-drop.ts",
+    "./iterator-prototype-every": "./src/iterator-prototype-every.ts",
+    "./iterator-prototype-filter": "./src/iterator-prototype-filter.ts",
+    "./iterator-prototype-find": "./src/iterator-prototype-find.ts",
+    "./iterator-prototype-flat-map": "./src/iterator-prototype-flat-map.ts",
+    "./iterator-prototype-for-each": "./src/iterator-prototype-for-each.ts",
+    "./iterator-prototype-map": "./src/iterator-prototype-map.ts",
+    "./iterator-prototype-reduce": "./src/iterator-prototype-reduce.ts",
+    "./iterator-prototype-some": "./src/iterator-prototype-some.ts",
+    "./iterator-prototype-take": "./src/iterator-prototype-take.ts",
+    "./iterator-prototype-to-array": "./src/iterator-prototype-to-array.ts",
+    "./iterator-prototype": "./src/iterator-prototype.ts",
+    "./utils": "./src/utils.ts"
+  },
+  "dependencies": {}
+}

package/src/base.ts

@@ -0,0 +1,10 @@
+export function polyfill(condition: unknown, polyfill: () => void) {
+  if (!condition) polyfill();
+}
+
+export function polyfillProperty<Value extends object>(value: Value, key: keyof Value | (PropertyKey & {}), descriptor: PropertyDescriptor) {
+  if (!(key in value)) {
+    const { writable = true, enumerable = true, configurable = true } = descriptor;
+    Object.defineProperty(value, key, { ...descriptor, writable, enumerable, configurable });
+  }
+}

package/src/global-iterator.ts

@@ -0,0 +1,8 @@
+import { polyfillProperty } from "./base";
+import { IteratorConstructor } from "./iterator-constructor";
+
+polyfillProperty(globalThis, "Iterator", {
+  value: IteratorConstructor,
+});
+
+export {};

package/src/global.ts

@@ -0,0 +1,2 @@
+import "./global-iterator";
+import "./index";

package/src/index.ts

@@ -0,0 +1,15 @@
+import "./iterator-from";
+import "./iterator-prototype-drop";
+import "./iterator-prototype-every";
+import "./iterator-prototype-filter";
+import "./iterator-prototype-find";
+import "./iterator-prototype-flat-map";
+import "./iterator-prototype-for-each";
+import "./iterator-prototype-map";
+import "./iterator-prototype-reduce";
+import "./iterator-prototype-some";
+import "./iterator-prototype-take";
+import "./iterator-prototype-to-array";
+
+export * from "./iterator-constructor";
+export * from "./iterator-prototype";

package/src/iterator-constructor.ts

@@ -0,0 +1,20 @@
+import { polyfill, polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+import { isIteratorInstance } from "./utils";
+
+polyfill("constructor" in IteratorPrototype, () => {
+  const IteratorConstructor = function Iterator(this: Iterator<unknown>): Iterator<unknown> {
+    if (!isIteratorInstance(this)) throw new TypeError("Constructor Iterator requires 'new'");
+    if (Object.getPrototypeOf(this) === IteratorPrototype) throw new TypeError("Abstract class Iterator not directly constructable");
+    return this;
+  };
+  IteratorConstructor.prototype = IteratorPrototype;
+  polyfillProperty(IteratorPrototype, "constructor", { value: IteratorConstructor, enumerable: false });
+});
+export const IteratorConstructor = IteratorPrototype.constructor as never as (abstract new <T, TReturn = unknown, TNext = unknown>() => Iterator<
+  T,
+  TReturn,
+  TNext
+>) & {
+  from<T, TReturn = unknown, TNext = unknown>(it: Iterator<T, TReturn, TNext> | Iterable<T, TReturn, TNext>): IteratorObject<T, TReturn, TNext>;
+};

package/src/iterator-from.ts

@@ -0,0 +1,50 @@
+import { polyfillProperty } from "./base";
+import { IteratorConstructor } from "./iterator-constructor";
+import { IteratorPrototype } from "./iterator-prototype";
+import { isIterable, isIteratorInstance } from "./utils";
+
+const doneKey = Symbol.for("proxy-iterator-done");
+const targetKey = Symbol.for("proxy-iterator-target");
+
+type ProxyIterator<T, TReturn = unknown, TNext = unknown> = Iterator<T, TReturn, TNext> & {
+  [doneKey]: boolean;
+  readonly [targetKey]: Iterator<T, TReturn, TNext>;
+};
+
+function ProxyIterator<T, TReturn = unknown, TNext = unknown>(this: ProxyIterator<T, TReturn, TNext>, target: Iterator<T, TReturn, TNext>) {
+  this[doneKey] = false;
+  polyfillProperty(this, targetKey, { value: target, writable: false });
+}
+ProxyIterator.prototype = Object.create(IteratorPrototype, {
+  next: {
+    value: function proxyNext(this: ProxyIterator<unknown, unknown, unknown>, value: unknown) {
+      if (this[doneKey]) return { done: true, value: undefined };
+      return this[targetKey].next(value);
+    },
+  },
+  return: {
+    value: function proxyReturn(this: ProxyIterator<unknown, unknown, unknown>, value?: unknown) {
+      this[doneKey] = true;
+      if (!this[targetKey].return) return { value, done: true };
+      return this[targetKey].return?.(value);
+    },
+  },
+  throw: {
+    value: function proxyThrow(this: ProxyIterator<unknown, unknown, unknown>, error?: unknown) {
+      this[doneKey] = true;
+      if (!this[targetKey].throw) throw error;
+      return this[targetKey].throw(error);
+    },
+  },
+}) as ProxyIterator<unknown, unknown, unknown>;
+
+polyfillProperty(IteratorConstructor, "from", {
+  value: function from<T, TReturn = unknown, TNext = unknown>(it: Iterator<T, TReturn, TNext> | Iterable<T>): IteratorObject<T, TReturn, TNext> {
+    if (isIteratorInstance<T, TReturn, TNext>(it)) return it;
+    const iterator = isIterable(it) ? it[Symbol.iterator]() : it;
+    if (isIteratorInstance<T, TReturn, TNext>(iterator)) return iterator;
+    return Reflect.construct(ProxyIterator, [iterator]) as never;
+  },
+});
+
+export {};

package/src/iterator-prototype-drop.ts

@@ -0,0 +1,16 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "drop", {
+  value: function* drop<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>, limit: number): Generator<T, TReturn, TNext> {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return result.value;
+      if (index >= limit) yield result.value;
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-every.ts

@@ -0,0 +1,19 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "every", {
+  value: function every<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>, predicate: (value: T, index: number) => boolean): boolean {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return true;
+      if (!predicate(result.value, index)) {
+        this.return?.(undefined);
+        return false;
+      }
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-filter.ts

@@ -0,0 +1,21 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "filter", {
+  value: function* filter<T, TReturn, TNext>(
+    this: Iterator<T, TReturn, TNext>,
+    predicate: (value: T, index: number) => boolean,
+  ): Generator<T, TReturn, TNext> {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return result.value;
+      if (predicate(result.value, index)) {
+        yield result.value;
+      }
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-find.ts

@@ -0,0 +1,19 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "find", {
+  value: function find<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>, predicate: (value: T, index: number) => boolean): T | undefined {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return undefined;
+      if (predicate(result.value, index)) {
+        this.return?.(undefined);
+        return result.value;
+      }
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-flat-map.ts

@@ -0,0 +1,20 @@
+import { polyfillProperty } from "./base";
+import { IteratorConstructor } from "./iterator-constructor";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "flatMap", {
+  value: function* flatMap<T, TReturn, TNext, U>(
+    this: Iterator<T, TReturn, TNext>,
+    project: (value: T, index: number) => Iterator<U> | Iterable<U>,
+  ): Generator<U, TReturn, undefined> {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return result.value;
+      yield* IteratorConstructor.from(project(result.value, index));
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-for-each.ts

@@ -0,0 +1,16 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "forEach", {
+  value: function forEach<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>, callback: (value: T, index: number) => void): void {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return;
+      callback(result.value, index);
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-map.ts

@@ -0,0 +1,19 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "map", {
+  value: function* map<T, TReturn, TNext, U>(
+    this: Iterator<T, TReturn, TNext>,
+    project: (value: T, index: number) => U,
+  ): Generator<U, TReturn, TNext> {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return result.value;
+      yield project(result.value, index);
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-reduce.ts

@@ -0,0 +1,27 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "reduce", {
+  value: function reduce<T, TReturn, TNext, U>(
+    this: Iterator<T, TReturn, TNext>,
+    reducer: (aggregation: U, value: T, index: number) => U,
+    ...args: [initialValue?: U]
+  ): U {
+    let index = 0;
+    let aggregation: U = args[0] as never;
+    let initiated = args.length > 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return aggregation;
+      if (!initiated && args.length === 0) {
+        aggregation = result.value as never;
+        initiated = true;
+        continue;
+      }
+      aggregation = reducer(aggregation, result.value, index);
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-some.ts

@@ -0,0 +1,19 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "some", {
+  value: function some<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>, predicate: (value: T, index: number) => boolean): boolean {
+    let index = 0;
+    while (true) {
+      const result = this.next();
+      if (result.done) return false;
+      if (predicate(result.value, index)) {
+        this.return?.(undefined);
+        return true;
+      }
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-take.ts

@@ -0,0 +1,19 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "take", {
+  value: function* take<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>, limit: number): Generator<T, T | TReturn | undefined, TNext> {
+    let index = 0;
+    while (true) {
+      if (index >= limit) {
+        return this.return?.(undefined).value;
+      }
+      const result = this.next();
+      if (result.done) return result.value;
+      yield result.value;
+      index += 1;
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype-to-array.ts

@@ -0,0 +1,15 @@
+import { polyfillProperty } from "./base";
+import { IteratorPrototype } from "./iterator-prototype";
+
+polyfillProperty(IteratorPrototype, "toArray", {
+  value: function toArray<T, TReturn, TNext>(this: Iterator<T, TReturn, TNext>): T[] {
+    const items: T[] = [];
+    while (true) {
+      const result = this.next();
+      if (result.done) return items;
+      items.push(result.value);
+    }
+  },
+});
+
+export {};

package/src/iterator-prototype.ts

@@ -0,0 +1,14 @@
+import { polyfillProperty } from "./base";
+
+export const IteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())) as Iterator<unknown>;
+
+polyfillProperty(IteratorPrototype, Symbol.toStringTag, {
+  value: "Iterator",
+  writable: false,
+  enumerable: false,
+});
+polyfillProperty(IteratorPrototype, Symbol.iterator, {
+  value: function iterator() {
+    return this;
+  },
+});

package/src/utils.ts

@@ -0,0 +1,9 @@
+import { IteratorPrototype } from "./iterator-prototype";
+
+export function isIteratorInstance<T, TReturn = unknown, TNext = unknown>(value: object): value is IteratorObject<T, TReturn, TNext> {
+  return Object.prototype.isPrototypeOf.call(IteratorPrototype, value);
+}
+
+export function isIterable<T>(value: object): value is Iterable<T> {
+  return Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
+}