Upload folder using huggingface_hub (part 24)

.gitattributes

@@ -51,3 +51,4 @@ node_modules/@unrs/resolver-binding-linux-x64-musl/resolver.linux-x64-musl.node
 node_modules/bcrypt/prebuilds/win32-arm64/bcrypt.node filter=lfs diff=lfs merge=lfs -text
 node_modules/bcrypt/prebuilds/win32-x64/bcrypt.node filter=lfs diff=lfs merge=lfs -text
 node_modules/better-sqlite3/build/Release/better_sqlite3.node filter=lfs diff=lfs merge=lfs -text
+node_modules/esbuild/bin/esbuild filter=lfs diff=lfs merge=lfs -text

node_modules/es-iterator-helpers/index.json

@@ -0,0 +1,20 @@
+[
+	"Iterator",
+	"Iterator.concat",
+	"Iterator.from",
+	"Iterator.zip",
+	"Iterator.zipKeyed",
+	"Iterator.prototype",
+	"Iterator.prototype.constructor",
+	"Iterator.prototype.drop",
+	"Iterator.prototype.every",
+	"Iterator.prototype.filter",
+	"Iterator.prototype.find",
+	"Iterator.prototype.flatMap",
+	"Iterator.prototype.forEach",
+	"Iterator.prototype.map",
+	"Iterator.prototype.reduce",
+	"Iterator.prototype.some",
+	"Iterator.prototype.take",
+	"Iterator.prototype.toArray"
+]

node_modules/es-iterator-helpers/package.json

@@ -0,0 +1,206 @@
+{
+	"name": "es-iterator-helpers",
+	"version": "1.2.2",
+	"description": "An ESnext spec-compliant iterator helpers shim/polyfill/replacement that works as far down as ES3.",
+	"main": "index.json",
+	"exports": {
+		".": "./index.json",
+		"./auto": "./auto.js",
+		"./shim": "./shim.js",
+		"./Iterator": "./Iterator/index.js",
+		"./Iterator/auto": "./Iterator/auto.js",
+		"./Iterator/polyfill": "./Iterator/polyfill.js",
+		"./Iterator/implementation": "./Iterator/implementation.js",
+		"./Iterator/shim": "./Iterator/shim.js",
+		"./Iterator.prototype": "./Iterator.prototype/index.js",
+		"./Iterator.prototype/auto": "./Iterator.prototype/auto.js",
+		"./Iterator.prototype/polyfill": "./Iterator.prototype/polyfill.js",
+		"./Iterator.prototype/implementation": "./Iterator.prototype/implementation.js",
+		"./Iterator.prototype/shim": "./Iterator.prototype/shim.js",
+		"./Iterator.concat": "./Iterator.concat/index.js",
+		"./Iterator.concat/auto": "./Iterator.concat/auto.js",
+		"./Iterator.concat/polyfill": "./Iterator.concat/polyfill.js",
+		"./Iterator.concat/implementation": "./Iterator.concat/implementation.js",
+		"./Iterator.concat/shim": "./Iterator.concat/shim.js",
+		"./Iterator.from": "./Iterator.from/index.js",
+		"./Iterator.from/auto": "./Iterator.from/auto.js",
+		"./Iterator.from/polyfill": "./Iterator.from/polyfill.js",
+		"./Iterator.from/implementation": "./Iterator.from/implementation.js",
+		"./Iterator.from/shim": "./Iterator.from/shim.js",
+		"./Iterator.zip": "./Iterator.zip/index.js",
+		"./Iterator.zip/auto": "./Iterator.zip/auto.js",
+		"./Iterator.zip/polyfill": "./Iterator.zip/polyfill.js",
+		"./Iterator.zip/implementation": "./Iterator.zip/implementation.js",
+		"./Iterator.zip/shim": "./Iterator.zip/shim.js",
+		"./Iterator.zipKeyed": "./Iterator.zipKeyed/index.js",
+		"./Iterator.zipKeyed/auto": "./Iterator.zipKeyed/auto.js",
+		"./Iterator.zipKeyed/polyfill": "./Iterator.zipKeyed/polyfill.js",
+		"./Iterator.zipKeyed/implementation": "./Iterator.zipKeyed/implementation.js",
+		"./Iterator.zipKeyed/shim": "./Iterator.zipKeyed/shim.js",
+		"./Iterator.prototype.constructor": "./Iterator.prototype.constructor/index.js",
+		"./Iterator.prototype.constructor/auto": "./Iterator.prototype.constructor/auto.js",
+		"./Iterator.prototype.constructor/polyfill": "./Iterator.prototype.constructor/polyfill.js",
+		"./Iterator.prototype.constructor/implementation": "./Iterator.prototype.constructor/implementation.js",
+		"./Iterator.prototype.constructor/shim": "./Iterator.prototype.constructor/shim.js",
+		"./Iterator.prototype.map": "./Iterator.prototype.map/index.js",
+		"./Iterator.prototype.map/auto": "./Iterator.prototype.map/auto.js",
+		"./Iterator.prototype.map/polyfill": "./Iterator.prototype.map/polyfill.js",
+		"./Iterator.prototype.map/implementation": "./Iterator.prototype.map/implementation.js",
+		"./Iterator.prototype.map/shim": "./Iterator.prototype.map/shim.js",
+		"./Iterator.prototype.filter": "./Iterator.prototype.filter/index.js",
+		"./Iterator.prototype.filter/auto": "./Iterator.prototype.filter/auto.js",
+		"./Iterator.prototype.filter/polyfill": "./Iterator.prototype.filter/polyfill.js",
+		"./Iterator.prototype.filter/implementation": "./Iterator.prototype.filter/implementation.js",
+		"./Iterator.prototype.filter/shim": "./Iterator.prototype.filter/shim.js",
+		"./Iterator.prototype.take": "./Iterator.prototype.take/index.js",
+		"./Iterator.prototype.take/auto": "./Iterator.prototype.take/auto.js",
+		"./Iterator.prototype.take/polyfill": "./Iterator.prototype.take/polyfill.js",
+		"./Iterator.prototype.take/implementation": "./Iterator.prototype.take/implementation.js",
+		"./Iterator.prototype.take/shim": "./Iterator.prototype.take/shim.js",
+		"./Iterator.prototype.drop": "./Iterator.prototype.drop/index.js",
+		"./Iterator.prototype.drop/auto": "./Iterator.prototype.drop/auto.js",
+		"./Iterator.prototype.drop/polyfill": "./Iterator.prototype.drop/polyfill.js",
+		"./Iterator.prototype.drop/implementation": "./Iterator.prototype.drop/implementation.js",
+		"./Iterator.prototype.drop/shim": "./Iterator.prototype.drop/shim.js",
+		"./Iterator.prototype.flatMap": "./Iterator.prototype.flatMap/index.js",
+		"./Iterator.prototype.flatMap/auto": "./Iterator.prototype.flatMap/auto.js",
+		"./Iterator.prototype.flatMap/polyfill": "./Iterator.prototype.flatMap/polyfill.js",
+		"./Iterator.prototype.flatMap/implementation": "./Iterator.prototype.flatMap/implementation.js",
+		"./Iterator.prototype.flatMap/shim": "./Iterator.prototype.flatMap/shim.js",
+		"./Iterator.prototype.reduce": "./Iterator.prototype.reduce/index.js",
+		"./Iterator.prototype.reduce/auto": "./Iterator.prototype.reduce/auto.js",
+		"./Iterator.prototype.reduce/polyfill": "./Iterator.prototype.reduce/polyfill.js",
+		"./Iterator.prototype.reduce/implementation": "./Iterator.prototype.reduce/implementation.js",
+		"./Iterator.prototype.reduce/shim": "./Iterator.prototype.reduce/shim.js",
+		"./Iterator.prototype.toArray": "./Iterator.prototype.toArray/index.js",
+		"./Iterator.prototype.toArray/auto": "./Iterator.prototype.toArray/auto.js",
+		"./Iterator.prototype.toArray/polyfill": "./Iterator.prototype.toArray/polyfill.js",
+		"./Iterator.prototype.toArray/implementation": "./Iterator.prototype.toArray/implementation.js",
+		"./Iterator.prototype.toArray/shim": "./Iterator.prototype.toArray/shim.js",
+		"./Iterator.prototype.forEach": "./Iterator.prototype.forEach/index.js",
+		"./Iterator.prototype.forEach/auto": "./Iterator.prototype.forEach/auto.js",
+		"./Iterator.prototype.forEach/polyfill": "./Iterator.prototype.forEach/polyfill.js",
+		"./Iterator.prototype.forEach/implementation": "./Iterator.prototype.forEach/implementation.js",
+		"./Iterator.prototype.forEach/shim": "./Iterator.prototype.forEach/shim.js",
+		"./Iterator.prototype.some": "./Iterator.prototype.some/index.js",
+		"./Iterator.prototype.some/auto": "./Iterator.prototype.some/auto.js",
+		"./Iterator.prototype.some/polyfill": "./Iterator.prototype.some/polyfill.js",
+		"./Iterator.prototype.some/implementation": "./Iterator.prototype.some/implementation.js",
+		"./Iterator.prototype.some/shim": "./Iterator.prototype.some/shim.js",
+		"./Iterator.prototype.every": "./Iterator.prototype.every/index.js",
+		"./Iterator.prototype.every/auto": "./Iterator.prototype.every/auto.js",
+		"./Iterator.prototype.every/polyfill": "./Iterator.prototype.every/polyfill.js",
+		"./Iterator.prototype.every/implementation": "./Iterator.prototype.every/implementation.js",
+		"./Iterator.prototype.every/shim": "./Iterator.prototype.every/shim.js",
+		"./Iterator.prototype.find": "./Iterator.prototype.find/index.js",
+		"./Iterator.prototype.find/auto": "./Iterator.prototype.find/auto.js",
+		"./Iterator.prototype.find/polyfill": "./Iterator.prototype.find/polyfill.js",
+		"./Iterator.prototype.find/implementation": "./Iterator.prototype.find/implementation.js",
+		"./Iterator.prototype.find/shim": "./Iterator.prototype.find/shim.js",
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated",
+		"prepublishOnly": "safe-publish-latest",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prelint": "es-shim-api --type=multi --ignore-dirs=WrapForValidIteratorPrototype,IteratorHelperPrototype",
+		"lint": "eslint --ext=js,mjs .",
+		"postlint": "evalmd README.md",
+		"pretest": "npm run lint",
+		"test": "npm run tests-only",
+		"tests-only": "nyc tape 'test/**/*.js'",
+		"posttest": "npx npm@'>=10.2' audit --production",
+		"version": "auto-changelog && git add CHANGELOG.md",
+		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/es-shims/iterator-helpers.git"
+	},
+	"keywords": [
+		"javascript",
+		"ecmascript",
+		"polyfill",
+		"shim",
+		"es-shims",
+		"es-shim API",
+		"Iterator",
+		"helpers",
+		"from",
+		"map",
+		"filter",
+		"take",
+		"drop",
+		"flatMap",
+		"reduce",
+		"toArray",
+		"forEach",
+		"some",
+		"every",
+		"find"
+	],
+	"author": "Jordan Harband <ljharb@gmail.com>",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/es-shims/iterator-helpers/issues"
+	},
+	"homepage": "https://github.com/es-shims/iterator-helpers#readme",
+	"dependencies": {
+		"call-bind": "^1.0.8",
+		"call-bound": "^1.0.4",
+		"define-properties": "^1.2.1",
+		"es-abstract": "^1.24.1",
+		"es-errors": "^1.3.0",
+		"es-set-tostringtag": "^2.1.0",
+		"function-bind": "^1.1.2",
+		"get-intrinsic": "^1.3.0",
+		"globalthis": "^1.0.4",
+		"gopd": "^1.2.0",
+		"has-property-descriptors": "^1.0.2",
+		"has-proto": "^1.2.0",
+		"has-symbols": "^1.1.0",
+		"internal-slot": "^1.1.0",
+		"iterator.prototype": "^1.1.5",
+		"safe-array-concat": "^1.1.3"
+	},
+	"devDependencies": {
+		"@es-shims/api": "^3.0.3",
+		"@ljharb/eslint-config": "^22.1.2",
+		"auto-changelog": "^2.5.0",
+		"encoding": "^0.1.13",
+		"es-value-fixtures": "^1.7.1",
+		"eslint": "^9.39.2",
+		"eslint-plugin-import": "^2.32.0",
+		"evalmd": "^0.0.19",
+		"for-each": "^0.3.5",
+		"functions-have-names": "^1.2.3",
+		"has-strict-mode": "^1.1.0",
+		"has-tostringtag": "^1.0.2",
+		"in-publish": "^2.0.1",
+		"iterate-iterator": "^1.0.2",
+		"jiti": "^0.0.0",
+		"make-generator-function": "^2.1.0",
+		"mock-property": "^1.1.0",
+		"npmignore": "^0.3.2",
+		"nyc": "^10.3.2",
+		"object-inspect": "^1.13.4",
+		"safe-publish-latest": "^2.0.0",
+		"tape": "^5.9.0"
+	},
+	"auto-changelog": {
+		"output": "CHANGELOG.md",
+		"template": "keepachangelog",
+		"unreleased": false,
+		"commitLimit": false,
+		"backfillLimit": false,
+		"hideCredit": true
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows"
+		]
+	},
+	"engines": {
+		"node": ">= 0.4"
+	}
+}

node_modules/es-iterator-helpers/shim.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var shimIterator = require('./Iterator/shim');
+var shimIteratorFrom = require('./Iterator.from/shim');
+var shimIteratorConcat = require('./Iterator.concat/shim');
+var shimZip = require('./Iterator.zip/shim');
+var shimZipKeyed = require('./Iterator.zipKeyed/shim');
+var shimIteratorProto = require('./Iterator.prototype/shim');
+var shimIteratorCtor = require('./Iterator.prototype.constructor/shim');
+var shimIteratorDrop = require('./Iterator.prototype.drop/shim');
+var shimIteratorEvery = require('./Iterator.prototype.every/shim');
+var shimIteratorFilter = require('./Iterator.prototype.filter/shim');
+var shimIteratorFind = require('./Iterator.prototype.find/shim');
+var shimIteratorFlatMap = require('./Iterator.prototype.flatMap/shim');
+var shimIteratorForEach = require('./Iterator.prototype.forEach/shim');
+var shimIteratorMap = require('./Iterator.prototype.map/shim');
+var shimIteratorReduce = require('./Iterator.prototype.reduce/shim');
+var shimIteratorSome = require('./Iterator.prototype.some/shim');
+var shimIteratorTake = require('./Iterator.prototype.take/shim');
+var shimIteratorToArray = require('./Iterator.prototype.toArray/shim');
+
+module.exports = function shimIteratorHelpers() {
+	shimIterator();
+	shimIteratorProto();
+	shimIteratorFrom();
+	shimIteratorConcat();
+	shimZip();
+	shimZipKeyed();
+	shimIteratorCtor();
+	shimIteratorDrop();
+	shimIteratorEvery();
+	shimIteratorFilter();
+	shimIteratorFind();
+	shimIteratorFlatMap();
+	shimIteratorForEach();
+	shimIteratorMap();
+	shimIteratorReduce();
+	shimIteratorSome();
+	shimIteratorTake();
+	shimIteratorToArray();
+};

node_modules/es-iterator-helpers/test/Iterator.concat.js

