{"id":20311114,"url":"https://github.com/mcmath/chai-iterator","last_synced_at":"2025-07-10T06:35:27.858Z","repository":{"id":65248922,"uuid":"59892063","full_name":"mcmath/chai-iterator","owner":"mcmath","description":"Chai assertions for iterable objects","archived":false,"fork":false,"pushed_at":"2019-11-06T17:32:24.000Z","size":40,"stargazers_count":3,"open_issues_count":5,"forks_count":5,"subscribers_count":2,"default_branch":"master","last_synced_at":"2025-04-11T16:12:35.079Z","etag":null,"topics":["chai","chai-plugin","generator","iterable","iterator","javascript","plugin","test","testing","typescript"],"latest_commit_sha":null,"homepage":"","language":"CoffeeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/mcmath.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2016-05-28T11:48:11.000Z","updated_at":"2020-10-21T16:45:48.000Z","dependencies_parsed_at":"2023-01-16T15:01:00.877Z","dependency_job_id":null,"html_url":"https://github.com/mcmath/chai-iterator","commit_stats":null,"previous_names":[],"tags_count":11,"template":false,"template_full_name":null,"purl":"pkg:github/mcmath/chai-iterator","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mcmath%2Fchai-iterator","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mcmath%2Fchai-iterator/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mcmath%2Fchai-iterator/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mcmath%2Fchai-iterator/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/mcmath","download_url":"https://codeload.github.com/mcmath/chai-iterator/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/mcmath%2Fchai-iterator/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":264538587,"owners_count":23624437,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["chai","chai-plugin","generator","iterable","iterator","javascript","plugin","test","testing","typescript"],"created_at":"2024-11-14T17:36:14.751Z","updated_at":"2025-07-10T06:35:27.809Z","avatar_url":"https://github.com/mcmath.png","language":"CoffeeScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Chai Iterator: Assertions for iterable objects\n\n[![Version][version-badge]][npm]\n[![License][license-badge]][license]\n[![Build][build-badge]][travis]\n[![Coverage][coverage-badge]][coveralls]\n[![Dependencies][dependencies-badge]][gemnasium]\n\n## Contents\n\n- [Overview](#overview)\n- [Compatibility](#compatibility)\n- [Installation](#installation)\n- [Setup](#setup)\n- [Expect/Should API](#expectshould-api)\n- [Assert API](#assert-api)\n- [License](#license)\n\n## Overview\n\n**Chai Iterator** extends the [Chai][chai] assertion library with methods for\ntesting [iterable][iterable] objects. Introduced in the\n[ES2015 specification][ecma-iterable], iterable objects have an\n[`@@iterator`][iterator-method] method, which allows us to iterate over them with\na [`for...of`][for-of] loop. A number of [built-in][built-in-iterable] types are\niterable by default, while [custom iterable objects][custom-iterable] may also\nbe defined. Chai Iterator makes it easy to test all such objects.\n\n#### Basic usage\n\nHere is a fairly exhaustive sample of the assertions we can make using Chai\nIterator. While we could just as easily use `expect` or `assert`, we'll use\nChai's `should()` [assertion style][assertion-style], just to be different.\n\n```js\n[2, 3, 5].should.be.iterable;\n\n[2, 3, 5].should.iterate.over([2, 3, 5]);\n[2, 3, 5].should.iterate.from([2, 3]);\n[2, 3, 5].should.iterate.until([3, 5]);\n\n[2, 3, 5].should.iterate.for.lengthOf(3);\n[2, 3, 5].should.iterate.for.length.above(2);\n[2, 3, 5].should.iterate.for.length.below(4);\n[2, 3, 5].should.iterate.for.length.of.at.least(3);\n[2, 3, 5].should.iterate.for.length.of.at.most(3);\n[2, 3, 5].should.iterate.for.length.within(2, 4);\n\n[2, 3, 5].should.not.iterate.over([1, 2, 3]);\n[{n: 2}, {n: 3}].should.deep.iterate.from([{n: 2}]);\n```\n\nLet's not limit ourselves to Arrays; we can test any iterable object.\n\n```js\n'abcde'.should.iterate.until(['c', 'd', 'e']);\n```\n\nAnd we can pass any iterable as our expected values too.\n\n```js\n'abcde'.should.iterate.until('cde');\n```\n\n#### User-defined iterable objects\n\nThat's enough fiddling around with built-in objects whose iteration\nbehavior is well-known. Chai Iterator is best used to test\n[user-defined iterable objects][custom-iterable], like the one constructed by\nthe following [class][class].\n\n```js\nclass Count {\n\n  constructor(start=0, step=1) {\n    this.start = start;\n    this.step = step;\n  }\n\n  *[Symbol.iterator]() {\n    for (let n = this.start; true; n += this.step) {\n      yield n;\n    }\n  }\n}\n```\n\nThe sequence generated by `Count.prototype[@@iterator]()` is infinite;\nit continues to yield values indefinitely. Still, we can safely\nuse the [`from()`](#iteratefromexpected) assertion with it, since it will\nterminate as soon as our expected iterable is done.\n\n```js\nlet tens = new Count(10, 10);\n\ntens.should.be.iterable;\ntens.should.iterate.from([10, 20, 30]);\ntens.should.iterate.from([10, 20, 30, 40, 50]);\n```\n\nJust don't go trying to use [`over()`](#iterateoverexpected) or\n[`until()`](#iterateuntilexpected) on infinite sequences. The former will always\nfail; the latter will never stop.\n\n#### Generators and iterators\n\nLet's generate the [fibonacci sequence][fibonacci-sequence]. A\n[generator function][generator-function] is just a function that returns a\n[`Generator`][generator] object \u0026mdash; an [iterator][iterator] that is also\n[iterable][iterable]. We can test a `Generator` just as we would any other\niterable.\n\n```js\nfunction* fibonacci() {\n  for (let [x, y] = [1, 1]; true; [x, y] = [y, x + y]) {\n    yield x;\n  }\n}\n\nfibonacci().should.iterate.from([1, 1, 2, 3, 5]);\n```\n\nBe careful though. Iterators can't go back in time. Once a value has\nbeen yielded, it is lost forever. And so the following assertions pass.\n\n```js\nlet fiborator = fibonacci();\n\nfiborator.should.iterate.from([1, 1, 2, 3, 5]);\nfiborator.should.iterate.from([8, 13, 21, 34]);\n```\n\nIt usually makes more sense to construct a new `Generator` for each assertion.\n\n```js\nfibonacci().should.iterate.from([1, 1, 2, 3, 5]);\nfibonacci().should.iterate.from([1, 1, 2, 3, 5, 8, 13]);\n```\n\n## Compatibility\n\nChai Iterator requires that [`Symbol.iterator`][iterator-method] be\navailable in the environment. In [Node][node], this means the version must be\nv4.0 or greater. While the latest versions of [most browsers][browser-list] are\ncompatible, web-facing projects should almost certainly use a polyfill.\n\nThe [Babel polyfill][babel-polyfill] is one option for environments that do not\nnatively support `Symbol.iterator`. More minimally, we can get away with just\ntwo sub-modules from the [core-js][core-js] library, like so.\n\n```js\nrequire('core-js/es6/symbol');\nrequire('core-js/fn/symbol/iterator');\n```\n\n## Installation\n\nInstall Chai Iterator using [npm][npm]. And be sure, of course, to install [Chai][chai-npm].\n\n```sh\nnpm install --save chai chai-iterator\n```\n\n## Setup\n\nChai Iterator can be imported as a [Node][node] module, an [AMD][amd]\nmodule, or included in an HTML [`\u003cscript\u003e`][script-tag] tag. For\n[TypeScript][typescript] users, declarations are installed with the package.\n\n#### Node\n\nTo set up Chai Iterator for [Node][node], make sure the version is v4.0 or\nhigher, as prior versions lack support for the [`@@iterator`][iterator-method]\nmethod.\n\n```js\nconst chai = require('chai');\nconst chaiIterator = require('chai-iterator');\n\nchai.use(chaiIterator);\n```\n\n#### AMD\n\nChai Iterator can be set up inside of an [AMD][amd] module like so.\n\n```js\ndefine((require, exports, module) =\u003e {\n  let chai = require('chai');\n  let chaiIterator = require('chai-iterator');\n\n  chai.use(chaiIterator);\n});\n```\n\n#### HTML script tag\n\nChai Iterator can be included via a [`\u003cscript\u003e`][script-tag] tag. If it is\nloaded after `chai.js`, Chai will use it automatically.\n\n```html\n\u003cscript src=\"chai.js\"\u003e\u003c/script\u003e\n\u003cscript src=\"chai-iterator.js\"\u003e\u003c/script\u003e\n```\n\n#### TypeScript\n\n[TypeScript][typescript] declarations are included in the package. To use them,\nensure Chai Iterator is installed with [npm][npm], then install the declarations\nand their dependencies via [typings][typings]. And be sure to install the\ndeclarations for [chai][chai-typings].\n\n```sh\ntypings install --save-dev npm~chai npm:chai-iterator\n```\n\nIn the [compiler options][compiler-options], set `\"target\"` to `\"es6\"`, or at\nleast include a reference to [`lib.es6.d.ts`][es6-lib]. Now the following will\njust work.\n\n```ts\nimport chai = require(\"chai\");\nimport chaiIterator = require(\"chai-iterator\");\n\nchai.use(chaiIterator);\n\n[2, 3, 5].should.iterate.over([2, 3, 5]);\n```\n\n## Expect/Should API\n\n#### Assertions\n\n- [`iterable`](#iterable)\n- [`iterate.over()`](#iterateoverexpected)\n- [`iterate.from()`](#iteratefromexpected)\n- [`iterate.until()`](#iterateuntilexpected)\n- [`iterate.for.lengthOf()`](#iterateforlengthofn)\n- [`iterate.for.length.above()`](#iterateforlengthaboven)\n- [`iterate.for.length.below()`](#iterateforlengthbelown)\n- [`iterate.for.length.of.at.least()`](#iterateforlengthofatleastn)\n- [`iterate.for.length.of.at.most()`](#iterateforlengthofatmostn)\n- [`iterate.for.length.within()`](#iterateforlengthwithinmin-max)\n\n#### `iterable`\n\nAsserts that the target is an iterable object, i.e., that it has an\n[`@@iterator`][iterator-method] method.\n\n```js\nexpect([2, 3, 5]).to.be.iterable;\nexpect('abcdefg').to.be.iterable;\nexpect(12345).not.to.be.iterable;\n```\n\n#### `iterate.over(expected)`\n\nAsserts that the target iterates over a given sequence of values. Set the\n[`deep`][deep] flag to use deep equality to compare values.\n\n| Param     | Type     | Description         |\n| :-------- | :------- | :------------------ |\n| expected  | `object` | An iterable object. |\n\n```js\nexpect([2, 3, 5]).to.iterate.over([2, 3, 5]);\nexpect('abcdefg').to.itetate.over('abcdefg');\nexpect([2, 3, 5]).not.to.iterate.over([2, 3]);\nexpect([{n: 2}, {n: 3}]).to.deep.iterate.over([{n: 2}, {n: 3}]);\n```\n\n#### `iterate.from(expected)`\n\nAsserts that the target begins iterating over a given sequence of values. Set\nthe [`deep`][deep] flag to use deep equality to compare values.\n\n| Param     | Type     | Description         |\n| :-------- | :------- | :------------------ |\n| expected  | `object` | An iterable object. |\n\n```js\nexpect([2, 3, 5]).to.iterate.from([2, 3]);\nexpect('abcdefg').to.iterate.from('abc');\nexpect([2, 3, 5]).not.to.iterate.from([3, 5]);\nexpect([{n: 2}, {n: 3}]).to.deep.iterate.from([{n: 2}]);\n```\n\n#### `iterate.until(expected)`\n\nAsserts that the target ends iteration with a given sequence of values. Set the\n[`deep`][deep] flag to use deep equality to compare values.\n\n| Param     | Type     | Description         |\n| :-------- | :------- | :------------------ |\n| expected  | `object` | An iterable object. |\n\n```js\nexpect([2, 3, 5]).to.iterate.until([3, 5]);\nexpect('abcdefg').to.iterate.until('efg');\nexpect([2, 3, 5]).not.to.iterate.until([2, 3]);\nexpect([{n: 2}, {n: 3}]).to.deep.iterate.until([{n: 3}]);\n```\n\n#### `iterate.for.lengthOf(n)`\n\nAsserts that the target yields exactly *n* values.\n\n| Param  | Type     | Description         |\n| :----- | :------- | :------------------ |\n| n      | `number` | A positive integer  |\n\n```js\nexpect([2, 3, 5]).to.iterate.for.lengthOf(3);\nexpect('abcdefg').to.iterate.for.lengthOf(7);\nexpect([2, 3, 5]).not.to.iterate.for.lengthOf(7);\n```\n\n#### `iterate.for.length.above(n)`\n\nAsserts that the target yields more than *n* values.\n\n| Param  | Type     | Description         |\n| :----- | :------- | :------------------ |\n| n      | `number` | A positive integer  |\n\n```js\nexpect([2, 3, 5]).to.iterate.for.length.above(2);\nexpect('abcdefg').to.iterate.for.length.above(5);\nexpect([2, 3, 5]).not.to.iterate.for.length.above(3);\n```\n\n#### `iterate.for.length.below(n)`\n\nAsserts that the target yields fewer than *n* values.\n\n| Param  | Type     | Description         |\n| :----- | :------- | :------------------ |\n| n      | `number` | A positive integer  |\n\n```js\nexpect([2, 3, 5]).to.iterate.for.length.below(4);\nexpect('abcdefg').to.iterate.for.length.below(10);\nexpect([2, 3, 5]).not.to.iterate.for.length.below(3);\n```\n\n#### `iterate.for.length.of.at.least(n)`\n\nAsserts that the target yields at least *n* values.\n\n| Param  | Type     | Description         |\n| :----- | :------- | :------------------ |\n| n      | `number` | A positive integer  |\n\n```js\nexpect([2, 3, 5]).to.iterate.for.length.of.at.least(2);\nexpect([2, 3, 5]).to.iterate.for.length.of.at.least(3);\nexpect([2, 3, 5]).not.to.iterate.for.length.of.at.least(4);\n```\n\n#### `iterate.for.length.of.at.most(n)`\n\nAsserts that the target yields at most *n* values.\n\n| Param  | Type     | Description         |\n| :----- | :------- | :------------------ |\n| n      | `number` | A positive integer  |\n\n```js\nexpect([2, 3, 5]).to.iterate.for.length.of.at.most(4);\nexpect([2, 3, 5]).to.iterate.for.length.of.at.most(3);\nexpect([2, 3, 5]).not.to.iterate.for.length.of.at.most(2);\n```\n\n#### `iterate.for.length.within(min, max)`\n\nAsserts that the target yields between *min* and *max* values, inclusive.\n\n| Param  | Type     | Description          |\n| :----- | :------- | :------------------- |\n| min    | `number` | A positive integer   |\n| max    | `number` | A positive integer   |\n\n```js\nexpect([2, 3, 5]).to.iterate.for.length.within(2, 4);\nexpect([2, 3, 5]).to.iterate.for.length.within(3, 3);\nexpect([2, 3, 5]).not.to.iterate.for.length.within(4, 7);\n```\n\n## Assert API\n\n#### Assertions\n\n- [`isIterable()`](#isiterablevalue-message)\n- [`isNotIterable()`](#isnotiterablevalue-message)\n- [`iteratesOver()`](#iteratesovervalue-expected-message)\n- [`doesNotIterateOver()`](#doesnotiterateovervalue-expected-message)\n- [`deepIteratesOver()`](#deepiteratesovervalue-expected-message)\n- [`doesNotDeepIterateOver()`](#doesnotdeepiterateovervalue-expected-message)\n- [`iteratesFrom()`](#iteratesfromvalue-expected-message)\n- [`doesNotIterateFrom()`](#doesnotiteratefromvalue-expected-message)\n- [`deepIteratesFrom()`](#deepiteratesfromvalue-expected-message)\n- [`doesNotDeepIterateFrom()`](#doesnotdeepiteratefromvalue-expected-message)\n- [`iteratesUntil()`](#iteratesuntilvalue-expected-message)\n- [`doesNotIterateUntil()`](#doesnotiterateuntilvalue-expected-message)\n- [`deepIteratesUntil()`](#deepiteratesuntilvalue-expected-message)\n- [`doesNotDeepIterateUntil()`](#doesnotdeepiterateuntilvalue-expected-message)\n- [`lengthOf()`](#lengthofvalue-n-message)\n\n#### Parameters\n\nThe parameters for the assert methods are as follows.\n\n| Param    | Type     | Description                              |\n| :------- | :------- | :--------------------------------------- |\n| value    | `any`    | Any value.                               |\n| expected | `object` | An iterable object.                      |\n| n        | `number` | A positive integer.                      |\n| message? | `string` | An optional message to display on error. |\n\n#### `isIterable(value, [message])`\n\nAsserts that a value is an iterable object, i.e., that it is an object with\nan [`@@iterator`][iterator-method] method.\n\n```js\nassert.isIterable([2, 3, 5]);\nassert.isIterable('abcdefg');\n```\n\n#### `isNotIterable(value, [message])`\n\nAsserts that a value is not an iterable object, i.e., that it lacks an\n[`@@iterator`][iterator-method] method.\n\n```js\nassert.isNotIterable(235);\nassert.isNotIterable(true);\n```\n\n#### `iteratesOver(value, expected, [message])`\n\nAsserts that a value iterates exactly over a given sequence of values.\n\n```js\nassert.iteratesOver([2, 3, 5], [2, 3, 5]);\nassert.iteratesOver('abcdefg', 'abcdefg');\n```\n\n#### `doesNotIterateOver(value, expected, [message])`\n\nAsserts that a value does not iterate exactly over a given sequence of values.\n\n```js\nassert.doesNotIterateOver([2, 3, 5], [1, 2, 3]);\nassert.doesNotIterateOver('abcdefg', 'abc');\n```\n\n#### `deepIteratesOver(value, expected, [message])`\n\nAsserts that a value iterates exactly over a given sequence of values, using\ndeep equality.\n\n```js\nassert.deepIteratesOver([{n: 2}, {n: 3}], [{n: 2}, {n: 3}]);\nassert.deepIteratesOver([[0, 2], [1, 3]], [[0, 2], [1, 3]]);\n```\n\n#### `doesNotDeepIterateOver(value, expected, [message])`\n\nAsserts that a value does not iterate exactly over a given sequence of values,\nusing deep equality.\n\n```js\nassert.doesNotDeepIterateOver([{n: 2}, {n: 3}], [{n: 5}, {n: 7}]);\nassert.doesNotDeepIterateOver([[0, 2], [1, 3]], [[1, 3], [0, 2]]);\n```\n\n#### `iteratesFrom(value, expected, [message])`\n\nAsserts that a value begins iteration with a given sequence of values.\n\n```js\nassert.iteratesFrom([2, 3, 5], [2, 3, 5]);\nassert.iteratesFrom([2, 3, 5], [2, 3]);\nassert.iteratesFrom('abcdefg', 'abc');\nassert.iteratesFrom('abcdefg', '');\n```\n\n#### `doesNotIterateFrom(value, expected, [message])`\n\nAsserts that a value does not begin iteration with a given sequence of values.\n\n```js\nassert.doesNotIterateFrom([2, 3, 5], [3, 5]);\nassert.doesNotIterateFrom('abcdefg', 'cdef');\n```\n\n#### `deepIteratesFrom(value, expected, [message])`\n\nAsserts that a value begins iteration with a given sequence of values, using\ndeep equality.\n\n```js\nassert.deepIteratesFrom([{n: 2}, {n: 3}], [{n: 2}]);\nassert.deepIteratesFrom([[0, 2], [1, 3]], [[0, 2]]);\n```\n\n#### `doesNotDeepIterateFrom(value, expected, [message])`\n\nAsserts that a value does not begin iteration with a given sequence of values,\nusing deep equality.\n\n```js\nassert.doesNotDeepIterateFrom([{n: 2}, {n: 3}], [{n: 5}]);\nassert.doesNotDeepIterateFrom([[0, 2], [1, 3]], [[1, 3]]);\n```\n\n#### `iteratesUntil(value, expected, [message])`\n\nAsserts that a value ends iteration with a given sequence of values.\n\n```js\nassert.iteratesUntil([2, 3, 5], [2, 3, 5]);\nassert.iteratesUntil([2, 3, 5], [3, 5]);\nassert.iteratesUntil('abcdefg', 'efg');\nassert.iteratesUntil('abcdefg', '');\n```\n\n#### `doesNotIterateUntil(value, expected, [message])`\n\nAsserts that a value does not end iteration with a given sequence of values.\n\n```js\nassert.doesNotIterateUntil([2, 3, 5], [2, 3]);\nassert.doesNotIterateUntil('abcdefg', 'cdef');\n```\n\n#### `deepIteratesUntil(value, expected, [message])`\n\nAsserts that a value ends iteration with a given sequence of values, using\ndeep equality.\n\n```js\nassert.deepIteratesUntil([{n: 2}, {n: 3}], [{n: 3}]);\nassert.deepIteratesUntil([[0, 2], [1, 3]], [[1, 3]]);\n```\n\n#### `doesNotDeepIterateUntil(value, expected, [message])`\n\nAsserts that a value does not end iteration with a given sequence of values,\nusing deep equality.\n\n```js\nassert.doesNotDeepIterateUntil([{n: 2}, {n: 3}], [{n: 5}]);\nassert.doesNotDeepIterateUntil([[0, 2], [1, 3]], [[0, 2]]);\n```\n\n#### `lengthOf(value, n, [message])`\n\nAsserts that an iterable yields a given number of values. If *value* is not an\niterable object, or if it has a `'length'` property, Chai's built-in\n[`assert.lengthOf()`][chai-assert-lengthof] will be used.\n\n```js\nfunction* range(min=0, max=Infinity, step=1) {\n  for (let n = min; n \u003c max; n += step) {\n    yield n;\n  }\n}\n\nassert.lengthOf(range(0, 10), 10);\nassert.lengthOf(range(6, 42), 36);\n```\n\n## License\n\nCopyright \u0026copy; 2016\u0026ndash;2017 Akim McMath. Licensed under the [MIT License][license].\n\n[version-badge]: https://img.shields.io/npm/v/chai-iterator.svg?style=flat-square\n[license-badge]: https://img.shields.io/npm/l/chai-iterator.svg?style=flat-square\n[build-badge]: https://img.shields.io/travis/mcmath/chai-iterator/master.svg?style=flat-square\n[coverage-badge]: https://img.shields.io/coveralls/mcmath/chai-iterator/master.svg?style=flat-square\u0026service=github\n[dependencies-badge]: https://img.shields.io/gemnasium/mcmath/chai-iterator.svg?style=flat-square\n[npm]: https://www.npmjs.com/package/chai-iterator\n[license]: LICENSE\n[travis]: https://travis-ci.org/mcmath/chai-iterator\n[coveralls]: https://coveralls.io/github/mcmath/chai-iterator?branch=master\n[gemnasium]: https://gemnasium.com/mcmath/chai-iterator\n[chai]: http://chaijs.com/\n[iterable]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols#iterable\n[ecma-iterable]: http://www.ecma-international.org/ecma-262/6.0/#sec-iterable-interface\n[iterator-method]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator\n[for-of]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of\n[built-in-iterable]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#Builtin_iterables\n[custom-iterable]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#User-defined_iterables\n[assertion-style]: http://chaijs.com/guide/styles/\n[class]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes\n[fibonacci-sequence]: https://en.wikipedia.org/wiki/Fibonacci_number\n[generator-function]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*\n[generator]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator\n[iterator]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols#iterator\n[node]: https://nodejs.org/\n[browser-list]: https://kangax.github.io/compat-table/es6/#test-well-known_symbols_Symbol.iterator,_existence\n[babel-polyfill]: https://babeljs.io/docs/usage/polyfill/\n[core-js]: https://github.com/zloirock/core-js\n[amd]: https://github.com/amdjs/amdjs-api/wiki/AMD\n[script-tag]: https://developer.mozilla.org/en/docs/Web/HTML/Element/script\n[typescript]: http://www.typescriptlang.org/\n[chai-typings]: https://github.com/typed-typings/npm-chai\n[typings]: https://github.com/typings/typings\n[compiler-options]: https://www.typescriptlang.org/docs/handbook/compiler-options.html\n[es6-lib]: https://github.com/Microsoft/TypeScript/blob/master/lib/lib.es6.d.ts\n[deep]: http://chaijs.com/api/bdd/#method_deep\n[chai-npm]: https://www.npmjs.com/package/chai\n[chai-assert-lengthof]: http://chaijs.com/api/assert/#method_lengthof\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmcmath%2Fchai-iterator","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fmcmath%2Fchai-iterator","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fmcmath%2Fchai-iterator/lists"}