[
  {
    "path": ".eslintrc.yml",
    "content": "root: true\n\nenv:\n  commonjs: true\n  es6: true\n\nextends:\n  - eslint:recommended\n  - prettier\n\nrules:\n  ## Possible Errors\n\n  for-direction: error\n  no-prototype-builtins: error\n  no-template-curly-in-string: error\n\n  ## Best Practices\n\n  array-callback-return: error\n  block-scoped-var: error\n  complexity:\n    - error\n    - 16\n  consistent-return: error\n  curly: error\n  default-case: error\n  dot-notation: error\n  eqeqeq: error\n  guard-for-in: error\n  no-alert: error\n  no-caller: error\n  no-div-regex: error\n  no-empty-function: error\n  no-empty-pattern: error\n  no-eq-null: error\n  no-eval: error\n  no-extend-native: error\n  no-extra-bind: error\n  no-extra-label: error\n  no-global-assign: error\n  no-implicit-coercion: error\n  no-implicit-globals: error\n  no-implied-eval: error\n  no-iterator: error\n  no-labels: error\n  no-lone-blocks: error\n  no-loop-func: error\n  no-multi-str: error\n  no-new: error\n  no-new-func: error\n  no-new-wrappers: error\n  no-octal-escape: error\n  no-proto: error\n  no-return-assign: error\n  no-script-url: error\n  no-self-compare: error\n  no-sequences: error\n  no-throw-literal: error\n  no-unmodified-loop-condition: error\n  no-unused-expressions: error\n  no-useless-call: error\n  no-useless-concat: error\n  no-useless-return: error\n  no-void: error\n  no-with: error\n  prefer-promise-reject-errors: error\n  radix: error\n  yoda: error\n\n  ## Strict Mode\n\n  strict: error\n\n  ## Variables\n\n  no-catch-shadow: error\n  no-label-var: error\n  no-shadow: error\n  no-shadow-restricted-names: error\n  no-undef-init: error\n  no-undefined: error\n  no-use-before-define: error\n\n  ## Node.js and CommonJS\n\n  callback-return: error\n  handle-callback-err: error\n  no-buffer-constructor: error\n  no-mixed-requires: error\n  no-new-require: error\n  no-path-concat: error\n  no-process-env: error\n  no-process-exit: error\n\n  ## Stylistic Issues\n\n  camelcase: error\n  capitalized-comments:\n    - error\n    - always\n    - ignoreConsecutiveComments: true\n  consistent-this: error\n  func-name-matching: error\n  func-style:\n    - error\n    - declaration\n    - allowArrowFunctions: true\n  id-match: error\n  lines-between-class-members: error\n  max-depth: error\n  max-nested-callbacks:\n    - error\n    - max: 6\n  max-statements-per-line: error\n  new-cap: error\n  no-array-constructor: error\n  no-bitwise: error\n  no-continue: error\n  no-lonely-if: error\n  no-multi-assign: error\n  no-negated-condition: error\n  no-nested-ternary: error\n  no-new-object: error\n  no-underscore-dangle:\n    - error\n    - allowAfterThis: true\n  no-unneeded-ternary: error\n  one-var:\n    - error\n    - never\n  operator-assignment: error\n  padding-line-between-statements: error\n  sort-vars: error\n  spaced-comment: error\n\n  ## ECMAScript 6\n\n  arrow-body-style: error\n  no-duplicate-imports: error\n  no-restricted-imports: error\n  no-useless-computed-key: error\n  no-useless-constructor: error\n  no-useless-rename: error\n  no-var: error\n  object-shorthand: error\n  prefer-arrow-callback: error\n  prefer-const: error\n  prefer-destructuring: error\n  prefer-numeric-literals: error\n  prefer-spread: error\n  prefer-template: error\n  sort-imports: error\n  symbol-description: error\n"
  },
  {
    "path": ".gitignore",
    "content": "node_modules/\nyarn-error.log\n\n.nyc_output/\ncoverage/\n"
  },
  {
    "path": ".npmrc",
    "content": "save-exact = true\n"
  },
  {
    "path": ".nycrc",
    "content": "{\n  \"reporter\": [\n    \"lcov\",\n    \"text-summary\"\n  ]\n}\n"
  },
  {
    "path": ".prettierignore",
    "content": ".nyc_output/\ncoverage/\n"
  },
  {
    "path": ".prettierrc.yml",
    "content": "singleQuote: true\ntrailingComma: es5\n"
  },
  {
    "path": ".travis.yml",
    "content": "language: node_js\n\n# https://github.com/nodejs/Release\nnode_js:\n  - 12 # EOL: 2022-04-01\n  - 10 # EOL: 2021-04-01\n\nos:\n  - linux\n  - osx\n\nmatrix:\n  include:\n    - env: IMMUTABLE_VERSION=^4.0.0-rc\n\ninstall:\n  - yarn install --frozen-lockfile\n\nbefore_script:\n  - if [ \"$IMMUTABLE_VERSION\" ]; then yarn add --dev immutable@$IMMUTABLE_VERSION; fi\n\nafter_script:\n  - if [[ \"$TRAVIS_OS_NAME\" == \"linux\" && \"$TRAVIS_NODE_VERSION\" == \"12\" ]]; then yarn coveralls; fi\n\nnotifications:\n  email:\n    on_success: never\n    on_failure: always\n\n# Identifies `a.b.c-xxx.n` tags as pre-releases, and `a.b.c` as stable releases\nbefore_deploy: |\n  function dist_tag() {\n    if [[ \"$TRAVIS_TAG\" = *\"-\"* ]]; then\n      echo \"next\"\n    else\n      echo \"latest\"\n    fi\n  }\n\ndeploy:\n  provider: npm\n  tag: $(dist_tag)\n  email:\n    secure: bXNlycnAR6z+PawxKBB6fSKuoAQb61bH3gYhOD8yIP5Lx0zj6HHDj8Ze4jsE8X133RVVWUPONqw0D09b/w0ahWfRlY80/TzOlT6HgYHTLKuKZsgGrLDbSBBGeXzU4I+/Zuo3fJ7xGIUIRe4qrUELnUYNE7VuB1Un78xTmkuZ0cY=\n  api_key:\n    secure: lmkAwQspZnROe6Ev0QdV/9l1cN10BWMyc7BfkecNVr1Ab1G6Kws4LoczbJS/VJmLmvKaSMppLvmA+32pIu1XGa3ezjQQoobi1VPTH7RUGOY57y3japctsgI9JFXzFIESJo6lspe8blSHH7J6pyEJ0Vbl6gnDju9ploQWCawdh1g=\n  on:\n    node: 10\n    os: linux\n    tags: true\n    repo: astorije/chai-immutable\n\n# If the current release is a stable release, remove potential pre-release tag\nafter_deploy: |\n  if [ \"$(dist_tag)\" == \"latest\" ]; then\n    npm dist-tag rm chai-immutable next || true\n  fi\n"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "content": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, we as\ncontributors and maintainers pledge to making participation in our project and\nour community a harassment-free experience for everyone, regardless of age, body\nsize, disability, ethnicity, gender identity and expression, level of experience,\nnationality, personal appearance, race, religion, or sexual identity and\norientation.\n\n## Our Standards\n\nExamples of behavior that contributes to creating a positive environment\ninclude:\n\n- Using welcoming and inclusive language\n- Being respectful of differing viewpoints and experiences\n- Gracefully accepting constructive criticism\n- Focusing on what is best for the community\n- Showing empathy towards other community members\n\nExamples of unacceptable behavior by participants include:\n\n- The use of sexualized language or imagery and unwelcome sexual attention or\n  advances\n- Trolling, insulting/derogatory comments, and personal or political attacks\n- Public or private harassment\n- Publishing others' private information, such as a physical or electronic\n  address, without explicit permission\n- Other conduct which could reasonably be considered inappropriate in a\n  professional setting\n\n## Our Responsibilities\n\nProject maintainers are responsible for clarifying the standards of acceptable\nbehavior and are expected to take appropriate and fair corrective action in\nresponse to any instances of unacceptable behavior.\n\nProject maintainers have the right and responsibility to remove, edit, or\nreject comments, commits, code, wiki edits, issues, and other contributions\nthat are not aligned to this Code of Conduct, or to ban temporarily or\npermanently any contributor for other behaviors that they deem inappropriate,\nthreatening, offensive, or harmful.\n\n## Scope\n\nThis Code of Conduct applies both within project spaces and in public spaces\nwhen an individual is representing the project or its community. Examples of\nrepresenting a project or community include using an official project e-mail\naddress, posting via an official social media account, or acting as an appointed\nrepresentative at an online or offline event. Representation of a project may be\nfurther defined and clarified by project maintainers.\n\n## Enforcement\n\nInstances of abusive, harassing, or otherwise unacceptable behavior may be\nreported by contacting the project owner at jeremie (at) astori (dot) fr. All\ncomplaints will be reviewed and investigated and will result in a response that\nis deemed necessary and appropriate to the circumstances. The project team is\nobligated to maintain confidentiality with regard to the reporter of an incident.\nFurther details of specific enforcement policies may be posted separately.\n\nProject maintainers who do not follow or enforce the Code of Conduct in good\nfaith may face temporary or permanent repercussions as determined by other\nmembers of the project's leadership.\n\n## Attribution\n\nThis Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,\navailable at [http://contributor-covenant.org/version/1/4][version]\n\n[homepage]: http://contributor-covenant.org\n[version]: http://contributor-covenant.org/version/1/4/\n"
  },
  {
    "path": "LICENSE",
    "content": "The MIT License (MIT)\n\nCopyright (c) 2015 Jérémie Astori\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
  },
  {
    "path": "README.md",
    "content": "[![npm Version](https://img.shields.io/npm/v/chai-immutable.svg)](https://npmjs.org/package/chai-immutable)\n[![License](https://img.shields.io/npm/l/chai-immutable.svg)](LICENSE)\n[![Build Status](https://travis-ci.org/astorije/chai-immutable.svg?branch=master)](https://travis-ci.org/astorije/chai-immutable)\n[![Build Status](https://ci.appveyor.com/api/projects/status/407ts84pq7wd4kt9/branch/master?svg=true)](https://ci.appveyor.com/project/astorije/chai-immutable/branch/master)\n[![Coverage Status](https://coveralls.io/repos/astorije/chai-immutable/badge.svg)](https://coveralls.io/r/astorije/chai-immutable)\n[![devDependencies Status](https://david-dm.org/astorije/chai-immutable/dev-status.svg)](https://david-dm.org/astorije/chai-immutable?type=dev)\n[![peerDependencies Status](https://david-dm.org/astorije/chai-immutable/peer-status.svg)](https://david-dm.org/astorije/chai-immutable?type=peer)\n\n# Chai Immutable\n\nThis plugin provides a set of [Chai](http://chaijs.com/) assertions for [Facebook's Immutable library for JavaScript collections](http://facebook.github.io/immutable-js/).\n\n<!-- fulky:globals\nconst chai = require('chai');\nconst { assert, expect } = chai;\n\nconst Immutable = require('immutable');\nconst {\n  List,\n  Map,\n  Set,\n  Stack,\n} = Immutable;\n\nchai.use(require('./chai-immutable'));\n-->\n\n## Assertions\n\n- BDD API Reference (Expect / Should)\n  - [`.empty`](#empty)\n  - [`.equal(collection)`](#equalcollection)\n  - [`.referenceEqual(value)`](#referenceequalvalue)\n  - [`.include(value)`](#includevalue)\n  - [`.keys(key1[, key2[, ...]])`](#keyskey1-key2-)\n  - [`.property(path[, val])`](#propertypath-val)\n  - [`.size(value)`](#sizevalue)\n- TDD API Reference (Assert)\n  - [`.equal(actual, expected)`](#equalactual-expected)\n  - [`.referenceEqual(actual, expected)`](#referenceequalactual-expected)\n  - [`.notEqual(actual, expected)`](#notequalactual-expected)\n  - [`.notReferenceEqual(actual, expected)`](#notreferenceequalactual-expected)\n  - [`.sizeOf(collection, length)`](#sizeofcollection-length)\n\n## Installation\n\n### Node.js\n\nInstall via [npm](http://npmjs.org) or [yarn](https://yarnpkg.com/):\n\n```bash\nnpm install --save-dev chai-immutable\nyarn add --dev chai-immutable\n```\n\nYou can then use this plugin as any other Chai plugins:\n\n<!-- fulky:skip-test -->\n\n```js\nconst chai = require('chai');\nconst chaiImmutable = require('chai-immutable');\n\nchai.use(chaiImmutable);\n```\n\n### ES6 syntax (needs Babel transpiling)\n\n<!-- fulky:skip-test -->\n\n```js\nimport chai from 'chai';\nimport chaiImmutable from 'chai-immutable';\n\nchai.use(chaiImmutable);\n```\n\n### In the browser\n\nInclude this plugin after including Chai and Immutable. It will automatically\nplug in to Chai and be ready for use:\n\n```html\n<script src=\"chai-immutable.js\"></script>\n```\n\n### Using `chai-immutable` with other plugins\n\nIf you are using this plugin with\n[`chai-as-promised`](https://github.com/domenic/chai-as-promised/) or\n[`dirty-chai`](https://github.com/prodatakey/dirty-chai), note that\n`chai-immutable` must be loaded **before** any of them. For example:\n\n<!-- fulky:skip-test -->\n\n```js\nconst chai = require('chai');\nconst chaiAsPromised = require('chai-as-promised');\nconst chaiImmutable = require('chai-immutable');\nconst dirtyChai = require('dirty-chai');\nconst { expect } = chai;\n\nchai.use(chaiImmutable);\nchai.use(chaiAsPromised);\nchai.use(dirtyChai);\n\nconst { List } = require('immutable');\n\n/* ... */\n\nexpect(Promise.resolve(List.of(1, 2, 3))).to.eventually.have.size(3);\nexpect(true).to.be.true();\n```\n\n## BDD API Reference (Expect / Should)\n\n### .empty\n\nAsserts that the immutable collection is empty.\n\n```js\nexpect(List()).to.be.empty;\nexpect(List.of(1, 2, 3)).to.not.be.empty;\n```\n\n### .equal(collection)\n\n- **@param** _{ Collection }_ collection\n\nAsserts that the values of the target are equivalent to the values of\n`collection`. Aliases of Chai's original `equal` method are also supported.\n\n```js\nconst a = List.of(1, 2, 3);\nconst b = List.of(1, 2, 3);\nexpect(a).to.equal(b);\n```\n\nImmutable data structures should only contain other immutable data\nstructures (unlike `Array`s and `Object`s) to be considered immutable and\nproperly work against `.equal()`. See\n[issue #24](https://github.com/astorije/chai-immutable/issues/24) for more\ninformation.\n\nAlso, note that `deep.equal` and `eql` are synonyms of `equal` when\ntested against immutable data structures, therefore they are aliases to\n`equal`.\n\n### .referenceEqual(value)\n\n- **@param** _{Collection}_ value\n\nAsserts that the reference of the target is equivalent to the reference of\n`collection`. This method preserves the original behavior of Chai's `equal`.\n\nSee [issue #210](https://github.com/astorije/chai-immutable/issues/210) for\nmore details.\n\n```js\nconst a = List.of(1, 2, 3);\nconst b = a;\nconst c = List.of(1, 2, 3);\nexpect(a).to.referenceEqual(b);\nexpect(a).to.not.referenceEqual(c);\n```\n\n### .include(value)\n\n- **@param** _{ Mixed }_ val\n\nThe `include` and `contain` assertions can be used as either property\nbased language chains or as methods to assert the inclusion of a value or\nsubset in an immutable collection. When used as language chains, they toggle\nthe `contains` flag for the `keys` assertion.\n\nNote that `deep.include` behaves exactly like `include` in the context of\nimmutable data structures.\n\n```js\nexpect(new List([1, 2, 3])).to.include(2);\nexpect(new List([1, 2, 3])).to.deep.include(2);\nexpect(new Map({ foo: 'bar', hello: 'world' })).to.include('bar');\nexpect(new Map({ a: 1, b: 2, c: 3 })).to.include(new Map({ a: 1, b: 2 }));\nexpect(new Map({ foo: 'bar', hello: 'world' })).to.include.keys('foo');\n```\n\n### .keys(key1[, key2[, ...]])\n\n- **@param** _{ String... | Array | Object | Collection }_ key*N*\n\nAsserts that the target collection has the given keys.\n\nWhen the target is an object or array, keys can be provided as one or more\nstring arguments, a single array argument, a single object argument, or an\nimmutable collection. In the last 2 cases, only the keys in the given\nobject/collection matter; the values are ignored.\n\n```js\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys('foo', 'bar');\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new List(['bar', 'foo']));\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new Set(['bar', 'foo']));\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new Stack(['bar', 'foo']));\nexpect(new List(['x', 'y'])).to.have.all.keys(0, 1);\n\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(['foo', 'bar']);\nexpect(new List(['x', 'y'])).to.have.all.keys([0, 1]);\n\n// Values in the passed object are ignored:\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys({ bar: 6, foo: 7 });\nexpect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(\n  new Map({ bar: 6, foo: 7 })\n);\nexpect(new List(['x', 'y'])).to.have.all.keys({ 0: 4, 1: 5 });\n```\n\nNote that `deep.property` behaves exactly like `property` in the context of\nimmutable data structures.\n\nBy default, the target must have all of the given keys and no more. Add\n`.any` earlier in the chain to only require that the target have at least\none of the given keys. Also, add `.not` earlier in the chain to negate\n`.keys`. It's often best to add `.any` when negating `.keys`, and to use\n`.all` when asserting `.keys` without negation.\n\nWhen negating `.keys`, `.any` is preferred because `.not.any.keys` asserts\nexactly what's expected of the output, whereas `.not.all.keys` creates\nuncertain expectations.\n\n```js\n// Recommended; asserts that target doesn't have any of the given keys\nexpect(new Map({ a: 1, b: 2 })).to.not.have.any.keys('c', 'd');\n\n// Not recommended; asserts that target doesn't have all of the given\n// keys but may or may not have some of them\nexpect(new Map({ a: 1, b: 2 })).to.not.have.all.keys('c', 'd');\n```\n\nWhen asserting `.keys` without negation, `.all` is preferred because\n`.all.keys` asserts exactly what's expected of the output, whereas\n`.any.keys` creates uncertain expectations.\n\n```js\n// Recommended; asserts that target has all the given keys\nexpect(new Map({ a: 1, b: 2 })).to.have.all.keys('a', 'b');\n\n// Not recommended; asserts that target has at least one of the given\n// keys but may or may not have more of them\nexpect(new Map({ a: 1, b: 2 })).to.have.any.keys('a', 'b');\n```\n\nNote that `.all` is used by default when neither `.all` nor `.any` appear\nearlier in the chain. However, it's often best to add `.all` anyway because\nit improves readability.\n\n```js\n// Both assertions are identical\nexpect(new Map({ a: 1, b: 2 })).to.have.all.keys('a', 'b'); // Recommended\nexpect(new Map({ a: 1, b: 2 })).to.have.keys('a', 'b'); // Not recommended\n```\n\nAdd `.include` earlier in the chain to require that the target's keys be a\nsuperset of the expected keys, rather than identical sets.\n\n```js\n// Target object's keys are a superset of ['a', 'b'] but not identical\nexpect(new Map({ a: 1, b: 2, c: 3 })).to.include.all.keys('a', 'b');\nexpect(new Map({ a: 1, b: 2, c: 3 })).to.not.have.all.keys('a', 'b');\n```\n\nHowever, if `.any` and `.include` are combined, only the `.any` takes\neffect. The `.include` is ignored in this case.\n\n```js\n// Both assertions are identical\nexpect(new Map({ a: 1 })).to.have.any.keys('a', 'b');\nexpect(new Map({ a: 1 })).to.include.any.keys('a', 'b');\n```\n\nThe alias `.key` can be used interchangeably with `.keys`.\n\n```js\nexpect(new Map({ foo: 1 })).to.have.key('foo');\n```\n\n### .property(path[, val])\n\n- **@param** _{ String | Array | Iterable }_ path\n- **@param** _{ Mixed }_ val (optional)\n\nAsserts that the target has a property with the given `path`.\n\n```js\nexpect(new Map({ a: 1 })).to.have.property('a');\n```\n\nWhen `val` is provided, `.property` also asserts that the property's value\nis equal to the given `val`. `val` can be an immutable collection.\n\n```js\nexpect(new Map({ a: 1 })).to.have.property('a', 1);\n```\n\nNote that `deep.property` behaves exactly like `property` in the context of\nimmutable data structures.\n\nAdd `.nested` earlier in the chain to enable dot- and bracket-notation when\nreferencing nested properties. An immutable `List` can also be used as the\nstarting point of a `nested.property`.\n\n```js\nexpect(Immutable.fromJS({ a: { b: ['x', 'y'] } })).to.have.nested.property(\n  'a.b[1]'\n);\nexpect(Immutable.fromJS({ a: { b: ['x', 'y'] } })).to.have.nested.property(\n  'a.b[1]',\n  'y'\n);\nexpect(Immutable.fromJS({ a: { b: ['x', 'y'] } })).to.have.nested.property(\n  ['a', 'b', 1],\n  'y'\n);\nexpect(Immutable.fromJS({ a: { b: ['x', 'y'] } })).to.have.nested.property(\n  new List(['a', 'b', 1]),\n  'y'\n);\n```\n\nIf `.` or `[]` are part of an actual property name, they can be escaped by\nadding two backslashes before them.\n\n```js\nexpect(Immutable.fromJS({ '.a': { '[b]': 'x' } })).to.have.nested.property(\n  '\\\\.a.\\\\[b\\\\]'\n);\n```\n\nAdd `.not` earlier in the chain to negate `.property`.\n\n```js\nexpect(new Map({ a: 1 })).to.not.have.property('b');\n```\n\nHowever, it's dangerous to negate `.property` when providing `val`. The\nproblem is that it creates uncertain expectations by asserting that the\ntarget either doesn't have a property at the given `path`, or that it\ndoes have a property at the given key `path` but its value isn't equal to\nthe given `val`. It's often best to identify the exact output that's\nexpected, and then write an assertion that only accepts that exact output.\n\nWhen the target isn't expected to have a property at the given\n`path`, it's often best to assert exactly that.\n\n```js\nexpect(new Map({ b: 2 })).to.not.have.property('a'); // Recommended\nexpect(new Map({ b: 2 })).to.not.have.property('a', 1); // Not recommended\n```\n\nWhen the target is expected to have a property at the given key `path`,\nit's often best to assert that the property has its expected value, rather\nthan asserting that it doesn't have one of many unexpected values.\n\n```js\nexpect(new Map({ a: 3 })).to.have.property('a', 3); // Recommended\nexpect(new Map({ a: 3 })).to.not.have.property('a', 1); // Not recommended\n```\n\n`.property` changes the target of any assertions that follow in the chain\nto be the value of the property from the original target object.\n\n```js\nexpect(new Map({ a: 1 }))\n  .to.have.property('a')\n  .that.is.a('number');\n```\n\n### .size(value)\n\n- **@param** _{ Number }_ size\n\nAsserts that the immutable collection has the expected size.\n\n```js\nexpect(List.of(1, 2, 3)).to.have.size(3);\n```\n\nIt can also be used as a chain precursor to a value comparison for the\n`size` property.\n\n```js\nexpect(List.of(1, 2, 3)).to.have.size.least(3);\nexpect(List.of(1, 2, 3)).to.have.size.most(3);\nexpect(List.of(1, 2, 3)).to.have.size.above(2);\nexpect(List.of(1, 2, 3)).to.have.size.below(4);\nexpect(List.of(1, 2, 3)).to.have.size.within(2, 4);\n```\n\nSimilarly to `length`/`lengthOf`, `sizeOf` is an alias of `size`:\n\n```js\nexpect(List.of(1, 2, 3)).to.have.sizeOf(3);\n```\n\n## TDD API Reference (Assert)\n\n### .equal(actual, expected)\n\n- **@param** _{ Collection }_ actual\n- **@param** _{ Collection }_ expected\n\nAsserts that the values of `actual` are equivalent to the values of\n`expected`. Note that `.strictEqual()` and `.deepEqual()` assert\nexactly like `.equal()` in the context of Immutable data structures.\n\n```js\nconst a = List.of(1, 2, 3);\nconst b = List.of(1, 2, 3);\nassert.equal(a, b);\n```\n\nImmutable data structures should only contain other immutable data\nstructures (unlike `Array`s and `Object`s) to be considered immutable and\nproperly work against `.equal()`, `.strictEqual()` or `.deepEqual()`. See\n[issue #24](https://github.com/astorije/chai-immutable/issues/24) for more\ninformation.\n\n### .referenceEqual(actual, expected)\n\n- **@param** _{Collection}_ actual\n- **@param** _{Collection}_ expected\n\nAsserts that the reference of `actual` is equivalent to the reference of\n`expected`. This method preserves the original behavior of Chai's `equal`.\n\nSee [issue #210](https://github.com/astorije/chai-immutable/issues/210) for\nmore details.\n\n```js\nconst a = List.of(1, 2, 3);\nconst b = a;\nconst c = List.of(1, 2, 3);\nassert.referenceEqual(a, b);\nassert.throws(() => assert.referenceEqual(a, c));\n```\n\n### .notEqual(actual, expected)\n\n- **@param** _{ Collection }_ actual\n- **@param** _{ Collection }_ expected\n\nAsserts that the values of `actual` are not equivalent to the values of\n`expected`. Note that `.notStrictEqual()` and `.notDeepEqual()` assert\nexactly like `.notEqual()` in the context of Immutable data structures.\n\n```js\nconst a = List.of(1, 2, 3);\nconst b = List.of(4, 5, 6);\nassert.notEqual(a, b);\n```\n\n### .notReferenceEqual(actual, expected)\n\n- **@param** _{Collection}_ actual\n- **@param** _{Collection}_ expected\n\nAsserts that the reference of `actual` is not equivalent to the reference of\n`expected`. This method preserves the original behavior of Chai's `notEqual`.\n\nSee [issue #210](https://github.com/astorije/chai-immutable/issues/210) for\nmore details.\n\n```js\nconst a = List.of(1, 2, 3);\nconst b = a;\nconst c = List.of(1, 2, 3);\nassert.throws(() => assert.notReferenceEqual(a, b));\nassert.notReferenceEqual(a, c);\n```\n\n### .sizeOf(collection, length)\n\n- **@param** _{ Collection }_ collection\n- **@param** _{ Number }_ size\n\nAsserts that the immutable collection has the expected size.\n\n```js\nassert.sizeOf(List.of(1, 2, 3), 3);\nassert.sizeOf(new List(), 0);\n```\n"
  },
  {
    "path": "appveyor.yml",
    "content": "# http://www.appveyor.com/docs/appveyor-yml\n\n# Build version format\nversion: '{build}'\n\n# Do not build on tags (GitHub only)\nskip_tags: true\n\nenvironment:\n  matrix:\n    - nodejs_version: 12 # EOL: 2022-04-01\n    - nodejs_version: 10 # EOL: 2021-04-01\n\ninstall:\n  - ps: Install-Product node $env:nodejs_version\n  - yarn install --frozen-lockfile\n  - yarn add --dev mocha-appveyor-reporter\n  - echo --reporter mocha-appveyor-reporter >> test/mocha.opts\n\ntest_script:\n  - node --version\n  - yarn --version\n  - yarn test\n\n# cache npm modules\ncache:\n  - \"%LOCALAPPDATA%\\\\Yarn\"\n\n# Don't actually build\nbuild: off\n"
  },
  {
    "path": "chai-immutable.js",
    "content": "'use strict';\n\n((context, factory) => {\n  if (\n    typeof require === 'function' &&\n    typeof exports === 'object' &&\n    typeof module === 'object'\n  ) {\n    // Node.js\n    module.exports = factory(require('immutable'));\n  } else {\n    // Other environments (usually <script> tag)\n    context.chai.use(factory(context.Immutable));\n  }\n})(this, (Immutable) => (chai, utils) => {\n  function isImmutable(value) {\n    if (typeof Immutable.isImmutable === 'undefined') {\n      return Immutable.Iterable.isIterable(value);\n    } else {\n      return Immutable.isImmutable(value);\n    }\n  }\n\n  const { Assertion } = chai;\n\n  function assertIsIterable(obj) {\n    new Assertion(obj).assert(\n      Immutable.Iterable.isIterable(obj),\n      'expected #{this} to be an Iterable'\n    );\n  }\n\n  /**\n   * ## BDD API Reference\n   */\n\n  /**\n   * ### .empty\n   *\n   * Asserts that the immutable collection is empty.\n   *\n   * ```js\n   * expect(List()).to.be.empty;\n   * expect(List.of(1, 2, 3)).to.not.be.empty;\n   * ```\n   *\n   * @name empty\n   * @namespace BDD\n   * @api public\n   */\n\n  Assertion.overwriteProperty(\n    'empty',\n    (_super) =>\n      function () {\n        const obj = this._obj;\n\n        if (Immutable.Iterable.isIterable(obj)) {\n          const { size } = obj;\n          new Assertion(size).a('number');\n\n          this.assert(\n            size === 0,\n            'expected #{this} to be empty but got size #{act}',\n            'expected #{this} to not be empty'\n          );\n        } else {\n          _super.apply(this, arguments);\n        }\n      }\n  );\n\n  /**\n   * ### .equal(collection)\n   *\n   * Asserts that the values of the target are equivalent to the values of\n   * `collection`. Aliases of Chai's original `equal` method are also supported.\n   *\n   * ```js\n   * const a = List.of(1, 2, 3);\n   * const b = List.of(1, 2, 3);\n   * expect(a).to.equal(b);\n   * ```\n   *\n   * Immutable data structures should only contain other immutable data\n   * structures (unlike `Array`s and `Object`s) to be considered immutable and\n   * properly work against `.equal()`. See\n   * [issue #24](https://github.com/astorije/chai-immutable/issues/24) for more\n   * information.\n   *\n   * Also, note that `deep.equal` and `eql` are synonyms of `equal` when\n   * tested against immutable data structures, therefore they are aliases to\n   * `equal`.\n   *\n   * @name equal\n   * @alias equals\n   * @alias eq\n   * @alias eql\n   * @alias eqls\n   * @alias deep.equal\n   * @param {Collection} value\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertImmutableEqual(_super) {\n    return function (collection) {\n      const obj = this._obj;\n\n      if (isImmutable(obj)) {\n        this.assert(\n          Immutable.is(obj, collection),\n          'expected #{act} to equal #{exp}',\n          'expected #{act} to not equal #{exp}',\n          collection.toJS(),\n          obj.toJS(),\n          true\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  Assertion.overwriteMethod('equal', assertImmutableEqual);\n  Assertion.overwriteMethod('equals', assertImmutableEqual);\n  Assertion.overwriteMethod('eq', assertImmutableEqual);\n  Assertion.overwriteMethod('eql', assertImmutableEqual);\n  Assertion.overwriteMethod('eqls', assertImmutableEqual);\n\n  /**\n   * ### .referenceEqual(value)\n   *\n   * Asserts that the reference of the target is equivalent to the reference of\n   * `collection`. This method preserves the original behavior of Chai's `equal`.\n   *\n   * See [issue #210](https://github.com/astorije/chai-immutable/issues/210) for\n   * more details.\n   *\n   * ```js\n   * const a = List.of(1, 2, 3);\n   * const b = a;\n   * const c = List.of(1, 2, 3);\n   * expect(a).to.referenceEqual(b);\n   * expect(a).to.not.referenceEqual(c);\n   * ```\n   *\n   * @name referenceEqual\n   * @param {Collection} value\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertCollectionReferenceEqual() {\n    return function (collection) {\n      const obj = this._obj;\n\n      this.assert(\n        obj === collection,\n        'expected #{act} reference to equal #{exp}',\n        'expected #{act} reference to not equal #{exp}',\n        collection.toJS(),\n        obj.toJS(),\n        true\n      );\n    };\n  }\n\n  Assertion.addMethod('referenceEqual', assertCollectionReferenceEqual);\n\n  /**\n   * ### .include(value)\n   *\n   * The `include` and `contain` assertions can be used as either property\n   * based language chains or as methods to assert the inclusion of a value or subset\n   * in an immutable collection. When used as language chains, they toggle the\n   * `contains` flag for the `keys` assertion.\n   *\n   * Note that `deep.include` behaves exactly like `include` in the context of\n   * immutable data structures.\n   *\n   * ```js\n   * expect(new List([1, 2, 3])).to.include(2);\n   * expect(new List([1, 2, 3])).to.deep.include(2);\n   * expect(new Map({ foo: 'bar', hello: 'world' })).to.include('bar');\n   * expect(new Map({ a: 1, b: 2, c: 3 })).to.include(new Map({ a: 1, b: 2 }));\n   * expect(new Map({ foo: 'bar', hello: 'world' })).to.include.keys('foo');\n   * ```\n   *\n   * @name include\n   * @alias contain\n   * @alias includes\n   * @alias contains\n   * @param {Mixed} val\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertCollectionInclude(_super) {\n    return function (val) {\n      const obj = this._obj;\n\n      if (Immutable.Iterable.isIterable(obj)) {\n        const isIncluded =\n          obj.includes(val) ||\n          (Immutable.Iterable.isIterable(val) && obj.isSuperset(val));\n        this.assert(\n          isIncluded,\n          'expected #{act} to include #{exp}',\n          'expected #{act} to not include #{exp}',\n          val,\n          obj.toString()\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  function chainCollectionInclude(_super) {\n    return function () {\n      _super.apply(this, arguments);\n    };\n  }\n\n  ['include', 'contain', 'contains', 'includes'].forEach((keyword) => {\n    Assertion.overwriteChainableMethod(\n      keyword,\n      assertCollectionInclude,\n      chainCollectionInclude\n    );\n  });\n\n  /**\n   * ### .keys(key1[, key2[, ...]])\n   *\n   * Asserts that the target collection has the given keys.\n   *\n   * When the target is an object or array, keys can be provided as one or more\n   * string arguments, a single array argument, a single object argument, or an\n   * immutable collection. In the last 2 cases, only the keys in the given\n   * object/collection matter; the values are ignored.\n   *\n   * ```js\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys('foo', 'bar');\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new List(['bar', 'foo']));\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new Set(['bar', 'foo']));\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new Stack(['bar', 'foo']));\n   * expect(new List(['x', 'y'])).to.have.all.keys(0, 1);\n   *\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(['foo', 'bar']);\n   * expect(new List(['x', 'y'])).to.have.all.keys([0, 1]);\n   *\n   * // Values in the passed object are ignored:\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys({ 'bar': 6, 'foo': 7 });\n   * expect(new Map({ foo: 1, bar: 2 })).to.have.all.keys(new Map({ 'bar': 6, 'foo': 7 }));\n   * expect(new List(['x', 'y'])).to.have.all.keys({0: 4, 1: 5});\n   * ```\n   *\n   * Note that `deep.property` behaves exactly like `property` in the context of\n   * immutable data structures.\n   *\n   * By default, the target must have all of the given keys and no more. Add\n   * `.any` earlier in the chain to only require that the target have at least\n   * one of the given keys. Also, add `.not` earlier in the chain to negate\n   * `.keys`. It's often best to add `.any` when negating `.keys`, and to use\n   * `.all` when asserting `.keys` without negation.\n   *\n   * When negating `.keys`, `.any` is preferred because `.not.any.keys` asserts\n   * exactly what's expected of the output, whereas `.not.all.keys` creates\n   * uncertain expectations.\n   *\n   * ```js\n   * // Recommended; asserts that target doesn't have any of the given keys\n   * expect(new Map({a: 1, b: 2})).to.not.have.any.keys('c', 'd');\n   *\n   * // Not recommended; asserts that target doesn't have all of the given\n   * // keys but may or may not have some of them\n   * expect(new Map({a: 1, b: 2})).to.not.have.all.keys('c', 'd');\n   * ```\n   *\n   * When asserting `.keys` without negation, `.all` is preferred because\n   * `.all.keys` asserts exactly what's expected of the output, whereas\n   * `.any.keys` creates uncertain expectations.\n   *\n   * ```js\n   * // Recommended; asserts that target has all the given keys\n   * expect(new Map({a: 1, b: 2})).to.have.all.keys('a', 'b');\n   *\n   * // Not recommended; asserts that target has at least one of the given\n   * // keys but may or may not have more of them\n   * expect(new Map({a: 1, b: 2})).to.have.any.keys('a', 'b');\n   * ```\n   *\n   * Note that `.all` is used by default when neither `.all` nor `.any` appear\n   * earlier in the chain. However, it's often best to add `.all` anyway because\n   * it improves readability.\n   *\n   * ```js\n   * // Both assertions are identical\n   * expect(new Map({a: 1, b: 2})).to.have.all.keys('a', 'b'); // Recommended\n   * expect(new Map({a: 1, b: 2})).to.have.keys('a', 'b'); // Not recommended\n   * ```\n   *\n   * Add `.include` earlier in the chain to require that the target's keys be a\n   * superset of the expected keys, rather than identical sets.\n   *\n   * ```js\n   * // Target object's keys are a superset of ['a', 'b'] but not identical\n   * expect(new Map({a: 1, b: 2, c: 3})).to.include.all.keys('a', 'b');\n   * expect(new Map({a: 1, b: 2, c: 3})).to.not.have.all.keys('a', 'b');\n   * ```\n   *\n   * However, if `.any` and `.include` are combined, only the `.any` takes\n   * effect. The `.include` is ignored in this case.\n   *\n   * ```js\n   * // Both assertions are identical\n   * expect(new Map({a: 1})).to.have.any.keys('a', 'b');\n   * expect(new Map({a: 1})).to.include.any.keys('a', 'b');\n   * ```\n   *\n   * The alias `.key` can be used interchangeably with `.keys`.\n   *\n   * ```js\n   * expect(new Map({ foo: 1 })).to.have.key('foo');\n   * ```\n   *\n   * @name keys\n   * @alias key\n   * @alias deep.key\n   * @param {...String|Array|Object|Collection} keys\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertKeyedCollectionKeys(_super) {\n    return function (keys) {\n      const obj = this._obj;\n\n      if (Immutable.Iterable.isIterable(obj)) {\n        const ssfi = utils.flag(this, 'ssfi');\n\n        switch (utils.type(keys)) {\n          case 'Object':\n            if (Immutable.Iterable.isIndexed(keys)) {\n              keys = keys.toJS();\n            } else if (Immutable.Iterable.isIterable(keys)) {\n              keys = keys.keySeq().toJS();\n            } else {\n              keys = Object.keys(keys);\n            }\n          // `keys` is now an array so this statement safely falls through\n          case 'Array':\n            if (arguments.length > 1) {\n              throw new chai.AssertionError(\n                'when testing keys against an immutable collection, you must ' +\n                  'give a single Array|Object|String|Collection argument or ' +\n                  'multiple String arguments',\n                null,\n                ssfi\n              );\n            }\n            break;\n          default:\n            keys = Array.prototype.slice.call(arguments);\n            break;\n        }\n\n        // Only stringify non-Symbols because Symbols would become \"Symbol()\"\n        keys = keys.map((val) => (typeof val === 'symbol' ? val : String(val)));\n\n        if (!keys.length) {\n          throw new chai.AssertionError('keys required', null, ssfi);\n        }\n\n        let all = utils.flag(this, 'all');\n        const any = utils.flag(this, 'any');\n        const contains = utils.flag(this, 'contains');\n        let ok;\n        let str = contains ? 'contain ' : 'have ';\n\n        if (!any && !all) {\n          all = true;\n        }\n\n        if (any) {\n          ok = keys.some((key) => obj.has(key));\n        } else {\n          ok = keys.every((key) => obj.has(key));\n\n          if (!contains) {\n            ok = ok && keys.length === obj.count();\n          }\n        }\n\n        if (keys.length > 1) {\n          keys = keys.map(utils.inspect);\n          const last = keys.pop();\n          const conjunction = any ? 'or' : 'and';\n          str += `keys ${keys.join(', ')}, ${conjunction} ${last}`;\n        } else {\n          str += `key ${utils.inspect(keys[0])}`;\n        }\n\n        this.assert(\n          ok,\n          `expected #{act} to ${str}`,\n          `expected #{act} to not ${str}`,\n          keys.slice(0).sort(utils.compareByInspect),\n          obj.toString(),\n          true\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  Assertion.overwriteMethod('keys', assertKeyedCollectionKeys);\n  Assertion.overwriteMethod('key', assertKeyedCollectionKeys);\n\n  /**\n   * ## parsePath(path)\n   *\n   * Helper function used to parse string paths into arrays of keys and\n   * indices.\n   *\n   * ```js\n   * const parsed = parsePath('myobject.key.subkey');\n   * ```\n   *\n   * ### Paths:\n   *\n   * - Can be as near infinitely deep and nested\n   * - Arrays are also valid using the formal `myobject.document[3].key`.\n   * - Literal dots and brackets (not delimiter) must be backslash-escaped.\n   *\n   * This function is inspired from Chai's original `parsePath` function:\n   * https://github.com/chaijs/chai/blob/d664ef4/lib/chai/utils/getPathInfo.js#L46-L74\n   *\n   * @param {String} path\n   * @returns {Array} parsed\n   * @api private\n   */\n  function parsePath(path) {\n    // Given the following path: 'a.b[1]'\n    // Separates keys followed by indices with a dot: 'a.b.[1]'\n    const str = path.replace(/([^\\\\])\\[/g, '$1.[');\n    // Extracts all indices and keys into an array: ['a', 'b', '[1]']\n    const parts = str.match(/(\\\\\\.|[^.]+?)+/g);\n\n    // Removes brackets and escaping backslashes, and extracts digits from\n    // each value in the array: ['a', 'b', 1]\n    return parts.map((value) => {\n      // Extracts indices wrapped in brackets\n      const re = /^\\[(\\d+)\\]$/;\n      // Builds ['[<index>]', '<index>'] if value is a digit, null otherwise\n      const mArr = re.exec(value);\n\n      // If the value was of form '[<index>]', returns <index>\n      // Otherwise, returns the key without the escaping backslashes\n      if (mArr) {\n        return parseFloat(mArr[1]);\n      } else {\n        return value.replace(/\\\\([.[\\]])/g, '$1');\n      }\n    });\n  }\n\n  /**\n   * ### .property(path[, val])\n   *\n   * Asserts that the target has a property with the given `path`.\n   *\n   * ```js\n   * expect(new Map({a: 1})).to.have.property('a');\n   * ```\n   *\n   * When `val` is provided, `.property` also asserts that the property's value\n   * is equal to the given `val`. `val` can be an immutable collection.\n   *\n   * ```js\n   * expect(new Map({a: 1})).to.have.property('a', 1);\n   * ```\n   *\n   * Note that `deep.property` behaves exactly like `property` in the context of\n   * immutable data structures.\n   *\n   * Add `.nested` earlier in the chain to enable dot- and bracket-notation when\n   * referencing nested properties. An immutable `List` can also be used as the\n   * starting point of a `nested.property`.\n   *\n   * ```js\n   * expect(Immutable.fromJS({a: {b: ['x', 'y']}})).to.have.nested.property('a.b[1]');\n   * expect(Immutable.fromJS({a: {b: ['x', 'y']}})).to.have.nested.property('a.b[1]', 'y');\n   * expect(Immutable.fromJS({a: {b: ['x', 'y']}})).to.have.nested.property(['a', 'b', 1], 'y');\n   * expect(Immutable.fromJS({a: {b: ['x', 'y']}})).to.have.nested.property(new List(['a', 'b', 1]), 'y');\n   * ```\n   *\n   * If `.` or `[]` are part of an actual property name, they can be escaped by\n   * adding two backslashes before them.\n   *\n   * ```js\n   * expect(Immutable.fromJS({'.a': {'[b]': 'x'}})).to.have.nested.property('\\\\.a.\\\\[b\\\\]');\n   * ```\n   *\n   * Add `.not` earlier in the chain to negate `.property`.\n   *\n   * ```js\n   * expect(new Map({a: 1})).to.not.have.property('b');\n   * ```\n   *\n   * However, it's dangerous to negate `.property` when providing `val`. The\n   * problem is that it creates uncertain expectations by asserting that the\n   * target either doesn't have a property at the given `path`, or that it\n   * does have a property at the given key `path` but its value isn't equal to\n   * the given `val`. It's often best to identify the exact output that's\n   * expected, and then write an assertion that only accepts that exact output.\n   *\n   * When the target isn't expected to have a property at the given\n   * `path`, it's often best to assert exactly that.\n   *\n   * ```js\n   * expect(new Map({b: 2})).to.not.have.property('a'); // Recommended\n   * expect(new Map({b: 2})).to.not.have.property('a', 1); // Not recommended\n   * ```\n   *\n   * When the target is expected to have a property at the given key `path`,\n   * it's often best to assert that the property has its expected value, rather\n   * than asserting that it doesn't have one of many unexpected values.\n   *\n   * ```js\n   * expect(new Map({a: 3})).to.have.property('a', 3); // Recommended\n   * expect(new Map({a: 3})).to.not.have.property('a', 1); // Not recommended\n   * ```\n   *\n   * `.property` changes the target of any assertions that follow in the chain\n   * to be the value of the property from the original target object.\n   *\n   * ```js\n   * expect(new Map({a: 1})).to.have.property('a').that.is.a('number');\n   * ```\n   *\n   * @name property\n   * @alias deep.equal\n   * @param {String|Array|Iterable} path\n   * @param {Mixed} val (optional)\n   * @returns value of property for chaining\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertProperty(_super) {\n    return function (path, val) {\n      const obj = this._obj;\n\n      if (Immutable.Iterable.isIterable(obj)) {\n        const isNested = utils.flag(this, 'nested');\n        const negate = utils.flag(this, 'negate');\n\n        let descriptor;\n        let hasProperty;\n        let value;\n\n        if (isNested) {\n          descriptor = 'nested ';\n          if (typeof path === 'string') {\n            path = parsePath(path);\n          }\n          value = obj.getIn(path);\n          hasProperty = obj.hasIn(path);\n        } else {\n          value = obj.get(path);\n          hasProperty = obj.has(path);\n        }\n\n        // When performing a negated assertion for both name and val, merely\n        // having a property with the given name isn't enough to cause the\n        // assertion to fail. It must both have a property with the given name,\n        // and the value of that property must equal the given val. Therefore,\n        // skip this assertion in favor of the next.\n        if (!negate || arguments.length === 1) {\n          this.assert(\n            hasProperty,\n            `expected #{this} to have ${descriptor}property ` +\n              `${utils.inspect(path)}`,\n            `expected #{this} to not have ${descriptor}property ` +\n              `${utils.inspect(path)}`\n          );\n        }\n\n        if (arguments.length > 1) {\n          let isEqual;\n          if (Immutable.Iterable.isIterable(val)) {\n            isEqual = Immutable.is(val, value);\n          } else {\n            isEqual = val === value;\n          }\n\n          this.assert(\n            hasProperty && isEqual,\n            `expected #{this} to have ${descriptor}property ` +\n              `${utils.inspect(path)} of #{exp}, but got #{act}`,\n            `expected #{this} to not have ${descriptor}property ` +\n              `${utils.inspect(path)} of #{act}`,\n            val,\n            value\n          );\n        }\n\n        utils.flag(this, 'object', value);\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  Assertion.overwriteMethod('property', assertProperty);\n\n  /**\n   * ### .size(value)\n   *\n   * Asserts that the immutable collection has the expected size.\n   *\n   * ```js\n   * expect(List.of(1, 2, 3)).to.have.size(3);\n   * ```\n   *\n   * It can also be used as a chain precursor to a value comparison for the\n   * `size` property.\n   *\n   * ```js\n   * expect(List.of(1, 2, 3)).to.have.size.least(3);\n   * expect(List.of(1, 2, 3)).to.have.size.most(3);\n   * expect(List.of(1, 2, 3)).to.have.size.above(2);\n   * expect(List.of(1, 2, 3)).to.have.size.below(4);\n   * expect(List.of(1, 2, 3)).to.have.size.within(2,4);\n   * ```\n   *\n   * Similarly to `length`/`lengthOf`, `sizeOf` is an alias of `size`:\n   *\n   * ```js\n   * expect(List.of(1, 2, 3)).to.have.sizeOf(3);\n   * ```\n   *\n   * @name size\n   * @alias sizeOf\n   * @param {Number} size\n   * @namespace BDD\n   * @api public\n   */\n\n  function assertCollectionSize(n) {\n    assertIsIterable(this._obj);\n\n    const { size } = this._obj;\n    new Assertion(size).a('number');\n\n    this.assert(\n      size === n,\n      'expected #{this} to have size #{exp} but got #{act}',\n      'expected #{this} to not have size #{act}',\n      n,\n      size\n    );\n  }\n\n  function chainCollectionSize() {\n    utils.flag(this, 'immutable.collection.size', true);\n  }\n\n  Assertion.addChainableMethod(\n    'size',\n    assertCollectionSize,\n    chainCollectionSize\n  );\n  Assertion.addMethod('sizeOf', assertCollectionSize);\n\n  // Numerical comparator overwrites\n\n  function assertCollectionSizeLeast(_super) {\n    return function (n) {\n      if (utils.flag(this, 'immutable.collection.size')) {\n        assertIsIterable(this._obj);\n\n        const { size } = this._obj;\n        new Assertion(size).a('number');\n\n        this.assert(\n          size >= n,\n          'expected #{this} to have a size of at least #{exp} but got #{act}',\n          'expected #{this} to not have a size of at least #{exp} but got ' +\n            '#{act}',\n          n,\n          size\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  function assertCollectionSizeMost(_super) {\n    return function (n) {\n      if (utils.flag(this, 'immutable.collection.size')) {\n        assertIsIterable(this._obj);\n\n        const { size } = this._obj;\n        new Assertion(size).a('number');\n\n        this.assert(\n          size <= n,\n          'expected #{this} to have a size of at most #{exp} but got #{act}',\n          'expected #{this} to not have a size of at most #{exp} but got ' +\n            '#{act}',\n          n,\n          size\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  function assertCollectionSizeAbove(_super) {\n    return function (n) {\n      if (utils.flag(this, 'immutable.collection.size')) {\n        assertIsIterable(this._obj);\n\n        const { size } = this._obj;\n        new Assertion(size).a('number');\n\n        this.assert(\n          size > n,\n          'expected #{this} to have a size above #{exp} but got #{act}',\n          'expected #{this} to not have a size above #{exp} but got #{act}',\n          n,\n          size\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  function assertCollectionSizeBelow(_super) {\n    return function (n) {\n      if (utils.flag(this, 'immutable.collection.size')) {\n        assertIsIterable(this._obj);\n\n        const { size } = this._obj;\n        new Assertion(size).a('number');\n\n        this.assert(\n          size < n,\n          'expected #{this} to have a size below #{exp} but got #{act}',\n          'expected #{this} to not have a size below #{exp} but got #{act}',\n          n,\n          size\n        );\n      } else {\n        _super.apply(this, arguments);\n      }\n    };\n  }\n\n  Assertion.overwriteMethod('least', assertCollectionSizeLeast);\n  Assertion.overwriteMethod('gte', assertCollectionSizeLeast);\n\n  Assertion.overwriteMethod('most', assertCollectionSizeMost);\n  Assertion.overwriteMethod('lte', assertCollectionSizeMost);\n\n  Assertion.overwriteMethod('above', assertCollectionSizeAbove);\n  Assertion.overwriteMethod('gt', assertCollectionSizeAbove);\n  Assertion.overwriteMethod('greaterThan', assertCollectionSizeAbove);\n\n  Assertion.overwriteMethod('below', assertCollectionSizeBelow);\n  Assertion.overwriteMethod('lt', assertCollectionSizeBelow);\n  Assertion.overwriteMethod('lessThan', assertCollectionSizeBelow);\n\n  Assertion.overwriteMethod(\n    'within',\n    (_super) =>\n      function (min, max) {\n        if (utils.flag(this, 'immutable.collection.size')) {\n          assertIsIterable(this._obj);\n\n          const { size } = this._obj;\n          new Assertion(size).a('number');\n\n          this.assert(\n            min <= size && size <= max,\n            'expected #{this} to have a size within #{exp} but got #{act}',\n            'expected #{this} to not have a size within #{exp} but got #{act}',\n            `${min}..${max}`,\n            size\n          );\n        } else {\n          _super.apply(this, arguments);\n        }\n      }\n  );\n\n  /**\n   * ## TDD API Reference\n   */\n\n  const { assert } = chai;\n  const originalEqual = assert.equal;\n  const originalNotEqual = assert.notEqual;\n\n  /**\n   * ### .equal(actual, expected)\n   *\n   * Asserts that the values of `actual` are equivalent to the values of\n   * `expected`. Note that `.strictEqual()` and `.deepEqual()` assert\n   * exactly like `.equal()` in the context of Immutable data structures.\n   *\n   * ```js\n   * const a = List.of(1, 2, 3);\n   * const b = List.of(1, 2, 3);\n   * assert.equal(a, b);\n   * ```\n   *\n   * Immutable data structures should only contain other immutable data\n   * structures (unlike `Array`s and `Object`s) to be considered immutable and\n   * properly work against `.equal()`, `.strictEqual()` or `.deepEqual()`. See\n   * [issue #24](https://github.com/astorije/chai-immutable/issues/24) for more\n   * information.\n   *\n   * @name equal\n   * @param {Collection} actual\n   * @param {Collection} expected\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.equal = (actual, expected) => {\n    // It seems like we shouldn't actually need this check, however,\n    // `assert.equal` actually behaves differently than its BDD counterpart!\n    // Namely, the BDD version is strict while the \"assert\" one isn't.\n    if (Immutable.Iterable.isIterable(actual)) {\n      return new Assertion(actual).equal(expected);\n    } else {\n      return originalEqual(actual, expected);\n    }\n  };\n\n  /**\n   * ### .referenceEqual(actual, expected)\n   *\n   * Asserts that the reference of `actual` is equivalent to the reference of\n   * `expected`. This method preserves the original behavior of Chai's `equal`.\n   *\n   * See [issue #210](https://github.com/astorije/chai-immutable/issues/210) for\n   * more details.\n   *\n   * ```js\n   * const a = List.of(1, 2, 3);\n   * const b = a;\n   * const c = List.of(1, 2, 3);\n   * assert.referenceEqual(a, b);\n   * assert.throws(() => assert.referenceEqual(a, c));\n   * ```\n   *\n   * @name referenceEqual\n   * @param {Collection} actual\n   * @param {Collection} expected\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.referenceEqual = originalEqual;\n\n  /**\n   * ### .notEqual(actual, expected)\n   *\n   * Asserts that the values of `actual` are not equivalent to the values of\n   * `expected`. Note that `.notStrictEqual()` and `.notDeepEqual()` assert\n   * exactly like `.notEqual()` in the context of Immutable data structures.\n   *\n   * ```js\n   * const a = List.of(1, 2, 3);\n   * const b = List.of(4, 5, 6);\n   * assert.notEqual(a, b);\n   * ```\n   *\n   * @name notEqual\n   * @param {Collection} actual\n   * @param {Collection} expected\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notEqual = (actual, expected) => {\n    if (Immutable.Iterable.isIterable(actual)) {\n      return new Assertion(actual).not.equal(expected);\n    } else {\n      return originalNotEqual(actual, expected);\n    }\n  };\n\n  /**\n   * ### .notReferenceEqual(actual, expected)\n   *\n   * Asserts that the reference of `actual` is not equivalent to the reference of\n   * `expected`. This method preserves the original behavior of Chai's `notEqual`.\n   *\n   * See [issue #210](https://github.com/astorije/chai-immutable/issues/210) for\n   * more details.\n   *\n   * ```js\n   * const a = List.of(1, 2, 3);\n   * const b = a;\n   * const c = List.of(1, 2, 3);\n   * assert.throws(() => assert.notReferenceEqual(a, b));\n   * assert.notReferenceEqual(a, c);\n   * ```\n   *\n   * @name notReferenceEqual\n   * @param {Collection} actual\n   * @param {Collection} expected\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.notReferenceEqual = originalNotEqual;\n\n  /**\n   * ### .sizeOf(collection, length)\n   *\n   * Asserts that the immutable collection has the expected size.\n   *\n   * ```js\n   * assert.sizeOf(List.of(1, 2, 3), 3);\n   * assert.sizeOf(new List(), 0);\n   * ```\n   *\n   * @name sizeOf\n   * @param {Collection} collection\n   * @param {Number} size\n   * @namespace Assert\n   * @api public\n   */\n\n  assert.sizeOf = (collection, expected) => {\n    new Assertion(collection).size(expected);\n  };\n});\n"
  },
  {
    "path": "package.json",
    "content": "{\n  \"name\": \"chai-immutable\",\n  \"version\": \"2.1.0\",\n  \"description\": \"Chai assertions for Facebook's Immutable library for JavaScript collections\",\n  \"main\": \"chai-immutable.js\",\n  \"files\": [\n    \"chai-immutable.js\"\n  ],\n  \"scripts\": {\n    \"format\": \"run-s -c \\\"lint:eslint --fix\\\" \\\"lint:prettier --write\\\"\",\n    \"lint:eslint\": \"eslint --ignore-path .gitignore . --report-unused-disable-directives\",\n    \"lint:prettier\": \"prettier --list-different .\",\n    \"test\": \"run-s -c test:* lint:* eslint-check:*\",\n    \"test:readme\": \"mocha --require fulky/md-compiler README.md\",\n    \"test:mocha\": \"nyc mocha\",\n    \"coveralls\": \"nyc report --reporter=text-lcov | coveralls\",\n    \"eslint-check:main\": \"eslint --print-config chai-immutable.js | eslint-config-prettier-check\",\n    \"eslint-check:test\": \"eslint --print-config test/test.js | eslint-config-prettier-check\"\n  },\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/astorije/chai-immutable.git\"\n  },\n  \"keywords\": [\n    \"chai\",\n    \"chai-plugin\",\n    \"browser\",\n    \"test\",\n    \"assertions\",\n    \"immutable\"\n  ],\n  \"author\": {\n    \"name\": \"Jérémie Astori\",\n    \"url\": \"https://jeremie.astori.fr\"\n  },\n  \"license\": \"MIT\",\n  \"engines\": {\n    \"node\": \">=10\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/astorije/chai-immutable/issues\"\n  },\n  \"homepage\": \"https://github.com/astorije/chai-immutable\",\n  \"peerDependencies\": {\n    \"chai\": \"^4.0.0\",\n    \"immutable\": \"^3.0.0\"\n  },\n  \"devDependencies\": {\n    \"chai\": \"4.3.4\",\n    \"coveralls\": \"3.1.0\",\n    \"eslint\": \"6.8.0\",\n    \"eslint-config-prettier\": \"6.15.0\",\n    \"eslint-plugin-chai-expect\": \"2.2.0\",\n    \"eslint-plugin-chai-friendly\": \"0.6.0\",\n    \"eslint-plugin-mocha\": \"6.3.0\",\n    \"fulky\": \"0.2.0\",\n    \"immutable\": \"3.8.2\",\n    \"mocha\": \"6.2.3\",\n    \"npm-run-all\": \"4.1.5\",\n    \"nyc\": \"15.1.0\",\n    \"prettier\": \"2.2.1\"\n  }\n}\n"
  },
  {
    "path": "renovate.json",
    "content": "{\n  \"extends\": [\"config:base\", \":rebaseStalePrs\"],\n  \"labels\": [\"dependencies\"]\n}\n"
  },
  {
    "path": "test/.eslintrc.yml",
    "content": "env:\n  mocha: true\n\nplugins:\n  - chai-friendly\n  - mocha\n\nextends:\n  - plugin:chai-expect/recommended\n  - plugin:chai-friendly/recommended\n\n# Override from root `.eslintrc.yml`\nrules:\n  # Disabling this rule in favor of mocha/prefer-arrow-callback\n  # https://github.com/lo1tuma/eslint-plugin-mocha/blob/master/docs/rules/prefer-arrow-callback.md\n  prefer-arrow-callback: off\n\n  ## eslint-plugin-chai-expect\n  ## https://github.com/Turbo87/eslint-plugin-chai-expect\n  chai-expect/no-inner-literal: off\n\n  ## eslint-plugin-mocha\n  ## https://github.com/lo1tuma/eslint-plugin-mocha\n\n  mocha/handle-done-callback: error\n  mocha/max-top-level-suites: error\n  mocha/no-exclusive-tests: error\n  mocha/no-global-tests: error\n  mocha/no-hooks: error\n  mocha/no-identical-title: error\n  mocha/no-mocha-arrows: error\n  mocha/no-nested-tests: error\n  mocha/no-pending-tests: error\n  mocha/no-return-and-callback: error\n  mocha/no-sibling-hooks: error\n  mocha/no-skipped-tests: error\n  mocha/prefer-arrow-callback: error\n  mocha/valid-suite-description: error\n"
  },
  {
    "path": "test/index.html",
    "content": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"utf-8\" />\n    <title>Chai Immutable - Browser tests</title>\n    <link rel=\"stylesheet\" href=\"../node_modules/mocha/mocha.css\" />\n  </head>\n  <body>\n    <div id=\"mocha\"></div>\n\n    <script src=\"../node_modules/mocha/mocha.js\"></script>\n    <script src=\"../node_modules/chai/chai.js\"></script>\n    <script src=\"../node_modules/immutable/dist/immutable.min.js\"></script>\n    <script src=\"../chai-immutable.js\"></script>\n    <script>\n      mocha.setup('bdd');\n    </script>\n    <script src=\"./test.js\"></script>\n    <script>\n      mocha.checkLeaks();\n      mocha.run();\n    </script>\n  </body>\n</html>\n"
  },
  {
    "path": "test/test.js",
    "content": "'use strict';\n\n// From http://stackoverflow.com/a/728694\nfunction clone(obj) {\n  if (obj === null || typeof obj !== 'object') {\n    return obj;\n  }\n  const copy = obj.constructor();\n  for (const attr in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, attr)) {\n      copy[attr] = obj[attr];\n    }\n  }\n  return copy;\n}\n\n// These can be global if they are coming from a browser environment, so `let`\n// cannot be used here.\nvar chai; // eslint-disable-line no-var\nvar chaiImmutable; // eslint-disable-line no-var\nvar Immutable; // eslint-disable-line no-var\n\nif (!chai) {\n  chai = require('chai');\n  chaiImmutable = require('../chai-immutable');\n  Immutable = require('immutable');\n  chai.use(chaiImmutable);\n}\n\nconst clonedImmutable = clone(Immutable);\n\nconst { assert, expect } = chai;\nconst { List, Map, Set, Stack } = Immutable;\n\n/**\n * Test helper to check that a given function (wrapping the assertion) will\n * fail.\n */\nfunction fail(fn, msg) {\n  if (msg) {\n    expect(fn).to.throw(chai.AssertionError, msg);\n  } else {\n    expect(fn).to.throw(chai.AssertionError);\n  }\n}\n\ndescribe('chai-immutable', function () {\n  const list3 = List.of(1, 2, 3);\n  const deepMap = new Map({ foo: 'bar', list: List.of(1, 2, 3) });\n  const sameDeepMap = new Map({ foo: 'bar', list: List.of(1, 2, 3) });\n  const differentDeepMap = new Map({ foo: 'bar', list: List.of(42) });\n  const clonedImmutableList = clonedImmutable.List.of(1, 2, 3);\n\n  describe('BDD interface', function () {\n    describe('empty property', function () {\n      it('should pass given an empty collection', function () {\n        expect(new List()).to.be.empty;\n      });\n\n      it('should pass using `not` given a non-empty collection', function () {\n        expect(list3).to.not.be.empty;\n      });\n\n      it('should not affect the original assertions', function () {\n        expect([]).to.be.empty;\n        expect('').to.be.empty;\n        expect({}).to.be.empty;\n      });\n\n      it('should fail given a non-empty collection', function () {\n        fail(() => expect(list3).to.be.empty);\n      });\n\n      it('should fail using `not` given an empty collection', function () {\n        fail(() => expect(new List()).to.not.be.empty);\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        expect(new clonedImmutable.List()).to.be.empty;\n      });\n    });\n\n    describe('equal method', function () {\n      it('should pass given equal values', function () {\n        expect(list3).to.equal(List.of(1, 2, 3));\n      });\n\n      it('should pass using `not` given different values', function () {\n        expect(list3).to.not.equal(new List());\n      });\n\n      it('aliases of equal should also work', function () {\n        expect(list3).to.equal(List.of(1, 2, 3));\n        expect(list3).to.not.equal(new List());\n        expect(list3).to.equals(List.of(1, 2, 3));\n        expect(list3).to.not.equals(new List());\n        expect(list3).to.eq(List.of(1, 2, 3));\n        expect(list3).to.not.eq(new List());\n        expect(list3).to.eql(List.of(1, 2, 3));\n        expect(list3).to.eqls(List.of(1, 2, 3));\n        expect(list3).to.not.eql(new List());\n        expect(list3).to.not.eqls(new List());\n        expect(list3).to.deep.equal(List.of(1, 2, 3));\n        expect(list3).to.not.deep.equal(new List());\n      });\n\n      it('should not affect the original assertions', function () {\n        expect('hello').to.equal('hello');\n        expect(42).to.equal(42);\n        expect(1).to.not.equal(true);\n        expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });\n        expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });\n      });\n\n      it('should pass given deeply equal values', function () {\n        expect(deepMap).to.equal(sameDeepMap);\n        expect(deepMap).to.equals(sameDeepMap);\n        expect(deepMap).to.eq(sameDeepMap);\n        expect(deepMap).to.eql(sameDeepMap);\n        expect(deepMap).to.eqls(sameDeepMap);\n        expect(deepMap).to.deep.equal(sameDeepMap);\n      });\n\n      it('should pass using `not` given deeply different values', function () {\n        expect(deepMap).to.not.equal(differentDeepMap);\n        expect(deepMap).to.not.equals(differentDeepMap);\n        expect(deepMap).to.not.eq(differentDeepMap);\n        expect(deepMap).to.not.eql(differentDeepMap);\n        expect(deepMap).to.not.eqls(differentDeepMap);\n        expect(deepMap).to.not.deep.equal(differentDeepMap);\n      });\n\n      it('should pass using `not` given a non-Immutable value', function () {\n        expect([]).to.not.equal(new List());\n      });\n\n      // See https://github.com/astorije/chai-immutable/issues/7\n      it('should display a helpful failure output on big objects', function () {\n        const actual = new Map({ foo: 'foo foo foo foo foo foo foo foo' });\n        const expected = new Map({ bar: 'bar bar bar bar bar bar bar bar' });\n        // AssertionError: expected { Object (foo) } to equal { Object (bar) }\n        // + expected - actual\n        //\n        //  {\n        // -  \"foo\": \"foo foo foo foo foo foo foo foo\"\n        // +  \"bar\": \"bar bar bar bar bar bar bar bar\"\n        //  }\n        fail(\n          () => expect(actual).to.equal(expected),\n          'expected { Object (foo) } to equal { Object (bar) }'\n        );\n      });\n\n      it('should fail given a non-Immutable value', function () {\n        fail(() => expect([]).to.equal(new List()));\n      });\n\n      it('should fail given different values', function () {\n        fail(() => expect(list3).to.equal(new List()));\n      });\n\n      it('should fail using `not` given equal values', function () {\n        fail(() => expect(list3).to.not.equal(List.of(1, 2, 3)));\n      });\n\n      it('should fail given deeply different values', function () {\n        fail(() => expect(deepMap).to.equal(differentDeepMap));\n        fail(() => expect(deepMap).to.equals(differentDeepMap));\n        fail(() => expect(deepMap).to.eq(differentDeepMap));\n        fail(() => expect(deepMap).to.eql(differentDeepMap));\n        fail(() => expect(deepMap).to.eqls(differentDeepMap));\n        fail(() => expect(deepMap).to.deep.equal(differentDeepMap));\n      });\n\n      it('should fail using `not` given deeply equal values', function () {\n        fail(() => expect(deepMap).to.not.equal(sameDeepMap));\n        fail(() => expect(deepMap).to.not.equals(sameDeepMap));\n        fail(() => expect(deepMap).to.not.eq(sameDeepMap));\n        fail(() => expect(deepMap).to.not.eql(sameDeepMap));\n        fail(() => expect(deepMap).to.not.eqls(sameDeepMap));\n        fail(() => expect(deepMap).to.not.deep.equal(sameDeepMap));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        expect(clonedImmutableList).to.equal(List.of(1, 2, 3));\n      });\n    });\n\n    describe('referenceEqual method', function () {\n      it('should pass for equal references', function () {\n        const list1 = List.of(1, 2, 3);\n        const list2 = list1;\n\n        expect(list1).to.referenceEqual(list2);\n      });\n\n      it('should not pass for different immutable collections with equal values', function () {\n        const list1 = List.of(1, 2, 3);\n        const list2 = List.of(1, 2, 3);\n\n        expect(list1).to.not.referenceEqual(list2);\n      });\n    });\n\n    describe('include method', function () {\n      it('should pass given an existing value', function () {\n        expect(new List([1, 2, 3])).to.include(2);\n        expect(new List([1, 2, 3])).to.deep.include(2);\n      });\n\n      it('should pass using `not` given an inexisting value', function () {\n        expect(new List([1, 2, 3])).to.not.include(42);\n        expect(new List([1, 2, 3])).to.not.deep.include(42);\n      });\n\n      it('should chain and pass given an existing key', function () {\n        expect(new Map({ foo: 'bar', hello: 'world' })).to.include.keys('foo');\n        expect(new Map({ foo: 'bar', hello: 'world' })).to.deep.include.keys(\n          'foo'\n        );\n      });\n\n      it('should chain and pass using `not` given an inexisting key', function () {\n        expect(new Map({ foo: 'bar', hello: 'world' })).to.not.include.keys(\n          'not-foo'\n        );\n        expect(\n          new Map({ foo: 'bar', hello: 'world' })\n        ).to.not.deep.include.keys('not-foo');\n      });\n\n      it('aliases of include should also work', function () {\n        expect(new List([1, 2, 3])).contain(2);\n        expect(new List([1, 2, 3])).not.contain(42);\n        expect(new List([1, 2, 3])).contains(2);\n        expect(new List([1, 2, 3])).not.contains(42);\n        expect(new List([1, 2, 3])).includes(2);\n        expect(new List([1, 2, 3])).not.includes(42);\n      });\n\n      it('should not affect the original assertions', function () {\n        expect([1, 2, 3]).to.include(2);\n        expect([1, 2, 3]).to.deep.include(2);\n        expect('foobar').to.contain('foo');\n        expect('foobar').to.deep.contain('foo');\n        expect({ foo: 'bar', hello: 'world' }).to.include.keys('foo');\n        expect({ foo: 'bar', hello: 'world' }).to.deep.include.keys('foo');\n      });\n\n      // See https://github.com/astorije/chai-immutable/issues/7\n      it('should display a helpful failure output on big objects', function () {\n        const lengthyMap = new Map({ foo: 'foo foo foo foo foo foo foo foo ' });\n        fail(() => expect(lengthyMap).to.include('not-foo'), /(foo ){8}/);\n        fail(() => expect(lengthyMap).to.deep.include('not-foo'), /(foo ){8}/);\n      });\n\n      it('should fail given an inexisting value', function () {\n        fail(() => expect(new List([1, 2, 3])).to.include(42));\n        fail(() => expect(new List([1, 2, 3])).to.deep.include(42));\n      });\n\n      it('should fail using `not` given an existing value', function () {\n        fail(() => expect(new List([1, 2, 3])).not.to.include(2));\n        fail(() => expect(new List([1, 2, 3])).not.to.deep.include(2));\n      });\n\n      it('should chain and fail given an inexisting key', function () {\n        fail(() =>\n          expect(new Map({ foo: 'bar', hello: 'world' })).to.include.keys(\n            'not-foo'\n          )\n        );\n        fail(() =>\n          expect(new Map({ foo: 'bar', hello: 'world' })).to.deep.include.keys(\n            'not-foo'\n          )\n        );\n      });\n\n      it('should chain and fail using `not` given an existing key', function () {\n        fail(() =>\n          expect(new Map({ foo: 'bar', hello: 'world' })).to.not.include.keys(\n            'foo'\n          )\n        );\n        fail(() =>\n          expect(\n            new Map({ foo: 'bar', hello: 'world' })\n          ).to.not.deep.include.keys('foo')\n        );\n      });\n    });\n\n    describe('keys method', function () {\n      const obj = { x: 1, y: 2 };\n      const map = new Map(obj);\n\n      it('should pass given an existing key', function () {\n        expect(new Map({ x: 1 })).to.have.key('x');\n        expect(new Map({ x: 1 })).to.have.deep.key('x');\n      });\n\n      it('should pass using `not` given an inexisting key', function () {\n        expect(map).to.not.have.key('z');\n        expect(map).to.not.have.deep.key('z');\n      });\n\n      it('should pass given multiple existing keys', function () {\n        expect(map).to.have.keys('x', 'y');\n        expect(map).to.have.deep.keys('x', 'y');\n      });\n\n      it('should pass using `not` given multiple inexisting keys', function () {\n        expect(map).to.not.have.keys('z1', 'z2');\n        expect(map).to.not.have.deep.keys('z1', 'z2');\n      });\n\n      it('should accept an Array of keys to check against', function () {\n        expect(map).to.have.keys(['x', 'y']);\n        expect(map).to.have.deep.keys(['x', 'y']);\n      });\n\n      it('should accept a List of keys to check against', function () {\n        expect(map).to.have.keys(new List(['x', 'y']));\n        expect(map).to.have.deep.keys(new List(['x', 'y']));\n      });\n\n      it('should accept a Set of keys to check against', function () {\n        expect(map).to.have.keys(new Set(['x', 'y']));\n        expect(map).to.have.deep.keys(new Set(['x', 'y']));\n      });\n\n      it('should accept a Stack of keys to check against', function () {\n        expect(map).to.have.keys(new Stack(['x', 'y']));\n        expect(map).to.have.deep.keys(new Stack(['x', 'y']));\n      });\n\n      it('should accept an Object to check against', function () {\n        expect(map).to.have.keys({ x: 6, y: 7 });\n        expect(map).to.have.deep.keys({ x: 6, y: 7 });\n        expect(new List(['x', 'y'])).to.have.all.keys({ 0: 4, 1: 5 });\n      });\n\n      it('should accept a Map to check against', function () {\n        expect(map).to.have.keys(new Map({ x: 6, y: 7 }));\n        expect(map).to.have.deep.keys(new Map({ x: 6, y: 7 }));\n      });\n\n      it('should error when given multiple non-scalar arguments', function () {\n        const msg =\n          'when testing keys against an immutable collection, ' +\n          'you must give a single Array|Object|String|Collection argument or ' +\n          'multiple String arguments';\n\n        fail(() => expect(map).to.have.all.keys(['x'], 'y'), msg);\n        fail(() => expect(map).to.have.all.keys(new List(['x']), 'y'), msg);\n        fail(() => expect(map).to.have.all.keys(new Set(['x']), 'y'), msg);\n        fail(() => expect(map).to.have.all.keys(new Stack(['x']), 'y'), msg);\n        fail(() => expect(map).to.have.all.keys({ x: 1 }, 'y'), msg);\n        fail(() => expect(map).to.have.all.keys(new Map({ x: 1 }), 'y'), msg);\n      });\n\n      it('should error when given no arguments', function () {\n        const msg = 'keys required';\n\n        fail(() => expect(map).to.have.all.keys([]), msg);\n        fail(() => expect(map).to.have.all.keys(new List()), msg);\n        fail(() => expect(map).to.have.all.keys(new Set()), msg);\n        fail(() => expect(map).to.have.all.keys(new Stack()), msg);\n        fail(() => expect(map).to.have.all.keys({}), msg);\n        fail(() => expect(map).to.have.all.keys(new Map()), msg);\n      });\n\n      it('should pass using `any` given an existing key', function () {\n        expect(map).to.have.any.keys('x', 'z');\n        expect(map).to.have.any.deep.keys('x', 'z');\n      });\n\n      it('should pass using `not` and `any` given inexisting keys', function () {\n        expect(map).to.not.have.any.keys('z1', 'z2');\n        expect(map).to.not.have.any.deep.keys('z1', 'z2');\n      });\n\n      it('should pass using `all` given existing keys', function () {\n        expect(map).to.have.all.keys('x', 'y');\n        expect(map).to.have.all.deep.keys('x', 'y');\n      });\n\n      it('should pass using `not` and `all` given inexisting keys', function () {\n        expect(map).to.not.have.all.keys('z1', 'y');\n        expect(map).to.not.have.all.deep.keys('z1', 'y');\n      });\n\n      it('should pass using `contain` given an existing key', function () {\n        expect(map).to.contain.key('x');\n        expect(map).to.contain.deep.key('x');\n      });\n\n      it('should not affect the original assertions', function () {\n        expect({ x: 1, y: 2 }).to.have.any.keys('x', 'z');\n        expect({ x: 1, y: 2 }).to.have.any.deep.keys('x', 'z');\n        expect({ x: 1, y: 2 }).to.have.any.keys('x');\n        expect({ x: 1, y: 2 }).to.have.any.deep.keys('x');\n        expect({ x: 1, y: 2 }).to.contain.any.keys('y', 'z');\n        expect({ x: 1, y: 2 }).to.contain.any.deep.keys('y', 'z');\n        expect({ x: 1, y: 2 }).to.contain.any.keys(['x']);\n        expect({ x: 1, y: 2 }).to.contain.any.deep.keys(['x']);\n        expect({ x: 1, y: 2 }).to.contain.any.keys({ x: 6 });\n        expect({ x: 1, y: 2 }).to.contain.any.deep.keys({ x: 6 });\n        expect({ x: 1, y: 2 }).to.have.all.keys(['x', 'y']);\n        expect({ x: 1, y: 2 }).to.have.all.deep.keys(['x', 'y']);\n        expect({ x: 1, y: 2 }).to.have.all.keys({ x: 6, y: 7 });\n        expect({ x: 1, y: 2 }).to.have.all.deep.keys({ x: 6, y: 7 });\n        expect({ x: 1, y: 2, z: 3 }).to.contain.all.keys(['x', 'y']);\n        expect({ x: 1, y: 2, z: 3 }).to.contain.all.deep.keys(['x', 'y']);\n        expect({ x: 1, y: 2, z: 3 }).to.contain.all.keys({ x: 6 });\n        expect({ x: 1, y: 2, z: 3 }).to.contain.all.deep.keys({ x: 6 });\n      });\n\n      // See https://github.com/astorije/chai-immutable/issues/7\n      it('should display a helpful failure output on big objects', function () {\n        const lengthyMap = new Map({ foo: 'foo foo foo foo foo foo foo foo ' });\n\n        fail(() => expect(lengthyMap).to.have.keys('not-foo'), /(foo ){8}/);\n\n        fail(\n          () => expect(lengthyMap).to.have.deep.keys('not-foo'),\n          /(foo ){8}/\n        );\n      });\n\n      it('should pass against Lists', function () {\n        expect(new List(['x', 'y'])).to.have.all.keys(0, 1);\n        expect(new List(['x', 'y'])).to.have.all.keys([0, 1]);\n      });\n\n      it('should fail given an inexisting key', function () {\n        fail(() => expect(new Map({ x: 1 })).to.have.key('z'));\n        fail(() => expect(new Map({ x: 1 })).to.have.deep.key('z'));\n        fail(() => expect({ x: 1 }).to.have.key('z'));\n        fail(() => expect({ x: 1 }).to.have.deep.key('z'));\n      });\n\n      it('should fail given multiple inexisting keys', function () {\n        fail(() => expect(map).to.have.keys('z1', 'z2'));\n        fail(() => expect(map).to.have.deep.keys('z1', 'z2'));\n      });\n\n      it('should fail using `not` given multiple existing keys', function () {\n        fail(() => expect(map).to.not.have.keys('x', 'y'));\n        fail(() => expect(map).to.not.have.deep.keys('x', 'y'));\n      });\n\n      it('should fail using `any` given inexisting keys', function () {\n        fail(() => expect(map).to.have.any.keys('z1', 'z2'));\n        fail(() => expect(map).to.have.any.deep.keys('z1', 'z2'));\n      });\n\n      it('should fail using `not` and `any` given an existing key', function () {\n        fail(() => expect(map).to.not.have.any.keys('x', 'z'));\n        fail(() => expect(map).to.not.have.any.deep.keys('x', 'z'));\n      });\n\n      it('should fail using `all` given an inexisting key', function () {\n        fail(() => expect(map).to.have.all.keys('z1', 'y'));\n        fail(() => expect(map).to.have.all.deep.keys('z1', 'y'));\n      });\n\n      it('should fail using `not` and `all` given existing keys', function () {\n        fail(() => expect(map).to.not.have.all.keys('x', 'y'));\n        fail(() => expect(map).to.not.have.all.deep.keys('x', 'y'));\n      });\n\n      it('should fail using `contain` given an inexisting key', function () {\n        fail(() => expect(map).to.contain.key('z'));\n        fail(() => expect(map).to.contain.deep.key('z'));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        expect(new clonedImmutable.Map({ x: 1 })).to.have.key('x');\n        expect(new clonedImmutable.Map({ x: 1 })).to.have.deep.key('x');\n      });\n    });\n\n    describe('property property', function () {\n      it('should not affect the original assertion', function () {\n        expect({ x: 1 }).to.have.property('x', 1);\n      });\n\n      it('should not affect the original assertion using `not`', function () {\n        expect({ x: 1 }).not.to.have.property('z');\n        expect({ x: 1 }).not.to.have.property('z', 42);\n      });\n\n      // All following tests assert against regular `.property` and\n      // `.deep.property`. In the Immutable world, these are supposed to carry\n      // the same meaning (similar to `.equal` vs. `.deep.equal`).\n      const obj = Immutable.fromJS({ x: 1 });\n      const nestedObj = Immutable.fromJS({ x: 1, y: { x: 2, y: 3 } });\n\n      it('should fail given an inexisting property', function () {\n        fail(() => expect(obj).to.have.property('z'));\n        fail(() => expect(obj).to.have.deep.property('z'));\n      });\n\n      it('should pass using `not` given an inexisting property', function () {\n        expect(obj).not.to.have.property('z');\n        expect(obj).not.to.have.deep.property('z');\n      });\n\n      it('should pass using `not` given an inexisting property and value', function () {\n        expect(obj).not.to.have.property('z', 42);\n        expect(obj).not.to.have.deep.property('z', 42);\n      });\n\n      it('should pass given an existing property', function () {\n        expect(obj).to.have.property('x');\n        expect(obj).to.have.deep.property('x');\n      });\n\n      it('should fail using `not` given an existing property', function () {\n        fail(() => expect(obj).not.to.have.property('x'));\n        fail(() => expect(obj).not.to.have.deep.property('x'));\n      });\n\n      it('should fail given a property with a bad value', function () {\n        fail(() => expect(obj).to.have.property('x', 'different'));\n        fail(() => expect(obj).to.have.deep.property('x', 'different'));\n      });\n\n      it('should pass given a property with the good value', function () {\n        expect(obj).to.have.property('x', 1);\n        expect(obj).to.have.deep.property('x', 1);\n      });\n\n      it('should pass given an immutable value', function () {\n        const obj2 = Immutable.fromJS({ foo: { bar: 42 } });\n        expect(obj2).to.have.property('foo', new Map({ bar: 42 }));\n        expect(obj2).to.have.deep.property('foo', new Map({ bar: 42 }));\n      });\n\n      it('should change the subject to the value of that property', function () {\n        const sub = nestedObj.get('y');\n        expect(nestedObj).to.have.property('y').that.equal(sub);\n        expect(nestedObj).to.have.deep.property('y').that.equal(sub);\n      });\n\n      describe('using the `nested` flag', function () {\n        it('should not affect the original assertion', function () {\n          expect({ x: 1, y: { x: 2, y: 3 } }).to.have.nested.property('y.x', 2);\n          expect({ x: 1, y: { x: 2, y: 3 } }).to.have.nested.deep.property(\n            'y.x',\n            2\n          );\n        });\n\n        it('should not affect the original assertion using `not`', function () {\n          expect({ x: 1, y: { x: 2 } }).not.to.have.nested.property('z.z');\n          expect({ x: 1, y: { x: 2 } }).not.to.have.nested.deep.property('z.z');\n          expect({ x: 1, y: { x: 2 } }).not.to.have.nested.property('z.z', 42);\n          expect({ x: 1, y: { x: 2 } }).not.to.have.nested.deep.property(\n            'z.z',\n            42\n          );\n        });\n\n        it('should fail given an inexisting property', function () {\n          fail(() => expect(nestedObj).to.have.nested.property(['y', 'z']));\n          fail(() =>\n            expect(nestedObj).to.have.nested.deep.property(['y', 'z'])\n          );\n        });\n\n        it('should pass using `not` given an inexisting property', function () {\n          expect(nestedObj).not.to.have.nested.property(['y', 'z']);\n          expect(nestedObj).not.to.have.nested.deep.property(['y', 'z']);\n          expect(nestedObj).not.to.have.property('a', new Map({ x: 2 }));\n        });\n\n        it('should pass using `not` given an inexisting property and value', function () {\n          expect(obj).not.to.have.nested.property(['y', 'x'], 'different');\n          expect(obj).not.to.have.nested.deep.property(['y', 'x'], 'different');\n        });\n\n        it('should pass given an existing property', function () {\n          expect(nestedObj).to.have.nested.property(['y', 'x']);\n          expect(nestedObj).to.have.nested.deep.property(['y', 'x']);\n        });\n\n        it('should pass given an index', function () {\n          const obj2 = Immutable.fromJS({ items: ['a', 'b', 'c'] });\n          expect(obj2).to.have.nested.property(['items', 2], 'c');\n          expect(obj2).to.have.nested.deep.property(['items', 2], 'c');\n        });\n\n        it('should fail using `not` given an existing property', function () {\n          fail(() => expect(nestedObj).not.to.have.nested.property(['y', 'x']));\n          fail(() =>\n            expect(nestedObj).not.to.have.nested.deep.property(['y', 'x'])\n          );\n        });\n\n        it('should fail given a property with a bad value', function () {\n          fail(() =>\n            expect(nestedObj).to.have.nested.property(['y', 'x'], 'different')\n          );\n          fail(() =>\n            expect(nestedObj).to.have.nested.deep.property(\n              ['y', 'x'],\n              'different'\n            )\n          );\n        });\n\n        it('should pass given a property with the good value', function () {\n          expect(nestedObj).to.have.nested.property(['y', 'x'], 2);\n          expect(nestedObj).to.have.nested.deep.property(['y', 'x'], 2);\n        });\n\n        it('should fail using `not` given a property with good value', function () {\n          fail(() =>\n            expect(nestedObj).not.to.have.nested.property(['y', 'x'], 2)\n          );\n          fail(() =>\n            expect(nestedObj).not.to.have.nested.deep.property(['y', 'x'], 2)\n          );\n        });\n\n        it('should pass using `not` given a property with a bad value', function () {\n          expect(nestedObj).not.to.have.nested.property(\n            ['y', 'x'],\n            'different'\n          );\n          expect(nestedObj).not.to.have.nested.deep.property(\n            ['y', 'x'],\n            'different'\n          );\n        });\n\n        it('should pass given an immutable value', function () {\n          const nestedObj2 = Immutable.fromJS({ foo: [{ bar: 42 }] });\n          expect(nestedObj2).to.have.nested.property(\n            'foo[0]',\n            new Map({ bar: 42 })\n          );\n          expect(nestedObj2).to.have.nested.deep.property(\n            'foo[0]',\n            new Map({ bar: 42 })\n          );\n        });\n      });\n\n      describe('given a string-based path', function () {\n        const nestedObj2 = Immutable.fromJS({\n          items: [{ name: 'Jane' }, { name: 'John' }, { name: 'Jim' }],\n        });\n\n        it('should pass using `nested` given a single index', function () {\n          expect(nestedObj2.get('items'))\n            .to.have.nested.property('[1]')\n            .that.equals(new Map({ name: 'John' }));\n          expect(nestedObj2.get('items'))\n            .to.have.nested.deep.property('[1]')\n            .that.equals(new Map({ name: 'John' }));\n        });\n\n        it('should pass using `nested` given a single key', function () {\n          expect(nestedObj2)\n            .to.have.nested.property('items')\n            .that.equals(\n              new List([\n                new Map({ name: 'Jane' }),\n                new Map({ name: 'John' }),\n                new Map({ name: 'Jim' }),\n              ])\n            );\n          expect(nestedObj2)\n            .to.have.nested.deep.property('items')\n            .that.equals(\n              new List([\n                new Map({ name: 'Jane' }),\n                new Map({ name: 'John' }),\n                new Map({ name: 'Jim' }),\n              ])\n            );\n        });\n\n        it('should pass using `nested` starting with an index', function () {\n          expect(nestedObj2.get('items')).to.have.nested.property(\n            '[0].name',\n            'Jane'\n          );\n          expect(nestedObj2.get('items')).to.have.nested.deep.property(\n            '[0].name',\n            'Jane'\n          );\n        });\n\n        it('should pass using `nested` ending with an index', function () {\n          expect(nestedObj2)\n            .to.have.nested.property('items[1]')\n            .that.equals(new Map({ name: 'John' }));\n          expect(nestedObj2)\n            .to.have.nested.deep.property('items[1]')\n            .that.equals(new Map({ name: 'John' }));\n        });\n\n        it('should pass using `nested` given mix of keys and indices', function () {\n          expect(nestedObj2).to.have.nested.property('items[2].name', 'Jim');\n          expect(nestedObj2).to.have.nested.deep.property(\n            'items[2].name',\n            'Jim'\n          );\n        });\n\n        it('should expect unescaped path strings', function () {\n          const css = new Map({ '.link[target]': 42 });\n          expect(css).to.have.property('.link[target]', 42);\n          expect(css).to.have.deep.property('.link[target]', 42);\n        });\n\n        it('should expect escaped path strings using `nested`', function () {\n          const nestedCss = new Map({ '.link': new Map({ '[target]': 42 }) });\n          expect(nestedCss).to.have.nested.property('\\\\.link.\\\\[target\\\\]', 42);\n          expect(nestedCss).to.have.nested.deep.property(\n            '\\\\.link.\\\\[target\\\\]',\n            42\n          );\n        });\n      });\n    });\n\n    describe('size method', function () {\n      it('should pass given the right size', function () {\n        expect(list3).to.have.size(3);\n      });\n\n      it('should pass using `not` given the wrong size', function () {\n        expect(list3).to.not.have.size(42);\n      });\n\n      it('should also work with alias sizeOf', function () {\n        expect(list3).to.have.sizeOf(3);\n        expect(list3).to.not.have.sizeOf(42);\n      });\n\n      it('should fail given the wrong size', function () {\n        fail(() => expect(list3).to.have.size(42));\n      });\n\n      it('should fail using `not` given the right size', function () {\n        fail(() => expect(list3).to.not.have.size(3));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        expect(clonedImmutableList).to.have.size(3);\n      });\n    });\n\n    describe('size property', function () {\n      it('above should pass given a good min size', function () {\n        expect(list3).to.have.size.above(2);\n      });\n\n      it('above should pass using `not` given a bad min size', function () {\n        expect(list3).to.not.have.size.above(42);\n      });\n\n      it('aliases of above should also work', function () {\n        expect(list3).to.have.size.gt(2);\n        expect(list3).to.have.size.greaterThan(2);\n        expect(list3).to.not.have.size.gt(42);\n        expect(list3).to.not.have.size.greaterThan(42);\n      });\n\n      it('should not affect the original assertions of above', function () {\n        expect('foo').to.have.length.above(2);\n        expect([1, 2, 3]).to.have.length.above(2);\n      });\n\n      it('above should fail given a bad min size', function () {\n        fail(() => expect(list3).to.have.size.above(42));\n      });\n\n      it('above should fail using `not` given a good min size', function () {\n        fail(() => expect(list3).to.not.have.size.above(2));\n      });\n\n      it('below should pass given a good max size', function () {\n        expect(list3).to.have.size.below(42);\n      });\n\n      it('below should pass using `not` given a bad max size', function () {\n        expect(list3).to.not.have.size.below(1);\n      });\n\n      it('aliases of below should also work', function () {\n        expect(list3).to.have.size.lt(4);\n        expect(list3).to.have.size.lessThan(4);\n        expect(list3).to.not.have.size.lt(1);\n        expect(list3).to.not.have.size.lessThan(1);\n      });\n\n      it('should not affect the original assertions of below', function () {\n        expect('foo').to.have.length.below(4);\n        expect([1, 2, 3]).to.have.length.below(4);\n      });\n\n      it('below should fail given a bad max size', function () {\n        fail(() => expect(list3).to.have.size.below(1));\n      });\n\n      it('below should fail using `not` given a good max size', function () {\n        fail(() => expect(list3).to.not.have.size.below(42));\n      });\n\n      it('within should pass given a good range', function () {\n        expect(list3).to.have.size.within(2, 42);\n      });\n\n      it('within should pass using `not` given a bad range', function () {\n        expect(list3).to.not.have.size.within(10, 20);\n      });\n\n      it('should not affect the original assertions of within', function () {\n        expect('foo').to.have.length.within(2, 4);\n        expect([1, 2, 3]).to.have.length.within(2, 4);\n      });\n\n      it('within should fail given a bad range', function () {\n        fail(() => expect(list3).to.have.size.within(10, 20));\n      });\n\n      it('within should fail using `not` given a good range', function () {\n        fail(() => expect(list3).to.not.have.size.within(2, 42));\n      });\n\n      it('least should pass given a good min size', function () {\n        expect(list3).to.have.size.of.at.least(2);\n      });\n\n      it('least should pass using `not` given a bad min size', function () {\n        expect(list3).to.not.have.size.of.at.least(42);\n      });\n\n      it('aliases of least should also work', function () {\n        expect(list3).to.have.size.gte(2);\n        expect(list3).to.not.have.size.gte(42);\n      });\n\n      it('should not affect the original assertions of least', function () {\n        expect('foo').to.have.length.of.at.least(2);\n        expect([1, 2, 3]).to.have.length.of.at.least(3);\n      });\n\n      it('least should fail given a bad min size', function () {\n        fail(() => expect(list3).to.have.size.of.at.least(42));\n      });\n\n      it('least should fail using `not` given a good min size', function () {\n        fail(() => expect(list3).to.not.have.size.of.at.least(2));\n      });\n\n      it('most should pass given a good max size', function () {\n        expect(list3).to.have.size.of.at.most(42);\n      });\n\n      it('most should pass using `not` given a bad max size', function () {\n        expect(list3).to.not.have.size.of.at.most(2);\n      });\n\n      it('aliases of most should also work', function () {\n        expect(list3).to.have.size.lte(42);\n        expect(list3).to.not.have.size.lte(2);\n      });\n\n      it('should not affect the original assertions of most', function () {\n        expect('foo').to.have.length.of.at.most(4);\n        expect([1, 2, 3]).to.have.length.of.at.most(3);\n      });\n\n      it('most should fail given a good max size', function () {\n        fail(() => expect(list3).to.have.size.of.at.most(2));\n      });\n\n      it('most should fail using `not` given a bad max size', function () {\n        fail(() => expect(list3).to.not.have.size.of.at.most(42));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        expect(clonedImmutableList).to.have.size.above(2);\n      });\n    });\n  });\n\n  describe('TDD interface', function () {\n    describe('equal assertion', function () {\n      it('should pass given equal values', function () {\n        assert.equal(list3, List.of(1, 2, 3));\n      });\n\n      it('should pass given deeply equal values', function () {\n        assert.equal(deepMap, sameDeepMap);\n      });\n\n      it('should not affect the original assertion', function () {\n        assert.equal(42, 42);\n        assert.equal(3, '3');\n      });\n\n      // See https://github.com/astorije/chai-immutable/issues/7\n      it('should display a helpful failure output on big objects', function () {\n        const actual = new Map({ foo: 'foo foo foo foo foo foo foo foo ' });\n        const expected = new Map({ bar: 'bar bar bar bar bar bar bar bar ' });\n        // AssertionError: expected { Object (foo) } to equal { Object (bar) }\n        // + expected - actual\n        //\n        //  {\n        // -  \"foo\": \"foo foo foo foo foo foo foo foo\"\n        // +  \"bar\": \"bar bar bar bar bar bar bar bar\"\n        //  }\n        fail(\n          () => assert.equal(actual, expected),\n          'expected { Object (foo) } to equal { Object (bar) }'\n        );\n      });\n\n      it('should fail given a non-Immutable value', function () {\n        fail(() => assert.equal([], new List()));\n      });\n\n      it('should fail given different values', function () {\n        fail(() => assert.equal(list3, new List()));\n      });\n\n      it('should fail given deeply different values', function () {\n        fail(() => assert.equal(deepMap, differentDeepMap));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        assert.equal(clonedImmutableList, List.of(1, 2, 3));\n      });\n    });\n\n    describe('referenceEqual assertion', function () {\n      it('should pass for equal references', function () {\n        const list1 = List.of(1, 2, 3);\n        const list2 = list1;\n\n        assert.referenceEqual(list1, list2);\n      });\n\n      it('should not pass for different immutable collections with equal values', function () {\n        const list1 = List.of(1, 2, 3);\n        const list2 = List.of(1, 2, 3);\n\n        fail(() => assert.referenceEqual(list1, list2));\n      });\n    });\n\n    describe('notEqual assertion', function () {\n      it('should pass given different values', function () {\n        assert.notEqual(list3, new List());\n      });\n\n      it('should pass given deeply different values', function () {\n        assert.notEqual(deepMap, differentDeepMap);\n      });\n\n      it('should not affect the original assertion', function () {\n        assert.notEqual('oui', 'non');\n        assert.notEqual({ foo: 'bar' }, { foo: 'bar' });\n      });\n\n      it('should pass given a non-Immutable value', function () {\n        assert.notEqual([], new List());\n      });\n\n      it('should fail given equal values', function () {\n        fail(() => assert.notEqual(list3, List.of(1, 2, 3)));\n      });\n\n      it('should fail given deeply equal values', function () {\n        fail(() => assert.notEqual(deepMap, sameDeepMap));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        assert.notEqual(clonedImmutableList, List.of());\n      });\n    });\n\n    describe('notReferenceEqual assertion', function () {\n      it('should pass for different immutable collections with equal values', function () {\n        const list1 = List.of(1, 2, 3);\n        const list2 = List.of(1, 2, 3);\n\n        assert.notReferenceEqual(list1, list2);\n      });\n\n      it('should not pass for different immutable collections with equal values', function () {\n        const list1 = List.of(1, 2, 3);\n        const list2 = list1;\n\n        fail(() => assert.notReferenceEqual(list1, list2));\n      });\n    });\n\n    describe('unoverridden strictEqual and deepEqual assertions', function () {\n      it('should pass given equal values', function () {\n        assert.strictEqual(list3, List.of(1, 2, 3));\n        assert.deepEqual(list3, List.of(1, 2, 3));\n      });\n\n      it('should pass given deeply equal values', function () {\n        assert.strictEqual(deepMap, sameDeepMap);\n        assert.deepEqual(deepMap, sameDeepMap);\n      });\n\n      it('should fail given different values', function () {\n        fail(() => assert.strictEqual(list3, new List()));\n        fail(() => assert.deepEqual(list3, new List()));\n      });\n\n      it('should fail given deeply different values', function () {\n        fail(() => assert.strictEqual(deepMap, differentDeepMap));\n        fail(() => assert.deepEqual(deepMap, differentDeepMap));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        assert.strictEqual(clonedImmutableList, List.of(1, 2, 3));\n        assert.deepEqual(clonedImmutableList, List.of(1, 2, 3));\n      });\n    });\n\n    describe('unoverridden notStrictEqual and notDeepEqual assertions', function () {\n      it('should pass given different values', function () {\n        assert.notStrictEqual(list3, new List());\n        assert.notDeepEqual(list3, new List());\n      });\n\n      it('should pass given deeply different values', function () {\n        assert.notStrictEqual(deepMap, differentDeepMap);\n        assert.notDeepEqual(deepMap, differentDeepMap);\n      });\n\n      it('should fail given equal values', function () {\n        fail(() => assert.notStrictEqual(list3, List.of(1, 2, 3)));\n        fail(() => assert.notDeepEqual(list3, List.of(1, 2, 3)));\n      });\n\n      it('should fail given deeply equal values', function () {\n        fail(() => assert.notStrictEqual(deepMap, sameDeepMap));\n        fail(() => assert.notDeepEqual(deepMap, sameDeepMap));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        assert.notStrictEqual(clonedImmutableList, new List());\n        assert.notDeepEqual(clonedImmutableList, new List());\n      });\n    });\n\n    describe('include assertion', function () {\n      const map1 = new Map({ a: 1 });\n      const map2 = new Map({ b: 2 });\n      const list = new List([map1, map2]);\n      const map = new Map({ foo: map1, bar: map2 });\n\n      it('should ensure deep equality', function () {\n        assert.include(list, map1);\n        assert.include(list, new Map({ a: 1 }));\n\n        assert.include(map, map1);\n        assert.include(map, new Map({ a: 1 }));\n      });\n\n      it('should find plain values', function () {\n        assert.include(map1, 1);\n      });\n\n      it('should treat partial collections as sub-collections', function () {\n        assert.include(map, new Map({ foo: map1 }));\n        assert.include(map, new Map({ foo: map1, bar: map2 }));\n      });\n    });\n\n    describe('notInclude assertion', function () {\n      const map1 = new Map({ a: 1 });\n      const map2 = new Map({ b: 2 });\n      const list = new List([map1, map2]);\n      const map = new Map({ foo: map1, bar: map2 });\n\n      it('should ensure deep equality', function () {\n        fail(() => assert.notInclude(map, new Map({ foo: map1 })));\n        fail(() => assert.notInclude(map, new Map({ foo: map1, bar: map2 })));\n      });\n\n      it('should fail for existing collections', function () {\n        fail(() => assert.notInclude(list, map1));\n        fail(() => assert.notInclude(list, new Map({ a: 1 })));\n      });\n\n      it('should treat partial overlap as failure', function () {\n        assert.notInclude(map, new Map({ foo: new Map({ a: 1, b: 2 }) }));\n      });\n    });\n\n    describe('property assertions', function () {\n      const obj = Immutable.fromJS({ x: 1 });\n      const nestedObj = Immutable.fromJS({ x: 1, y: { x: 2, y: 3 } });\n\n      it('should pass for existing property', function () {\n        assert.property(obj, 'x');\n      });\n\n      it('should fail for missing property', function () {\n        fail(() => assert.property(obj, 'z'));\n      });\n\n      it('should pass for missing property using `not`', function () {\n        assert.notProperty(obj, 'z');\n      });\n\n      it('should fail for existing property using `not`', function () {\n        fail(() => assert.notProperty(obj, 'x'));\n      });\n\n      it('should pass for existing property and value', function () {\n        assert.propertyVal(obj, 'x', 1);\n        assert.deepPropertyVal(obj, 'x', 1);\n      });\n\n      it('should fail for wrong property or value', function () {\n        fail(() => assert.propertyVal(obj, 'z', 1));\n        fail(() => assert.deepPropertyVal(obj, 'z', 1));\n        fail(() => assert.propertyVal(obj, 'x', 42));\n        fail(() => assert.deepPropertyVal(obj, 'x', 42));\n      });\n\n      it('should pass for wrong property or value using `not`', function () {\n        assert.notPropertyVal(obj, 'z', 1);\n        assert.notDeepPropertyVal(obj, 'z', 1);\n        assert.notPropertyVal(obj, 'x', 42);\n        assert.notDeepPropertyVal(obj, 'x', 42);\n        assert.notPropertyVal(obj, 'foo', new Map({ bar: 'baz' }));\n        assert.notDeepPropertyVal(obj, 'foo', new Map({ bar: 'baz' }));\n      });\n\n      it('should fail for existing property and value using `not`', function () {\n        fail(() => assert.notPropertyVal(obj, 'x', 1));\n        fail(() => assert.notDeepPropertyVal(obj, 'x', 1));\n      });\n\n      it('should succeed for equal nested property', function () {\n        assert.nestedProperty(nestedObj, ['y', 'x']);\n      });\n\n      it('should fail for unequal nested property', function () {\n        fail(() => assert.nestedPropertyVal(nestedObj, ['y', 'x'], 42));\n        fail(() => assert.deepNestedPropertyVal(nestedObj, ['y', 'x'], 42));\n      });\n    });\n\n    describe('sizeOf assertion', function () {\n      it('should pass given the right size', function () {\n        assert.sizeOf(list3, 3);\n      });\n\n      it('should work with empty collections', function () {\n        assert.sizeOf(new List(), 0);\n      });\n\n      it('should fail given the wrong size', function () {\n        fail(() => assert.sizeOf(list3, 42));\n      });\n\n      it('should work if using different copies of Immutable', function () {\n        assert.sizeOf(clonedImmutableList, 3);\n      });\n    });\n  });\n});\n"
  }
]