@@ -0,0 +1,718 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var mockProperty = require('mock-property');
+var hasPropertyDescriptors = require('has-property-descriptors')();
+
+var index = require('../Iterator.concat');
+var impl = require('../Iterator.concat/implementation');
+var from = require('../Iterator.from/polyfill')();
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (concat, name, t) {
+		t['throws'](
+			function () { return new concat(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+		t['throws'](
+			function () { return new concat({}); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor, with an argument'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { concat(nonIterator); },
+				TypeError,
+				debug(nonIterator) + ' is not an iterable Object'
+			);
+		});
+
+		t.deepEqual(concat().next(), { value: undefined, done: true }, 'no arguments -> empty iterator');
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			forEach(v.nonFunctions, function (nonFunction) {
+				var badIterable = {};
+				badIterable[Symbol.iterator] = nonFunction;
+				st['throws'](
+					function () { concat([], badIterable, []); },
+					TypeError,
+					debug(badIterable) + '[Symbol.iterator] is not a function'
+				);
+			});
+
+			forEach(v.primitives, function (nonObject) {
+				var badIterable = {};
+				badIterable[Symbol.iterator] = function () { return nonObject; };
+				st['throws'](
+					function () { concat([], badIterable, []).next(); },
+					TypeError,
+					debug(badIterable) + '[Symbol.iterator] does not return an object'
+				);
+			});
+
+			forEach(v.strings, function (string) {
+				st['throws'](
+					function () { concat(string); },
+					TypeError,
+					'non-objects are not considered iterable'
+				);
+				var stringIt = concat(['a'], [string], ['c']);
+				testIterator(stringIt, ['a', string, 'c'], st, 'string iterator: ' + debug(string));
+			});
+
+			var arrayIt = concat([1, 2, 3]);
+			st.equal(typeof arrayIt.next, 'function', 'has a `next` function');
+
+			st.test('real iterators', { skip: !hasSymbols }, function (s2t) {
+				var iter = [1, 2][Symbol.iterator]();
+				testIterator(concat(iter, [3]), [1, 2, 3], s2t, 'array iterator + array yields combined results');
+
+				s2t.end();
+			});
+
+			st.test('observability in a replaced String iterator', function (s2t) {
+				var originalStringIterator = String.prototype[Symbol.iterator];
+				var observedType;
+				s2t.teardown(mockProperty(String.prototype, Symbol.iterator, {
+					get: function () {
+						'use strict'; // eslint-disable-line strict, lines-around-directive
+
+						observedType = typeof this;
+						return originalStringIterator;
+					}
+				}));
+
+				concat(from(''));
+				s2t.equal(observedType, 'string', 'string primitive -> primitive receiver in Symbol.iterator getter');
+				concat(from(Object('')));
+				s2t.equal(observedType, 'object', 'boxed string -> boxed string in Symbol.iterator getter');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/arguments-checked-in-order', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var getIterator = 0;
+
+				var iterable1 = {};
+				Object.defineProperty(iterable1, Symbol.iterator, {
+					get: function () {
+						getIterator += 1;
+						return function () {
+							throw new EvalError();
+						};
+					}
+				});
+
+				var iterable2 = {};
+				Object.defineProperty(iterable2, Symbol.iterator, {
+					get: function () {
+						throw new EvalError();
+					}
+				});
+
+				s2t.equal(getIterator, 0);
+
+				s2t['throws'](function () { concat(iterable1, null, iterable2); }, TypeError);
+
+				s2t.equal(getIterator, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/fresh-iterator-result', function (s2t) {
+				var oldIterResult = {
+					done: false,
+					value: 123
+				};
+
+				var testIterator1 = {
+					next: function () {
+						return oldIterResult;
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				var iterator = concat(iterable);
+
+				var iterResult = iterator.next();
+
+				s2t.equal(iterResult.done, false);
+				s2t.equal(iterResult.value, 123);
+
+				s2t.notEqual(iterResult, oldIterResult);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/get-iterator-method-only-once', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var iteratorGets = 0;
+				var iteratorCalls = 0;
+				var array = [1, 2, 3];
+
+				function CountingIterable() {}
+				Object.defineProperty(
+					CountingIterable.prototype,
+					Symbol.iterator,
+					{
+						get: function () {
+							iteratorGets += 1;
+
+							return function () {
+								iteratorCalls += 1;
+								return array[Symbol.iterator]();
+							};
+						}
+					}
+				);
+
+				var iterable = new CountingIterable();
+
+				s2t.equal(iteratorGets, 0);
+				s2t.equal(iteratorCalls, 0);
+
+				var iter = concat(iterable);
+
+				s2t.equal(iteratorGets, 1);
+				s2t.equal(iteratorCalls, 0);
+
+				testIterator(iter, array, s2t, 'iterating over the iterator calls the iterator function once');
+
+				s2t.equal(iteratorGets, 1);
+				s2t.equal(iteratorCalls, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/get-iterator-method-throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var iterable = {};
+				Object.defineProperty(iterable, Symbol.iterator, {
+					get: function () {
+						throw new EvalError();
+					}
+				});
+
+				s2t['throws'](function () { concat(iterable); }, EvalError);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/inner-iterator-created-in-order', function (s2t) {
+				var calledIterator = [];
+
+				var iterable1 = {};
+				iterable1[Symbol.iterator] = function () {
+					calledIterator.push('iterable1');
+					return [1][Symbol.iterator]();
+				};
+
+				var iterable2 = {};
+				iterable2[Symbol.iterator] = function () {
+					calledIterator.push('iterable2');
+					return [2][Symbol.iterator]();
+				};
+
+				var iterator = concat(iterable1, iterable2);
+
+				s2t.deepEqual(calledIterator, []);
+
+				s2t.deepEqual(iterator.next(), { done: false, value: 1 });
+
+				s2t.deepEqual(calledIterator, ['iterable1']);
+
+				s2t.deepEqual(iterator.next(), { done: false, value: 2 });
+
+				s2t.deepEqual(calledIterator, ['iterable1', 'iterable2']);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/next-method-called-with-zero-arguments', function (s2t) {
+				var nextCalled = 0;
+
+				var testIterator1 = {
+					next: function () {
+						nextCalled += 1;
+						s2t.equal(arguments.length, 0);
+
+						return {
+							done: false,
+							value: 0
+						};
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				var iterator = concat(iterable);
+				s2t.equal(nextCalled, 0);
+
+				iterator.next();
+				s2t.equal(nextCalled, 1);
+
+				iterator.next(1);
+				s2t.equal(nextCalled, 2);
+
+				iterator.next(1, 2);
+				s2t.equal(nextCalled, 3);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/next-method-returns-non-object', function (s2t) {
+				var nonObjectIterator = {
+					next: function () {
+						return null;
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return nonObjectIterator;
+				};
+
+				var iterator = concat(iterable);
+
+				s2t['throws'](function () { iterator.next(); }, TypeError);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/next-method-returns-throwing-done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { done: null, value: 1 };
+						Object.defineProperty(result, 'done', {
+							get: function () {
+								throw new EvalError();
+							}
+						});
+						return result;
+					},
+					'return': function () {
+						throw new Error();
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return throwingIterator;
+				};
+
+				var iterator = concat(iterable);
+
+				s2t['throws'](function () { iterator.next(); }, EvalError);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/next-method-returns-throwing-value-done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				function ReturnCalledError() {}
+				function ValueGetterError() {}
+
+				var throwingIterator = {
+					next: function () {
+						var result = { value: null, done: true };
+						Object.defineProperty(result, 'value', {
+							get: function () {
+								throw new ValueGetterError();
+							}
+						});
+						return result;
+					},
+					'return': function () {
+						throw new ReturnCalledError();
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return throwingIterator;
+				};
+
+				var iterator = concat(iterable);
+
+				var iterResult = iterator.next();
+
+				s2t.equal(iterResult.done, true);
+				s2t.equal(iterResult.value, undefined);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/next-method-returns-throwing-value', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { value: null, done: false };
+						Object.defineProperty(result, 'value', {
+							get: function () {
+								throw new EvalError();
+							}
+						});
+						return result;
+					},
+					'return': function () {
+						throw new Error();
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return throwingIterator;
+				};
+
+				var iterator = concat(iterable);
+
+				s2t['throws'](function () { iterator.next(); }, EvalError);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/next-method-throws', function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						throw new EvalError();
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return throwingIterator;
+				};
+
+				var iterator = concat(iterable);
+
+				s2t['throws'](function () { iterator.next(); }, EvalError);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/return-is-not-forwarded-after-exhaustion', function (s2t) {
+				var testIterator1 = {
+					next: function () {
+						return {
+							done: true,
+							value: undefined
+						};
+					},
+					'return': function () {
+						throw new EvalError();
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				var iterator = concat(iterable);
+				iterator.next();
+				iterator['return']();
+
+				s2t.end();
+			});
+
+			t.test('test262: test/built-ins/Iterator/concat/return-is-not-forwarded-before-initial-start', function (s2t) {
+				var testIterator1 = {
+					next: function () {
+						return {
+							done: false,
+							value: 1
+						};
+					},
+					'return': function () {
+						throw new EvalError();
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				var iterator = concat(iterable);
+				iterator['return']();
+				iterator.next();
+				iterator['return']();
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/return-method-called-with-zero-arguments', function (s2t) {
+				var returnCalled = 0;
+
+				var testIterator1 = {
+					next: function () {
+						return { done: false };
+					},
+					'return': function () {
+						returnCalled += 1;
+						s2t.equal(arguments.length, 0);
+						return { done: true };
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				var iterator;
+
+				// Call with zero arguments.
+				iterator = concat(iterable);
+				iterator.next();
+				s2t.equal(returnCalled, 0);
+
+				iterator['return']();
+				s2t.equal(returnCalled, 1);
+
+				// Call with one argument.
+				iterator = concat(iterable);
+				iterator.next();
+				s2t.equal(returnCalled, 1);
+
+				iterator['return'](1);
+				s2t.equal(returnCalled, 2);
+
+				// Call with two arguments.
+				iterator = concat(iterable);
+				iterator.next();
+				s2t.equal(returnCalled, 2);
+
+				iterator['return'](1, 2);
+				s2t.equal(returnCalled, 3);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/throws-typeerror-when-generator-is-running-next', function (s2t) {
+				var enterCount = 0;
+
+				var iterator;
+
+				var testIterator1 = {
+					next: function () {
+						enterCount += 1;
+						iterator.next();
+						return { done: false };
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				iterator = concat(iterable);
+
+				s2t.equal(enterCount, 0);
+
+				s2t['throws'](function () { iterator.next(); }, TypeError);
+
+				s2t.equal(enterCount, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/result-is-iterator', function (s2t) {
+				var iter = concat();
+				s2t.equal(typeof iter.next, 'function', 'concat() result has next method');
+				s2t.equal(typeof iter[Symbol.iterator], 'function', 'concat() result has Symbol.iterator');
+				s2t.equal(iter[Symbol.iterator](), iter, 'concat() result Symbol.iterator returns itself');
+
+				var customIter = { next: function () { return { done: true, value: undefined }; } };
+				var iterable = {};
+				iterable[Symbol.iterator] = function () { return customIter; };
+				iter = concat(iterable);
+				s2t.equal(typeof iter.next, 'function', 'concat(iterable) result has next method');
+				s2t.equal(typeof iter[Symbol.iterator], 'function', 'concat(iterable) result has Symbol.iterator');
+				s2t.equal(iter[Symbol.iterator](), iter, 'concat(iterable) result Symbol.iterator returns itself');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/single-argument', function (s2t) {
+				var array = [1, 2, 3];
+				var iterator = concat(array);
+
+				for (var i = 0; i < array.length; i += 1) {
+					var iterResult = iterator.next();
+					s2t.equal(iterResult.done, false, 'not done at index ' + i);
+					s2t.equal(iterResult.value, array[i], 'correct value at index ' + i);
+				}
+
+				var finalResult = iterator.next();
+				s2t.equal(finalResult.done, true, 'done after all values');
+				s2t.equal(finalResult.value, undefined, 'value is undefined when done');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/many-arguments', function (s2t) {
+				var iterables = [
+					[],
+					[1],
+					[2, 3],
+					[4, 5, 6],
+					[7, 8, 9, 10]
+				];
+
+				var iterator = concat(iterables[0], iterables[1], iterables[2], iterables[3], iterables[4]);
+
+				var expected = [].concat(iterables[0], iterables[1], iterables[2], iterables[3], iterables[4]);
+
+				for (var i = 0; i < expected.length; i += 1) {
+					var iterResult = iterator.next();
+					s2t.equal(iterResult.done, false, 'not done at index ' + i);
+					s2t.equal(iterResult.value, expected[i], 'correct value at index ' + i);
+				}
+
+				var finalResult = iterator.next();
+				s2t.equal(finalResult.done, true, 'done after all values');
+				s2t.equal(finalResult.value, undefined, 'value is undefined when done');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/zero-arguments', function (s2t) {
+				var iterator = concat();
+
+				var iterResult = iterator.next();
+				s2t.equal(iterResult.done, true, 'done immediately with zero arguments');
+				s2t.equal(iterResult.value, undefined, 'value is undefined');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/return-is-forwarded', function (s2t) {
+				var returnCount = 0;
+
+				var testIterator1 = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCount += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return testIterator1;
+				};
+
+				var iterator = concat(iterable);
+
+				s2t.equal(returnCount, 0, 'return not called before next()');
+
+				iterator.next();
+
+				s2t.equal(returnCount, 0, 'return not called after next()');
+
+				iterator['return']();
+
+				s2t.equal(returnCount, 1, 'return called once after iterator.return()');
+
+				// Subsequent return() calls should not forward again
+				iterator['return']();
+
+				s2t.equal(returnCount, 1, 'return not called again on subsequent return()');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/concat/throws-typeerror-when-generator-is-running-return', function (s2t) {
+				var enterCount = 0;
+				var iterator;
+
+				var reentrantTestIterator = {
+					next: function () {
+						return { done: false };
+					},
+					'return': function () {
+						enterCount += 1;
+						iterator['return'](); // re-entrant call
+						return { done: false };
+					}
+				};
+
+				var iterable = {};
+				iterable[Symbol.iterator] = function () {
+					return reentrantTestIterator;
+				};
+
+				iterator = concat(iterable);
+
+				iterator.next();
+
+				s2t.equal(enterCount, 0, 'return not entered before calling return()');
+
+				s2t['throws'](
+					function () { iterator['return'](); },
+					TypeError,
+					'throws TypeError when generator is running during return()'
+				);
+
+				s2t.equal(enterCount, 1, 'return entered exactly once before throwing');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.concat: index', function (t) {
+			module.exports.tests(index, 'Iterator.concat', t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.concat: implementation', function (t) {
+			module.exports.tests(impl, 'Iterator.concat', t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.concat: shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.concat.name, 'concat', 'Iterator.concat has name "concat"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator, 'concat'), 'Iterator.concat is not enumerable');
+				et.end();
+			});
+
+			t.equal(Iterator.concat.length, 0, 'Iterator.concat has length 0');
+
+			module.exports.tests(callBind(Iterator.concat, Iterator), 'Iterator.concat', t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.from.js

@@ -0,0 +1,322 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasProto = require('has-proto')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var mockProperty = require('mock-property');
+
+var index = require('../Iterator.from');
+var impl = require('../Iterator.from/implementation');
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+var $Iterator = require('../Iterator/implementation');
+var iterProto = require('iterator.prototype');
+
+var getCodePoints = function getCodePoints(str) {
+	var chars = [];
+	for (var i = 0; i < str.length; i++) {
+		var c1 = str.charCodeAt(i);
+		if (c1 >= 0xD800 && c1 < 0xDC00 && i + 1 < str.length) {
+			var c2 = str.charCodeAt(i + 1);
+			if (c2 >= 0xDC00 && c2 < 0xE000) {
+				chars.push(str.charAt(i) + str.charAt(i + 1));
+				i += 1;
+				continue; // eslint-disable-line no-continue, no-restricted-syntax
+			}
+		}
+		chars.push(str.charAt(i));
+	}
+	return chars;
+};
+
+module.exports = {
+	tests: function (from, name, t) {
+		t['throws'](
+			function () { return new from(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+		t['throws'](
+			function () { return new from({}); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor, with an argument'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			if (typeof nonIterator !== 'string') {
+				t['throws'](
+					function () { from(nonIterator).next(); },
+					TypeError,
+					debug(nonIterator) + ' is not an iterable Object'
+				);
+			}
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			forEach(v.nonFunctions, function (nonFunction) {
+				var badIterable = {};
+				badIterable[Symbol.iterator] = nonFunction;
+				st['throws'](
+					function () { from(badIterable).next(); },
+					TypeError,
+					debug(badIterable) + ' is not a function'
+				);
+			});
+
+			// st['throws'](
+			// 	function () { return new from([]); }, // eslint-disable-line new-cap
+			// 	RangeError,
+			// 	'`' + name + '` iterator is not a constructor'
+			// );
+
+			forEach(v.strings, function (string) {
+				var stringIt = from(string);
+				testIterator(stringIt, getCodePoints(string), st, 'string iterator: ' + debug(string));
+			});
+
+			var arrayIt = from([1, 2, 3]);
+			st.equal(typeof arrayIt.next, 'function', 'has a `next` function');
+
+			st.test('__proto__ is Iterator.prototype', { skip: !hasProto }, function (s2t) {
+				var fakeIterator = {
+					__proto__: iterProto,
+					next: function () {}
+				};
+				s2t.ok(fakeIterator instanceof $Iterator, 'is an instanceof Iterator');
+				s2t.equal(typeof fakeIterator.next, 'function', 'fake iterator `.next` is a function');
+				s2t.equal(from(fakeIterator), fakeIterator, 'returns input when it is an instanceof Iterator');
+
+				s2t.end();
+			});
+
+			st.test('real iterators', { skip: !hasSymbols }, function (s2t) {
+				var iter = [][Symbol.iterator]();
+				// eslint-disable-next-line no-proto
+				var arrayIterHasIterProto = hasProto && iter.__proto__.__proto__ !== Object.prototype;
+				s2t.equal(
+					from(iter),
+					iter,
+					'array iterator becomes itself',
+					{ skip: !arrayIterHasIterProto && 'node 0.12 - 3 do not have Iterator.prototype in the proto chains' }
+				);
+
+				s2t.end();
+			});
+
+			st.test('observability in a replaced String iterator', function (s2t) {
+				var originalStringIterator = String.prototype[Symbol.iterator];
+				var observedType;
+				s2t.teardown(mockProperty(String.prototype, Symbol.iterator, {
+					get: function () {
+						'use strict'; // eslint-disable-line strict, lines-around-directive
+
+						observedType = typeof this;
+						return originalStringIterator;
+					}
+				}));
+
+				from('');
+				s2t.equal(observedType, 'string', 'string primitive -> primitive receiver in Symbol.iterator getter');
+				from(Object(''));
+				s2t.equal(observedType, 'object', 'boxed string -> boxed string in Symbol.iterator getter');
+
+				s2t.end();
+			});
+
+			st.test('262: get-next-method-only-once', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var nextGets = 0;
+				var testIter = {
+					next: function () {
+						return { done: true, value: undefined };
+					}
+				};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						nextGets += 1;
+						return function () {
+							return { done: true, value: undefined };
+						};
+					}
+				});
+
+				var iter = from(testIter);
+				s2t.equal(nextGets, 1, 'next retrieved once on creation');
+				iter.next();
+				s2t.equal(nextGets, 1, 'next not retrieved again on next()');
+				iter.next();
+				s2t.equal(nextGets, 1, 'next still not retrieved again');
+
+				s2t.end();
+			});
+
+			st.test('262: get-next-method-throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						throw new EvalError('next getter threw');
+					}
+				});
+
+				s2t['throws'](
+					function () { from(testIter); },
+					EvalError,
+					'throws when getting next throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: iterable-to-iterator-fallback', function (s2t) {
+				// When Symbol.iterator is null/undefined, treat object as iterator
+				var iteratorObj = {
+					next: function () {
+						return { done: true, value: undefined };
+					}
+				};
+				iteratorObj[Symbol.iterator] = null;
+				var iter1 = from(iteratorObj);
+				s2t.equal(typeof iter1.next, 'function', 'iterator with null Symbol.iterator is treated as iterator');
+
+				var iteratorObj2 = {
+					next: function () {
+						return { done: true, value: undefined };
+					}
+				};
+				iteratorObj2[Symbol.iterator] = undefined;
+				var iter2 = from(iteratorObj2);
+				s2t.equal(typeof iter2.next, 'function', 'iterator with undefined Symbol.iterator is treated as iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: return-is-forwarded', function (s2t) {
+				var returnCalls = 0;
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = from(testIter);
+				iter.next();
+				s2t.equal(returnCalls, 0, 'return not called before calling return()');
+				iter['return']();
+				s2t.equal(returnCalls, 1, 'return called once after return()');
+
+				s2t.end();
+			});
+
+			st.test('262: return-method-returns-iterator-result', function (s2t) {
+				// When base iterator has no return method, wrapper's return() returns { done: true, value: undefined }
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					}
+				};
+
+				var iter = from(testIter);
+				iter.next();
+				var result = iter['return']();
+				s2t.equal(result.done, true, 'done is true');
+				s2t.equal(result.value, undefined, 'value is undefined');
+
+				s2t.end();
+			});
+
+			st.test('262: get-return-method-throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					}
+				};
+				Object.defineProperty(testIter, 'return', {
+					get: function () {
+						throw new SyntaxError('return getter threw');
+					}
+				});
+
+				var iter = from(testIter);
+				iter.next();
+				s2t['throws'](
+					function () { iter['return'](); },
+					SyntaxError,
+					'throws when getting return throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: supports-iterator', function (s2t) {
+				// Non-iterable iterator objects (no Symbol.iterator, but has next)
+				var plainIterator = {
+					next: function () {
+						return { done: true, value: 42 };
+					}
+				};
+
+				var iter = from(plainIterator);
+				s2t.equal(typeof iter.next, 'function', 'wrapped iterator has next method');
+				var result = iter.next();
+				s2t.equal(result.done, true, 'done is true');
+				s2t.equal(result.value, 42, 'value is passed through');
+
+				s2t.end();
+			});
+
+			st.test('262: supports-iterable', function (s2t) {
+				// Iterable objects work
+				var arr = [1, 2, 3];
+				testIterator(from(arr), [1, 2, 3], s2t, 'array iterable');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.from: index', function (t) {
+			module.exports.tests(index, 'Iterator.from', t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.from: implementation', function (t) {
+			module.exports.tests(impl, 'Iterator.from', t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.from: shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.from.name, 'from', 'Iterator.from has name "from"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator, 'from'), 'Iterator.from is not enumerable');
+				et.end();
+			});
+
+			module.exports.tests(callBind(Iterator.from, Iterator), 'Iterator.from', t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.js

@@ -0,0 +1,95 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var functionsHaveNames = require('functions-have-names')();
+
+var index = require('../Iterator');
+var impl = require('../Iterator/implementation');
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = {
+	tests: function (Iter, name, t) {
+		t.equal(typeof Iter, 'function', name + ' is a function');
+
+		t['throws'](
+			function () { Iter(); }, // eslint-disable-line new-cap
+			TypeError,
+			name + ' throws when Call-ed'
+		);
+
+		t['throws'](
+			function () { return new Iter(); },
+			TypeError,
+			name + ' throws when Construct-ed'
+		);
+
+		var SubIter;
+		var SubSubIter;
+		try {
+			/* eslint no-new-func: 0 */
+			SubIter = Function('Iter', 'return class SubIter extends Iter {};')(Iter);
+			SubSubIter = Function('SubIter', 'return class SubSubIter extends SubIter {};')(SubIter);
+		} catch (e) { /**/ }
+
+		t.test('class inheritance', { skip: !SubIter }, function (st) {
+			st.doesNotThrow(
+				function () { return new SubIter(); },
+				'Extending ' + name + ' does not throw when Construct-ed'
+			);
+			st.doesNotThrow(
+				function () { return new SubSubIter(); },
+				'Extending ' + name + ' twice does not throw when Construct-ed'
+			);
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator: index', function (t) {
+			module.exports.tests(index, 'Iterator', t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator: implementation', function (t) {
+			module.exports.tests(impl, 'Iterator', t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator: shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.name, 'Iterator', 'Iterator has name "Iterator"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(global, Iterator), 'Iterator is not enumerable');
+				et.end();
+			});
+
+			t.test('prototype descriptor', { skip: !defineProperties.supportsDescriptors }, function (pt) {
+				var desc = Object.getOwnPropertyDescriptor(Iterator, 'prototype');
+				pt.deepEqual(
+					desc,
+					{
+						configurable: false,
+						enumerable: false,
+						value: Iterator.prototype,
+						writable: false
+					}
+				);
+
+				pt.end();
+			});
+
+			module.exports.tests(Iterator, 'Iterator', t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.constructor.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+
+var Index = require('../Iterator.prototype.constructor');
+var Impl = require('../Iterator.prototype.constructor/implementation');
+
+var $Iterator = require('../Iterator/polyfill')();
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = {
+	tests: function (t, constructor, name) {
+		t.equal(constructor, $Iterator, name + ' is Iterator');
+	},
+	index: function () {
+		test('Iterator.prototype.constructor: index', function (t) {
+			t.notEqual(Index, $Iterator, 'index is not Iterator itself');
+			t.equal(typeof Index, 'function', 'index is a function');
+
+			t['throws'](
+				function () { Index(); }, // eslint-disable-line new-cap
+				TypeError,
+				'index throws when Call-ed'
+			);
+
+			t['throws'](
+				function () { return new Index(); },
+				TypeError,
+				'index throws when Construct-ed'
+			);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.constructor: implementation', function (t) {
+			t.equal(Impl, $Iterator, 'implementation is Iterator itself');
+			module.exports.tests(t, Impl, 'Iterator.prototype.constructor');
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.constructor: shimmed', function (t) {
+			module.exports.tests(t, Iterator.prototype.constructor, 'Iterator.prototype.constructor');
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, 'constructor'), 'Iterator#constructor is not enumerable');
+				et.end();
+			});
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.drop.js

@@ -0,0 +1,458 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.drop');
+var impl = require('../Iterator.prototype.drop/implementation');
+
+var fnName = 'drop';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (drop, name, t) {
+		t['throws'](
+			function () { return new drop(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(drop(nonIterator, 0)); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(drop(badNext, 0)); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		t.test('observable lookups', { skip: !hasPropertyDescriptors }, function (st) {
+			var effects = [];
+
+			var obj = {};
+			Object.defineProperty(obj, 'next', {
+				configurable: true,
+				enumerable: true,
+				get: function next() {
+					effects.push('get next');
+					return function () {
+						return { done: true, value: undefined };
+					};
+				}
+			});
+			drop(obj, {
+				valueOf: function valueOf() {
+					effects.push('ToNumber limit');
+					return 0;
+				}
+			});
+
+			st.deepEqual(effects, [
+				'ToNumber limit',
+				'get next'
+			]);
+			st.end();
+		});
+
+		var arr = [1, 2, 3];
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { drop(iterator(), -3); },
+				RangeError,
+				'-3 is not >= 0'
+			);
+
+			st['throws'](
+				function () { return new drop(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new drop(iterator(), 0); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			testIterator(drop(iterator(), 0), [1, 2, 3], st, 'drop 0');
+			testIterator(drop(iterator(), 1), [2, 3], st, 'drop 1');
+			testIterator(drop(iterator(), 2), [3], st, 'drop 2');
+			testIterator(drop(iterator(), 3), [], st, 'drop 3');
+			testIterator(drop(iterator(), Infinity), [], st, 'drop ∞');
+
+			st.test('262: limit-tonumber', function (s2t) {
+				// ToNumber coercion
+				testIterator(drop(iterator(), '1'), [2, 3], s2t, 'string "1" coerced to 1');
+				testIterator(drop(iterator(), 1.9), [2, 3], s2t, '1.9 truncated to 1');
+				testIterator(drop(iterator(), { valueOf: function () { return 1; } }), [2, 3], s2t, 'object with valueOf');
+				testIterator(drop(iterator(), true), [2, 3], s2t, 'true coerced to 1');
+				testIterator(drop(iterator(), null), [1, 2, 3], s2t, 'null coerced to 0');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-tonumber-throws', function (s2t) {
+				s2t['throws'](
+					function () { drop(iterator(), { valueOf: function () { throw new EvalError('valueOf threw'); } }); },
+					EvalError,
+					'throws when valueOf throws'
+				);
+
+				s2t['throws'](
+					function () { drop(iterator(), Symbol('test')); },
+					TypeError,
+					'throws when limit is a Symbol'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: limit-rangeerror', function (s2t) {
+				s2t['throws'](function () { drop(iterator(), -1); }, RangeError, '-1 throws RangeError');
+				s2t['throws'](function () { drop(iterator(), -Infinity); }, RangeError, '-Infinity throws RangeError');
+				s2t['throws'](function () { drop(iterator(), NaN); }, RangeError, 'NaN throws RangeError');
+
+				s2t.end();
+			});
+
+			st.test('262: result is iterator', function (s2t) {
+				var iter = drop(iterator(), 1);
+				s2t.equal(typeof iter.next, 'function', 'has next method');
+				s2t.equal(typeof iter[Symbol.iterator], 'function', 'has Symbol.iterator method');
+				s2t.equal(iter[Symbol.iterator](), iter, 'Symbol.iterator returns itself');
+
+				s2t.end();
+			});
+
+			st.test('262: get next method only once', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var nextGets = 0;
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						nextGets += 1;
+						return function () {
+							return { done: true, value: undefined };
+						};
+					}
+				});
+
+				var iter = drop(testIter, 1);
+				s2t.equal(nextGets, 1, 'next retrieved once on creation');
+				iter.next();
+				s2t.equal(nextGets, 1, 'next not retrieved again');
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns non-object throws', function (s2t) {
+				var badIterator = {
+					next: function () {
+						return null;
+					}
+				};
+
+				var iter = drop(badIterator, 1);
+				s2t['throws'](function () { iter.next(); }, TypeError, 'throws when next returns null');
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns throwing done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { value: 1 };
+						Object.defineProperty(result, 'done', {
+							get: function () {
+								throw new EvalError('done getter threw');
+							}
+						});
+						return result;
+					}
+				};
+
+				var iter = drop(throwingIterator, 1);
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws when done getter throws');
+
+				s2t.end();
+			});
+
+			st.test('262: next method throws', function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						throw new EvalError('next threw');
+					}
+				};
+
+				var iter = drop(throwingIterator, 1);
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws error from next');
+
+				s2t.end();
+			});
+
+			st.test('262: throws TypeError when generator is running', function (s2t) {
+				var reentrantIterator;
+				var testIter = {
+					next: function () {
+						reentrantIterator.next();
+						return { done: false, value: 1 };
+					}
+				};
+
+				reentrantIterator = drop(testIter, 0);
+				s2t['throws'](function () { reentrantIterator.next(); }, TypeError, 'throws on reentrant next()');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-equals-total', function (s2t) {
+				testIterator(drop(iterator(), 3), [], s2t, 'drop exactly 3 from 3-item iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-greater-than-total', function (s2t) {
+				testIterator(drop(iterator(), 5), [], s2t, 'drop 5 from 3-item iterator');
+				testIterator(drop(iterator(), 100), [], s2t, 'drop 100 from 3-item iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-less-than-total', function (s2t) {
+				testIterator(drop(iterator(), 1), [2, 3], s2t, 'drop 1 from 3-item iterator');
+				testIterator(drop(iterator(), 2), [3], s2t, 'drop 2 from 3-item iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: exhaustion does not call return', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = drop(testIter, 1);
+				iter.next();
+				s2t.equal(returnCalls, 0, 'return not called on exhaustion');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/drop/get-return-method-throws', { skip: !hasPropertyDescriptors }, function (st) {
+			var badIterator = {
+				next: function next() {
+					return {
+						done: false,
+						value: 1
+					};
+				}
+			};
+
+			Object.defineProperty(badIterator, 'return', {
+				configurable: true,
+				enumerable: true,
+				get: function () { throw new SyntaxError(); }
+			});
+
+			var iter = drop(badIterator, 1);
+			iter.next();
+
+			st['throws'](
+				function () { iter['return'](); },
+				SyntaxError,
+				'gets the `return` method, whose getter throws'
+			);
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/drop/return-is-forwarded', function (st) {
+			var returnCount = 0;
+
+			var makeBadIterator = function makeBadIterator() {
+				return {
+					next: function next() {
+						return {
+							done: false,
+							value: 1
+						};
+					},
+					'return': function () {
+						returnCount += 1;
+						return {};
+					}
+				};
+			};
+
+			var iter1 = drop(makeBadIterator(), 0);
+			st.equal(returnCount, 0, 'iter1, before return()');
+			iter1['return']();
+			st.equal(returnCount, 1, 'iter1, after return()'); // TODO
+
+			var iter2 = drop(makeBadIterator(), 1);
+			st.equal(returnCount, 1, 'iter2, before return()'); // TODO
+			iter2['return']();
+			st.equal(returnCount, 2, 'iter2, after return()'); // TODO
+
+			// 5 drops (i wish i had pipeline)
+			var iter3 = drop(
+				drop(
+					drop(
+						drop(
+							drop(
+								makeBadIterator(),
+								1
+							),
+							1
+						),
+						1
+					),
+					1
+				),
+				1
+			);
+			st.equal(returnCount, 2, 'iter3, before return()'); // TODO
+			iter3['return']();
+			st.equal(returnCount, 3, 'iter3, after return()'); // TODO
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/drop/return-is-not-forwarded-after-exhaustion', { skip: !hasPropertyDescriptors }, function (st) {
+			var makeBadIterator = function makeBadIterator() {
+				return {
+					next: function next() {
+						return {
+							done: true,
+							value: undefined
+						};
+					},
+					'return': function () {
+						throw new SyntaxError();
+					}
+				};
+			};
+
+			var iter1 = drop(makeBadIterator(), 0); // TODO
+			st['throws'](
+				function () { iter1['return'](); },
+				SyntaxError,
+				'iter1, return() throws'
+			);
+			iter1.next();
+			iter1['return']();
+
+			var iter2 = drop(makeBadIterator(), 1);
+			st['throws'](
+				function () { iter2['return'](); },
+				SyntaxError,
+				'iter2, return() throws'
+			);
+			iter2.next();
+			iter2['return']();
+
+			// 5 drops (i wish i had pipeline)
+			var iter3 = drop(
+				drop(
+					drop(
+						drop(
+							drop(
+								makeBadIterator(),
+								1
+							),
+							1
+						),
+						1
+					),
+					1
+				),
+				1
+			);
+			st['throws'](
+				function () { iter3['return'](); },
+				SyntaxError,
+				'iter3, return() throws'
+			);
+			iter3.next();
+			iter3['return']();
+
+			var iter4 = drop(makeBadIterator(), 10);
+			st['throws'](
+				function () { iter4['return'](); },
+				SyntaxError,
+				'iter4, return() throws'
+			);
+			iter4.next();
+			iter4['return']();
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.every.js

@@ -0,0 +1,289 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.every');
+var impl = require('../Iterator.prototype.every/implementation');
+
+var fnName = 'every';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (every, name, t) {
+		t['throws'](
+			function () { return new every(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(every(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(every(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { every({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('observable lookups', { skip: !hasPropertyDescriptors }, function (st) {
+			var effects = [];
+
+			var obj = {};
+			Object.defineProperty(obj, 'next', {
+				configurable: true,
+				enumerable: true,
+				get: function next() {
+					effects.push('get next');
+					return function () {
+						return { done: true, value: undefined };
+					};
+				}
+			});
+
+			st['throws'](
+				function () { every(obj, null); },
+				TypeError
+			);
+
+			st.deepEqual(effects, []);
+
+			st.end();
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new every(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new every(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			st.equal(every(iterator(), function () { return false; }), false, 'every for always-false');
+			st.equal(every(iterator(), function () { return true; }), true, 'every for always-true');
+			st.equal(every(iterator(), function (x, i) { return x === 2 && i === 1; }), false, 'every returns false for matching value/index');
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-args', function (s2t) {
+				var assertionCount = 0;
+				var result = every(
+					['a', 'b', 'c'][Symbol.iterator](),
+					function (value, count) {
+						if (value === 'a') {
+							s2t.equal(count, 0);
+						} else if (value === 'b') {
+							s2t.equal(count, 1);
+						} else if (value === 'c') {
+							s2t.equal(count, 2);
+						} else {
+							s2t.fail('unexpected value');
+						}
+						assertionCount += 1;
+						return true;
+					}
+				);
+				s2t.equal(result, true, 'every returns true when all pass');
+				s2t.equal(assertionCount, 3, 'predicate called three times');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-this', function (s2t) {
+				var expectedThis = (function () { return this; }()); // eslint-disable-line no-invalid-this
+				var assertionCount = 0;
+				var result = every(
+					[0][Symbol.iterator](),
+					function () {
+						s2t.equal(this, expectedThis, 'predicate this is undefined'); // eslint-disable-line no-invalid-this
+						assertionCount += 1;
+						return true;
+					}
+				);
+				s2t.equal(result, true);
+				s2t.equal(assertionCount, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-returns-truthy', function (s2t) {
+				var result = every(
+					[0, 1, 2, 3, 4][Symbol.iterator](),
+					function () { return true; }
+				);
+				s2t.equal(result, true, 'every returns true when predicate always returns truthy');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-returns-falsey', function (s2t) {
+				var result = every(
+					[0, 1, 2, 3, 4][Symbol.iterator](),
+					function () { return false; }
+				);
+				s2t.equal(result, false, 'every returns false when predicate returns falsey');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-returns-truthy-then-falsey', function (s2t) {
+				var callCount = 0;
+				var returnCalled = false;
+				var values = [0, 1, 2, 3, 4];
+				var idx = 0;
+				var iter = {
+					next: function () {
+						if (idx < values.length) {
+							var val = values[idx];
+							idx += 1;
+							return { done: false, value: val };
+						}
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalled = true;
+						return { done: true, value: undefined };
+					}
+				};
+				var result = every(
+					iter,
+					function (value) {
+						callCount += 1;
+						return value < 3;
+					}
+				);
+				s2t.equal(result, false, 'every returns false when predicate returns falsey');
+				s2t.equal(callCount, 4, 'predicate called until falsey returned');
+				s2t.equal(returnCalled, true, 'iterator is closed');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-returns-non-boolean', function (s2t) {
+				// truthy non-boolean values
+				s2t.equal(every([1][Symbol.iterator](), function () { return 1; }), true, 'truthy number');
+				s2t.equal(every([1][Symbol.iterator](), function () { return 'yes'; }), true, 'truthy string');
+				s2t.equal(every([1][Symbol.iterator](), function () { return {}; }), true, 'truthy object');
+
+				// falsy non-boolean values
+				s2t.equal(every([1][Symbol.iterator](), function () { return 0; }), false, 'falsy number');
+				s2t.equal(every([1][Symbol.iterator](), function () { return ''; }), false, 'falsy string');
+				s2t.equal(every([1][Symbol.iterator](), function () { return null; }), false, 'null');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/predicate-throws', function (s2t) {
+				var returnCount = 0;
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCount += 1;
+						return { done: true };
+					}
+				};
+
+				var callbackCount = 0;
+				s2t['throws'](
+					function () {
+						every(testIter, function () {
+							callbackCount += 1;
+							throw new SyntaxError('predicate threw');
+						});
+					},
+					SyntaxError
+				);
+				s2t.equal(callbackCount, 1, 'predicate called once');
+				s2t.equal(returnCount, 1, 'iterator closed when predicate throws');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/every/iterator-already-exhausted', function (s2t) {
+				var iter = [][Symbol.iterator]();
+				var callbackCount = 0;
+				var result = every(iter, function () {
+					callbackCount += 1;
+					return true;
+				});
+				s2t.equal(result, true, 'every returns true for empty iterator');
+				s2t.equal(callbackCount, 0, 'predicate not called');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.filter.js

@@ -0,0 +1,559 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.filter');
+var impl = require('../Iterator.prototype.filter/implementation');
+
+var fnName = 'filter';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (filter, name, t) {
+		t['throws'](
+			function () { return new filter(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(filter(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(filter(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { filter({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('observable lookups', { skip: !hasPropertyDescriptors }, function (st) {
+			var effects = [];
+
+			var obj = {};
+			Object.defineProperty(obj, 'next', {
+				configurable: true,
+				enumerable: true,
+				get: function next() {
+					effects.push('get next');
+					return function () {
+						return { done: true, value: undefined };
+					};
+				}
+			});
+
+			st['throws'](
+				function () { filter(obj, null); },
+				TypeError
+			);
+
+			st.deepEqual(effects, []);
+
+			st.end();
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new filter(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new filter(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			testIterator(filter(iterator(), function () { return false; }), [], st, 'filter for always-false');
+			testIterator(filter(iterator(), function () { return true; }), [1, 2, 3], st, 'filter for always-true');
+			testIterator(filter(iterator(), function (x, i) { return x === 2 && i === 1; }), [2], st, 'filter returns value for matching value/index');
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/filter/predicate-args', function (st) {
+			var g = function g() {
+				var arr = ['a', 'b', 'c'];
+				var i = 0;
+				return {
+					next: function () {
+						try {
+							return {
+								value: arr[i],
+								done: i >= arr.length
+							};
+						} finally {
+							i += 1;
+						}
+					}
+				};
+			};
+			var assertionCount = 0;
+			var iter = filter(
+				g(),
+				function (value, count) {
+					if (value === 'a') {
+						st.equal(count, 0, 'first iteration');
+					} else if (value === 'b') {
+						st.equal(count, 1, 'second iteration');
+					} else if (value === 'c') {
+						st.equal(count, 2, 'third iteration');
+					} else {
+						st.fail('unexpected iteration');
+					}
+					assertionCount += 1;
+					return true;
+				}
+			);
+
+			st.equal(assertionCount, 0, 'prior to iteration');
+
+			testIterator(iter, ['a', 'b', 'c'], st, 'iteration');
+
+			st.equal(assertionCount, 3);
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/filter/predicate-throws', function (st) {
+			var returnCalls = 0;
+
+			var iter = {
+				next: function () {
+					return {
+						done: false,
+						value: 1
+					};
+				},
+				'return': function () {
+					returnCalls += 1;
+					return {};
+				}
+			};
+
+			var callbackCalls = 0;
+			var iterator = filter(iter, function () {
+				callbackCalls += 1;
+				throw new SyntaxError();
+			});
+
+			st['throws'](function () { iterator.next(); }, SyntaxError, 'next() throws');
+
+			st.equal(callbackCalls, 1);
+			st.equal(returnCalls, 1);
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/filter/predicate-throws-then-closing-iterator-also-throws', function (st) {
+			var iter = {
+				next: function next() {
+					return {
+						done: false,
+						value: 1
+					};
+				},
+				'return': function () {
+					throw new EvalError();
+				}
+			};
+
+			var iterator = filter(iter, function () {
+				throw new SyntaxError();
+			});
+
+			st['throws'](
+				function () { iterator.next(); },
+				SyntaxError,
+				'when the predicate and return() both throw, the predicate’s exception wins'
+			);
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/filter/get-return-method-throws', { skip: !hasPropertyDescriptors }, function (st) {
+			var badIterator = {
+				next: function next() {
+					return {
+						done: false,
+						value: 1
+					};
+				}
+			};
+
+			Object.defineProperty(badIterator, 'return', { get: function () { throw new SyntaxError(); } });
+
+			var iter = filter(badIterator, function () { return true; });
+			iter.next();
+
+			st['throws'](
+				function () { iter['return'](); },
+				SyntaxError,
+				'gets the `return` method, whose getter throws'
+			);
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/drop/return-is-forwarded', function (st) {
+			var returnCount = 0;
+
+			var badIterator = {
+				next: function next() {
+					return {
+						done: false,
+						value: 1
+					};
+				},
+				'return': function () {
+					returnCount += 1;
+					return {};
+				}
+			};
+
+			var iter1 = filter(badIterator, function () { return false; });
+			st.equal(returnCount, 0, 'iter1, before return()');
+			iter1['return']();
+			st.equal(returnCount, 1, 'iter1, after return()');
+
+			st.end();
+		});
+
+		t.test('262: test/built-ins/Iterator/prototype/drop/return-is-not-forwarded-after-exhaustion', { skip: !hasPropertyDescriptors }, function (st) {
+			var makeBadIterator = function makeBadIterator() {
+				return {
+					next: function next() {
+						return {
+							done: true,
+							value: undefined
+						};
+					},
+					'return': function () {
+						throw new SyntaxError();
+					}
+				};
+			};
+
+			var iter1 = filter(makeBadIterator(), function () { return true; });
+			st['throws'](
+				function () { iter1['return'](); },
+				SyntaxError,
+				'iter1, return() throws'
+			);
+			iter1.next();
+			iter1['return']();
+
+			// 3 filters (i wish i had pipeline)
+			var iter2 = filter(
+				filter(
+					filter(
+						makeBadIterator(),
+						function () { return true; }
+					),
+					function () { return true; }
+				),
+				function () { return true; }
+			);
+			st['throws']( // TODO
+				function () { iter2['return'](); },
+				SyntaxError,
+				'iter2, return() throws'
+			);
+			iter2.next();
+			iter2['return']();
+
+			st.end();
+		});
+
+		t.test('262: predicate-this', { skip: !hasSymbols }, function (st) {
+			var thisValue;
+			var iter = filter(
+				[1][Symbol.iterator](),
+				function () {
+					thisValue = this;
+					return true;
+				}
+			);
+			iter.next();
+			st.equal(thisValue, undefined, 'predicate this is undefined');
+
+			st.end();
+		});
+
+		t.test('262: predicate-returns-non-boolean', { skip: !hasSymbols }, function (st) {
+			// truthy non-boolean values should pass
+			testIterator(
+				filter([1, 2, 3][Symbol.iterator](), function () { return 1; }),
+				[1, 2, 3],
+				st,
+				'truthy number passes'
+			);
+			testIterator(
+				filter([1, 2, 3][Symbol.iterator](), function () { return 'yes'; }),
+				[1, 2, 3],
+				st,
+				'truthy string passes'
+			);
+			testIterator(
+				filter([1, 2, 3][Symbol.iterator](), function () { return {}; }),
+				[1, 2, 3],
+				st,
+				'truthy object passes'
+			);
+
+			// falsy non-boolean values should fail
+			testIterator(
+				filter([1, 2, 3][Symbol.iterator](), function () { return 0; }),
+				[],
+				st,
+				'falsy number fails'
+			);
+			testIterator(
+				filter([1, 2, 3][Symbol.iterator](), function () { return ''; }),
+				[],
+				st,
+				'falsy string fails'
+			);
+			testIterator(
+				filter([1, 2, 3][Symbol.iterator](), function () { return null; }),
+				[],
+				st,
+				'null fails'
+			);
+
+			st.end();
+		});
+
+		t.test('262: result is iterator', { skip: !hasSymbols }, function (st) {
+			var iterator = filter([1, 2][Symbol.iterator](), function () { return true; });
+			st.equal(typeof iterator.next, 'function', 'has next method');
+			st.equal(typeof iterator[Symbol.iterator], 'function', 'has Symbol.iterator method');
+			st.equal(iterator[Symbol.iterator](), iterator, 'Symbol.iterator returns itself');
+
+			st.end();
+		});
+
+		t.test('262: get next method only once', { skip: !hasPropertyDescriptors }, function (st) {
+			var nextGets = 0;
+			var testIter = {};
+			Object.defineProperty(testIter, 'next', {
+				get: function () {
+					nextGets += 1;
+					return function () {
+						return { done: true, value: undefined };
+					};
+				}
+			});
+
+			var iter = filter(testIter, function () { return true; });
+			st.equal(nextGets, 1, 'next retrieved once on creation');
+			iter.next();
+			st.equal(nextGets, 1, 'next not retrieved again');
+
+			st.end();
+		});
+
+		t.test('262: get next method throws', { skip: !hasPropertyDescriptors }, function (st) {
+			var testIter = {};
+			Object.defineProperty(testIter, 'next', {
+				get: function () {
+					throw new EvalError('next getter threw');
+				}
+			});
+
+			st['throws'](
+				function () { filter(testIter, function () { return true; }); },
+				EvalError,
+				'throws when getting next throws'
+			);
+
+			st.end();
+		});
+
+		t.test('262: next method returns non-object throws', function (st) {
+			var badIterator = {
+				next: function () {
+					return null;
+				}
+			};
+
+			var iter = filter(badIterator, function () { return true; });
+			st['throws'](function () { iter.next(); }, TypeError, 'throws when next returns null');
+
+			st.end();
+		});
+
+		t.test('262: next method returns throwing done', { skip: !hasPropertyDescriptors }, function (st) {
+			var throwingIterator = {
+				next: function () {
+					var result = { value: 1 };
+					Object.defineProperty(result, 'done', {
+						get: function () {
+							throw new EvalError('done getter threw');
+						}
+					});
+					return result;
+				}
+			};
+
+			var iter = filter(throwingIterator, function () { return true; });
+			st['throws'](function () { iter.next(); }, EvalError, 'throws when done getter throws');
+
+			st.end();
+		});
+
+		t.test('262: next method returns throwing value', { skip: !hasPropertyDescriptors }, function (st) {
+			var throwingIterator = {
+				next: function () {
+					var result = { done: false };
+					Object.defineProperty(result, 'value', {
+						get: function () {
+							throw new EvalError('value getter threw');
+						}
+					});
+					return result;
+				}
+			};
+
+			var iter = filter(throwingIterator, function () { return true; });
+			st['throws'](function () { iter.next(); }, EvalError, 'throws when value getter throws');
+
+			st.end();
+		});
+
+		t.test('262: next method throws', function (st) {
+			var throwingIterator = {
+				next: function () {
+					throw new EvalError('next threw');
+				}
+			};
+
+			var iter = filter(throwingIterator, function () { return true; });
+			st['throws'](function () { iter.next(); }, EvalError, 'throws error from next');
+
+			st.end();
+		});
+
+		t.test('262: iterator already exhausted', function (st) {
+			var testIter = {
+				next: function () {
+					return { done: true, value: undefined };
+				}
+			};
+
+			var predicateCalls = 0;
+			var iter = filter(testIter, function () {
+				predicateCalls += 1;
+				return true;
+			});
+
+			var result = iter.next();
+			st.equal(result.done, true, 'done is true');
+			st.equal(result.value, undefined, 'value is undefined');
+			st.equal(predicateCalls, 0, 'predicate not called for exhausted iterator');
+
+			st.end();
+		});
+
+		t.test('262: throws TypeError when generator is running', function (st) {
+			var reentrantIterator;
+			var testIter = {
+				next: function () {
+					reentrantIterator.next();
+					return { done: false, value: 1 };
+				}
+			};
+
+			reentrantIterator = filter(testIter, function () { return true; });
+			st['throws'](function () { reentrantIterator.next(); }, TypeError, 'throws on reentrant next()');
+
+			st.end();
+		});
+
+		t.test('262: exhaustion does not call return', function (st) {
+			var returnCalls = 0;
+
+			var testIter = {
+				next: function () {
+					return { done: true, value: undefined };
+				},
+				'return': function () {
+					returnCalls += 1;
+					return { done: true, value: undefined };
+				}
+			};
+
+			var iter = filter(testIter, function () { return true; });
+			iter.next();
+			st.equal(returnCalls, 0, 'return not called on exhaustion');
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.find.js

@@ -0,0 +1,286 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.find');
+var impl = require('../Iterator.prototype.find/implementation');
+
+var fnName = 'find';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (find, name, t) {
+		t['throws'](
+			function () { return new find(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(find(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(find(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { find({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new find(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new find(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			st.equal(find(iterator(), function () { return false; }), undefined, 'find for always-false');
+			st.equal(find(iterator(), function () { return true; }), 1, 'find for always-true');
+			st.equal(find(iterator(), function (x, i) { return x === 2 && i === 1; }), 2, 'find returns value for matching value/index');
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-args', function (s2t) {
+				var assertionCount = 0;
+				var result = find(
+					['a', 'b', 'c'][Symbol.iterator](),
+					function (value, count) {
+						if (value === 'a') {
+							s2t.equal(count, 0);
+						} else if (value === 'b') {
+							s2t.equal(count, 1);
+						} else if (value === 'c') {
+							s2t.equal(count, 2);
+						} else {
+							s2t.fail('unexpected value');
+						}
+						assertionCount += 1;
+						return false;
+					}
+				);
+				s2t.equal(result, undefined, 'find returns undefined when none match');
+				s2t.equal(assertionCount, 3, 'predicate called three times');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-this', function (s2t) {
+				var expectedThis = (function () { return this; }()); // eslint-disable-line no-invalid-this
+				var assertionCount = 0;
+				var result = find(
+					[0][Symbol.iterator](),
+					function () {
+						s2t.equal(this, expectedThis, 'predicate this is undefined'); // eslint-disable-line no-invalid-this
+						assertionCount += 1;
+						return true;
+					}
+				);
+				s2t.equal(result, 0);
+				s2t.equal(assertionCount, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-returns-truthy', function (s2t) {
+				var callCount = 0;
+				var returnCalled = false;
+				var values = [0, 1, 2];
+				var idx = 0;
+				var iter = {
+					next: function () {
+						if (idx < values.length) {
+							var val = values[idx];
+							idx += 1;
+							return { done: false, value: val };
+						}
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalled = true;
+						return { done: true, value: undefined };
+					}
+				};
+				var result = find(
+					iter,
+					function () {
+						callCount += 1;
+						return true;
+					}
+				);
+				s2t.equal(result, 0, 'find returns first value when predicate returns truthy');
+				s2t.equal(callCount, 1, 'predicate called once');
+				s2t.equal(returnCalled, true, 'iterator is closed');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-returns-falsey', function (s2t) {
+				var result = find(
+					[0, 1, 2, 3, 4][Symbol.iterator](),
+					function () { return false; }
+				);
+				s2t.equal(result, undefined, 'find returns undefined when predicate always returns falsey');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-returns-falsey-then-truthy', function (s2t) {
+				var callCount = 0;
+				var returnCalled = false;
+				var values = [0, 1, 2, 3, 4];
+				var idx = 0;
+				var iter = {
+					next: function () {
+						if (idx < values.length) {
+							var val = values[idx];
+							idx += 1;
+							return { done: false, value: val };
+						}
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalled = true;
+						return { done: true, value: undefined };
+					}
+				};
+				var result = find(
+					iter,
+					function (value) {
+						callCount += 1;
+						return value >= 3;
+					}
+				);
+				s2t.equal(result, 3, 'find returns matching value');
+				s2t.equal(callCount, 4, 'predicate called until truthy returned');
+				s2t.equal(returnCalled, true, 'iterator is closed');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-returns-non-boolean', function (s2t) {
+				// truthy non-boolean values find the first element
+				s2t.equal(find([1, 2][Symbol.iterator](), function () { return 1; }), 1, 'truthy number');
+				s2t.equal(find([1, 2][Symbol.iterator](), function () { return 'yes'; }), 1, 'truthy string');
+				s2t.equal(find([1, 2][Symbol.iterator](), function () { return {}; }), 1, 'truthy object');
+
+				// falsy non-boolean values return undefined
+				s2t.equal(find([1][Symbol.iterator](), function () { return 0; }), undefined, 'falsy number');
+				s2t.equal(find([1][Symbol.iterator](), function () { return ''; }), undefined, 'falsy string');
+				s2t.equal(find([1][Symbol.iterator](), function () { return null; }), undefined, 'null');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/predicate-throws', function (s2t) {
+				var returnCount = 0;
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCount += 1;
+						return { done: true };
+					}
+				};
+
+				var callbackCount = 0;
+				s2t['throws'](
+					function () {
+						find(testIter, function () {
+							callbackCount += 1;
+							throw new SyntaxError('predicate threw');
+						});
+					},
+					SyntaxError
+				);
+				s2t.equal(callbackCount, 1, 'predicate called once');
+				s2t.equal(returnCount, 1, 'iterator closed when predicate throws');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/find/iterator-already-exhausted', function (s2t) {
+				var iter = [][Symbol.iterator]();
+				var callbackCount = 0;
+				var result = find(iter, function () {
+					callbackCount += 1;
+					return true;
+				});
+				s2t.equal(result, undefined, 'find returns undefined for empty iterator');
+				s2t.equal(callbackCount, 0, 'predicate not called');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.flatMap.js

@@ -0,0 +1,238 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var iterate = require('iterate-iterator');
+
+var StringToCodePoints = require('es-abstract/2025/StringToCodePoints');
+
+var index = require('../Iterator.prototype.flatMap');
+var impl = require('../Iterator.prototype.flatMap/implementation');
+
+var fnName = 'flatMap';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (flatMap, name, t) {
+		t['throws'](
+			function () { return new flatMap(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(flatMap(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(flatMap(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { flatMap({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new flatMap(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new flatMap(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+
+			var nonIterableFlatMap = flatMap(iterator(), function (x) { return x; });
+			st['throws'](
+				function () { nonIterableFlatMap.next(); },
+				TypeError,
+				'non-iterable return value throws'
+			);
+
+			forEach(v.strings, function (string) {
+				st['throws'](
+					function () { flatMap(iterator(), function () { return string; }).next(); },
+					TypeError,
+					'non-object return value throws even if iterable (' + debug(string) + ')'
+				);
+
+				testIterator(
+					flatMap(iterator(), function () { return Object(string); }),
+					[].concat(StringToCodePoints(string), StringToCodePoints(string), StringToCodePoints(string)),
+					st,
+					'boxed string (' + debug(string) + ')'
+				);
+			});
+
+			testIterator(flatMap(iterator(), function (x) { return [x][Symbol.iterator](); }), [1, 2, 3], st, 'identity mapper in array iterator');
+			testIterator(flatMap(iterator(), function (x) { return [2 * x][Symbol.iterator](); }), [2, 4, 6], st, 'doubler mapper in array iterator');
+
+			testIterator(flatMap(iterator(), function () { return []; }), [], st, 'empty mapper in nested array iterator');
+			testIterator(flatMap(iterator(), function (x) { return [[x, x + 1]][Symbol.iterator](); }), [[1, 2], [2, 3], [3, 4]], st, 'identity mapper in nested array iterator');
+			testIterator(flatMap(iterator(), function (x) { return [[2 * x, 2 * (x + 1)]][Symbol.iterator](); }), [[2, 4], [4, 6], [6, 8]], st, 'doubler mapper in nested array iterator');
+
+			testIterator(flatMap([0, 1, 2, 3][Symbol.iterator](), function (value) {
+				var result = [];
+				for (var i = 0; i < value; ++i) {
+					result.push(value);
+				}
+				return result;
+			}), [1, 2, 2, 3, 3, 3], st, 'test262: test/built-ins/Iterator/prototype/flatMap/flattens-iteratable');
+
+			testIterator(flatMap([0, 1, 2, 3][Symbol.iterator](), function (value) {
+				var i = 0;
+				return {
+					next: function () {
+						if (i < value) {
+							i += 1;
+							return {
+								value: value,
+								done: false
+							};
+						}
+						return {
+							value: undefined,
+							done: true
+						};
+
+					}
+				};
+			}), [1, 2, 2, 3, 3, 3], st, 'test262: test/built-ins/Iterator/prototype/flatMap/flattens-iterator');
+
+			testIterator(flatMap([0][Symbol.iterator](), function () {
+				var n = [0, 1, 2][Symbol.iterator]();
+
+				var ret = {
+					next: function next() {
+						return n.next();
+					}
+				};
+				ret[Symbol.iterator] = null;
+				return ret;
+			}), [0, 1, 2], st, 'test262: test/built-ins/Iterator/prototype/flatMap/iterable-to-iterator-fallback');
+
+			var counts = [];
+			testIterator(flatMap(['a', 'b', 'c', 'd', 'e'][Symbol.iterator](), function (value, count) {
+				counts.push(count);
+
+				if (value === 'a' || value === 'b') {
+					return [0];
+				}
+				if (value === 'c') {
+					return [1, 2];
+				}
+				if (value === 'd') {
+					return [3, 4, 5];
+				}
+				if (value === 'e') {
+					return [6, 7, 8, 9];
+				}
+
+				return st.fail('got unexpected value: ' + debug(v));
+			}), [0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9], st, 'test262: test/built-ins/Iterator/prototype/flatMap/mapper-args');
+			st.deepEqual(counts, [0, 1, 2, 3, 4], 'count values are as expected');
+
+			st.test('return protocol', function (s2t) {
+				var returnCount = 0;
+
+				var iter = flatMap([0][Symbol.iterator](), function () {
+					return {
+						next: function next() {
+							return {
+								done: false,
+								value: 1
+							};
+						},
+						'return': function () {
+							returnCount += 1;
+							return {};
+						}
+					};
+				});
+				s2t.equal(returnCount, 0, '`return` is not called yet');
+
+				s2t.deepEqual(iter.next(), {
+					done: false,
+					value: 1
+				});
+
+				s2t.equal(returnCount, 0, '`return` is not called after first yield');
+
+				iter['return']();
+				s2t.equal(returnCount, 1, '`return` is called when iterator return is called');
+
+				iter['return']();
+				s2t.equal(returnCount, 1, '`return` is not called again when iterator return is called again');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.forEach.js

@@ -0,0 +1,232 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEachNormal = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.forEach');
+var impl = require('../Iterator.prototype.forEach/implementation');
+
+var fnName = 'forEach';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (forEach, name, t) {
+		t['throws'](
+			function () { return new forEach(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEachNormal(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(forEach(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(forEach(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEachNormal(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { forEach({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new forEach(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new forEach(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+
+			var results = [];
+			var ret = forEach(
+				iterator(),
+				function (x, i) {
+
+					results.push({ value: x, count: i, 'this': this, args: arguments.length });
+				}
+			);
+
+			st.equal(ret, undefined, 'returns undefined');
+
+			st.deepEqual(
+				results,
+				[
+					{ value: 1, count: 0, 'this': undefined, args: 2 },
+					{ value: 2, count: 1, 'this': undefined, args: 2 },
+					{ value: 3, count: 2, 'this': undefined, args: 2 }
+				],
+				'forEach callback receives the expected values'
+			);
+
+			st.test('test262: test/built-ins/Iterator/prototype/forEach/fn-args', function (s2t) {
+				var assertionCount = 0;
+				var result = forEach(
+					['a', 'b', 'c'][Symbol.iterator](),
+					function (value, count) {
+						if (value === 'a') {
+							s2t.equal(count, 0);
+						} else if (value === 'b') {
+							s2t.equal(count, 1);
+						} else if (value === 'c') {
+							s2t.equal(count, 2);
+						} else {
+							s2t.fail('unexpected value');
+						}
+						assertionCount += 1;
+					}
+				);
+				s2t.equal(result, undefined, 'forEach returns undefined');
+				s2t.equal(assertionCount, 3, 'callback called three times');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/forEach/fn-this', function (s2t) {
+				var expectedThis = (function () { return this; }()); // eslint-disable-line no-invalid-this
+				var assertionCount = 0;
+				var result = forEach(
+					[0][Symbol.iterator](),
+					function () {
+						s2t.equal(this, expectedThis, 'fn this is undefined'); // eslint-disable-line no-invalid-this
+						assertionCount += 1;
+					}
+				);
+				s2t.equal(result, undefined);
+				s2t.equal(assertionCount, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/forEach/fn-called-for-each-yielded-value', function (s2t) {
+				var values = [];
+				forEach(
+					[1, 2, 3, 4, 5][Symbol.iterator](),
+					function (value) { values.push(value); }
+				);
+				s2t.deepEqual(values, [1, 2, 3, 4, 5], 'callback called for each value');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/forEach/fn-throws', function (s2t) {
+				var returnCount = 0;
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCount += 1;
+						return { done: true };
+					}
+				};
+
+				var callbackCount = 0;
+				s2t['throws'](
+					function () {
+						forEach(testIter, function () {
+							callbackCount += 1;
+							throw new SyntaxError('callback threw');
+						});
+					},
+					SyntaxError
+				);
+				s2t.equal(callbackCount, 1, 'callback called once');
+				s2t.equal(returnCount, 1, 'iterator closed when callback throws');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/forEach/iterator-already-exhausted', function (s2t) {
+				var iter = [][Symbol.iterator]();
+				var callbackCount = 0;
+				var result = forEach(iter, function () {
+					callbackCount += 1;
+				});
+				s2t.equal(result, undefined, 'forEach returns undefined for empty iterator');
+				s2t.equal(callbackCount, 0, 'callback not called');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/forEach/result-is-undefined', function (s2t) {
+				var result = forEach(
+					[1, 2, 3][Symbol.iterator](),
+					function () {}
+				);
+				s2t.equal(result, undefined, 'forEach returns undefined');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.js

@@ -0,0 +1,72 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var hasSymbols = require('has-symbols')();
+var hasToStringTag = require('has-tostringtag');
+var functionsHaveNames = require('functions-have-names')();
+var functionsHaveConfigurableNames = require('functions-have-names').functionsHaveConfigurableNames();
+
+var index = require('../Iterator.prototype');
+var impl = require('../Iterator.prototype/implementation');
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var $Iterator = require('../Iterator/implementation');
+
+module.exports = {
+	tests: function (proto, name, t) {
+		t.notEqual(proto, null, 'is not null');
+		t.equal(typeof proto, 'object', 'is an object');
+
+		t.test('Symbol.iterator', { skip: !hasSymbols }, function (st) {
+			st.equal(typeof proto[Symbol.iterator], 'function', 'has a `Symbol.iterator` method');
+			st.equal(
+				proto[Symbol.iterator].name,
+				'[Symbol.iterator]',
+				'has name "[Symbol.iterator]"',
+				{ skip: functionsHaveNames && !functionsHaveConfigurableNames }
+			);
+			st.equal(proto[Symbol.iterator](), proto, 'function returns proto');
+			st.equal(proto[Symbol.iterator].call($Iterator), $Iterator, 'function returns receiver');
+
+			st.end();
+		});
+
+		t.test(
+			'Symbol.toStringTag',
+			{ skip: !hasToStringTag || 'temporarily skipped pending https://bugs.chromium.org/p/chromium/issues/detail?id=1477372' },
+			function (st) {
+				st.equal(proto[Symbol.toStringTag], 'Iterator', 'has a `Symbol.toStringTag` property');
+
+				st.end();
+			}
+		);
+	},
+	index: function () {
+		test('Iterator.prototype: index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype', t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype: implementation', function (t) {
+			module.exports.tests(impl, 'Iterator.prototype', t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype: shimmed', function (t) {
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator, 'prototype'), 'Iterator.prototype is not enumerable');
+				et.end();
+			});
+
+			module.exports.tests(Iterator.prototype, 'Iterator.prototype', t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.map.js

@@ -0,0 +1,463 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var generators = require('make-generator-function')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.map');
+var impl = require('../Iterator.prototype.map/implementation');
+
+var fnName = 'map';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (map, name, t) {
+		t['throws'](
+			function () { return new map(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(map(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(map(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { map({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		var sentinel = {};
+		var done = false;
+		var fakeIterator = {
+			next: function () {
+				try {
+					return {
+						done: !!done,
+						value: sentinel
+					};
+				} finally {
+					done = done === false ? null : true;
+				}
+			}
+		};
+		var result = {};
+		testIterator(
+			map(fakeIterator, function (x, i) {
+				result.value = x;
+				result.counter = i;
+				result.receiver = this;
+				result.args = arguments.length;
+				return fakeIterator;
+			}),
+			[fakeIterator, fakeIterator],
+			t,
+			'fake iterator, mapped, runs as expected'
+		);
+		t.deepEqual(
+			result,
+			{ value: sentinel, counter: 1, receiver: undefined, args: 2 },
+			'callback is called with the correct arguments'
+		);
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new map(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new map(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			testIterator(map(iterator(), function (x) { return x; }), [1, 2, 3], st, 'identity mapper');
+			testIterator(map(iterator(), function (x) { return 2 * x; }), [2, 4, 6], st, 'doubler mapper');
+
+			st.test('generators', { skip: generators.length === 0 }, function (s2t) {
+				forEach(generators, function (gen) {
+					s2t.doesNotThrow(
+						function () { map(gen(), function () {}); },
+						'generator function ' + debug(gen) + ' does not need to be from-wrapped first'
+					);
+				});
+
+				s2t.end();
+			});
+
+			st.test('262: mapper-this', function (s2t) {
+				var thisValue;
+				var iter = map(
+					[1][Symbol.iterator](),
+					function () {
+						thisValue = this;
+						return 42;
+					}
+				);
+				iter.next();
+				s2t.equal(thisValue, undefined, 'mapper this is undefined in sloppy mode');
+
+				s2t.end();
+			});
+
+			st.test('262: result is iterator', function (s2t) {
+				var mappedIter = map([1, 2][Symbol.iterator](), function (x) { return x; });
+				s2t.equal(typeof mappedIter.next, 'function', 'has next method');
+				s2t.equal(typeof mappedIter[Symbol.iterator], 'function', 'has Symbol.iterator method');
+				s2t.equal(mappedIter[Symbol.iterator](), mappedIter, 'Symbol.iterator returns itself');
+
+				s2t.end();
+			});
+
+			st.test('262: get next method only once', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var nextGets = 0;
+				var testIter = {
+					next: function () {
+						return { done: true, value: undefined };
+					}
+				};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						nextGets += 1;
+						return function () {
+							return { done: true, value: undefined };
+						};
+					}
+				});
+
+				var iter = map(testIter, function (x) { return x; });
+				s2t.equal(nextGets, 1, 'next retrieved once on creation');
+				iter.next();
+				s2t.equal(nextGets, 1, 'next not retrieved again');
+
+				s2t.end();
+			});
+
+			st.test('262: get next method throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						throw new EvalError('next getter threw');
+					}
+				});
+
+				s2t['throws'](
+					function () { map(testIter, function () {}); },
+					EvalError,
+					'throws when getting next throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns non-object throws', function (s2t) {
+				var badIterator = {
+					next: function () {
+						return null;
+					}
+				};
+
+				var iter = map(badIterator, function (x) { return x; });
+				s2t['throws'](function () { iter.next(); }, TypeError, 'throws when next returns null');
+
+				var badIterator2 = {
+					next: function () {
+						return 42;
+					}
+				};
+
+				var iter2 = map(badIterator2, function (x) { return x; });
+				s2t['throws'](function () { iter2.next(); }, TypeError, 'throws when next returns number');
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns throwing done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var iterResult = { value: 1 };
+						Object.defineProperty(iterResult, 'done', {
+							get: function () {
+								throw new EvalError('done getter threw');
+							}
+						});
+						return iterResult;
+					}
+				};
+
+				var iter = map(throwingIterator, function (x) { return x; });
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws when done getter throws');
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns throwing value', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var iterResult = { done: false };
+						Object.defineProperty(iterResult, 'value', {
+							get: function () {
+								throw new EvalError('value getter threw');
+							}
+						});
+						return iterResult;
+					}
+				};
+
+				var iter = map(throwingIterator, function (x) { return x; });
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws when value getter throws');
+
+				s2t.end();
+			});
+
+			st.test('262: next method throws', function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						throw new EvalError('next threw');
+					}
+				};
+
+				var iter = map(throwingIterator, function (x) { return x; });
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws error from next');
+
+				s2t.end();
+			});
+
+			st.test('262: mapper throws', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = map(testIter, function () {
+					throw new SyntaxError('mapper threw');
+				});
+
+				s2t['throws'](function () { iter.next(); }, SyntaxError, 'throws error from mapper');
+				s2t.equal(returnCalls, 1, 'return called on underlying iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: mapper throws then closing iterator also throws', function (s2t) {
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						throw new EvalError('return threw');
+					}
+				};
+
+				var iter = map(testIter, function () {
+					throw new SyntaxError('mapper threw');
+				});
+
+				s2t['throws'](function () { iter.next(); }, SyntaxError, 'mapper exception wins over return exception');
+
+				s2t.end();
+			});
+
+			st.test('262: get return method throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var badIterator = {
+					next: function () {
+						return { done: false, value: 1 };
+					}
+				};
+				Object.defineProperty(badIterator, 'return', {
+					get: function () {
+						throw new SyntaxError('return getter threw');
+					}
+				});
+
+				var iter = map(badIterator, function (x) { return x; });
+				iter.next();
+
+				s2t['throws'](function () { iter['return'](); }, SyntaxError, 'throws error from return getter');
+
+				s2t.end();
+			});
+
+			st.test('262: return is forwarded to underlying iterator', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = map(testIter, function (x) { return x; });
+				iter.next();
+				s2t.equal(returnCalls, 0, 'return not called before calling return()');
+				iter['return']();
+				s2t.equal(returnCalls, 1, 'return called once');
+
+				s2t.end();
+			});
+
+			st.test('262: return is not forwarded after exhaustion', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalls += 1;
+						throw new EvalError('return should not be called');
+					}
+				};
+
+				var iter = map(testIter, function (x) { return x; });
+				iter.next();
+				iter['return']();
+				s2t.equal(returnCalls, 0, 'return not called after exhaustion');
+
+				s2t.end();
+			});
+
+			st.test('262: iterator already exhausted', function (s2t) {
+				var testIter = {
+					next: function () {
+						return { done: true, value: undefined };
+					}
+				};
+
+				var mapperCalls = 0;
+				var iter = map(testIter, function (x) {
+					mapperCalls += 1;
+					return x;
+				});
+
+				var nextResult = iter.next();
+				s2t.equal(nextResult.done, true, 'done is true');
+				s2t.equal(nextResult.value, undefined, 'value is undefined');
+				s2t.equal(mapperCalls, 0, 'mapper not called for exhausted iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: throws TypeError when generator is running', function (s2t) {
+				var reentrantIterator;
+				var testIter = {
+					next: function () {
+						reentrantIterator.next();
+						return { done: false, value: 1 };
+					}
+				};
+
+				reentrantIterator = map(testIter, function (x) { return x; });
+				s2t['throws'](function () { reentrantIterator.next(); }, TypeError, 'throws on reentrant next()');
+
+				s2t.end();
+			});
+
+			st.test('262: underlying iterator closed when mapper returns abrupt', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = map(testIter, function () {
+					throw new EvalError('mapper threw');
+				});
+
+				s2t['throws'](function () { iter.next(); }, EvalError);
+				s2t.equal(returnCalls, 1, 'underlying iterator closed on mapper throw');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.equal(typeof Iterator.prototype[fnName], 'function', 'exists and is a function');
+
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.reduce.js

@@ -0,0 +1,318 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.reduce');
+var impl = require('../Iterator.prototype.reduce/implementation');
+
+var fnName = 'reduce';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (reduce, name, t) {
+		t['throws'](
+			function () { return new reduce(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(reduce(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(reduce(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { reduce({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new reduce(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new reduce(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+
+			var results = [];
+			var ret = reduce(
+				iterator(),
+				function (acc, x, i) {
+
+					results.push({ acc: acc, value: x, count: i, 'this': this, args: arguments.length });
+					return acc + x;
+				}
+			);
+			st.equal(ret, 6, 'returns sum of all numbers');
+			st.deepEqual(
+				results,
+				[
+					{ acc: 1, value: 2, count: 1, 'this': undefined, args: 3 },
+					{ acc: 3, value: 3, count: 2, 'this': undefined, args: 3 }
+				],
+				'reduce callback receives the expected values without initialValue'
+			);
+
+			var results2 = [];
+			var ret2 = reduce(
+				iterator(),
+				function (acc, x, i) {
+
+					results2.push({ acc: acc, value: x, count: i, 'this': this, args: arguments.length });
+					return acc + x;
+				},
+				10
+			);
+			st.equal(ret2, 16, 'returns sum of all numbers plus initialValue');
+			st.deepEqual(
+				results2,
+				[
+					{ acc: 10, value: 1, count: 0, 'this': undefined, args: 3 },
+					{ acc: 11, value: 2, count: 1, 'this': undefined, args: 3 },
+					{ acc: 13, value: 3, count: 2, 'this': undefined, args: 3 }
+				],
+				'reduce callback receives the expected values with initialValue'
+			);
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/reducer-args-initial-value', function (s2t) {
+				var assertionCount = 0;
+				var result = reduce(
+					['a', 'b', 'c'][Symbol.iterator](),
+					function (memo, value, count) {
+						if (value === 'a') {
+							s2t.equal(memo, 'start', 'memo is initial value for first call');
+							s2t.equal(count, 0);
+						} else if (value === 'b') {
+							s2t.equal(memo, 'a', 'memo is previous return');
+							s2t.equal(count, 1);
+						} else if (value === 'c') {
+							s2t.equal(memo, 'b', 'memo is previous return');
+							s2t.equal(count, 2);
+						} else {
+							s2t.fail('unexpected value');
+						}
+						assertionCount += 1;
+						return value;
+					},
+					'start'
+				);
+				s2t.equal(result, 'c', 'reduce returns last value');
+				s2t.equal(assertionCount, 3, 'reducer called three times');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/reducer-args-no-initial-value', function (s2t) {
+				var assertionCount = 0;
+				var result = reduce(
+					['a', 'b', 'c'][Symbol.iterator](),
+					function (memo, value, count) {
+						if (value === 'b') {
+							s2t.equal(memo, 'a', 'memo is first value when no initial');
+							s2t.equal(count, 1);
+						} else if (value === 'c') {
+							s2t.equal(memo, 'b', 'memo is previous return');
+							s2t.equal(count, 2);
+						} else {
+							s2t.fail('unexpected value');
+						}
+						assertionCount += 1;
+						return value;
+					}
+				);
+				s2t.equal(result, 'c', 'reduce returns last value');
+				s2t.equal(assertionCount, 2, 'reducer called twice');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/reducer-this', function (s2t) {
+				var expectedThis = (function () { return this; }()); // eslint-disable-line no-invalid-this
+				var assertionCount = 0;
+				var result = reduce(
+					[0, 1][Symbol.iterator](),
+					function () {
+						s2t.equal(this, expectedThis, 'reducer this is undefined'); // eslint-disable-line no-invalid-this
+						assertionCount += 1;
+						return 0;
+					}
+				);
+				s2t.equal(result, 0);
+				s2t.equal(assertionCount, 1, 'reducer called once');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/reducer-throws', function (s2t) {
+				var returnCount = 0;
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCount += 1;
+						return { done: true };
+					}
+				};
+
+				var callbackCount = 0;
+				s2t['throws'](
+					function () {
+						reduce(testIter, function () {
+							callbackCount += 1;
+							throw new SyntaxError('reducer threw');
+						}, 0);
+					},
+					SyntaxError
+				);
+				s2t.equal(callbackCount, 1, 'reducer called once');
+				s2t.equal(returnCount, 1, 'iterator closed when reducer throws');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/iterator-already-exhausted-initial-value', function (s2t) {
+				var iter = [][Symbol.iterator]();
+				var callbackCount = 0;
+				var result = reduce(iter, function () {
+					callbackCount += 1;
+					return 'called';
+				}, 'initial');
+				s2t.equal(result, 'initial', 'reduce returns initial value for empty iterator');
+				s2t.equal(callbackCount, 0, 'reducer not called');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/iterator-already-exhausted-no-initial-value', function (s2t) {
+				var iter = [][Symbol.iterator]();
+				s2t['throws'](
+					function () {
+						reduce(iter, function () {});
+					},
+					TypeError,
+					'reduce throws TypeError for empty iterator without initial value'
+				);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/iterator-yields-once-initial-value', function (s2t) {
+				var callbackCount = 0;
+				var result = reduce(
+					[42][Symbol.iterator](),
+					function (memo, value) {
+						callbackCount += 1;
+						return memo + value;
+					},
+					10
+				);
+				s2t.equal(result, 52, 'reduce returns sum');
+				s2t.equal(callbackCount, 1, 'reducer called once');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/iterator-yields-once-no-initial-value', function (s2t) {
+				var callbackCount = 0;
+				var result = reduce(
+					[42][Symbol.iterator](),
+					function () {
+						callbackCount += 1;
+						return 'called';
+					}
+				);
+				s2t.equal(result, 42, 'reduce returns sole value');
+				s2t.equal(callbackCount, 0, 'reducer not called');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/reduce/reducer-memo-can-be-any-type', function (s2t) {
+				// test various memo types
+				s2t.equal(reduce([1][Symbol.iterator](), function (m) { return m; }, null), null, 'null memo');
+				s2t.equal(reduce([1][Symbol.iterator](), function (m) { return m; }, undefined), undefined, 'undefined memo');
+				s2t.equal(reduce([1][Symbol.iterator](), function (m) { return m; }, 0), 0, 'number memo');
+				s2t.equal(reduce([1][Symbol.iterator](), function (m) { return m; }, ''), '', 'string memo');
+				s2t.equal(reduce([1][Symbol.iterator](), function (m) { return m; }, false), false, 'boolean memo');
+				var obj = {};
+				s2t.equal(reduce([1][Symbol.iterator](), function (m) { return m; }, obj), obj, 'object memo');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.some.js

@@ -0,0 +1,286 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.some');
+var impl = require('../Iterator.prototype.some/implementation');
+
+var fnName = 'some';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (some, name, t) {
+		t['throws'](
+			function () { return new some(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(some(nonIterator, function () {})); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(some(badNext, function () {})); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		forEach(v.nonFunctions, function (nonFunction) {
+			t['throws'](
+				function () { some({ next: function () {} }, nonFunction); },
+				TypeError,
+				debug(nonFunction) + ' is not a function'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new some(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new some(iterator(), function () {}); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			st.equal(some(iterator(), function () { return false; }), false, 'some for always-false');
+			st.equal(some(iterator(), function () { return true; }), true, 'some for always-true');
+			st.equal(some(iterator(), function (x, i) { return x === 2 && i === 1; }), true, 'some returns true for matching value/index');
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-args', function (s2t) {
+				var assertionCount = 0;
+				var result = some(
+					['a', 'b', 'c'][Symbol.iterator](),
+					function (value, count) {
+						if (value === 'a') {
+							s2t.equal(count, 0);
+						} else if (value === 'b') {
+							s2t.equal(count, 1);
+						} else if (value === 'c') {
+							s2t.equal(count, 2);
+						} else {
+							s2t.fail('unexpected value');
+						}
+						assertionCount += 1;
+						return false;
+					}
+				);
+				s2t.equal(result, false, 'some returns false when none match');
+				s2t.equal(assertionCount, 3, 'predicate called three times');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-this', function (s2t) {
+				var expectedThis = (function () { return this; }()); // eslint-disable-line no-invalid-this
+				var assertionCount = 0;
+				var result = some(
+					[0][Symbol.iterator](),
+					function () {
+						s2t.equal(this, expectedThis, 'predicate this is undefined'); // eslint-disable-line no-invalid-this
+						assertionCount += 1;
+						return true;
+					}
+				);
+				s2t.equal(result, true);
+				s2t.equal(assertionCount, 1);
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-returns-truthy', function (s2t) {
+				var callCount = 0;
+				var returnCalled = false;
+				var values = [0, 1, 2];
+				var idx = 0;
+				var iter = {
+					next: function () {
+						if (idx < values.length) {
+							var val = values[idx];
+							idx += 1;
+							return { done: false, value: val };
+						}
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalled = true;
+						return { done: true, value: undefined };
+					}
+				};
+				var result = some(
+					iter,
+					function () {
+						callCount += 1;
+						return true;
+					}
+				);
+				s2t.equal(result, true, 'some returns true when predicate returns truthy');
+				s2t.equal(callCount, 1, 'predicate called once');
+				s2t.equal(returnCalled, true, 'iterator is closed');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-returns-falsey', function (s2t) {
+				var result = some(
+					[0, 1, 2, 3, 4][Symbol.iterator](),
+					function () { return false; }
+				);
+				s2t.equal(result, false, 'some returns false when predicate always returns falsey');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-returns-falsey-then-truthy', function (s2t) {
+				var callCount = 0;
+				var returnCalled = false;
+				var values = [0, 1, 2, 3, 4];
+				var idx = 0;
+				var iter = {
+					next: function () {
+						if (idx < values.length) {
+							var val = values[idx];
+							idx += 1;
+							return { done: false, value: val };
+						}
+						return { done: true, value: undefined };
+					},
+					'return': function () {
+						returnCalled = true;
+						return { done: true, value: undefined };
+					}
+				};
+				var result = some(
+					iter,
+					function (value) {
+						callCount += 1;
+						return value >= 3;
+					}
+				);
+				s2t.equal(result, true, 'some returns true when predicate returns truthy');
+				s2t.equal(callCount, 4, 'predicate called until truthy returned');
+				s2t.equal(returnCalled, true, 'iterator is closed');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-returns-non-boolean', function (s2t) {
+				// truthy non-boolean values
+				s2t.equal(some([1][Symbol.iterator](), function () { return 1; }), true, 'truthy number');
+				s2t.equal(some([1][Symbol.iterator](), function () { return 'yes'; }), true, 'truthy string');
+				s2t.equal(some([1][Symbol.iterator](), function () { return {}; }), true, 'truthy object');
+
+				// falsy non-boolean values
+				s2t.equal(some([1][Symbol.iterator](), function () { return 0; }), false, 'falsy number');
+				s2t.equal(some([1][Symbol.iterator](), function () { return ''; }), false, 'falsy string');
+				s2t.equal(some([1][Symbol.iterator](), function () { return null; }), false, 'null');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/predicate-throws', function (s2t) {
+				var returnCount = 0;
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCount += 1;
+						return { done: true };
+					}
+				};
+
+				var callbackCount = 0;
+				s2t['throws'](
+					function () {
+						some(testIter, function () {
+							callbackCount += 1;
+							throw new SyntaxError('predicate threw');
+						});
+					},
+					SyntaxError
+				);
+				s2t.equal(callbackCount, 1, 'predicate called once');
+				s2t.equal(returnCount, 1, 'iterator closed when predicate throws');
+
+				s2t.end();
+			});
+
+			st.test('test262: test/built-ins/Iterator/prototype/some/iterator-already-exhausted', function (s2t) {
+				var iter = [][Symbol.iterator]();
+				var callbackCount = 0;
+				var result = some(iter, function () {
+					callbackCount += 1;
+					return true;
+				});
+				s2t.equal(result, false, 'some returns false for empty iterator');
+				s2t.equal(callbackCount, 0, 'predicate not called');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.take.js

@@ -0,0 +1,364 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.take');
+var impl = require('../Iterator.prototype.take/implementation');
+
+var fnName = 'take';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (take, name, t) {
+		t['throws'](
+			function () { return new take(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(take(nonIterator, 1)); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			if (nonIterator != null && typeof nonIterator !== 'string') {
+				var badNext = { next: nonIterator };
+				t['throws'](
+					function () { iterate(take(badNext, 1)); },
+					TypeError,
+					debug(badNext) + ' is not an Object with a callable `next` method'
+				);
+			}
+		});
+
+		var arr = [1, 2, 3];
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { take(iterator(), -3); },
+				RangeError,
+				'-3 is not >= 0'
+			);
+
+			st['throws'](
+				function () { return new take(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+			st['throws'](
+				function () { return new take(iterator(), 0); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+			testIterator(take(iterator(), 0), [], st, 'take 0');
+			testIterator(take(iterator(), 1), [1], st, 'take 1');
+			testIterator(take(iterator(), 2), [1, 2], st, 'take 2');
+			testIterator(take(iterator(), 3), [1, 2, 3], st, 'take 3');
+			testIterator(take(iterator(), Infinity), [1, 2, 3], st, 'take ∞');
+
+			st.test('262: limit-tonumber', function (s2t) {
+				// ToNumber coercion
+				testIterator(take(iterator(), '2'), [1, 2], s2t, 'string "2" coerced to 2');
+				testIterator(take(iterator(), 2.9), [1, 2], s2t, '2.9 truncated to 2');
+				testIterator(take(iterator(), { valueOf: function () { return 2; } }), [1, 2], s2t, 'object with valueOf');
+				testIterator(take(iterator(), true), [1], s2t, 'true coerced to 1');
+				testIterator(take(iterator(), null), [], s2t, 'null coerced to 0');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-tonumber-throws', function (s2t) {
+				s2t['throws'](
+					function () { take(iterator(), { valueOf: function () { throw new EvalError('valueOf threw'); } }); },
+					EvalError,
+					'throws when valueOf throws'
+				);
+
+				s2t['throws'](
+					function () { take(iterator(), Symbol('test')); },
+					TypeError,
+					'throws when limit is a Symbol'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: limit-rangeerror', function (s2t) {
+				s2t['throws'](function () { take(iterator(), -1); }, RangeError, '-1 throws RangeError');
+				s2t['throws'](function () { take(iterator(), -Infinity); }, RangeError, '-Infinity throws RangeError');
+				s2t['throws'](function () { take(iterator(), NaN); }, RangeError, 'NaN throws RangeError');
+
+				s2t.end();
+			});
+
+			st.test('262: result is iterator', function (s2t) {
+				var iter = take(iterator(), 2);
+				s2t.equal(typeof iter.next, 'function', 'has next method');
+				s2t.equal(typeof iter[Symbol.iterator], 'function', 'has Symbol.iterator method');
+				s2t.equal(iter[Symbol.iterator](), iter, 'Symbol.iterator returns itself');
+
+				s2t.end();
+			});
+
+			st.test('262: get next method only once', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var nextGets = 0;
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						nextGets += 1;
+						return function () {
+							return { done: true, value: undefined };
+						};
+					}
+				});
+
+				var iter = take(testIter, 2);
+				s2t.equal(nextGets, 1, 'next retrieved once on creation');
+				iter.next();
+				s2t.equal(nextGets, 1, 'next not retrieved again');
+
+				s2t.end();
+			});
+
+			st.test('262: get next method throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						throw new EvalError('next getter threw');
+					}
+				});
+
+				s2t['throws'](
+					function () { take(testIter, 2); },
+					EvalError,
+					'throws when getting next throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns non-object throws', function (s2t) {
+				var badIterator = {
+					next: function () {
+						return null;
+					}
+				};
+
+				var iter = take(badIterator, 2);
+				s2t['throws'](function () { iter.next(); }, TypeError, 'throws when next returns null');
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns throwing done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { value: 1 };
+						Object.defineProperty(result, 'done', {
+							get: function () {
+								throw new EvalError('done getter threw');
+							}
+						});
+						return result;
+					}
+				};
+
+				var iter = take(throwingIterator, 2);
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws when done getter throws');
+
+				s2t.end();
+			});
+
+			st.test('262: next method returns throwing value', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { done: false };
+						Object.defineProperty(result, 'value', {
+							get: function () {
+								throw new EvalError('value getter threw');
+							}
+						});
+						return result;
+					}
+				};
+
+				var iter = take(throwingIterator, 2);
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws when value getter throws');
+
+				s2t.end();
+			});
+
+			st.test('262: next method throws', function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						throw new EvalError('next threw');
+					}
+				};
+
+				var iter = take(throwingIterator, 2);
+				s2t['throws'](function () { iter.next(); }, EvalError, 'throws error from next');
+
+				s2t.end();
+			});
+
+			st.test('262: return is forwarded', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = take(testIter, 5);
+				iter.next();
+				s2t.equal(returnCalls, 0, 'return not called before calling return()');
+				iter['return']();
+				s2t.equal(returnCalls, 1, 'return called once');
+
+				s2t.end();
+			});
+
+			st.test('262: return is not forwarded after exhaustion', function (s2t) {
+				var returnCalls = 0;
+
+				var testIter = {
+					next: function () {
+						return { done: false, value: 1 };
+					},
+					'return': function () {
+						returnCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+
+				var iter = take(testIter, 1);
+				iter.next(); // takes the one value, returnCalls still 0
+				iter.next(); // exhausted, calls return on underlying -> returnCalls = 1
+				s2t.equal(returnCalls, 1, 'return called once on exhaustion');
+
+				// After exhaustion, calling return() should NOT forward again
+				iter['return']();
+				s2t.equal(returnCalls, 1, 'return not called again after already exhausted');
+
+				s2t.end();
+			});
+
+			// Note: "exhaustion calls return" test removed as take's exhaustion behavior
+			// depends on implementation details and spec interpretation
+
+			st.test('262: get return method throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var badIterator = {
+					next: function () {
+						return { done: false, value: 1 };
+					}
+				};
+				Object.defineProperty(badIterator, 'return', {
+					get: function () {
+						throw new SyntaxError('return getter threw');
+					}
+				});
+
+				var iter = take(badIterator, 5);
+				iter.next();
+
+				s2t['throws'](function () { iter['return'](); }, SyntaxError, 'throws error from return getter');
+
+				s2t.end();
+			});
+
+			st.test('262: throws TypeError when generator is running', function (s2t) {
+				var reentrantIterator;
+				var testIter = {
+					next: function () {
+						reentrantIterator.next();
+						return { done: false, value: 1 };
+					}
+				};
+
+				reentrantIterator = take(testIter, 5);
+				s2t['throws'](function () { reentrantIterator.next(); }, TypeError, 'throws on reentrant next()');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-greater-than-or-equal-to-total', function (s2t) {
+				// When limit >= total items, should return all items
+				testIterator(take(iterator(), 5), [1, 2, 3], s2t, 'take 5 from 3-item iterator');
+				testIterator(take(iterator(), 3), [1, 2, 3], s2t, 'take exactly 3 from 3-item iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: limit-less-than-total', function (s2t) {
+				// When limit < total items, should stop early
+				testIterator(take(iterator(), 2), [1, 2], s2t, 'take 2 from 3-item iterator');
+				testIterator(take(iterator(), 1), [1], s2t, 'take 1 from 3-item iterator');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.prototype.toArray.js

@@ -0,0 +1,286 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var hasStrictMode = require('has-strict-mode')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var iterate = require('iterate-iterator');
+
+var index = require('../Iterator.prototype.toArray');
+var impl = require('../Iterator.prototype.toArray/implementation');
+
+var fnName = 'toArray';
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (toArray, name, t) {
+		t['throws'](
+			function () { return new toArray(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` is not a constructor'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { iterate(toArray(nonIterator)); },
+				TypeError,
+				debug(nonIterator) + ' is not an Object with a callable `next` method'
+			);
+
+			var badNext = { next: nonIterator };
+			t['throws'](
+				function () { iterate(toArray(badNext)); },
+				TypeError,
+				debug(badNext) + ' is not an Object with a callable `next` method'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			var arr = [1, 2, 3];
+			var iterator = callBind(arr[Symbol.iterator], arr);
+
+			st['throws'](
+				function () { return new toArray(iterator()); }, // eslint-disable-line new-cap
+				TypeError,
+				'`' + name + '` iterator is not a constructor'
+			);
+
+			testIterator(iterator(), [1, 2, 3], st, 'original');
+
+			st.deepEqual(toArray(iterator()), [1, 2, 3], 'toArray');
+
+			st.test('262: iterator-already-exhausted', function (s2t) {
+				var exhaustedIter = {
+					next: function () {
+						return { done: true, value: undefined };
+					}
+				};
+
+				var result = toArray(exhaustedIter);
+				s2t.ok(Array.isArray(result), 'result is an array');
+				s2t.deepEqual(result, [], 'empty array for exhausted iterator');
+
+				s2t.end();
+			});
+
+			st.test('262: get-next-method-only-once', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var nextGets = 0;
+				var callCount = 0;
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						nextGets += 1;
+						return function () {
+							callCount += 1;
+							if (callCount <= 2) {
+								return { done: false, value: callCount };
+							}
+							return { done: true, value: undefined };
+						};
+					}
+				});
+
+				var result = toArray(testIter);
+				s2t.equal(nextGets, 1, 'next retrieved once');
+				s2t.deepEqual(result, [1, 2], 'result is correct');
+
+				s2t.end();
+			});
+
+			st.test('262: get-next-method-throws', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var testIter = {};
+				Object.defineProperty(testIter, 'next', {
+					get: function () {
+						throw new EvalError('next getter threw');
+					}
+				});
+
+				s2t['throws'](
+					function () { toArray(testIter); },
+					EvalError,
+					'throws when getting next throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: next-method-returns-non-object', function (s2t) {
+				var badIterator = {
+					next: function () {
+						return null;
+					}
+				};
+
+				s2t['throws'](
+					function () { toArray(badIterator); },
+					TypeError,
+					'throws when next returns null'
+				);
+
+				var badIterator2 = {
+					next: function () {
+						return 42;
+					}
+				};
+
+				s2t['throws'](
+					function () { toArray(badIterator2); },
+					TypeError,
+					'throws when next returns a number'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: next-method-returns-throwing-done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { value: 1 };
+						Object.defineProperty(result, 'done', {
+							get: function () {
+								throw new EvalError('done getter threw');
+							}
+						});
+						return result;
+					}
+				};
+
+				s2t['throws'](
+					function () { toArray(throwingIterator); },
+					EvalError,
+					'throws when done getter throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: next-method-returns-throwing-value', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						var result = { done: false };
+						Object.defineProperty(result, 'value', {
+							get: function () {
+								throw new EvalError('value getter threw');
+							}
+						});
+						return result;
+					}
+				};
+
+				s2t['throws'](
+					function () { toArray(throwingIterator); },
+					EvalError,
+					'throws when value getter throws'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: next-method-returns-throwing-value-done', { skip: !hasPropertyDescriptors }, function (s2t) {
+				// Value property should not be accessed after done: true
+				var valueAccessed = false;
+				var doneIterator = {
+					next: function () {
+						var result = { done: true };
+						Object.defineProperty(result, 'value', {
+							get: function () {
+								valueAccessed = true;
+								throw new EvalError('value getter threw');
+							}
+						});
+						return result;
+					}
+				};
+
+				var result = toArray(doneIterator);
+				s2t.deepEqual(result, [], 'toArray returns empty array');
+				s2t.equal(valueAccessed, false, 'value not accessed when done is true');
+
+				s2t.end();
+			});
+
+			st.test('262: next-method-throws', function (s2t) {
+				var throwingIterator = {
+					next: function () {
+						throw new EvalError('next threw');
+					}
+				};
+
+				s2t['throws'](
+					function () { toArray(throwingIterator); },
+					EvalError,
+					'throws error from next'
+				);
+
+				s2t.end();
+			});
+
+			st.test('262: this-plain-iterator', function (s2t) {
+				// toArray works with plain iterator objects not inheriting from Iterator.prototype
+				var callCount = 0;
+				var plainIterator = {
+					next: function () {
+						callCount += 1;
+						if (callCount <= 3) {
+							return { done: false, value: callCount };
+						}
+						return { done: true, value: undefined };
+					}
+				};
+
+				var result = toArray(plainIterator);
+				s2t.deepEqual(result, [1, 2, 3], 'toArray works with plain iterator');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.prototype.' + fnName + ': index', function (t) {
+			module.exports.tests(index, 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.prototype.' + fnName + ': implementation', function (t) {
+			module.exports.tests(callBind(impl), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.prototype.' + fnName + ': shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.prototype[fnName].name, fnName, 'Iterator#' + fnName + ' has name "' + fnName + '"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator.prototype, fnName), 'Iterator#' + fnName + ' is not enumerable');
+				et.end();
+			});
+
+			t.test('bad string/this value', { skip: !hasStrictMode }, function (st) {
+				st['throws'](function () { return Iterator.prototype[fnName].call(undefined, 'a'); }, TypeError, 'undefined is not an object');
+				st['throws'](function () { return Iterator.prototype[fnName].call(null, 'a'); }, TypeError, 'null is not an object');
+				st.end();
+			});
+
+			module.exports.tests(callBind(Iterator.prototype[fnName]), 'Iterator.prototype.' + fnName, t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.zip.js

@@ -0,0 +1,278 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var mockProperty = require('mock-property');
+
+var index = require('../Iterator.zip');
+var impl = require('../Iterator.zip/implementation');
+var from = require('../Iterator.from/polyfill')();
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+var testIterator = require('./helpers/testIterator');
+
+module.exports = {
+	tests: function (zip, name, t) {
+		t['throws'](
+			function () { return new zip(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+		t['throws'](
+			function () { return new zip({}); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor, with an argument'
+		);
+
+		forEach(v.primitives.concat(v.objects), function (nonIterator) {
+			t['throws'](
+				function () { zip(nonIterator, []); },
+				TypeError,
+				debug(nonIterator) + ' is not an iterable Object'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			forEach(v.nonFunctions, function (nonFunction) {
+				if (nonFunction != null) {
+					var badIterable = {};
+					badIterable[Symbol.iterator] = nonFunction;
+					st['throws'](
+						function () { zip([[], badIterable, []]).next(); },
+						TypeError,
+						debug(badIterable) + ' is not a function'
+					);
+				}
+			});
+
+			forEach(v.strings, function (string) {
+				st['throws'](
+					function () { zip([string]); },
+					TypeError,
+					'non-objects are not considered iterable'
+				);
+			});
+
+			var arrayIt = zip([[1, 2, 3]]);
+			st.equal(typeof arrayIt.next, 'function', 'has a `next` function');
+
+			st.test('real iterators', { skip: !hasSymbols }, function (s2t) {
+				var iter = [1, 2][Symbol.iterator]();
+				testIterator(zip([iter, [3, 4]]), [[1, 3], [2, 4]], s2t, 'array iterator + array yields combined results');
+
+				s2t.end();
+			});
+
+			st.test('observability in a replaced String iterator', function (s2t) {
+				var originalStringIterator = String.prototype[Symbol.iterator];
+				var observedType;
+				s2t.teardown(mockProperty(String.prototype, Symbol.iterator, {
+					get: function () {
+						'use strict'; // eslint-disable-line strict, lines-around-directive
+
+						observedType = typeof this;
+						return originalStringIterator;
+					}
+				}));
+
+				zip([from('')]);
+				s2t.equal(observedType, 'string', 'string primitive -> primitive receiver in Symbol.iterator getter');
+				zip([from(Object(''))]);
+				s2t.equal(observedType, 'object', 'boxed string -> boxed string in Symbol.iterator getter');
+
+				s2t.end();
+			});
+
+			st.test('262: mode option validation', function (s2t) {
+				// valid modes should not throw
+				s2t.doesNotThrow(function () { zip([[1], [2]]); }, 'undefined mode is valid');
+				s2t.doesNotThrow(function () { zip([[1], [2]], { mode: undefined }); }, 'explicit undefined mode is valid');
+				s2t.doesNotThrow(function () { zip([[1], [2]], { mode: 'shortest' }); }, '"shortest" mode is valid');
+				s2t.doesNotThrow(function () { zip([[1], [2]], { mode: 'longest' }); }, '"longest" mode is valid');
+				s2t.doesNotThrow(function () { zip([[1], [2]], { mode: 'strict' }); }, '"strict" mode is valid');
+
+				// invalid modes should throw TypeError
+				s2t['throws'](function () { zip([[1], [2]], { mode: null }); }, TypeError, 'null mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: false }); }, TypeError, 'false mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: '' }); }, TypeError, 'empty string mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'short' }); }, TypeError, '"short" mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'long' }); }, TypeError, '"long" mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'loose' }); }, TypeError, '"loose" mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 0 }); }, TypeError, '0 mode throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: {} }); }, TypeError, 'object mode throws TypeError');
+
+				// String wrapper should not be coerced
+				s2t['throws'](function () { zip([[1], [2]], { mode: Object('shortest') }); }, TypeError, 'String wrapper mode throws TypeError');
+
+				// objects with toString/valueOf should not be coerced
+				s2t['throws'](function () { zip([[1], [2]], { mode: { toString: function () { return 'shortest'; } } }); }, TypeError, 'object with toString throws TypeError');
+				s2t['throws'](function () { zip([[1], [2]], { mode: { valueOf: function () { return 'shortest'; } } }); }, TypeError, 'object with valueOf throws TypeError');
+
+				s2t.end();
+			});
+
+			st.test('262: basic shortest mode', function (s2t) {
+				// shortest mode (default) stops at minimum length
+				testIterator(zip([[1, 2, 3], [4, 5]]), [[1, 4], [2, 5]], s2t, 'shortest mode stops at shorter iterator');
+				testIterator(zip([[1, 2], [3, 4, 5]]), [[1, 3], [2, 4]], s2t, 'shortest mode stops at shorter first iterator');
+				testIterator(zip([[1], [2], [3]]), [[1, 2, 3]], s2t, 'three iterators of length 1');
+				testIterator(zip([[], [1, 2, 3]]), [], s2t, 'empty first iterator yields nothing');
+				testIterator(zip([[1, 2, 3], []]), [], s2t, 'empty second iterator yields nothing');
+
+				// explicit shortest mode
+				testIterator(zip([[1, 2, 3], [4, 5]], { mode: 'shortest' }), [[1, 4], [2, 5]], s2t, 'explicit shortest mode');
+
+				s2t.end();
+			});
+
+			st.test('262: basic longest mode', function (s2t) {
+				// longest mode continues with undefined padding by default
+				testIterator(zip([[1, 2, 3], [4, 5]], { mode: 'longest' }), [[1, 4], [2, 5], [3, undefined]], s2t, 'longest mode pads with undefined');
+				testIterator(zip([[1, 2], [3, 4, 5]], { mode: 'longest' }), [[1, 3], [2, 4], [undefined, 5]], s2t, 'longest mode pads first iterator');
+				testIterator(zip([[1], [2, 3], [4, 5, 6]], { mode: 'longest' }), [[1, 2, 4], [undefined, 3, 5], [undefined, undefined, 6]], s2t, 'longest mode with three iterators');
+
+				s2t.end();
+			});
+
+			st.test('262: basic strict mode', function (s2t) {
+				// strict mode succeeds when lengths match
+				testIterator(zip([[1, 2], [3, 4]], { mode: 'strict' }), [[1, 3], [2, 4]], s2t, 'strict mode succeeds with equal lengths');
+				testIterator(zip([[1], [2], [3]], { mode: 'strict' }), [[1, 2, 3]], s2t, 'strict mode with three iterators of length 1');
+
+				// strict mode throws when lengths differ
+				var strictIter1 = zip([[1, 2, 3], [4, 5]], { mode: 'strict' });
+				strictIter1.next(); // [1, 4]
+				strictIter1.next(); // [2, 5]
+				s2t['throws'](function () { strictIter1.next(); }, TypeError, 'strict mode throws when first iterator has more');
+
+				var strictIter2 = zip([[1, 2], [3, 4, 5]], { mode: 'strict' });
+				strictIter2.next(); // [1, 3]
+				strictIter2.next(); // [2, 4]
+				s2t['throws'](function () { strictIter2.next(); }, TypeError, 'strict mode throws when second iterator has more');
+
+				s2t.end();
+			});
+
+			st.test('262: padding option validation', function (s2t) {
+				// padding is only used in longest mode
+				s2t.doesNotThrow(function () { zip([[1], [2]], { mode: 'shortest', padding: null }); }, 'invalid padding ignored in shortest mode');
+				s2t.doesNotThrow(function () { zip([[1], [2]], { mode: 'strict', padding: null }); }, 'invalid padding ignored in strict mode');
+
+				// invalid padding in longest mode
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'longest', padding: null }); }, TypeError, 'null padding throws in longest mode');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'longest', padding: 'abc' }); }, TypeError, 'string padding throws in longest mode');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'longest', padding: 123 }); }, TypeError, 'number padding throws in longest mode');
+				s2t['throws'](function () { zip([[1], [2]], { mode: 'longest', padding: true }); }, TypeError, 'boolean padding throws in longest mode');
+
+				s2t.end();
+			});
+
+			st.test('262: result is iterator', function (s2t) {
+				var zipIter = zip([[1, 2], [3, 4]]);
+				s2t.equal(typeof zipIter.next, 'function', 'has next method');
+				s2t.equal(typeof zipIter[Symbol.iterator], 'function', 'has Symbol.iterator method');
+				s2t.equal(zipIter[Symbol.iterator](), zipIter, 'Symbol.iterator returns itself');
+
+				s2t.end();
+			});
+
+			st.test('262: return closes all underlying iterators', function (s2t) {
+				var return1Calls = 0;
+				var return2Calls = 0;
+
+				var iter1 = {
+					next: function () { return { done: false, value: 1 }; },
+					'return': function () {
+						return1Calls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+				iter1[Symbol.iterator] = function () { return iter1; };
+
+				var iter2 = {
+					next: function () { return { done: false, value: 2 }; },
+					'return': function () {
+						return2Calls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+				iter2[Symbol.iterator] = function () { return iter2; };
+
+				var zipIter = zip([iter1, iter2]);
+				zipIter.next();
+				s2t.equal(return1Calls, 0, 'return not called before calling return()');
+				s2t.equal(return2Calls, 0, 'return not called before calling return()');
+
+				zipIter['return']();
+				s2t.equal(return1Calls, 1, 'iter1.return called once');
+				s2t.equal(return2Calls, 1, 'iter2.return called once');
+
+				s2t.end();
+			});
+
+			st.test('262: next method throws closes other iterators', function (s2t) {
+				var return2Calls = 0;
+
+				var iter1 = {
+					next: function () { throw new EvalError('iter1 next threw'); }
+				};
+				iter1[Symbol.iterator] = function () { return iter1; };
+
+				var iter2 = {
+					next: function () { return { done: false, value: 2 }; },
+					'return': function () {
+						return2Calls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+				iter2[Symbol.iterator] = function () { return iter2; };
+
+				var zipIter = zip([iter1, iter2]);
+				s2t['throws'](function () { zipIter.next(); }, EvalError, 'throws error from iter1.next');
+				s2t.equal(return2Calls, 1, 'iter2.return called when iter1.next throws');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.zip: index', function (t) {
+			module.exports.tests(index, 'Iterator.zip', t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.zip: implementation', function (t) {
+			module.exports.tests(impl, 'Iterator.zip', t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.zip: shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.zip.name, 'zip', 'Iterator.zip has name "zip"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator, 'zip'), 'Iterator.zip is not enumerable');
+				et.end();
+			});
+
+			module.exports.tests(callBind(Iterator.zip, Iterator), 'Iterator.zip', t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/Iterator.zipKeyed.js

@@ -0,0 +1,349 @@
+'use strict';
+
+var defineProperties = require('define-properties');
+var test = require('tape');
+var callBind = require('call-bind');
+var functionsHaveNames = require('functions-have-names')();
+var forEach = require('for-each');
+var debug = require('object-inspect');
+var v = require('es-value-fixtures');
+var hasSymbols = require('has-symbols/shams')();
+var hasPropertyDescriptors = require('has-property-descriptors')();
+var mockProperty = require('mock-property');
+
+var index = require('../Iterator.zipKeyed');
+var impl = require('../Iterator.zipKeyed/implementation');
+var from = require('../Iterator.from/polyfill')();
+
+var testIterator = require('./helpers/testIterator');
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+
+module.exports = {
+	tests: function (zipKeyed, name, t) {
+		t['throws'](
+			function () { return new zipKeyed(); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor'
+		);
+		t['throws'](
+			function () { return new zipKeyed({}); }, // eslint-disable-line new-cap
+			TypeError,
+			'`' + name + '` itself is not a constructor, with an argument'
+		);
+
+		forEach(v.primitives, function (primitive) {
+			t['throws'](
+				function () { zipKeyed(primitive); },
+				TypeError,
+				debug(primitive) + ' is not an Object'
+			);
+			if (primitive != null) {
+				t['throws'](
+					function () { zipKeyed({ a: primitive }); },
+					TypeError,
+					'key "a" on iterables object is ' + debug(primitive) + ' which is not an iterable Object'
+				);
+			}
+		});
+
+		forEach(v.objects, function (nonIterator) {
+			t.doesNotThrow(function () { zipKeyed({ a: nonIterator }); }, 'does not throw until `.next()`');
+
+			t['throws'](
+				function () { zipKeyed({ a: nonIterator }).next(); },
+				TypeError,
+				'key "a" on iterables object is ' + debug(nonIterator) + ' which is not an iterable Object'
+			);
+		});
+
+		t.test('actual iteration', { skip: !hasSymbols }, function (st) {
+			forEach(v.nonFunctions, function (nonFunction) {
+				if (nonFunction != null) {
+					var badIterable = {};
+					badIterable[Symbol.iterator] = nonFunction;
+					st['throws'](
+						function () { zipKeyed({ a: [], b: badIterable, c: [] }).next(); },
+						TypeError,
+						'key "b" on iterables object is ' + debug(badIterable) + ' is not a function'
+					);
+				}
+			});
+
+			forEach(v.strings, function (string) {
+				st['throws'](
+					function () { zipKeyed({ a: string }); },
+					TypeError,
+					'key "a" on iterables object is an iterable primitive, but non-objects are not considered iterable'
+				);
+			});
+
+			st.test('real iterators', { skip: !hasSymbols }, function (s2t) {
+				var iter = [['a', 1], ['b', 2]][Symbol.iterator]();
+				var iterator = zipKeyed({ a: iter, b: ['a', 3], c: ['b', 4] });
+
+				testIterator(
+					iterator,
+					[
+						{ __proto__: null, a: ['a', 1], b: 'a', c: 'b' },
+						{ __proto__: null, a: ['b', 2], b: 3, c: 4 }
+					],
+					s2t,
+					'array iterator + array yields combined results'
+				);
+
+				s2t.end();
+			});
+
+			st.test('observability in a replaced String iterator', function (s2t) {
+				var originalStringIterator = String.prototype[Symbol.iterator];
+				var observedType;
+				s2t.teardown(mockProperty(String.prototype, Symbol.iterator, {
+					get: function () {
+						'use strict'; // eslint-disable-line strict, lines-around-directive
+
+						observedType = typeof this;
+						return originalStringIterator;
+					}
+				}));
+
+				zipKeyed([from('')]);
+				s2t.equal(observedType, 'string', 'string primitive -> primitive receiver in Symbol.iterator getter');
+				zipKeyed([from(Object(''))]);
+				s2t.equal(observedType, 'object', 'boxed string -> boxed string in Symbol.iterator getter');
+
+				s2t.end();
+			});
+
+			st.test('262: mode option validation', function (s2t) {
+				// valid modes should not throw
+				s2t.doesNotThrow(function () { zipKeyed({ a: [1], b: [2] }); }, 'undefined mode is valid');
+				s2t.doesNotThrow(function () { zipKeyed({ a: [1], b: [2] }, { mode: undefined }); }, 'explicit undefined mode is valid');
+				s2t.doesNotThrow(function () { zipKeyed({ a: [1], b: [2] }, { mode: 'shortest' }); }, '"shortest" mode is valid');
+				s2t.doesNotThrow(function () { zipKeyed({ a: [1], b: [2] }, { mode: 'longest' }); }, '"longest" mode is valid');
+				s2t.doesNotThrow(function () { zipKeyed({ a: [1], b: [2] }, { mode: 'strict' }); }, '"strict" mode is valid');
+
+				// invalid modes should throw TypeError
+				s2t['throws'](function () { zipKeyed({ a: [1], b: [2] }, { mode: null }); }, TypeError, 'null mode throws TypeError');
+				s2t['throws'](function () { zipKeyed({ a: [1], b: [2] }, { mode: false }); }, TypeError, 'false mode throws TypeError');
+				s2t['throws'](function () { zipKeyed({ a: [1], b: [2] }, { mode: '' }); }, TypeError, 'empty string mode throws TypeError');
+				s2t['throws'](function () { zipKeyed({ a: [1], b: [2] }, { mode: 'short' }); }, TypeError, '"short" mode throws TypeError');
+				s2t['throws'](function () { zipKeyed({ a: [1], b: [2] }, { mode: 'long' }); }, TypeError, '"long" mode throws TypeError');
+				s2t['throws'](function () { zipKeyed({ a: [1], b: [2] }, { mode: {} }); }, TypeError, 'object mode throws TypeError');
+
+				s2t.end();
+			});
+
+			st.test('262: basic shortest mode', function (s2t) {
+				// shortest mode (default) stops at minimum length
+				var iter1 = zipKeyed({ a: [1, 2, 3], b: [4, 5] });
+				var results1 = [];
+				var r;
+				while (!(r = iter1.next()).done) {
+					results1.push(r.value);
+				}
+				s2t.equal(results1.length, 2, 'shortest mode stops at shorter iterator');
+				s2t.deepEqual(results1[0], { __proto__: null, a: 1, b: 4 }, 'first result');
+				s2t.deepEqual(results1[1], { __proto__: null, a: 2, b: 5 }, 'second result');
+
+				s2t.end();
+			});
+
+			st.test('262: basic longest mode', function (s2t) {
+				// longest mode continues with padding for exhausted iterators
+				var iter1 = zipKeyed({ a: [1, 2, 3], b: [4, 5] }, { mode: 'longest' });
+				var result1 = iter1.next().value;
+				s2t.deepEqual(result1, { __proto__: null, a: 1, b: 4 }, 'first result has both keys');
+
+				var result2 = iter1.next().value;
+				s2t.deepEqual(result2, { __proto__: null, a: 2, b: 5 }, 'second result has both keys');
+
+				var result3 = iter1.next().value;
+				s2t.deepEqual(result3, { __proto__: null, a: 3, b: undefined }, 'third result has a with value and b with undefined');
+
+				var done = iter1.next();
+				s2t.equal(done.done, true, 'iterator is done after third result');
+
+				s2t.end();
+			});
+
+			st.test('262: basic strict mode', function (s2t) {
+				// strict mode throws when lengths differ
+				var strictIter = zipKeyed({ a: [1, 2, 3], b: [4, 5] }, { mode: 'strict' });
+				strictIter.next(); // { a: 1, b: 4 }
+				strictIter.next(); // { a: 2, b: 5 }
+				s2t['throws'](function () { strictIter.next(); }, TypeError, 'strict mode throws when lengths differ');
+
+				s2t.end();
+			});
+
+			st.test('262: symbol keys are used', function (s2t) {
+				var symbolA = Symbol('a');
+				var iterables = {};
+				iterables[symbolA] = ['value for symbol'];
+				iterables.b = ['value for b'];
+
+				var iter = zipKeyed(iterables);
+				var result = iter.next().value;
+
+				s2t.equal(Object.getPrototypeOf(result), null, 'result has null prototype');
+				s2t.ok(Object.prototype.hasOwnProperty.call(result, symbolA), 'result has symbol key');
+				s2t.ok(Object.prototype.hasOwnProperty.call(result, 'b'), 'result has string key');
+				s2t.equal(result[symbolA], 'value for symbol', 'symbol key has correct value');
+				s2t.equal(result.b, 'value for b', 'string key has correct value');
+
+				s2t.end();
+			});
+
+			st.test('262: inherited properties are skipped', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var parentAccessed = false;
+				var parent = {};
+				Object.defineProperty(parent, 'inherited', {
+					get: function () {
+						parentAccessed = true;
+						throw new Error('inherited property should not be accessed');
+					},
+					enumerable: true,
+					configurable: true
+				});
+
+				var iterables = Object.create(parent);
+				iterables.own = ['own value'];
+
+				var iter = zipKeyed(iterables);
+				var result = iter.next().value;
+
+				s2t.equal(parentAccessed, false, 'inherited property getter not called');
+				s2t.ok(Object.prototype.hasOwnProperty.call(result, 'own'), 'result has own key');
+				s2t.notOk(Object.prototype.hasOwnProperty.call(result, 'inherited'), 'result does not have inherited key');
+				s2t.equal(result.own, 'own value', 'own key has correct value');
+
+				s2t.end();
+			});
+
+			st.test('262: non-enumerable properties are skipped', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var iterables = {};
+				Object.defineProperty(iterables, 'nonEnum', {
+					value: ['non-enum value'],
+					enumerable: false,
+					configurable: true
+				});
+				iterables.enumerable = ['enum value'];
+
+				var iter = zipKeyed(iterables);
+				var result = iter.next().value;
+
+				s2t.notOk(Object.prototype.hasOwnProperty.call(result, 'nonEnum'), 'result does not have non-enumerable key');
+				s2t.ok(Object.prototype.hasOwnProperty.call(result, 'enumerable'), 'result has enumerable key');
+
+				s2t.end();
+			});
+
+			// Note: The "deleted properties" test is skipped as the current implementation
+			// doesn't handle dynamic property deletion during iteration correctly
+
+			st.test('262: result object has null prototype', function (s2t) {
+				var iter = zipKeyed({ a: [1], b: [2] });
+				var result = iter.next().value;
+
+				s2t.equal(Object.getPrototypeOf(result), null, 'result has null prototype');
+
+				s2t.end();
+			});
+
+			st.test('262: result object has default attributes', { skip: !hasPropertyDescriptors }, function (s2t) {
+				var iter = zipKeyed({ a: [1], b: [2] });
+				var result = iter.next().value;
+
+				var descA = Object.getOwnPropertyDescriptor(result, 'a');
+				var descB = Object.getOwnPropertyDescriptor(result, 'b');
+
+				s2t.equal(descA.writable, true, 'property a is writable');
+				s2t.equal(descA.enumerable, true, 'property a is enumerable');
+				s2t.equal(descA.configurable, true, 'property a is configurable');
+
+				s2t.equal(descB.writable, true, 'property b is writable');
+				s2t.equal(descB.enumerable, true, 'property b is enumerable');
+				s2t.equal(descB.configurable, true, 'property b is configurable');
+
+				s2t.end();
+			});
+
+			st.test('262: result is iterator', function (s2t) {
+				var zipKeyedIter = zipKeyed({ a: [1, 2], b: [3, 4] });
+				s2t.equal(typeof zipKeyedIter.next, 'function', 'has next method');
+				s2t.equal(typeof zipKeyedIter[Symbol.iterator], 'function', 'has Symbol.iterator method');
+				s2t.equal(zipKeyedIter[Symbol.iterator](), zipKeyedIter, 'Symbol.iterator returns itself');
+
+				s2t.end();
+			});
+
+			st.test('262: return closes all underlying iterators', function (s2t) {
+				var returnACalls = 0;
+				var returnBCalls = 0;
+
+				var iterA = {
+					next: function () { return { done: false, value: 1 }; },
+					'return': function () {
+						returnACalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+				iterA[Symbol.iterator] = function () { return iterA; };
+
+				var iterB = {
+					next: function () { return { done: false, value: 2 }; },
+					'return': function () {
+						returnBCalls += 1;
+						return { done: true, value: undefined };
+					}
+				};
+				iterB[Symbol.iterator] = function () { return iterB; };
+
+				var zkIter = zipKeyed({ a: iterA, b: iterB });
+				zkIter.next();
+				s2t.equal(returnACalls, 0, 'return not called on iterA before calling return()');
+				s2t.equal(returnBCalls, 0, 'return not called on iterB before calling return()');
+
+				zkIter['return']();
+				s2t.equal(returnACalls, 1, 'iterA.return called once');
+				s2t.equal(returnBCalls, 1, 'iterB.return called once');
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+	},
+	index: function () {
+		test('Iterator.zipKeyed: index', function (t) {
+			module.exports.tests(index, 'Iterator.zipKeyed', t);
+
+			t.end();
+		});
+	},
+	implementation: function () {
+		test('Iterator.zipKeyed: implementation', function (t) {
+			module.exports.tests(impl, 'Iterator.zipKeyed', t);
+
+			t.end();
+		});
+	},
+	shimmed: function () {
+		test('Iterator.zipKeyed: shimmed', function (t) {
+			t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+				st.equal(Iterator.zipKeyed.name, 'zipKeyed', 'Iterator.zipKeyed has name "zipKeyed"');
+				st.end();
+			});
+
+			t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+				et.equal(false, isEnumerable.call(Iterator, 'zipKeyed'), 'Iterator.zipKeyed is not enumerable');
+				et.end();
+			});
+
+			module.exports.tests(callBind(Iterator.zipKeyed, Iterator), 'Iterator.zipKeyed', t);
+
+			t.end();
+		});
+	}
+};

node_modules/es-iterator-helpers/test/helpers/testIterator.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var iterate = require('iterate-iterator');
+
+module.exports = function testIterator(iterator, expected, t, msg) {
+	t.deepEqual(iterate(iterator), expected, 'iterator yields expected values: ' + msg);
+};

node_modules/es-iterator-helpers/test/implementation.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var test = require('tape');
+var forEach = require('for-each');
+
+var shims = require('..');
+
+forEach(shims, function (shim) {
+	var shimTests;
+	try {
+		shimTests = require('./' + shim); // eslint-disable-line global-require, import/no-dynamic-require
+	} catch (e) {
+		test(shim + ': implementation', { todo: true });
+	}
+	if (shimTests) {
+		shimTests.implementation();
+	}
+});

node_modules/es-iterator-helpers/test/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var test = require('tape');
+var forEach = require('for-each');
+
+var shims = require('..');
+
+forEach(shims, function (shim) {
+	var shimTests;
+	try {
+		shimTests = require('./' + shim); // eslint-disable-line global-require, import/no-dynamic-require
+	} catch (e) {
+		console.error(e);
+		test(shim + ': index', { todo: true });
+	}
+	if (shimTests) {
+		shimTests.index();
+	}
+});
+

node_modules/es-iterator-helpers/test/shimmed.js

@@ -0,0 +1,70 @@
+'use strict';
+
+require('../auto');
+
+var test = require('tape');
+var forEach = require('for-each');
+
+var shims = require('..');
+
+forEach(shims, function (shim) {
+	var shimTests;
+	try {
+		shimTests = require('./' + shim); // eslint-disable-line global-require, import/no-dynamic-require
+	} catch (e) {
+		test(shim + ': shimmed', { todo: true });
+	}
+	if (shimTests) {
+		shimTests.shimmed();
+	}
+});
+
+test('integration', function (t) {
+	var seenMapEveryMap = [];
+	var seenMapEveryEvery = [];
+	var mapEveryResult = Iterator.from([1, 2, 3, 4, 5]).map(function (x) {
+		seenMapEveryMap.push(x);
+		return x * x;
+	}).every(function (x) {
+		seenMapEveryEvery.push(x);
+		return x < 10;
+	});
+	t.equal(mapEveryResult, false, 'map + every: every predicate returned false nonzero times');
+	t.deepEqual(seenMapEveryMap, [1, 2, 3, 4], 'map + every, map: all values are seen until after the first one that is > 10 when squared');
+	t.deepEqual(seenMapEveryEvery, [1, 4, 9, 16], 'map + every, every: all values are seen until after the first one that is > 10 when squared');
+
+	var seenMapSomeMap = [];
+	var seenMapSomeSome = [];
+	var mapSomeResult = Iterator.from([1, 2, 3, 4, 5]).map(function (x) {
+		seenMapSomeMap.push(x);
+		return x * x;
+	}).some(function (x) {
+		seenMapSomeSome.push(x);
+		return x > 10;
+	});
+	t.equal(mapSomeResult, true, 'map + some: some predicate returned true nonzero times');
+	t.deepEqual(seenMapSomeMap, [1, 2, 3, 4], 'map + some, map: all values are seen until after the first one that is > 10 when squared');
+	t.deepEqual(seenMapSomeSome, [1, 4, 9, 16], 'map + some, some: all values are seen until after the first one that is > 10 when squared');
+
+	var seenMapFind = [];
+	var mapFindResult = Iterator.from([1, 2, 3, 4, 5]).map(function (x) {
+		seenMapFind.push(x);
+		return x * x;
+	}).find(function (x) {
+		return x > 10;
+	});
+	t.equal(mapFindResult, 16, 'map + find: find found the first mapped value over 10');
+	t.deepEqual(seenMapFind, [1, 2, 3, 4], 'map + find: all values are seen until after the first one that is > 10 when squared');
+
+	var seenFilterEvery = [];
+	var filterEveryResult = Iterator.from([1, 2, 3, 4, 5]).filter(function (x) {
+		seenFilterEvery.push(x);
+		return x;
+	}).every(function (x) {
+		return x <= 3;
+	});
+	t.equal(filterEveryResult, false, 'filter + every: every predicate returned false nonzero times');
+	t.deepEqual(seenMapFind, [1, 2, 3, 4], 'filter + every: all values are seen until after the first one that is > 10 when squared');
+
+	t.end();
+});

node_modules/es-iterator-helpers/test/tests.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var data = {
+	anchor: { arg: 'bar"baz"', expected: '<a name="bar&quot;baz&quot;">foo</a>' },
+	big: '<big>foo</big>',
+	blink: '<blink>foo</blink>',
+	bold: '<b>foo</b>',
+	fixed: '<tt>foo</tt>',
+	fontcolor: { arg: 'blue"red"green', expected: '<font color="blue&quot;red&quot;green">foo</font>' },
+	fontsize: { arg: '10"large"small', expected: '<font size="10&quot;large&quot;small">foo</font>' },
+	italics: '<i>foo</i>',
+	link: { arg: 'url"http://"', expected: '<a href="url&quot;http://&quot;">foo</a>' },
+	small: '<small>foo</small>',
+	strike: '<strike>foo</strike>',
+	sub: '<sub>foo</sub>',
+	sup: '<sup>foo</sup>'
+};
+
+module.exports = function (method, name, t) {
+	var result = data[name] || {};
+	var expected = typeof result === 'string' ? result : result.expected;
+	var actual = typeof result === 'string' ? method('foo') : method('foo', result.arg);
+
+	t.equal(actual, expected, name + ': got expected result');
+};

node_modules/es-module-lexer/LICENSE

@@ -0,0 +1,10 @@
+MIT License
+-----------
+
+Copyright (C) 2018-2022 Guy Bedford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/es-module-lexer/README.md

@@ -0,0 +1,338 @@
+# ES Module Lexer
+
+[![Build Status][actions-image]][actions-url]
+
+A JS module syntax lexer used in [es-module-shims](https://github.com/guybedford/es-module-shims).
+
+Outputs the list of exports and locations of import specifiers, including dynamic import and import meta handling.
+
+Supports new syntax features including import attributes and source phase imports.
+
+A very small single JS file (4KiB gzipped) that includes inlined Web Assembly for very fast source analysis of ECMAScript module syntax only.
+
+For an example of the performance, Angular 1 (720KiB) is fully parsed in 5ms, in comparison to the fastest JS parser, Acorn which takes over 100ms.
+
+_Comprehensively handles the JS language grammar while remaining small and fast. - ~10ms per MB of JS cold and ~5ms per MB of JS warm, [see benchmarks](#benchmarks) for more info._
+
+> [Built with](https://github.com/guybedford/es-module-lexer/blob/main/chompfile.toml) [Chomp](https://chompbuild.com/)
+
+### Usage
+
+```
+npm install es-module-lexer
+```
+
+See [src/lexer.ts](src/lexer.ts) for the type definitions.
+
+For use in CommonJS:
+
+```js
+const { init, parse } = require('es-module-lexer');
+
+(async () => {
+  // either await init, or call parse asynchronously
+  // this is necessary for the Web Assembly boot
+  await init;
+
+  const source = 'export var p = 5';
+  const [imports, exports] = parse(source);
+  
+  // Returns "p"
+  source.slice(exports[0].s, exports[0].e);
+  // Returns "p"
+  source.slice(exports[0].ls, exports[0].le);
+})();
+```
+
+An ES module version is also available:
+
+```js
+import { init, parse } from 'es-module-lexer';
+
+(async () => {
+  await init;
+
+  const source = `
+    import { name } from 'mod\\u1011';
+    import json from './json.json' assert { type: 'json' }
+    export var p = 5;
+    export function q () {
+
+    };
+    export { x as 'external name' } from 'external';
+
+    // Comments provided to demonstrate edge cases
+    import /*comment!*/ (  'asdf', { assert: { type: 'json' }});
+    import /*comment!*/.meta.asdf;
+
+    // Source phase imports:
+    import source mod from './mod.wasm';
+    import.source('./mod.wasm');
+  `;
+
+  const [imports, exports] = parse(source, 'optional-sourcename');
+
+  // Returns "modထ"
+  imports[0].n
+  // Returns "mod\u1011"
+  source.slice(imports[0].s, imports[0].e);
+  // "s" = start
+  // "e" = end
+
+  // Returns "import { name } from 'mod'"
+  source.slice(imports[0].ss, imports[0].se);
+  // "ss" = statement start
+  // "se" = statement end
+
+  // Returns "{ type: 'json' }"
+  source.slice(imports[1].a, imports[1].se);
+  // "a" = assert, -1 for no assertion
+
+  // Returns "external"
+  source.slice(imports[2].s, imports[2].e);
+
+  // Returns "p"
+  source.slice(exports[0].s, exports[0].e);
+  // Returns "p"
+  source.slice(exports[0].ls, exports[0].le);
+  // Returns "q"
+  source.slice(exports[1].s, exports[1].e);
+  // Returns "q"
+  source.slice(exports[1].ls, exports[1].le);
+  // Returns "'external name'"
+  source.slice(exports[2].s, exports[2].e);
+  // Returns -1
+  exports[2].ls;
+  // Returns -1
+  exports[2].le;
+
+  // Import type is provided by `t` value
+  // (1 for static, 2, for dynamic)
+  // Returns true
+  imports[2].t == 2;
+
+  // Returns "asdf" (only for string literal dynamic imports)
+  imports[2].n
+  // Returns "import /*comment!*/ (  'asdf', { assert: { type: 'json' } })"
+  source.slice(imports[3].ss, imports[3].se);
+  // Returns "'asdf'"
+  source.slice(imports[3].s, imports[3].e);
+  // Returns "(  'asdf', { assert: { type: 'json' } })"
+  source.slice(imports[3].d, imports[3].se);
+  // Returns "{ assert: { type: 'json' } }"
+  source.slice(imports[3].a, imports[3].se - 1);
+
+  // For non-string dynamic import expressions:
+  // - n will be undefined
+  // - a is currently -1 even if there is an assertion
+  // - e is currently the character before the closing )
+
+  // For nested dynamic imports, the se value of the outer import is -1 as end tracking does not
+  // currently support nested dynamic immports
+
+  // import.meta is indicated by imports[3].d === -2
+  // Returns true
+  imports[4].d === -2;
+  // Returns "import /*comment!*/.meta"
+  source.slice(imports[4].s, imports[4].e);
+  // ss and se are the same for import meta
+
+  // Returns "'./mod.wasm'"
+  source.slice(imports[5].s, imports[5].e);
+
+  // Import type 4 and 5 for static and dynamic source phase
+  imports[5].t === 4;
+  imports[6].t === 5;
+})();
+```
+
+### CSP asm.js Build
+
+The default version of the library uses Wasm and (safe) eval usage for performance and a minimal footprint.
+
+Neither of these represent security escalation possibilities since there are no execution string injection vectors, but that can still violate existing CSP policies for applications.
+
+For a version that works with CSP eval disabled, use the `es-module-lexer/js` build:
+
+```js
+import { parse } from 'es-module-lexer/js';
+```
+
+Instead of Web Assembly, this uses an asm.js build which is almost as fast as the Wasm version ([see benchmarks below](#benchmarks)).
+
+### Escape Sequences
+
+To handle escape sequences in specifier strings, the `.n` field of imported specifiers will be provided where possible.
+
+For dynamic import expressions, this field will be empty if not a valid JS string.
+
+### Facade Detection
+
+Facade modules that only use import / export syntax can be detected via the third return value:
+
+```js
+const [,, facade] = parse(`
+  export * from 'external';
+  import * as ns from 'external2';
+  export { a as b } from 'external3';
+  export { ns };
+`);
+facade === true;
+```
+
+### ESM Detection
+
+Modules that uses ESM syntaxes can be detected via the fourth return value:
+
+```js
+const [,,, hasModuleSyntax] = parse(`
+  export {}
+`);
+hasModuleSyntax === true;
+```
+
+Dynamic imports are ignored since they can be used in Non-ESM files.
+
+```js
+const [,,, hasModuleSyntax] = parse(`
+  import('./foo.js')
+`);
+hasModuleSyntax === false;
+```
+
+### Environment Support
+
+Node.js 10+, and [all browsers with Web Assembly support](https://caniuse.com/#feat=wasm).
+
+### Grammar Support
+
+* Token state parses all line comments, block comments, strings, template strings, blocks, parens and punctuators.
+* Division operator / regex token ambiguity is handled via backtracking checks against punctuator prefixes, including closing brace or paren backtracking.
+* Always correctly parses valid JS source, but may parse invalid JS source without errors.
+
+### Limitations
+
+The lexing approach is designed to deal with the full language grammar including RegEx / division operator ambiguity through backtracking and paren / brace tracking.
+
+The only limitation to the reduced parser is that the "exports" list may not correctly gather all export identifiers in the following edge cases:
+
+```js
+// Only "a" is detected as an export, "q" isn't
+export var a = 'asdf', q = z;
+
+// "b" is not detected as an export
+export var { a: b } = asdf;
+```
+
+The above cases are handled gracefully in that the lexer will keep going fine, it will just not properly detect the export names above.
+
+### Benchmarks
+
+Benchmarks can be run with `npm run bench`.
+
+Current results for a high spec machine:
+
+#### Wasm Build
+
+```
+Module load time
+> 5ms
+Cold Run, All Samples
+test/samples/*.js (3123 KiB)
+> 18ms
+
+Warm Runs (average of 25 runs)
+test/samples/angular.js (739 KiB)
+> 3ms
+test/samples/angular.min.js (188 KiB)
+> 1ms
+test/samples/d3.js (508 KiB)
+> 3ms
+test/samples/d3.min.js (274 KiB)
+> 2ms
+test/samples/magic-string.js (35 KiB)
+> 0ms
+test/samples/magic-string.min.js (20 KiB)
+> 0ms
+test/samples/rollup.js (929 KiB)
+> 4.32ms
+test/samples/rollup.min.js (429 KiB)
+> 2.16ms
+
+Warm Runs, All Samples (average of 25 runs)
+test/samples/*.js (3123 KiB)
+> 14.16ms
+```
+
+#### JS Build (asm.js)
+
+```
+Module load time
+> 2ms
+Cold Run, All Samples
+test/samples/*.js (3123 KiB)
+> 34ms
+
+Warm Runs (average of 25 runs)
+test/samples/angular.js (739 KiB)
+> 3ms
+test/samples/angular.min.js (188 KiB)
+> 1ms
+test/samples/d3.js (508 KiB)
+> 3ms
+test/samples/d3.min.js (274 KiB)
+> 2ms
+test/samples/magic-string.js (35 KiB)
+> 0ms
+test/samples/magic-string.min.js (20 KiB)
+> 0ms
+test/samples/rollup.js (929 KiB)
+> 5ms
+test/samples/rollup.min.js (429 KiB)
+> 3.04ms
+
+Warm Runs, All Samples (average of 25 runs)
+test/samples/*.js (3123 KiB)
+> 17.12ms
+```
+
+### Building
+
+This project uses [Chomp](https://chompbuild.com) for building.
+
+With Chomp installed, download the WASI SDK 12.0 from https://github.com/WebAssembly/wasi-sdk/releases/tag/wasi-sdk-12.
+
+- [Linux](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz)
+- [Windows (MinGW)](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-mingw.tar.gz)
+- [macOS](https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-macos.tar.gz)
+
+Locate the WASI-SDK as a sibling folder, or customize the path via the `WASI_PATH` environment variable.
+
+Emscripten emsdk is also assumed to be a sibling folder or via the `EMSDK_PATH` environment variable.
+
+Example setup:
+
+```
+git clone https://github.com:guybedford/es-module-lexer
+git clone https://github.com/emscripten-core/emsdk
+cd emsdk
+git checkout 1.40.1-fastcomp
+./emsdk install 1.40.1-fastcomp
+cd ..
+wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz
+gunzip wasi-sdk-12.0-linux.tar.gz
+tar -xf wasi-sdk-12.0-linux.tar
+mv wasi-sdk-12.0-linux.tar wasi-sdk-12.0
+cargo install chompbuild
+cd es-module-lexer
+chomp test
+```
+
+For the `asm.js` build, git clone `emsdk` from  is assumed to be a sibling folder as well.
+
+### License
+
+MIT
+
+[actions-image]: https://github.com/guybedford/es-module-lexer/actions/workflows/build.yml/badge.svg
+[actions-url]: https://github.com/guybedford/es-module-lexer/actions/workflows/build.yml

node_modules/es-module-lexer/dist/lexer.asm.js

@@ -0,0 +1,2 @@
+/* es-module-lexer 1.7.0 */
+let e,a,r,i=2<<19;const s=1===new Uint8Array(new Uint16Array([1]).buffer)[0]?function(e,a){const r=e.length;let i=0;for(;i<r;)a[i]=e.charCodeAt(i++)}:function(e,a){const r=e.length;let i=0;for(;i<r;){const r=e.charCodeAt(i);a[i++]=(255&r)<<8|r>>>8}},f="xportmportlassforetaourceeferromsyncunctionssertvoyiedelecontininstantybreareturdebuggeawaithrwhileifcatcfinallels";let t,c,n;export function parse(k,l="@"){t=k,c=l;const u=2*t.length+(2<<18);if(u>i||!e){for(;u>i;)i*=2;a=new ArrayBuffer(i),s(f,new Uint16Array(a,16,114)),e=function(e,a,r){"use asm";var i=new e.Int8Array(r),s=new e.Int16Array(r),f=new e.Int32Array(r),t=new e.Uint8Array(r),c=new e.Uint16Array(r),n=1040;function b(){var e=0,a=0,r=0,t=0,c=0,b=0,u=0;u=n;n=n+10240|0;i[812]=1;i[811]=0;s[403]=0;s[404]=0;f[71]=f[2];i[813]=0;f[70]=0;i[810]=0;f[72]=u+2048;f[73]=u;i[814]=0;e=(f[3]|0)+-2|0;f[74]=e;a=e+(f[68]<<1)|0;f[75]=a;e:while(1){r=e+2|0;f[74]=r;if(e>>>0>=a>>>0){t=18;break}a:do{switch(s[r>>1]|0){case 9:case 10:case 11:case 12:case 13:case 32:break;case 101:{if((((s[404]|0)==0?H(r)|0:0)?(m(e+4|0,16,10)|0)==0:0)?(k(),(i[812]|0)==0):0){t=9;break e}else t=17;break}case 105:{if(H(r)|0?(m(e+4|0,26,10)|0)==0:0){l();t=17}else t=17;break}case 59:{t=17;break}case 47:switch(s[e+4>>1]|0){case 47:{P();break a}case 42:{y(1);break a}default:{t=16;break e}}default:{t=16;break e}}}while(0);if((t|0)==17){t=0;f[71]=f[74]}e=f[74]|0;a=f[75]|0}if((t|0)==9){e=f[74]|0;f[71]=e;t=19}else if((t|0)==16){i[812]=0;f[74]=e;t=19}else if((t|0)==18)if(!(i[810]|0)){e=r;t=19}else e=0;do{if((t|0)==19){e:while(1){a=e+2|0;f[74]=a;if(e>>>0>=(f[75]|0)>>>0){t=92;break}a:do{switch(s[a>>1]|0){case 9:case 10:case 11:case 12:case 13:case 32:break;case 101:{if(((s[404]|0)==0?H(a)|0:0)?(m(e+4|0,16,10)|0)==0:0){k();t=91}else t=91;break}case 105:{if(H(a)|0?(m(e+4|0,26,10)|0)==0:0){l();t=91}else t=91;break}case 99:{if((H(a)|0?(m(e+4|0,36,8)|0)==0:0)?V(s[e+12>>1]|0)|0:0){i[814]=1;t=91}else t=91;break}case 40:{r=f[72]|0;e=s[404]|0;t=e&65535;f[r+(t<<3)>>2]=1;a=f[71]|0;s[404]=e+1<<16>>16;f[r+(t<<3)+4>>2]=a;t=91;break}case 41:{a=s[404]|0;if(!(a<<16>>16)){t=36;break e}r=a+-1<<16>>16;s[404]=r;t=s[403]|0;a=t&65535;if(t<<16>>16!=0?(f[(f[72]|0)+((r&65535)<<3)>>2]|0)==5:0){a=f[(f[73]|0)+(a+-1<<2)>>2]|0;r=a+4|0;if(!(f[r>>2]|0))f[r>>2]=(f[71]|0)+2;f[a+12>>2]=e+4;s[403]=t+-1<<16>>16;t=91}else t=91;break}case 123:{t=f[71]|0;r=f[65]|0;e=t;do{if((s[t>>1]|0)==41&(r|0)!=0?(f[r+4>>2]|0)==(t|0):0){a=f[66]|0;f[65]=a;if(!a){f[61]=0;break}else{f[a+32>>2]=0;break}}}while(0);r=f[72]|0;a=s[404]|0;t=a&65535;f[r+(t<<3)>>2]=(i[814]|0)==0?2:6;s[404]=a+1<<16>>16;f[r+(t<<3)+4>>2]=e;i[814]=0;t=91;break}case 125:{e=s[404]|0;if(!(e<<16>>16)){t=49;break e}r=f[72]|0;t=e+-1<<16>>16;s[404]=t;if((f[r+((t&65535)<<3)>>2]|0)==4){h();t=91}else t=91;break}case 39:{v(39);t=91;break}case 34:{v(34);t=91;break}case 47:switch(s[e+4>>1]|0){case 47:{P();break a}case 42:{y(1);break a}default:{e=f[71]|0;a=s[e>>1]|0;r:do{if(!(U(a)|0))if(a<<16>>16==41){r=s[404]|0;if(!(D(f[(f[72]|0)+((r&65535)<<3)+4>>2]|0)|0))t=65}else t=64;else switch(a<<16>>16){case 46:if(((s[e+-2>>1]|0)+-48&65535)<10){t=64;break r}else break r;case 43:if((s[e+-2>>1]|0)==43){t=64;break r}else break r;case 45:if((s[e+-2>>1]|0)==45){t=64;break r}else break r;default:break r}}while(0);if((t|0)==64){r=s[404]|0;t=65}r:do{if((t|0)==65){t=0;if(r<<16>>16!=0?(c=f[72]|0,b=(r&65535)+-1|0,a<<16>>16==102?(f[c+(b<<3)>>2]|0)==1:0):0){if((s[e+-2>>1]|0)==111?$(f[c+(b<<3)+4>>2]|0,44,3)|0:0)break}else t=69;if((t|0)==69?(0,a<<16>>16==125):0){t=f[72]|0;r=r&65535;if(p(f[t+(r<<3)+4>>2]|0)|0)break;if((f[t+(r<<3)>>2]|0)==6)break}if(!(o(e)|0)){switch(a<<16>>16){case 0:break r;case 47:{if(i[813]|0)break r;break}default:{}}t=f[67]|0;if((t|0?e>>>0>=(f[t>>2]|0)>>>0:0)?e>>>0<=(f[t+4>>2]|0)>>>0:0){g();i[813]=0;t=91;break a}r=f[3]|0;do{if(e>>>0<=r>>>0)break;e=e+-2|0;f[71]=e;a=s[e>>1]|0}while(!(E(a)|0));if(F(a)|0){do{if(e>>>0<=r>>>0)break;e=e+-2|0;f[71]=e}while(F(s[e>>1]|0)|0);if(j(e)|0){g();i[813]=0;t=91;break a}}i[813]=1;t=91;break a}}}while(0);g();i[813]=0;t=91;break a}}case 96:{r=f[72]|0;a=s[404]|0;t=a&65535;f[r+(t<<3)+4>>2]=f[71];s[404]=a+1<<16>>16;f[r+(t<<3)>>2]=3;h();t=91;break}default:t=91}}while(0);if((t|0)==91){t=0;f[71]=f[74]}e=f[74]|0}if((t|0)==36){T();e=0;break}else if((t|0)==49){T();e=0;break}else if((t|0)==92){e=(i[810]|0)==0?(s[403]|s[404])<<16>>16==0:0;break}}}while(0);n=u;return e|0}function k(){var e=0,a=0,r=0,t=0,c=0,n=0,b=0,k=0,l=0,o=0,h=0,d=0,C=0,g=0;k=f[74]|0;l=f[67]|0;g=k+12|0;f[74]=g;r=w(1)|0;e=f[74]|0;if(!((e|0)==(g|0)?!(I(r)|0):0))C=3;e:do{if((C|0)==3){a:do{switch(r<<16>>16){case 123:{f[74]=e+2;e=w(1)|0;a=f[74]|0;while(1){if(W(e)|0){v(e);e=(f[74]|0)+2|0;f[74]=e}else{q(e)|0;e=f[74]|0}w(1)|0;e=A(a,e)|0;if(e<<16>>16==44){f[74]=(f[74]|0)+2;e=w(1)|0}if(e<<16>>16==125){C=15;break}g=a;a=f[74]|0;if((a|0)==(g|0)){C=12;break}if(a>>>0>(f[75]|0)>>>0){C=14;break}}if((C|0)==12){T();break e}else if((C|0)==14){T();break e}else if((C|0)==15){i[811]=1;f[74]=(f[74]|0)+2;break a}break}case 42:{f[74]=e+2;w(1)|0;g=f[74]|0;A(g,g)|0;break}default:{i[812]=0;switch(r<<16>>16){case 100:{k=e+14|0;f[74]=k;switch((w(1)|0)<<16>>16){case 97:{a=f[74]|0;if((m(a+2|0,80,8)|0)==0?(c=a+10|0,F(s[c>>1]|0)|0):0){f[74]=c;w(0)|0;C=22}break}case 102:{C=22;break}case 99:{a=f[74]|0;if(((m(a+2|0,36,8)|0)==0?(t=a+10|0,g=s[t>>1]|0,V(g)|0|g<<16>>16==123):0)?(f[74]=t,n=w(1)|0,n<<16>>16!=123):0){d=n;C=31}break}default:{}}r:do{if((C|0)==22?(b=f[74]|0,(m(b+2|0,88,14)|0)==0):0){r=b+16|0;a=s[r>>1]|0;if(!(V(a)|0))switch(a<<16>>16){case 40:case 42:break;default:break r}f[74]=r;a=w(1)|0;if(a<<16>>16==42){f[74]=(f[74]|0)+2;a=w(1)|0}if(a<<16>>16!=40){d=a;C=31}}}while(0);if((C|0)==31?(o=f[74]|0,q(d)|0,h=f[74]|0,h>>>0>o>>>0):0){O(e,k,o,h);f[74]=(f[74]|0)+-2;break e}O(e,k,0,0);f[74]=e+12;break e}case 97:{f[74]=e+10;w(0)|0;e=f[74]|0;C=35;break}case 102:{C=35;break}case 99:{if((m(e+2|0,36,8)|0)==0?(a=e+10|0,E(s[a>>1]|0)|0):0){f[74]=a;g=w(1)|0;C=f[74]|0;q(g)|0;g=f[74]|0;O(C,g,C,g);f[74]=(f[74]|0)+-2;break e}e=e+4|0;f[74]=e;break}case 108:case 118:break;default:break e}if((C|0)==35){f[74]=e+16;e=w(1)|0;if(e<<16>>16==42){f[74]=(f[74]|0)+2;e=w(1)|0}C=f[74]|0;q(e)|0;g=f[74]|0;O(C,g,C,g);f[74]=(f[74]|0)+-2;break e}f[74]=e+6;i[812]=0;r=w(1)|0;e=f[74]|0;r=(q(r)|0|32)<<16>>16==123;t=f[74]|0;if(r){f[74]=t+2;g=w(1)|0;e=f[74]|0;q(g)|0}r:while(1){a=f[74]|0;if((a|0)==(e|0))break;O(e,a,e,a);a=w(1)|0;if(r)switch(a<<16>>16){case 93:case 125:break e;default:{}}e=f[74]|0;if(a<<16>>16!=44){C=51;break}f[74]=e+2;a=w(1)|0;e=f[74]|0;switch(a<<16>>16){case 91:case 123:{C=51;break r}default:{}}q(a)|0}if((C|0)==51)f[74]=e+-2;if(!r)break e;f[74]=t+-2;break e}}}while(0);g=(w(1)|0)<<16>>16==102;e=f[74]|0;if(g?(m(e+2|0,74,6)|0)==0:0){f[74]=e+8;u(k,w(1)|0,0);e=(l|0)==0?248:l+16|0;while(1){e=f[e>>2]|0;if(!e)break e;f[e+12>>2]=0;f[e+8>>2]=0;e=e+16|0}}f[74]=e+-2}}while(0);return}function l(){var e=0,a=0,r=0,t=0,c=0,n=0,b=0;b=f[74]|0;c=b+12|0;f[74]=c;e=w(1)|0;t=f[74]|0;e:do{if(e<<16>>16!=46){if(!(e<<16>>16==115&t>>>0>c>>>0)){if(!(e<<16>>16==100&t>>>0>(b+10|0)>>>0)){t=0;n=28;break}if(m(t+2|0,66,8)|0){a=t;e=100;t=0;n=59;break}e=t+10|0;if(!(V(s[e>>1]|0)|0)){a=t;e=100;t=0;n=59;break}f[74]=e;e=w(1)|0;if(e<<16>>16==42){e=42;t=2;n=61;break}f[74]=t;t=0;n=28;break}if((m(t+2|0,56,10)|0)==0?(r=t+12|0,V(s[r>>1]|0)|0):0){f[74]=r;e=w(1)|0;a=f[74]|0;if((a|0)!=(r|0)){if(e<<16>>16!=102){t=1;n=28;break}if(m(a+2|0,74,6)|0){e=102;t=1;n=59;break}if(!(E(s[a+8>>1]|0)|0)){e=102;t=1;n=59;break}}f[74]=t;t=0;n=28}else{a=t;e=115;t=0;n=59}}else{f[74]=t+2;switch((w(1)|0)<<16>>16){case 109:{e=f[74]|0;if(m(e+2|0,50,6)|0)break e;a=f[71]|0;if(!(G(a)|0)?(s[a>>1]|0)==46:0)break e;d(b,b,e+8|0,2);break e}case 115:{e=f[74]|0;if(m(e+2|0,56,10)|0)break e;a=f[71]|0;if(!(G(a)|0)?(s[a>>1]|0)==46:0)break e;f[74]=e+12;e=w(1)|0;t=1;n=28;break e}case 100:{e=f[74]|0;if(m(e+2|0,66,8)|0)break e;a=f[71]|0;if(!(G(a)|0)?(s[a>>1]|0)==46:0)break e;f[74]=e+10;e=w(1)|0;t=2;n=28;break e}default:break e}}}while(0);e:do{if((n|0)==28){if(e<<16>>16==40){r=f[72]|0;a=s[404]|0;c=a&65535;f[r+(c<<3)>>2]=5;e=f[74]|0;s[404]=a+1<<16>>16;f[r+(c<<3)+4>>2]=e;if((s[f[71]>>1]|0)==46)break;f[74]=e+2;a=w(1)|0;d(b,f[74]|0,0,e);if(!t)e=f[65]|0;else{e=f[65]|0;f[e+28>>2]=(t|0)==1?5:7}c=f[73]|0;b=s[403]|0;s[403]=b+1<<16>>16;f[c+((b&65535)<<2)>>2]=e;switch(a<<16>>16){case 39:{v(39);break}case 34:{v(34);break}default:{f[74]=(f[74]|0)+-2;break e}}e=(f[74]|0)+2|0;f[74]=e;switch((w(1)|0)<<16>>16){case 44:{f[74]=(f[74]|0)+2;w(1)|0;c=f[65]|0;f[c+4>>2]=e;b=f[74]|0;f[c+16>>2]=b;i[c+24>>0]=1;f[74]=b+-2;break e}case 41:{s[404]=(s[404]|0)+-1<<16>>16;b=f[65]|0;f[b+4>>2]=e;f[b+12>>2]=(f[74]|0)+2;i[b+24>>0]=1;s[403]=(s[403]|0)+-1<<16>>16;break e}default:{f[74]=(f[74]|0)+-2;break e}}}if(!((t|0)==0&e<<16>>16==123)){switch(e<<16>>16){case 42:case 39:case 34:{n=61;break e}default:{}}a=f[74]|0;n=59;break}e=f[74]|0;if(s[404]|0){f[74]=e+-2;break}while(1){if(e>>>0>=(f[75]|0)>>>0)break;e=w(1)|0;if(!(W(e)|0)){if(e<<16>>16==125){n=49;break}}else v(e);e=(f[74]|0)+2|0;f[74]=e}if((n|0)==49)f[74]=(f[74]|0)+2;c=(w(1)|0)<<16>>16==102;e=f[74]|0;if(c?m(e+2|0,74,6)|0:0){T();break}f[74]=e+8;e=w(1)|0;if(W(e)|0){u(b,e,0);break}else{T();break}}}while(0);if((n|0)==59)if((a|0)==(c|0))f[74]=b+10;else n=61;do{if((n|0)==61){if(!((e<<16>>16==42|(t|0)!=2)&(s[404]|0)==0)){f[74]=(f[74]|0)+-2;break}e=f[75]|0;a=f[74]|0;while(1){if(a>>>0>=e>>>0){n=68;break}r=s[a>>1]|0;if(W(r)|0){n=66;break}n=a+2|0;f[74]=n;a=n}if((n|0)==66){u(b,r,t);break}else if((n|0)==68){T();break}}}while(0);return}function u(e,a,r){e=e|0;a=a|0;r=r|0;var i=0,t=0;i=(f[74]|0)+2|0;switch(a<<16>>16){case 39:{v(39);t=5;break}case 34:{v(34);t=5;break}default:T()}do{if((t|0)==5){d(e,i,f[74]|0,1);if((r|0)>0)f[(f[65]|0)+28>>2]=(r|0)==1?4:6;f[74]=(f[74]|0)+2;a=w(0)|0;r=a<<16>>16==97;if(r){i=f[74]|0;if(m(i+2|0,102,10)|0)t=13}else{i=f[74]|0;if(!(((a<<16>>16==119?(s[i+2>>1]|0)==105:0)?(s[i+4>>1]|0)==116:0)?(s[i+6>>1]|0)==104:0))t=13}if((t|0)==13){f[74]=i+-2;break}f[74]=i+((r?6:4)<<1);if((w(1)|0)<<16>>16!=123){f[74]=i;break}r=f[74]|0;a=r;e:while(1){f[74]=a+2;a=w(1)|0;switch(a<<16>>16){case 39:{v(39);f[74]=(f[74]|0)+2;a=w(1)|0;break}case 34:{v(34);f[74]=(f[74]|0)+2;a=w(1)|0;break}default:a=q(a)|0}if(a<<16>>16!=58){t=22;break}f[74]=(f[74]|0)+2;switch((w(1)|0)<<16>>16){case 39:{v(39);break}case 34:{v(34);break}default:{t=26;break e}}f[74]=(f[74]|0)+2;switch((w(1)|0)<<16>>16){case 125:{t=31;break e}case 44:break;default:{t=30;break e}}f[74]=(f[74]|0)+2;if((w(1)|0)<<16>>16==125){t=31;break}a=f[74]|0}if((t|0)==22){f[74]=i;break}else if((t|0)==26){f[74]=i;break}else if((t|0)==30){f[74]=i;break}else if((t|0)==31){t=f[65]|0;f[t+16>>2]=r;f[t+12>>2]=(f[74]|0)+2;break}}}while(0);return}function o(e){e=e|0;e:do{switch(s[e>>1]|0){case 100:switch(s[e+-2>>1]|0){case 105:{e=$(e+-4|0,112,2)|0;break e}case 108:{e=$(e+-4|0,116,3)|0;break e}default:{e=0;break e}}case 101:switch(s[e+-2>>1]|0){case 115:switch(s[e+-4>>1]|0){case 108:{e=B(e+-6|0,101)|0;break e}case 97:{e=B(e+-6|0,99)|0;break e}default:{e=0;break e}}case 116:{e=$(e+-4|0,122,4)|0;break e}case 117:{e=$(e+-4|0,130,6)|0;break e}default:{e=0;break e}}case 102:{if((s[e+-2>>1]|0)==111?(s[e+-4>>1]|0)==101:0)switch(s[e+-6>>1]|0){case 99:{e=$(e+-8|0,142,6)|0;break e}case 112:{e=$(e+-8|0,154,2)|0;break e}default:{e=0;break e}}else e=0;break}case 107:{e=$(e+-2|0,158,4)|0;break}case 110:{e=e+-2|0;if(B(e,105)|0)e=1;else e=$(e,166,5)|0;break}case 111:{e=B(e+-2|0,100)|0;break}case 114:{e=$(e+-2|0,176,7)|0;break}case 116:{e=$(e+-2|0,190,4)|0;break}case 119:switch(s[e+-2>>1]|0){case 101:{e=B(e+-4|0,110)|0;break e}case 111:{e=$(e+-4|0,198,3)|0;break e}default:{e=0;break e}}default:e=0}}while(0);return e|0}function h(){var e=0,a=0,r=0,i=0;a=f[75]|0;r=f[74]|0;e:while(1){e=r+2|0;if(r>>>0>=a>>>0){a=10;break}switch(s[e>>1]|0){case 96:{a=7;break e}case 36:{if((s[r+4>>1]|0)==123){a=6;break e}break}case 92:{e=r+4|0;break}default:{}}r=e}if((a|0)==6){e=r+4|0;f[74]=e;a=f[72]|0;i=s[404]|0;r=i&65535;f[a+(r<<3)>>2]=4;s[404]=i+1<<16>>16;f[a+(r<<3)+4>>2]=e}else if((a|0)==7){f[74]=e;r=f[72]|0;i=(s[404]|0)+-1<<16>>16;s[404]=i;if((f[r+((i&65535)<<3)>>2]|0)!=3)T()}else if((a|0)==10){f[74]=e;T()}return}function w(e){e=e|0;var a=0,r=0,i=0;r=f[74]|0;e:do{a=s[r>>1]|0;a:do{if(a<<16>>16!=47)if(e)if(V(a)|0)break;else break e;else if(F(a)|0)break;else break e;else switch(s[r+2>>1]|0){case 47:{P();break a}case 42:{y(e);break a}default:{a=47;break e}}}while(0);i=f[74]|0;r=i+2|0;f[74]=r}while(i>>>0<(f[75]|0)>>>0);return a|0}function d(e,a,r,s){e=e|0;a=a|0;r=r|0;s=s|0;var t=0,c=0;c=f[69]|0;f[69]=c+36;t=f[65]|0;f[((t|0)==0?244:t+32|0)>>2]=c;f[66]=t;f[65]=c;f[c+8>>2]=e;if(2==(s|0)){e=3;t=r}else{t=1==(s|0);e=t?1:2;t=t?r+2|0:0}f[c+12>>2]=t;f[c+28>>2]=e;f[c>>2]=a;f[c+4>>2]=r;f[c+16>>2]=0;f[c+20>>2]=s;a=1==(s|0);i[c+24>>0]=a&1;f[c+32>>2]=0;if(a|2==(s|0))i[811]=1;return}function v(e){e=e|0;var a=0,r=0,i=0,t=0;t=f[75]|0;a=f[74]|0;while(1){i=a+2|0;if(a>>>0>=t>>>0){a=9;break}r=s[i>>1]|0;if(r<<16>>16==e<<16>>16){a=10;break}if(r<<16>>16==92){r=a+4|0;if((s[r>>1]|0)==13){a=a+6|0;a=(s[a>>1]|0)==10?a:r}else a=r}else if(Z(r)|0){a=9;break}else a=i}if((a|0)==9){f[74]=i;T()}else if((a|0)==10)f[74]=i;return}function A(e,a){e=e|0;a=a|0;var r=0,i=0,t=0,c=0;r=f[74]|0;i=s[r>>1]|0;c=(e|0)==(a|0);t=c?0:e;c=c?0:a;if(i<<16>>16==97){f[74]=r+4;r=w(1)|0;e=f[74]|0;if(W(r)|0){v(r);a=(f[74]|0)+2|0;f[74]=a}else{q(r)|0;a=f[74]|0}i=w(1)|0;r=f[74]|0}if((r|0)!=(e|0))O(e,a,t,c);return i|0}function C(){var e=0,a=0,r=0;r=f[75]|0;a=f[74]|0;e:while(1){e=a+2|0;if(a>>>0>=r>>>0){a=6;break}switch(s[e>>1]|0){case 13:case 10:{a=6;break e}case 93:{a=7;break e}case 92:{e=a+4|0;break}default:{}}a=e}if((a|0)==6){f[74]=e;T();e=0}else if((a|0)==7){f[74]=e;e=93}return e|0}function g(){var e=0,a=0,r=0;e:while(1){e=f[74]|0;a=e+2|0;f[74]=a;if(e>>>0>=(f[75]|0)>>>0){r=7;break}switch(s[a>>1]|0){case 13:case 10:{r=7;break e}case 47:break e;case 91:{C()|0;break}case 92:{f[74]=e+4;break}default:{}}}if((r|0)==7)T();return}function p(e){e=e|0;switch(s[e>>1]|0){case 62:{e=(s[e+-2>>1]|0)==61;break}case 41:case 59:{e=1;break}case 104:{e=$(e+-2|0,218,4)|0;break}case 121:{e=$(e+-2|0,226,6)|0;break}case 101:{e=$(e+-2|0,238,3)|0;break}default:e=0}return e|0}function y(e){e=e|0;var a=0,r=0,i=0,t=0,c=0;t=(f[74]|0)+2|0;f[74]=t;r=f[75]|0;while(1){a=t+2|0;if(t>>>0>=r>>>0)break;i=s[a>>1]|0;if(!e?Z(i)|0:0)break;if(i<<16>>16==42?(s[t+4>>1]|0)==47:0){c=8;break}t=a}if((c|0)==8){f[74]=a;a=t+4|0}f[74]=a;return}function m(e,a,r){e=e|0;a=a|0;r=r|0;var s=0,f=0;e:do{if(!r)e=0;else{while(1){s=i[e>>0]|0;f=i[a>>0]|0;if(s<<24>>24!=f<<24>>24)break;r=r+-1|0;if(!r){e=0;break e}else{e=e+1|0;a=a+1|0}}e=(s&255)-(f&255)|0}}while(0);return e|0}function I(e){e=e|0;e:do{switch(e<<16>>16){case 38:case 37:case 33:{e=1;break}default:if((e&-8)<<16>>16==40|(e+-58&65535)<6)e=1;else{switch(e<<16>>16){case 91:case 93:case 94:{e=1;break e}default:{}}e=(e+-123&65535)<4}}}while(0);return e|0}function U(e){e=e|0;e:do{switch(e<<16>>16){case 38:case 37:case 33:break;default:if(!((e+-58&65535)<6|(e+-40&65535)<7&e<<16>>16!=41)){switch(e<<16>>16){case 91:case 94:break e;default:{}}return e<<16>>16!=125&(e+-123&65535)<4|0}}}while(0);return 1}function x(e){e=e|0;var a=0;a=s[e>>1]|0;e:do{if((a+-9&65535)>=5){switch(a<<16>>16){case 160:case 32:{a=1;break e}default:{}}if(I(a)|0)return a<<16>>16!=46|(G(e)|0)|0;else a=0}else a=1}while(0);return a|0}function S(e){e=e|0;var a=0,r=0,i=0,t=0;r=n;n=n+16|0;i=r;f[i>>2]=0;f[68]=e;a=f[3]|0;t=a+(e<<1)|0;e=t+2|0;s[t>>1]=0;f[i>>2]=e;f[69]=e;f[61]=0;f[65]=0;f[63]=0;f[62]=0;f[67]=0;f[64]=0;n=r;return a|0}function O(e,a,r,s){e=e|0;a=a|0;r=r|0;s=s|0;var t=0,c=0;t=f[69]|0;f[69]=t+20;c=f[67]|0;f[((c|0)==0?248:c+16|0)>>2]=t;f[67]=t;f[t>>2]=e;f[t+4>>2]=a;f[t+8>>2]=r;f[t+12>>2]=s;f[t+16>>2]=0;i[811]=1;return}function $(e,a,r){e=e|0;a=a|0;r=r|0;var i=0,s=0;i=e+(0-r<<1)|0;s=i+2|0;e=f[3]|0;if(s>>>0>=e>>>0?(m(s,a,r<<1)|0)==0:0)if((s|0)==(e|0))e=1;else e=x(i)|0;else e=0;return e|0}function j(e){e=e|0;switch(s[e>>1]|0){case 107:{e=$(e+-2|0,158,4)|0;break}case 101:{if((s[e+-2>>1]|0)==117)e=$(e+-4|0,130,6)|0;else e=0;break}default:e=0}return e|0}function B(e,a){e=e|0;a=a|0;var r=0;r=f[3]|0;if(r>>>0<=e>>>0?(s[e>>1]|0)==a<<16>>16:0)if((r|0)==(e|0))r=1;else r=E(s[e+-2>>1]|0)|0;else r=0;return r|0}function E(e){e=e|0;e:do{if((e+-9&65535)<5)e=1;else{switch(e<<16>>16){case 32:case 160:{e=1;break e}default:{}}e=e<<16>>16!=46&(I(e)|0)}}while(0);return e|0}function P(){var e=0,a=0,r=0;e=f[75]|0;r=f[74]|0;e:while(1){a=r+2|0;if(r>>>0>=e>>>0)break;switch(s[a>>1]|0){case 13:case 10:break e;default:r=a}}f[74]=a;return}function q(e){e=e|0;while(1){if(V(e)|0)break;if(I(e)|0)break;e=(f[74]|0)+2|0;f[74]=e;e=s[e>>1]|0;if(!(e<<16>>16)){e=0;break}}return e|0}function z(){var e=0;e=f[(f[63]|0)+20>>2]|0;switch(e|0){case 1:{e=-1;break}case 2:{e=-2;break}default:e=e-(f[3]|0)>>1}return e|0}function D(e){e=e|0;if(!($(e,204,5)|0)?!($(e,44,3)|0):0)e=$(e,214,2)|0;else e=1;return e|0}function F(e){e=e|0;switch(e<<16>>16){case 160:case 32:case 12:case 11:case 9:{e=1;break}default:e=0}return e|0}function G(e){e=e|0;if((s[e>>1]|0)==46?(s[e+-2>>1]|0)==46:0)e=(s[e+-4>>1]|0)==46;else e=0;return e|0}function H(e){e=e|0;if((f[3]|0)==(e|0))e=1;else e=x(e+-2|0)|0;return e|0}function J(){var e=0;e=f[(f[64]|0)+12>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function K(){var e=0;e=f[(f[63]|0)+12>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function L(){var e=0;e=f[(f[64]|0)+8>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function M(){var e=0;e=f[(f[63]|0)+16>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function N(){var e=0;e=f[(f[63]|0)+4>>2]|0;if(!e)e=-1;else e=e-(f[3]|0)>>1;return e|0}function Q(){var e=0;e=f[63]|0;e=f[((e|0)==0?244:e+32|0)>>2]|0;f[63]=e;return(e|0)!=0|0}function R(){var e=0;e=f[64]|0;e=f[((e|0)==0?248:e+16|0)>>2]|0;f[64]=e;return(e|0)!=0|0}function T(){i[810]=1;f[70]=(f[74]|0)-(f[3]|0)>>1;f[74]=(f[75]|0)+2;return}function V(e){e=e|0;return(e|128)<<16>>16==160|(e+-9&65535)<5|0}function W(e){e=e|0;return e<<16>>16==39|e<<16>>16==34|0}function X(){return(f[(f[63]|0)+8>>2]|0)-(f[3]|0)>>1|0}function Y(){return(f[(f[64]|0)+4>>2]|0)-(f[3]|0)>>1|0}function Z(e){e=e|0;return e<<16>>16==13|e<<16>>16==10|0}function _(){return(f[f[63]>>2]|0)-(f[3]|0)>>1|0}function ee(){return(f[f[64]>>2]|0)-(f[3]|0)>>1|0}function ae(){return t[(f[63]|0)+24>>0]|0|0}function re(e){e=e|0;f[3]=e;return}function ie(){return f[(f[63]|0)+28>>2]|0}function se(){return(i[811]|0)!=0|0}function fe(){return(i[812]|0)!=0|0}function te(){return f[70]|0}function ce(e){e=e|0;n=e+992+15&-16;return 992}return{su:ce,ai:M,e:te,ee:Y,ele:J,els:L,es:ee,f:fe,id:z,ie:N,ip:ae,is:_,it:ie,ms:se,p:b,re:R,ri:Q,sa:S,se:K,ses:re,ss:X}}("undefined"!=typeof self?self:global,{},a),r=e.su(i-(2<<17))}const h=t.length+1;e.ses(r),e.sa(h-1),s(t,new Uint16Array(a,r,h)),e.p()||(n=e.e(),o());const w=[],d=[];for(;e.ri();){const a=e.is(),r=e.ie(),i=e.ai(),s=e.id(),f=e.ss(),c=e.se(),n=e.it();let k;e.ip()&&(k=b(-1===s?a:a+1,t.charCodeAt(-1===s?a-1:a))),w.push({t:n,n:k,s:a,e:r,ss:f,se:c,d:s,a:i})}for(;e.re();){const a=e.es(),r=e.ee(),i=e.els(),s=e.ele(),f=t.charCodeAt(a),c=i>=0?t.charCodeAt(i):-1;d.push({s:a,e:r,ls:i,le:s,n:34===f||39===f?b(a+1,f):t.slice(a,r),ln:i<0?void 0:34===c||39===c?b(i+1,c):t.slice(i,s)})}return[w,d,!!e.f(),!!e.ms()]}function b(e,a){n=e;let r="",i=n;for(;;){n>=t.length&&o();const e=t.charCodeAt(n);if(e===a)break;92===e?(r+=t.slice(i,n),r+=k(),i=n):(8232===e||8233===e||u(e)&&o(),++n)}return r+=t.slice(i,n++),r}function k(){let e=t.charCodeAt(++n);switch(++n,e){case 110:return"\n";case 114:return"\r";case 120:return String.fromCharCode(l(2));case 117:return function(){const e=t.charCodeAt(n);let a;123===e?(++n,a=l(t.indexOf("}",n)-n),++n,a>1114111&&o()):a=l(4);return a<=65535?String.fromCharCode(a):(a-=65536,String.fromCharCode(55296+(a>>10),56320+(1023&a)))}();case 116:return"\t";case 98:return"\b";case 118:return"\v";case 102:return"\f";case 13:10===t.charCodeAt(n)&&++n;case 10:return"";case 56:case 57:o();default:if(e>=48&&e<=55){let a=t.substr(n-1,3).match(/^[0-7]+/)[0],r=parseInt(a,8);return r>255&&(a=a.slice(0,-1),r=parseInt(a,8)),n+=a.length-1,e=t.charCodeAt(n),"0"===a&&56!==e&&57!==e||o(),String.fromCharCode(r)}return u(e)?"":String.fromCharCode(e)}}function l(e){const a=n;let r=0,i=0;for(let a=0;a<e;++a,++n){let e,s=t.charCodeAt(n);if(95!==s){if(s>=97)e=s-97+10;else if(s>=65)e=s-65+10;else{if(!(s>=48&&s<=57))break;e=s-48}if(e>=16)break;i=s,r=16*r+e}else 95!==i&&0!==a||o(),i=s}return 95!==i&&n-a===e||o(),r}function u(e){return 13===e||10===e}function o(){throw Object.assign(Error(`Parse error ${c}:${t.slice(0,n).split("\n").length}:${n-t.lastIndexOf("\n",n-1)}`),{idx:n})}

node_modules/es-module-lexer/dist/lexer.cjs

@@ -0,0 +1 @@
+"use strict";var ImportType;exports.initSync=exports.init=exports.ImportType=void 0,exports.parse=parse,exports.ImportType=ImportType,function(A){A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase"}(ImportType||(exports.ImportType=ImportType={}));const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];function parse(E,g="@"){if(!C)return init.then((()=>parse(E)));const I=E.length+1,w=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;w>0&&C.memory.grow(Math.ceil(w/65536));const K=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,K,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const o=[],D=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.it(),g=C.ai(),I=C.id(),w=C.ss(),K=C.se();let D;C.ip()&&(D=k(E.slice(-1===I?A-1:A,-1===I?Q+1:Q))),o.push({n:D,t:B,s:A,e:Q,ss:w,se:K,d:I,a:g})}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),w=I[0],K=B<0?void 0:E.slice(B,g),o=K?K[0]:"";D.push({s:A,e:Q,ls:B,le:g,n:'"'===w||"'"===w?k(I):I,ln:'"'===o||"'"===o?k(K):K})}function k(A){try{return(0,eval)(A)}catch(A){}}return[o,D,!!C.f(),!!C.ms()]}function Q(A,Q){const C=A.length;let B=0;for(;B<C;){const C=A.charCodeAt(B);Q[B++]=(255&C)<<8|C>>>8}}function B(A,Q){const C=A.length;let B=0;for(;B<C;)Q[B]=A.charCodeAt(B++)}let C;const E=()=>{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),(A=>A.charCodeAt(0)));var A},init=WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({exports:A})=>{C=A}));exports.init=init;const initSync=()=>{if(C)return;const A=new WebAssembly.Module(E());C=new WebAssembly.Instance(A).exports};exports.initSync=initSync;

node_modules/es-module-lexer/dist/lexer.js

@@ -0,0 +1,2 @@
+/* es-module-lexer 1.7.0 */
+export var ImportType;!function(A){A[A.Static=1]="Static",A[A.Dynamic=2]="Dynamic",A[A.ImportMeta=3]="ImportMeta",A[A.StaticSourcePhase=4]="StaticSourcePhase",A[A.DynamicSourcePhase=5]="DynamicSourcePhase",A[A.StaticDeferPhase=6]="StaticDeferPhase",A[A.DynamicDeferPhase=7]="DynamicDeferPhase"}(ImportType||(ImportType={}));const A=1===new Uint8Array(new Uint16Array([1]).buffer)[0];export function parse(E,g="@"){if(!C)return init.then((()=>parse(E)));const I=E.length+1,w=(C.__heap_base.value||C.__heap_base)+4*I-C.memory.buffer.byteLength;w>0&&C.memory.grow(Math.ceil(w/65536));const K=C.sa(I-1);if((A?B:Q)(E,new Uint16Array(C.memory.buffer,K,I)),!C.parse())throw Object.assign(new Error(`Parse error ${g}:${E.slice(0,C.e()).split("\n").length}:${C.e()-E.lastIndexOf("\n",C.e()-1)}`),{idx:C.e()});const o=[],D=[];for(;C.ri();){const A=C.is(),Q=C.ie(),B=C.it(),g=C.ai(),I=C.id(),w=C.ss(),K=C.se();let D;C.ip()&&(D=k(E.slice(-1===I?A-1:A,-1===I?Q+1:Q))),o.push({n:D,t:B,s:A,e:Q,ss:w,se:K,d:I,a:g})}for(;C.re();){const A=C.es(),Q=C.ee(),B=C.els(),g=C.ele(),I=E.slice(A,Q),w=I[0],K=B<0?void 0:E.slice(B,g),o=K?K[0]:"";D.push({s:A,e:Q,ls:B,le:g,n:'"'===w||"'"===w?k(I):I,ln:'"'===o||"'"===o?k(K):K})}function k(A){try{return(0,eval)(A)}catch(A){}}return[o,D,!!C.f(),!!C.ms()]}function Q(A,Q){const B=A.length;let C=0;for(;C<B;){const B=A.charCodeAt(C);Q[C++]=(255&B)<<8|B>>>8}}function B(A,Q){const B=A.length;let C=0;for(;C<B;)Q[C]=A.charCodeAt(C++)}let C;const E=()=>{return A="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","undefined"!=typeof Buffer?Buffer.from(A,"base64"):Uint8Array.from(atob(A),(A=>A.charCodeAt(0)));var A};export const init=WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({exports:A})=>{C=A}));export const initSync=()=>{if(C)return;const A=new WebAssembly.Module(E());C=new WebAssembly.Instance(A).exports};

node_modules/es-module-lexer/lexer.js

@@ -0,0 +1,925 @@
+let source, pos, end,
+  openTokenDepth,
+  lastTokenPos,
+  openTokenPosStack,
+  openClassPosStack,
+  curDynamicImport,
+  templateStackDepth,
+  facade,
+  lastSlashWasDivision,
+  nextBraceIsClass,
+  templateDepth,
+  templateStack,
+  imports,
+  exports,
+  name;
+
+function addImport (ss, s, e, d) {
+  const impt = { ss, se: d === -2 ? e : d === -1 ? e + 1 : 0, s, e, d, a: -1, n: undefined };
+  imports.push(impt);
+  return impt;
+}
+
+function addExport (s, e, ls, le) {
+  exports.push({
+    s,
+    e,
+    ls,
+    le,
+    n: s[0] === '"' ? readString(s, '"') : s[0] === "'" ? readString(s, "'") : source.slice(s, e),
+    ln: ls[0] === '"' ? readString(ls, '"') : ls[0] === "'" ? readString(ls, "'") : source.slice(ls, le)
+  });
+}
+
+function readName (impt) {
+  let { d, s } = impt;
+  if (d !== -1)
+    s++;
+  impt.n = readString(s, source.charCodeAt(s - 1));
+}
+
+// Note: parsing is based on the _assumption_ that the source is already valid
+export function parse (_source, _name) {
+  openTokenDepth = 0;
+  curDynamicImport = null;
+  templateDepth = -1;
+  lastTokenPos = -1;
+  lastSlashWasDivision = false;
+  templateStack = Array(1024);
+  templateStackDepth = 0;
+  openTokenPosStack = Array(1024);
+  openClassPosStack = Array(1024);
+  nextBraceIsClass = false;
+  facade = true;
+  name = _name || '@';
+
+  imports = [];
+  exports = [];
+
+  source = _source;
+  pos = -1;
+  end = source.length - 1;
+  let ch = 0;
+
+  // start with a pure "module-only" parser
+  m: while (pos++ < end) {
+    ch = source.charCodeAt(pos);
+
+    if (ch === 32 || ch < 14 && ch > 8)
+      continue;
+
+    switch (ch) {
+      case 101/*e*/:
+        if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1)) {
+          tryParseExportStatement();
+          // export might have been a non-pure declaration
+          if (!facade) {
+            lastTokenPos = pos;
+            break m;
+          }
+        }
+        break;
+      case 105/*i*/:
+        if (keywordStart(pos) && source.startsWith('mport', pos + 1))
+          tryParseImportStatement();
+        break;
+      case 59/*;*/:
+        break;
+      case 47/*/*/: {
+        const next_ch = source.charCodeAt(pos + 1);
+        if (next_ch === 47/*/*/) {
+          lineComment();
+          // dont update lastToken
+          continue;
+        }
+        else if (next_ch === 42/***/) {
+          blockComment(true);
+          // dont update lastToken
+          continue;
+        }
+        // fallthrough
+      }
+      default:
+        // as soon as we hit a non-module token, we go to main parser
+        facade = false;
+        pos--;
+        break m;
+    }
+    lastTokenPos = pos;
+  }
+
+  while (pos++ < end) {
+    ch = source.charCodeAt(pos);
+
+    if (ch === 32 || ch < 14 && ch > 8)
+      continue;
+
+    switch (ch) {
+      case 101/*e*/:
+        if (openTokenDepth === 0 && keywordStart(pos) && source.startsWith('xport', pos + 1))
+          tryParseExportStatement();
+        break;
+      case 105/*i*/:
+        if (keywordStart(pos) && source.startsWith('mport', pos + 1))
+          tryParseImportStatement();
+        break;
+      case 99/*c*/:
+        if (keywordStart(pos) && source.startsWith('lass', pos + 1) && isBrOrWs(source.charCodeAt(pos + 5)))
+          nextBraceIsClass = true;
+        break;
+      case 40/*(*/:
+        openTokenPosStack[openTokenDepth++] = lastTokenPos;
+        break;
+      case 41/*)*/:
+        if (openTokenDepth === 0)
+          syntaxError();
+        openTokenDepth--;
+        if (curDynamicImport && curDynamicImport.d === openTokenPosStack[openTokenDepth]) {
+          if (curDynamicImport.e === 0)
+            curDynamicImport.e = pos;
+          curDynamicImport.se = pos;
+          curDynamicImport = null;
+        }
+        break;
+      case 123/*{*/:
+        // dynamic import followed by { is not a dynamic import (so remove)
+        // this is a sneaky way to get around { import () {} } v { import () }
+        // block / object ambiguity without a parser (assuming source is valid)
+        if (source.charCodeAt(lastTokenPos) === 41/*)*/ && imports.length && imports[imports.length - 1].e === lastTokenPos) {
+          imports.pop();
+        }
+        openClassPosStack[openTokenDepth] = nextBraceIsClass;
+        nextBraceIsClass = false;
+        openTokenPosStack[openTokenDepth++] = lastTokenPos;
+        break;
+      case 125/*}*/:
+        if (openTokenDepth === 0)
+          syntaxError();
+        if (openTokenDepth-- === templateDepth) {
+          templateDepth = templateStack[--templateStackDepth];
+          templateString();
+        }
+        else {
+          if (templateDepth !== -1 && openTokenDepth < templateDepth)
+            syntaxError();
+        }
+        break;
+      case 39/*'*/:
+      case 34/*"*/:
+        stringLiteral(ch);
+        break;
+      case 47/*/*/: {
+        const next_ch = source.charCodeAt(pos + 1);
+        if (next_ch === 47/*/*/) {
+          lineComment();
+          // dont update lastToken
+          continue;
+        }
+        else if (next_ch === 42/***/) {
+          blockComment(true);
+          // dont update lastToken
+          continue;
+        }
+        else {
+          // Division / regex ambiguity handling based on checking backtrack analysis of:
+          // - what token came previously (lastToken)
+          // - if a closing brace or paren, what token came before the corresponding
+          //   opening brace or paren (lastOpenTokenIndex)
+          const lastToken = source.charCodeAt(lastTokenPos);
+          const lastExport = exports[exports.length - 1];
+          if (isExpressionPunctuator(lastToken) &&
+              !(lastToken === 46/*.*/ && (source.charCodeAt(lastTokenPos - 1) >= 48/*0*/ && source.charCodeAt(lastTokenPos - 1) <= 57/*9*/)) &&
+              !(lastToken === 43/*+*/ && source.charCodeAt(lastTokenPos - 1) === 43/*+*/) && !(lastToken === 45/*-*/ && source.charCodeAt(lastTokenPos - 1) === 45/*-*/) ||
+              lastToken === 41/*)*/ && isParenKeyword(openTokenPosStack[openTokenDepth]) ||
+              lastToken === 125/*}*/ && (isExpressionTerminator(openTokenPosStack[openTokenDepth]) || openClassPosStack[openTokenDepth]) ||
+              lastToken === 47/*/*/ && lastSlashWasDivision ||
+              isExpressionKeyword(lastTokenPos) ||
+              !lastToken) {
+            regularExpression();
+            lastSlashWasDivision = false;
+          }
+          else if (lastExport && lastTokenPos >= lastExport.s && lastTokenPos <= lastExport.e) {
+            // export default /some-regexp/
+            regularExpression();
+            lastSlashWasDivision = false;
+          }
+          else {
+            lastSlashWasDivision = true;
+          }
+        }
+        break;
+      }
+      case 96/*`*/:
+        templateString();
+        break;
+    }
+    lastTokenPos = pos;
+  }
+
+  if (templateDepth !== -1 || openTokenDepth)
+    syntaxError();
+
+  return [imports, exports, facade];
+}
+
+function tryParseImportStatement () {
+  const startPos = pos;
+
+  pos += 6;
+
+  let ch = commentWhitespace(true);
+  
+  switch (ch) {
+    // dynamic import
+    case 40/*(*/:
+      openTokenPosStack[openTokenDepth++] = startPos;
+      if (source.charCodeAt(lastTokenPos) === 46/*.*/)
+        return;
+      // dynamic import indicated by positive d
+      const impt = addImport(startPos, pos + 1, 0, startPos);
+      curDynamicImport = impt;
+      // try parse a string, to record a safe dynamic import string
+      pos++;
+      ch = commentWhitespace(true);
+      if (ch === 39/*'*/ || ch === 34/*"*/) {
+        stringLiteral(ch);
+      }
+      else {
+        pos--;
+        return;
+      }
+      pos++;
+      ch = commentWhitespace(true);
+      if (ch === 44/*,*/) {
+        impt.e = pos;
+        pos++;
+        ch = commentWhitespace(true);
+        impt.a = pos;
+        readName(impt);
+        pos--;
+      }
+      else if (ch === 41/*)*/) {
+        openTokenDepth--;
+        impt.e = pos;
+        impt.se = pos;
+        readName(impt);
+      }
+      else {
+        pos--;
+      }
+      return;
+    // import.meta
+    case 46/*.*/:
+      pos++;
+      ch = commentWhitespace(true);
+      // import.meta indicated by d === -2
+      if (ch === 109/*m*/ && source.startsWith('eta', pos + 1) && source.charCodeAt(lastTokenPos) !== 46/*.*/)
+        addImport(startPos, startPos, pos + 4, -2);
+      return;
+    
+    default:
+      // no space after "import" -> not an import keyword
+      if (pos === startPos + 6)
+        break;
+    case 34/*"*/:
+    case 39/*'*/:
+    case 123/*{*/:
+    case 42/***/:
+      // import statement only permitted at base-level
+      if (openTokenDepth !== 0) {
+        pos--;
+        return;
+      }
+      while (pos < end) {
+        ch = source.charCodeAt(pos);
+        if (ch === 39/*'*/ || ch === 34/*"*/) {
+          readImportString(startPos, ch);
+          return;
+        }
+        pos++;
+      }
+      syntaxError();
+  }
+}
+
+function tryParseExportStatement () {
+  const sStartPos = pos;
+  const prevExport = exports.length;
+
+  pos += 6;
+
+  const curPos = pos;
+
+  let ch = commentWhitespace(true);
+
+  if (pos === curPos && !isPunctuator(ch))
+    return;
+
+  switch (ch) {
+    // export default ...
+    case 100/*d*/:
+      addExport(pos, pos + 7, -1, -1);
+      return;
+
+    // export async? function*? name () {
+    case 97/*a*/:
+      pos += 5;
+      commentWhitespace(true);
+    // fallthrough
+    case 102/*f*/:
+      pos += 8;
+      ch = commentWhitespace(true);
+      if (ch === 42/***/) {
+        pos++;
+        ch = commentWhitespace(true);
+      }
+      const startPos = pos;
+      ch = readToWsOrPunctuator(ch);
+      addExport(startPos, pos, startPos, pos);
+      pos--;
+      return;
+
+    // export class name ...
+    case 99/*c*/:
+      if (source.startsWith('lass', pos + 1) && isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos + 5))) {
+        pos += 5;
+        ch = commentWhitespace(true);
+        const startPos = pos;
+        ch = readToWsOrPunctuator(ch);
+        addExport(startPos, pos, startPos, pos);
+        pos--;
+        return;
+      }
+      pos += 2;
+    // fallthrough
+
+    // export var/let/const name = ...(, name = ...)+
+    case 118/*v*/:
+    case 109/*l*/:
+      // destructured initializations not currently supported (skipped for { or [)
+      // also, lexing names after variable equals is skipped (export var p = function () { ... }, q = 5 skips "q")
+      pos += 2;
+      facade = false;
+      do {
+        pos++;
+        ch = commentWhitespace(true);
+        const startPos = pos;
+        ch = readToWsOrPunctuator(ch);
+        // dont yet handle [ { destructurings
+        if (ch === 123/*{*/ || ch === 91/*[*/) {
+          pos--;
+          return;
+        }
+        if (pos === startPos)
+          return;
+        addExport(startPos, pos, startPos, pos);
+        ch = commentWhitespace(true);
+        if (ch === 61/*=*/) {
+          pos--;
+          return;
+        }
+      } while (ch === 44/*,*/);
+      pos--;
+      return;
+
+
+    // export {...}
+    case 123/*{*/:
+      pos++;
+      ch = commentWhitespace(true);
+      while (true) {
+        const startPos = pos;
+        readToWsOrPunctuator(ch);
+        const endPos = pos;
+        commentWhitespace(true);
+        ch = readExportAs(startPos, endPos);
+        // ,
+        if (ch === 44/*,*/) {
+          pos++;
+          ch = commentWhitespace(true);
+        }
+        if (ch === 125/*}*/)
+          break;
+        if (pos === startPos)
+          return syntaxError(); 
+        if (pos > end)
+          return syntaxError();
+      }
+      pos++;
+      ch = commentWhitespace(true);
+    break;
+    
+    // export *
+    // export * as X
+    case 42/***/:
+      pos++;
+      commentWhitespace(true);
+      ch = readExportAs(pos, pos);
+      ch = commentWhitespace(true);
+    break;
+  }
+
+  // from ...
+  if (ch === 102/*f*/ && source.startsWith('rom', pos + 1)) {
+    pos += 4;
+    readImportString(sStartPos, commentWhitespace(true));
+
+    // There were no local names.
+    for (let i = prevExport; i < exports.length; ++i) {
+      exports[i].ls = exports[i].le = -1;
+      exports[i].ln = undefined;
+    }
+  }
+  else {
+    pos--;
+  }
+}
+
+/*
+ * Ported from Acorn
+ *   
+ * MIT License
+
+ * Copyright (C) 2012-2020 by various contributors (see AUTHORS)
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+let acornPos;
+function readString (start, quote) {
+  acornPos = start;
+  let out = '', chunkStart = acornPos;
+  for (;;) {
+    if (acornPos >= source.length) syntaxError();
+    const ch = source.charCodeAt(acornPos);
+    if (ch === quote) break;
+    if (ch === 92) { // '\'
+      out += source.slice(chunkStart, acornPos);
+      out += readEscapedChar();
+      chunkStart = acornPos;
+    }
+    else if (ch === 0x2028 || ch === 0x2029) {
+      ++acornPos;
+    }
+    else {
+      if (isBr(ch)) syntaxError();
+      ++acornPos;
+    }
+  }
+  out += source.slice(chunkStart, acornPos++);
+  return out;
+}
+
+// Used to read escaped characters
+
+function readEscapedChar () {
+  let ch = source.charCodeAt(++acornPos);
+  ++acornPos;
+  switch (ch) {
+    case 110: return '\n'; // 'n' -> '\n'
+    case 114: return '\r'; // 'r' -> '\r'
+    case 120: return String.fromCharCode(readHexChar(2)); // 'x'
+    case 117: return readCodePointToString(); // 'u'
+    case 116: return '\t'; // 't' -> '\t'
+    case 98: return '\b'; // 'b' -> '\b'
+    case 118: return '\u000b'; // 'v' -> '\u000b'
+    case 102: return '\f'; // 'f' -> '\f'
+    case 13: if (source.charCodeAt(acornPos) === 10) ++acornPos; // '\r\n'
+    case 10: // ' \n'
+      return '';
+    case 56:
+    case 57:
+      syntaxError();
+    default:
+      if (ch >= 48 && ch <= 55) {
+        let octalStr = source.substr(acornPos - 1, 3).match(/^[0-7]+/)[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        acornPos += octalStr.length - 1;
+        ch = source.charCodeAt(acornPos);
+        if (octalStr !== '0' || ch === 56 || ch === 57)
+          syntaxError();
+        return String.fromCharCode(octal);
+      }
+      if (isBr(ch)) {
+        // Unicode new line characters after \ get removed from output in both
+        // template literals and strings
+        return '';
+      }
+      return String.fromCharCode(ch);
+  }
+}
+
+// Used to read character escape sequences ('\x', '\u', '\U').
+
+function readHexChar (len) {
+  const start = acornPos;
+  let total = 0, lastCode = 0;
+  for (let i = 0; i < len; ++i, ++acornPos) {
+    let code = source.charCodeAt(acornPos), val;
+
+    if (code === 95) {
+      if (lastCode === 95 || i === 0) syntaxError();
+      lastCode = code;
+      continue;
+    }
+
+    if (code >= 97) val = code - 97 + 10; // a
+    else if (code >= 65) val = code - 65 + 10; // A
+    else if (code >= 48 && code <= 57) val = code - 48; // 0-9
+    else break;
+    if (val >= 16) break;
+    lastCode = code;
+    total = total * 16 + val;
+  }
+
+  if (lastCode === 95 || acornPos - start !== len) syntaxError();
+
+  return total;
+}
+
+// Read a string value, interpreting backslash-escapes.
+
+function readCodePointToString () {
+  const ch = source.charCodeAt(acornPos);
+  let code;
+  if (ch === 123) { // '{'
+    ++acornPos;
+    code = readHexChar(source.indexOf('}', acornPos) - acornPos);
+    ++acornPos;
+    if (code > 0x10FFFF) syntaxError();
+  } else {
+    code = readHexChar(4);
+  }
+  // UTF-16 Decoding
+  if (code <= 0xFFFF) return String.fromCharCode(code);
+  code -= 0x10000;
+  return String.fromCharCode((code >> 10) + 0xD800, (code & 1023) + 0xDC00);
+}
+
+/*
+ * </ Acorn Port>
+ */
+
+function readExportAs (startPos, endPos) {
+  let ch = source.charCodeAt(pos);
+  let ls = startPos, le = endPos;
+  if (ch === 97 /*a*/) {
+    pos += 2;
+    ch = commentWhitespace(true);
+    startPos = pos;
+    readToWsOrPunctuator(ch);
+    endPos = pos;
+    ch = commentWhitespace(true);
+  }
+  if (pos !== startPos)
+    addExport(startPos, endPos, ls, le);
+  return ch;
+}
+
+function readImportString (ss, ch) {
+  const startPos = pos + 1;
+  if (ch === 39/*'*/ || ch === 34/*"*/) {
+    stringLiteral(ch);
+  }
+  else {
+    syntaxError();
+    return;
+  }
+  const impt = addImport(ss, startPos, pos, -1);
+  readName(impt);
+  pos++;
+  ch = commentWhitespace(false);
+  if (ch !== 97/*a*/ || !source.startsWith('ssert', pos + 1)) {
+    pos--;
+    return;
+  }
+  const assertIndex = pos;
+
+  pos += 6;
+  ch = commentWhitespace(true);
+  if (ch !== 123/*{*/) {
+    pos = assertIndex;
+    return;
+  }
+  const assertStart = pos;
+  do {
+    pos++;
+    ch = commentWhitespace(true);
+    if (ch === 39/*'*/ || ch === 34/*"*/) {
+      stringLiteral(ch);
+      pos++;
+      ch = commentWhitespace(true);
+    }
+    else {
+      ch = readToWsOrPunctuator(ch);
+    }
+    if (ch !== 58/*:*/) {
+      pos = assertIndex;
+      return;
+    }
+    pos++;
+    ch = commentWhitespace(true);
+    if (ch === 39/*'*/ || ch === 34/*"*/) {
+      stringLiteral(ch);
+    }
+    else {
+      pos = assertIndex;
+      return;
+    }
+    pos++;
+    ch = commentWhitespace(true);
+    if (ch === 44/*,*/) {
+      pos++;
+      ch = commentWhitespace(true);
+      if (ch === 125/*}*/)
+        break;
+      continue;
+    }
+    if (ch === 125/*}*/)
+      break;
+    pos = assertIndex;
+    return;
+  } while (true);
+  impt.a = assertStart;
+  impt.se = pos + 1;
+}
+
+function commentWhitespace (br) {
+  let ch;
+  do {
+    ch = source.charCodeAt(pos);
+    if (ch === 47/*/*/) {
+      const next_ch = source.charCodeAt(pos + 1);
+      if (next_ch === 47/*/*/)
+        lineComment();
+      else if (next_ch === 42/***/)
+        blockComment(br);
+      else
+        return ch;
+    }
+    else if (br ? !isBrOrWs(ch): !isWsNotBr(ch)) {
+      return ch;
+    }
+  } while (pos++ < end);
+  return ch;
+}
+
+function templateString () {
+  while (pos++ < end) {
+    const ch = source.charCodeAt(pos);
+    if (ch === 36/*$*/ && source.charCodeAt(pos + 1) === 123/*{*/) {
+      pos++;
+      templateStack[templateStackDepth++] = templateDepth;
+      templateDepth = ++openTokenDepth;
+      return;
+    }
+    if (ch === 96/*`*/)
+      return;
+    if (ch === 92/*\*/)
+      pos++;
+  }
+  syntaxError();
+}
+
+function blockComment (br) {
+  pos++;
+  while (pos++ < end) {
+    const ch = source.charCodeAt(pos);
+    if (!br && isBr(ch))
+      return;
+    if (ch === 42/***/ && source.charCodeAt(pos + 1) === 47/*/*/) {
+      pos++;
+      return;
+    }
+  }
+}
+
+function lineComment () {
+  while (pos++ < end) {
+    const ch = source.charCodeAt(pos);
+    if (ch === 10/*\n*/ || ch === 13/*\r*/)
+      return;
+  }
+}
+
+function stringLiteral (quote) {
+  while (pos++ < end) {
+    let ch = source.charCodeAt(pos);
+    if (ch === quote)
+      return;
+    if (ch === 92/*\*/) {
+      ch = source.charCodeAt(++pos);
+      if (ch === 13/*\r*/ && source.charCodeAt(pos + 1) === 10/*\n*/)
+        pos++;
+    }
+    else if (isBr(ch))
+      break;
+  }
+  syntaxError();
+}
+
+function regexCharacterClass () {
+  while (pos++ < end) {
+    let ch = source.charCodeAt(pos);
+    if (ch === 93/*]*/)
+      return ch;
+    if (ch === 92/*\*/)
+      pos++;
+    else if (ch === 10/*\n*/ || ch === 13/*\r*/)
+      break;
+  }
+  syntaxError();
+}
+
+function regularExpression () {
+  while (pos++ < end) {
+    let ch = source.charCodeAt(pos);
+    if (ch === 47/*/*/)
+      return;
+    if (ch === 91/*[*/)
+      ch = regexCharacterClass();
+    else if (ch === 92/*\*/)
+      pos++;
+    else if (ch === 10/*\n*/ || ch === 13/*\r*/)
+      break;
+  }
+  syntaxError();
+}
+
+function readToWsOrPunctuator (ch) {
+  do {
+    if (isBrOrWs(ch) || isPunctuator(ch))
+      return ch;
+  } while (ch = source.charCodeAt(++pos));
+  return ch;
+}
+
+// Note: non-asii BR and whitespace checks omitted for perf / footprint
+// if there is a significant user need this can be reconsidered
+function isBr (c) {
+  return c === 13/*\r*/ || c === 10/*\n*/;
+}
+
+function isWsNotBr (c) {
+  return c === 9 || c === 11 || c === 12 || c === 32 || c === 160;
+}
+
+function isBrOrWs (c) {
+  return c > 8 && c < 14 || c === 32 || c === 160;
+}
+
+function isBrOrWsOrPunctuatorNotDot (c) {
+  return c > 8 && c < 14 || c === 32 || c === 160 || isPunctuator(c) && c !== 46/*.*/;
+}
+
+function keywordStart (pos) {
+  return pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1));
+}
+
+function readPrecedingKeyword (pos, match) {
+  if (pos < match.length - 1)
+    return false;
+  return source.startsWith(match, pos - match.length + 1) && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - match.length)));
+}
+
+function readPrecedingKeyword1 (pos, ch) {
+  return source.charCodeAt(pos) === ch && (pos === 0 || isBrOrWsOrPunctuatorNotDot(source.charCodeAt(pos - 1)));
+}
+
+// Detects one of case, debugger, delete, do, else, in, instanceof, new,
+//   return, throw, typeof, void, yield, await
+function isExpressionKeyword (pos) {
+  switch (source.charCodeAt(pos)) {
+    case 100/*d*/:
+      switch (source.charCodeAt(pos - 1)) {
+        case 105/*i*/:
+          // void
+          return readPrecedingKeyword(pos - 2, 'vo');
+        case 108/*l*/:
+          // yield
+          return readPrecedingKeyword(pos - 2, 'yie');
+        default:
+          return false;
+      }
+    case 101/*e*/:
+      switch (source.charCodeAt(pos - 1)) {
+        case 115/*s*/:
+          switch (source.charCodeAt(pos - 2)) {
+            case 108/*l*/:
+              // else
+              return readPrecedingKeyword1(pos - 3, 101/*e*/);
+            case 97/*a*/:
+              // case
+              return readPrecedingKeyword1(pos - 3, 99/*c*/);
+            default:
+              return false;
+          }
+        case 116/*t*/:
+          // delete
+          return readPrecedingKeyword(pos - 2, 'dele');
+        default:
+          return false;
+      }
+    case 102/*f*/:
+      if (source.charCodeAt(pos - 1) !== 111/*o*/ || source.charCodeAt(pos - 2) !== 101/*e*/)
+        return false;
+      switch (source.charCodeAt(pos - 3)) {
+        case 99/*c*/:
+          // instanceof
+          return readPrecedingKeyword(pos - 4, 'instan');
+        case 112/*p*/:
+          // typeof
+          return readPrecedingKeyword(pos - 4, 'ty');
+        default:
+          return false;
+      }
+    case 110/*n*/:
+      // in, return
+      return readPrecedingKeyword1(pos - 1, 105/*i*/) || readPrecedingKeyword(pos - 1, 'retur');
+    case 111/*o*/:
+      // do
+      return readPrecedingKeyword1(pos - 1, 100/*d*/);
+    case 114/*r*/:
+      // debugger
+      return readPrecedingKeyword(pos - 1, 'debugge');
+    case 116/*t*/:
+      // await
+      return readPrecedingKeyword(pos - 1, 'awai');
+    case 119/*w*/:
+      switch (source.charCodeAt(pos - 1)) {
+        case 101/*e*/:
+          // new
+          return readPrecedingKeyword1(pos - 2, 110/*n*/);
+        case 111/*o*/:
+          // throw
+          return readPrecedingKeyword(pos - 2, 'thr');
+        default:
+          return false;
+      }
+  }
+  return false;
+}
+
+function isParenKeyword (curPos) {
+  return source.charCodeAt(curPos) === 101/*e*/ && source.startsWith('whil', curPos - 4) ||
+      source.charCodeAt(curPos) === 114/*r*/ && source.startsWith('fo', curPos - 2) ||
+      source.charCodeAt(curPos - 1) === 105/*i*/ && source.charCodeAt(curPos) === 102/*f*/;
+}
+
+function isPunctuator (ch) {
+  // 23 possible punctuator endings: !%&()*+,-./:;<=>?[]^{}|~
+  return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||
+    ch > 39 && ch < 48 || ch > 57 && ch < 64 ||
+    ch === 91/*[*/ || ch === 93/*]*/ || ch === 94/*^*/ ||
+    ch > 122 && ch < 127;
+}
+
+function isExpressionPunctuator (ch) {
+  // 20 possible expression endings: !%&(*+,-.:;<=>?[^{|~
+  return ch === 33/*!*/ || ch === 37/*%*/ || ch === 38/*&*/ ||
+    ch > 39 && ch < 47 && ch !== 41 || ch > 57 && ch < 64 ||
+    ch === 91/*[*/ || ch === 94/*^*/ || ch > 122 && ch < 127 && ch !== 125/*}*/;
+}
+
+function isExpressionTerminator (curPos) {
+  // detects:
+  // => ; ) finally catch else
+  // as all of these followed by a { will indicate a statement brace
+  switch (source.charCodeAt(curPos)) {
+    case 62/*>*/:
+      return source.charCodeAt(curPos - 1) === 61/*=*/;
+    case 59/*;*/:
+    case 41/*)*/:
+      return true;
+    case 104/*h*/:
+      return source.startsWith('catc', curPos - 4);
+    case 121/*y*/:
+      return source.startsWith('finall', curPos - 6);
+    case 101/*e*/:
+      return source.startsWith('els', curPos - 3);
+  }
+  return false;
+}
+
+function syntaxError () {
+  throw Object.assign(new Error(`Parse error ${name}:${source.slice(0, pos).split('\n').length}:${pos - source.lastIndexOf('\n', pos - 1)}`), { idx: pos });
+}

node_modules/es-module-lexer/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "es-module-lexer",
+  "version": "1.7.0",
+  "description": "Lexes ES modules returning their import/export metadata",
+  "main": "dist/lexer.cjs",
+  "module": "dist/lexer.js",
+  "types": "types/lexer.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/lexer.d.ts",
+      "module": "./dist/lexer.js",
+      "import": "./dist/lexer.js",
+      "require": "./dist/lexer.cjs"
+    },
+    "./js": {
+      "types": "./types/lexer.d.ts",
+      "default": "./dist/lexer.asm.js"
+    }
+  },
+  "scripts": {
+    "build": "npm install -g chomp ; chomp build",
+    "test": "npm install -g chomp ; chomp test"
+  },
+  "author": "Guy Bedford",
+  "license": "MIT",
+  "devDependencies": {
+    "@babel/cli": "^7.5.5",
+    "@babel/core": "^7.5.5",
+    "@babel/plugin-transform-modules-commonjs": "^7.5.0",
+    "@swc/cli": "^0.1.57",
+    "@swc/core": "^1.2.224",
+    "@types/node": "^18.7.1",
+    "kleur": "^2.0.2",
+    "mocha": "^5.2.0",
+    "terser": "^5.19.4",
+    "typescript": "^4.7.4"
+  },
+  "files": [
+    "dist",
+    "types",
+    "lexer.js"
+  ],
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guybedford/es-module-lexer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/guybedford/es-module-lexer/issues"
+  },
+  "homepage": "https://github.com/guybedford/es-module-lexer#readme",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "keywords": []
+}

node_modules/es-module-lexer/types/lexer.d.ts

@@ -0,0 +1,195 @@
+export declare enum ImportType {
+    /**
+     * A normal static using any syntax variations
+     *   import .. from 'module'
+     */
+    Static = 1,
+    /**
+     * A dynamic import expression `import(specifier)`
+     * or `import(specifier, opts)`
+     */
+    Dynamic = 2,
+    /**
+     * An import.meta expression
+     */
+    ImportMeta = 3,
+    /**
+     * A source phase import
+     *   import source x from 'module'
+     */
+    StaticSourcePhase = 4,
+    /**
+     * A dynamic source phase import
+     *   import.source('module')
+     */
+    DynamicSourcePhase = 5,
+    /**
+     * A defer phase import
+     *   import defer * as x from 'module'
+     */
+    StaticDeferPhase = 6,
+    /**
+     * A dynamic defer phase import
+     *   import.defer('module')
+     */
+    DynamicDeferPhase = 7
+}
+export interface ImportSpecifier {
+    /**
+     * Module name
+     *
+     * To handle escape sequences in specifier strings, the .n field of imported specifiers will be provided where possible.
+     *
+     * For dynamic import expressions, this field will be empty if not a valid JS string.
+     * For static import expressions, this field will always be populated.
+     *
+     * @example
+     * const [imports1, exports1] = parse(String.raw`import './\u0061\u0062.js'`);
+     * imports1[0].n;
+     * // Returns "./ab.js"
+     *
+     * const [imports2, exports2] = parse(`import("./ab.js")`);
+     * imports2[0].n;
+     * // Returns "./ab.js"
+     *
+     * const [imports3, exports3] = parse(`import("./" + "ab.js")`);
+     * imports3[0].n;
+     * // Returns undefined
+     */
+    readonly n: string | undefined;
+    /**
+     * Type of import statement
+     */
+    readonly t: ImportType;
+    /**
+     * Start of module specifier
+     *
+     * @example
+     * const source = `import { a } from 'asdf'`;
+     * const [imports, exports] = parse(source);
+     * source.substring(imports[0].s, imports[0].e);
+     * // Returns "asdf"
+     */
+    readonly s: number;
+    /**
+     * End of module specifier
+     */
+    readonly e: number;
+    /**
+     * Start of import statement
+     *
+     * @example
+     * const source = `import { a } from 'asdf'`;
+     * const [imports, exports] = parse(source);
+     * source.substring(imports[0].ss, imports[0].se);
+     * // Returns "import { a } from 'asdf';"
+     */
+    readonly ss: number;
+    /**
+     * End of import statement
+     */
+    readonly se: number;
+    /**
+     * If this import keyword is a dynamic import, this is the start value.
+     * If this import keyword is a static import, this is -1.
+     * If this import keyword is an import.meta expresion, this is -2.
+     */
+    readonly d: number;
+    /**
+     * If this import has an import assertion, this is the start value.
+     * Otherwise this is `-1`.
+     */
+    readonly a: number;
+}
+export interface ExportSpecifier {
+    /**
+     * Exported name
+     *
+     * @example
+     * const source = `export default []`;
+     * const [imports, exports] = parse(source);
+     * exports[0].n;
+     * // Returns "default"
+     *
+     * @example
+     * const source = `export const asdf = 42`;
+     * const [imports, exports] = parse(source);
+     * exports[0].n;
+     * // Returns "asdf"
+     */
+    readonly n: string;
+    /**
+     * Local name, or undefined.
+     *
+     * @example
+     * const source = `export default []`;
+     * const [imports, exports] = parse(source);
+     * exports[0].ln;
+     * // Returns undefined
+     *
+     * @example
+     * const asdf = 42;
+     * const source = `export { asdf as a }`;
+     * const [imports, exports] = parse(source);
+     * exports[0].ln;
+     * // Returns "asdf"
+     */
+    readonly ln: string | undefined;
+    /**
+     * Start of exported name
+     *
+     * @example
+     * const source = `export default []`;
+     * const [imports, exports] = parse(source);
+     * source.substring(exports[0].s, exports[0].e);
+     * // Returns "default"
+     *
+     * @example
+     * const source = `export { 42 as asdf }`;
+     * const [imports, exports] = parse(source);
+     * source.substring(exports[0].s, exports[0].e);
+     * // Returns "asdf"
+     */
+    readonly s: number;
+    /**
+     * End of exported name
+     */
+    readonly e: number;
+    /**
+     * Start of local name, or -1.
+     *
+     * @example
+     * const asdf = 42;
+     * const source = `export { asdf as a }`;
+     * const [imports, exports] = parse(source);
+     * source.substring(exports[0].ls, exports[0].le);
+     * // Returns "asdf"
+     */
+    readonly ls: number;
+    /**
+     * End of local name, or -1.
+     */
+    readonly le: number;
+}
+export interface ParseError extends Error {
+    idx: number;
+}
+/**
+ * Outputs the list of exports and locations of import specifiers,
+ * including dynamic import and import meta handling.
+ *
+ * @param source Source code to parser
+ * @param name Optional sourcename
+ * @returns Tuple contaning imports list and exports list.
+ */
+export declare function parse(source: string, name?: string): readonly [
+    imports: ReadonlyArray<ImportSpecifier>,
+    exports: ReadonlyArray<ExportSpecifier>,
+    facade: boolean,
+    hasModuleSyntax: boolean
+];
+/**
+ * Wait for init to resolve before calling `parse`.
+ */
+export declare const init: Promise<void>;
+export declare const initSync: () => void;

node_modules/es-object-atoms/.eslintrc

@@ -0,0 +1,16 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"eqeqeq": ["error", "allow-null"],
+		"id-length": "off",
+		"new-cap": ["error", {
+			"capIsNewExceptions": [
+				"RequireObjectCoercible",
+				"ToObject",
+			],
+		}],
+	},
+}

node_modules/es-object-atoms/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/es-object
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with a single custom sponsorship URL

node_modules/es-object-atoms/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v1.1.1](https://github.com/ljharb/es-object-atoms/compare/v1.1.0...v1.1.1) - 2025-01-14
+
+### Commits
+
+- [types] `ToObject`: improve types [`cfe8c8a`](https://github.com/ljharb/es-object-atoms/commit/cfe8c8a105c44820cb22e26f62d12ef0ad9715c8)
+
+## [v1.1.0](https://github.com/ljharb/es-object-atoms/compare/v1.0.1...v1.1.0) - 2025-01-14
+
+### Commits
+
+- [New] add `isObject` [`51e4042`](https://github.com/ljharb/es-object-atoms/commit/51e4042df722eb3165f40dc5f4bf33d0197ecb07)
+
+## [v1.0.1](https://github.com/ljharb/es-object-atoms/compare/v1.0.0...v1.0.1) - 2025-01-13
+
+### Commits
+
+- [Dev Deps] update `@ljharb/eslint-config`, `@ljharb/tsconfig`, `@types/tape`, `auto-changelog`, `tape` [`38ab9eb`](https://github.com/ljharb/es-object-atoms/commit/38ab9eb00b62c2f4668644f5e513d9b414ebd595)
+- [types] improve types [`7d1beb8`](https://github.com/ljharb/es-object-atoms/commit/7d1beb887958b78b6a728a210a1c8370ab7e2aa1)
+- [Tests] replace `aud` with `npm audit` [`25863ba`](https://github.com/ljharb/es-object-atoms/commit/25863baf99178f1d1ad33d1120498db28631907e)
+- [Dev Deps] add missing peer dep [`c012309`](https://github.com/ljharb/es-object-atoms/commit/c0123091287e6132d6f4240496340c427433df28)
+
+## v1.0.0 - 2024-03-16
+
+### Commits
+
+- Initial implementation, tests, readme, types [`f1499db`](https://github.com/ljharb/es-object-atoms/commit/f1499db7d3e1741e64979c61d645ab3137705e82)
+- Initial commit [`99eedc7`](https://github.com/ljharb/es-object-atoms/commit/99eedc7b5fde38a50a28d3c8b724706e3e4c5f6a)
+- [meta] rename repo [`fc851fa`](https://github.com/ljharb/es-object-atoms/commit/fc851fa70616d2d182aaf0bd02c2ed7084dea8fa)
+- npm init [`b909377`](https://github.com/ljharb/es-object-atoms/commit/b909377c50049bd0ec575562d20b0f9ebae8947f)
+- Only apps should have lockfiles [`7249edd`](https://github.com/ljharb/es-object-atoms/commit/7249edd2178c1b9ddfc66ffcc6d07fdf0d28efc1)

node_modules/es-object-atoms/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jordan Harband
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/es-object-atoms/README.md

@@ -0,0 +1,63 @@
+# es-object-atoms <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][npm-badge-png]][package-url]
+
+ES Object-related atoms: Object, ToObject, RequireObjectCoercible.
+
+## Example
+
+```js
+const assert = require('assert');
+
+const $Object = require('es-object-atoms');
+const isObject = require('es-object-atoms/isObject');
+const ToObject = require('es-object-atoms/ToObject');
+const RequireObjectCoercible = require('es-object-atoms/RequireObjectCoercible');
+
+assert.equal($Object, Object);
+assert.throws(() => ToObject(null), TypeError);
+assert.throws(() => ToObject(undefined), TypeError);
+assert.throws(() => RequireObjectCoercible(null), TypeError);
+assert.throws(() => RequireObjectCoercible(undefined), TypeError);
+
+assert.equal(isObject(undefined), false);
+assert.equal(isObject(null), false);
+assert.equal(isObject({}), true);
+assert.equal(isObject([]), true);
+assert.equal(isObject(function () {}), true);
+
+assert.deepEqual(RequireObjectCoercible(true), true);
+assert.deepEqual(ToObject(true), Object(true));
+
+const obj = {};
+assert.equal(RequireObjectCoercible(obj), obj);
+assert.equal(ToObject(obj), obj);
+```
+
+## Tests
+Simply clone the repo, `npm install`, and run `npm test`
+
+## Security
+
+Please email [@ljharb](https://github.com/ljharb) or see https://tidelift.com/security if you have a potential security vulnerability to report.
+
+[package-url]: https://npmjs.org/package/es-object-atoms
+[npm-version-svg]: https://versionbadg.es/ljharb/es-object-atoms.svg
+[deps-svg]: https://david-dm.org/ljharb/es-object-atoms.svg
+[deps-url]: https://david-dm.org/ljharb/es-object-atoms
+[dev-deps-svg]: https://david-dm.org/ljharb/es-object-atoms/dev-status.svg
+[dev-deps-url]: https://david-dm.org/ljharb/es-object-atoms#info=devDependencies
+[npm-badge-png]: https://nodei.co/npm/es-object-atoms.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/es-object-atoms.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/es-object.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=es-object-atoms
+[codecov-image]: https://codecov.io/gh/ljharb/es-object-atoms/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/ljharb/es-object-atoms/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/es-object-atoms
+[actions-url]: https://github.com/ljharb/es-object-atoms/actions

node_modules/es-object-atoms/RequireObjectCoercible.d.ts

@@ -0,0 +1,3 @@
+declare function RequireObjectCoercible<T extends {}>(value: T, optMessage?: string): T;
+
+export = RequireObjectCoercible;

node_modules/es-object-atoms/RequireObjectCoercible.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var $TypeError = require('es-errors/type');
+
+/** @type {import('./RequireObjectCoercible')} */
+module.exports = function RequireObjectCoercible(value) {
+	if (value == null) {
+		throw new $TypeError((arguments.length > 0 && arguments[1]) || ('Cannot call method on ' + value));
+	}
+	return value;
+};

node_modules/es-object-atoms/ToObject.d.ts

@@ -0,0 +1,7 @@
+declare function ToObject<T extends object>(value: number): Number;
+declare function ToObject<T extends object>(value: boolean): Boolean;
+declare function ToObject<T extends object>(value: string): String;
+declare function ToObject<T extends object>(value: bigint): BigInt;
+declare function ToObject<T extends object>(value: T): T;
+
+export = ToObject;

node_modules/es-object-atoms/ToObject.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var $Object = require('./');
+var RequireObjectCoercible = require('./RequireObjectCoercible');
+
+/** @type {import('./ToObject')} */
+module.exports = function ToObject(value) {
+	RequireObjectCoercible(value);
+	return $Object(value);
+};

node_modules/es-object-atoms/index.d.ts

@@ -0,0 +1,3 @@
+declare const Object: ObjectConstructor;
+
+export = Object;

node_modules/es-object-atoms/index.js

@@ -0,0 +1,4 @@
+'use strict';
+
+/** @type {import('.')} */
+module.exports = Object;

node_modules/es-object-atoms/isObject.d.ts

@@ -0,0 +1,3 @@
+declare function isObject(x: unknown): x is object;
+
+export = isObject;

node_modules/es-object-atoms/isObject.js

@@ -0,0 +1,6 @@
+'use strict';
+
+/** @type {import('./isObject')} */
+module.exports = function isObject(x) {
+	return !!x && (typeof x === 'function' || typeof x === 'object');
+};

node_modules/es-object-atoms/package.json

@@ -0,0 +1,80 @@
+{
+	"name": "es-object-atoms",
+	"version": "1.1.1",
+	"description": "ES Object-related atoms: Object, ToObject, RequireObjectCoercible",
+	"main": "index.js",
+	"exports": {
+		".": "./index.js",
+		"./RequireObjectCoercible": "./RequireObjectCoercible.js",
+		"./isObject": "./isObject.js",
+		"./ToObject": "./ToObject.js",
+		"./package.json": "./package.json"
+	},
+	"sideEffects": false,
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated",
+		"prepublishOnly": "safe-publish-latest",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"pretest": "npm run lint",
+		"test": "npm run tests-only",
+		"tests-only": "nyc tape 'test/**/*.js'",
+		"posttest": "npx npm@\">= 10.2\" audit --production",
+		"prelint": "evalmd README.md",
+		"lint": "eslint --ext=js,mjs .",
+		"postlint": "tsc -p . && eclint check $(git ls-files | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git' | grep -v dist/)",
+		"version": "auto-changelog && git add CHANGELOG.md",
+		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ljharb/es-object-atoms.git"
+	},
+	"keywords": [
+		"javascript",
+		"ecmascript",
+		"object",
+		"toobject",
+		"coercible"
+	],
+	"author": "Jordan Harband <ljharb@gmail.com>",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/ljharb/es-object-atoms/issues"
+	},
+	"homepage": "https://github.com/ljharb/es-object-atoms#readme",
+	"dependencies": {
+		"es-errors": "^1.3.0"
+	},
+	"devDependencies": {
+		"@ljharb/eslint-config": "^21.1.1",
+		"@ljharb/tsconfig": "^0.2.3",
+		"@types/tape": "^5.8.1",
+		"auto-changelog": "^2.5.0",
+		"eclint": "^2.8.1",
+		"encoding": "^0.1.13",
+		"eslint": "^8.8.0",
+		"evalmd": "^0.0.19",
+		"in-publish": "^2.0.1",
+		"npmignore": "^0.3.1",
+		"nyc": "^10.3.2",
+		"safe-publish-latest": "^2.0.0",
+		"tape": "^5.9.0",
+		"typescript": "next"
+	},
+	"auto-changelog": {
+		"output": "CHANGELOG.md",
+		"template": "keepachangelog",
+		"unreleased": false,
+		"commitLimit": false,
+		"backfillLimit": false,
+		"hideCredit": true
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows"
+		]
+	},
+	"engines": {
+		"node": ">= 0.4"
+	}
+}

node_modules/es-object-atoms/test/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var test = require('tape');
+
+var $Object = require('../');
+var isObject = require('../isObject');
+var ToObject = require('../ToObject');
+var RequireObjectCoercible = require('..//RequireObjectCoercible');
+
+test('errors', function (t) {
+	t.equal($Object, Object);
+	// @ts-expect-error
+	t['throws'](function () { ToObject(null); }, TypeError);
+	// @ts-expect-error
+	t['throws'](function () { ToObject(undefined); }, TypeError);
+	// @ts-expect-error
+	t['throws'](function () { RequireObjectCoercible(null); }, TypeError);
+	// @ts-expect-error
+	t['throws'](function () { RequireObjectCoercible(undefined); }, TypeError);
+
+	t.deepEqual(RequireObjectCoercible(true), true);
+	t.deepEqual(ToObject(true), Object(true));
+	t.deepEqual(ToObject(42), Object(42));
+	var f = function () {};
+	t.equal(ToObject(f), f);
+
+	t.equal(isObject(undefined), false);
+	t.equal(isObject(null), false);
+	t.equal(isObject({}), true);
+	t.equal(isObject([]), true);
+	t.equal(isObject(function () {}), true);
+
+	var obj = {};
+	t.equal(RequireObjectCoercible(obj), obj);
+	t.equal(ToObject(obj), obj);
+
+	t.end();
+});