前端代码
This commit is contained in:
ChloeChen0423
21
node_modules/immutable/LICENSE
generated
vendored
Normal file
21
node_modules/immutable/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2014-present, Facebook, Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
474
node_modules/immutable/README.md
generated
vendored
Normal file
474
node_modules/immutable/README.md
generated
vendored
Normal file
@ -0,0 +1,474 @@
|
||||
Immutable collections for JavaScript
|
||||
====================================
|
||||
|
||||
[](https://travis-ci.org/facebook/immutable-js)
|
||||
|
||||
[Immutable][] data cannot be changed once created, leading to much simpler
|
||||
application development, no defensive copying, and enabling advanced memoization
|
||||
and change detection techniques with simple logic. [Persistent][] data presents
|
||||
a mutative API which does not update the data in-place, but instead always
|
||||
yields new updated data.
|
||||
|
||||
Immutable.js provides many Persistent Immutable data structures including:
|
||||
`List`, `Stack`, `Map`, `OrderedMap`, `Set`, `OrderedSet` and `Record`.
|
||||
|
||||
These data structures are highly efficient on modern JavaScript VMs by using
|
||||
structural sharing via [hash maps tries][] and [vector tries][] as popularized
|
||||
by Clojure and Scala, minimizing the need to copy or cache data.
|
||||
|
||||
`Immutable` also provides a lazy `Seq`, allowing efficient
|
||||
chaining of collection methods like `map` and `filter` without creating
|
||||
intermediate representations. Create some `Seq` with `Range` and `Repeat`.
|
||||
|
||||
Want to hear more? Watch the presentation about Immutable.js:
|
||||
|
||||
<a href="https://youtu.be/I7IdS-PbEgI" target="_blank" alt="Immutable Data and React"><img src="https://img.youtube.com/vi/I7IdS-PbEgI/0.jpg" /></a>
|
||||
|
||||
[Persistent]: http://en.wikipedia.org/wiki/Persistent_data_structure
|
||||
[Immutable]: http://en.wikipedia.org/wiki/Immutable_object
|
||||
[hash maps tries]: http://en.wikipedia.org/wiki/Hash_array_mapped_trie
|
||||
[vector tries]: http://hypirion.com/musings/understanding-persistent-vector-pt-1
|
||||
|
||||
|
||||
Getting started
|
||||
---------------
|
||||
|
||||
Install `immutable` using npm.
|
||||
|
||||
```shell
|
||||
npm install immutable
|
||||
```
|
||||
|
||||
Then require it into any module.
|
||||
|
||||
```javascript
|
||||
var Immutable = require('immutable');
|
||||
var map1 = Immutable.Map({a:1, b:2, c:3});
|
||||
var map2 = map1.set('b', 50);
|
||||
map1.get('b'); // 2
|
||||
map2.get('b'); // 50
|
||||
```
|
||||
|
||||
### Browser
|
||||
|
||||
To use `immutable` from a browser, download [dist/immutable.min.js](https://github.com/facebook/immutable-js/blob/master/dist/immutable.min.js)
|
||||
or use a CDN such as [CDNJS](https://cdnjs.com/libraries/immutable)
|
||||
or [jsDelivr](http://www.jsdelivr.com/#!immutable.js).
|
||||
|
||||
Then, add it as a script tag to your page:
|
||||
|
||||
```html
|
||||
<script src="immutable.min.js"></script>
|
||||
<script>
|
||||
var map1 = Immutable.Map({a:1, b:2, c:3});
|
||||
var map2 = map1.set('b', 50);
|
||||
map1.get('b'); // 2
|
||||
map2.get('b'); // 50
|
||||
</script>
|
||||
```
|
||||
|
||||
Or use an AMD loader (such as [RequireJS](http://requirejs.org/)):
|
||||
|
||||
```javascript
|
||||
require(['./immutable.min.js'], function (Immutable) {
|
||||
var map1 = Immutable.Map({a:1, b:2, c:3});
|
||||
var map2 = map1.set('b', 50);
|
||||
map1.get('b'); // 2
|
||||
map2.get('b'); // 50
|
||||
});
|
||||
```
|
||||
|
||||
If you're using [browserify](http://browserify.org/), the `immutable` npm module
|
||||
also works from the browser.
|
||||
|
||||
### TypeScript
|
||||
|
||||
Use these Immutable collections and sequences as you would use native
|
||||
collections in your [TypeScript](http://typescriptlang.org) programs while still taking
|
||||
advantage of type generics, error detection, and auto-complete in your IDE.
|
||||
|
||||
Just add a reference with a relative path to the type declarations at the top
|
||||
of your file.
|
||||
|
||||
```javascript
|
||||
///<reference path='./node_modules/immutable/dist/immutable.d.ts'/>
|
||||
import Immutable = require('immutable');
|
||||
var map1: Immutable.Map<string, number>;
|
||||
map1 = Immutable.Map({a:1, b:2, c:3});
|
||||
var map2 = map1.set('b', 50);
|
||||
map1.get('b'); // 2
|
||||
map2.get('b'); // 50
|
||||
```
|
||||
|
||||
|
||||
The case for Immutability
|
||||
-------------------------
|
||||
|
||||
Much of what makes application development difficult is tracking mutation and
|
||||
maintaining state. Developing with immutable data encourages you to think
|
||||
differently about how data flows through your application.
|
||||
|
||||
Subscribing to data events throughout your application creates a huge overhead of
|
||||
book-keeping which can hurt performance, sometimes dramatically, and creates
|
||||
opportunities for areas of your application to get out of sync with each other
|
||||
due to easy to make programmer error. Since immutable data never changes,
|
||||
subscribing to changes throughout the model is a dead-end and new data can only
|
||||
ever be passed from above.
|
||||
|
||||
This model of data flow aligns well with the architecture of [React][]
|
||||
and especially well with an application designed using the ideas of [Flux][].
|
||||
|
||||
When data is passed from above rather than being subscribed to, and you're only
|
||||
interested in doing work when something has changed, you can use equality.
|
||||
|
||||
Immutable collections should be treated as *values* rather than *objects*. While
|
||||
objects represents some thing which could change over time, a value represents
|
||||
the state of that thing at a particular instance of time. This principle is most
|
||||
important to understanding the appropriate use of immutable data. In order to
|
||||
treat Immutable.js collections as values, it's important to use the
|
||||
`Immutable.is()` function or `.equals()` method to determine value equality
|
||||
instead of the `===` operator which determines object reference identity.
|
||||
|
||||
```javascript
|
||||
var map1 = Immutable.Map({a:1, b:2, c:3});
|
||||
var map2 = map1.set('b', 2);
|
||||
assert(map1.equals(map2) === true);
|
||||
var map3 = map1.set('b', 50);
|
||||
assert(map1.equals(map3) === false);
|
||||
```
|
||||
|
||||
Note: As a performance optimization `Immutable` attempts to return the existing
|
||||
collection when an operation would result in an identical collection, allowing
|
||||
for using `===` reference equality to determine if something definitely has not
|
||||
changed. This can be extremely useful when used within memoization function
|
||||
which would prefer to re-run the function if a deeper equality check could
|
||||
potentially be more costly. The `===` equality check is also used internally by
|
||||
`Immutable.is` and `.equals()` as a performance optimization.
|
||||
|
||||
If an object is immutable, it can be "copied" simply by making another reference
|
||||
to it instead of copying the entire object. Because a reference is much smaller
|
||||
than the object itself, this results in memory savings and a potential boost in
|
||||
execution speed for programs which rely on copies (such as an undo-stack).
|
||||
|
||||
```javascript
|
||||
var map1 = Immutable.Map({a:1, b:2, c:3});
|
||||
var clone = map1;
|
||||
```
|
||||
|
||||
[React]: http://facebook.github.io/react/
|
||||
[Flux]: http://facebook.github.io/flux/docs/overview.html
|
||||
|
||||
|
||||
JavaScript-first API
|
||||
--------------------
|
||||
|
||||
While `immutable` is inspired by Clojure, Scala, Haskell and other functional
|
||||
programming environments, it's designed to bring these powerful concepts to
|
||||
JavaScript, and therefore has an Object-Oriented API that closely mirrors that
|
||||
of [ES6][] [Array][], [Map][], and [Set][].
|
||||
|
||||
[ES6]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla
|
||||
[Array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
|
||||
[Map]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map
|
||||
[Set]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
|
||||
|
||||
The difference for the immutable collections is that methods which would mutate
|
||||
the collection, like `push`, `set`, `unshift` or `splice` instead return a new
|
||||
immutable collection. Methods which return new arrays like `slice` or `concat`
|
||||
instead return new immutable collections.
|
||||
|
||||
```javascript
|
||||
var list1 = Immutable.List.of(1, 2);
|
||||
var list2 = list1.push(3, 4, 5);
|
||||
var list3 = list2.unshift(0);
|
||||
var list4 = list1.concat(list2, list3);
|
||||
assert(list1.size === 2);
|
||||
assert(list2.size === 5);
|
||||
assert(list3.size === 6);
|
||||
assert(list4.size === 13);
|
||||
assert(list4.get(0) === 1);
|
||||
```
|
||||
|
||||
Almost all of the methods on [Array][] will be found in similar form on
|
||||
`Immutable.List`, those of [Map][] found on `Immutable.Map`, and those of [Set][]
|
||||
found on `Immutable.Set`, including collection operations like `forEach()`
|
||||
and `map()`.
|
||||
|
||||
```javascript
|
||||
var alpha = Immutable.Map({a:1, b:2, c:3, d:4});
|
||||
alpha.map((v, k) => k.toUpperCase()).join();
|
||||
// 'A,B,C,D'
|
||||
```
|
||||
|
||||
### Accepts raw JavaScript objects.
|
||||
|
||||
Designed to inter-operate with your existing JavaScript, `immutable`
|
||||
accepts plain JavaScript Arrays and Objects anywhere a method expects an
|
||||
`Iterable` with no performance penalty.
|
||||
|
||||
```javascript
|
||||
var map1 = Immutable.Map({a:1, b:2, c:3, d:4});
|
||||
var map2 = Immutable.Map({c:10, a:20, t:30});
|
||||
var obj = {d:100, o:200, g:300};
|
||||
var map3 = map1.merge(map2, obj);
|
||||
// Map { a: 20, b: 2, c: 10, d: 100, t: 30, o: 200, g: 300 }
|
||||
```
|
||||
|
||||
This is possible because `immutable` can treat any JavaScript Array or Object
|
||||
as an Iterable. You can take advantage of this in order to get sophisticated
|
||||
collection methods on JavaScript Objects, which otherwise have a very sparse
|
||||
native API. Because Seq evaluates lazily and does not cache intermediate
|
||||
results, these operations can be extremely efficient.
|
||||
|
||||
```javascript
|
||||
var myObject = {a:1,b:2,c:3};
|
||||
Immutable.Seq(myObject).map(x => x * x).toObject();
|
||||
// { a: 1, b: 4, c: 9 }
|
||||
```
|
||||
|
||||
Keep in mind, when using JS objects to construct Immutable Maps, that
|
||||
JavaScript Object properties are always strings, even if written in a quote-less
|
||||
shorthand, while Immutable Maps accept keys of any type.
|
||||
|
||||
```js
|
||||
var obj = { 1: "one" };
|
||||
Object.keys(obj); // [ "1" ]
|
||||
obj["1"]; // "one"
|
||||
obj[1]; // "one"
|
||||
|
||||
var map = Immutable.fromJS(obj);
|
||||
map.get("1"); // "one"
|
||||
map.get(1); // undefined
|
||||
```
|
||||
|
||||
Property access for JavaScript Objects first converts the key to a string, but
|
||||
since Immutable Map keys can be of any type the argument to `get()` is
|
||||
not altered.
|
||||
|
||||
|
||||
### Converts back to raw JavaScript objects.
|
||||
|
||||
All `immutable` Iterables can be converted to plain JavaScript Arrays and
|
||||
Objects shallowly with `toArray()` and `toObject()` or deeply with `toJS()`.
|
||||
All Immutable Iterables also implement `toJSON()` allowing them to be passed to
|
||||
`JSON.stringify` directly.
|
||||
|
||||
```javascript
|
||||
var deep = Immutable.Map({ a: 1, b: 2, c: Immutable.List.of(3, 4, 5) });
|
||||
deep.toObject() // { a: 1, b: 2, c: List [ 3, 4, 5 ] }
|
||||
deep.toArray() // [ 1, 2, List [ 3, 4, 5 ] ]
|
||||
deep.toJS() // { a: 1, b: 2, c: [ 3, 4, 5 ] }
|
||||
JSON.stringify(deep) // '{"a":1,"b":2,"c":[3,4,5]}'
|
||||
```
|
||||
|
||||
### Embraces ES6
|
||||
|
||||
`Immutable` takes advantage of features added to JavaScript in [ES6][],
|
||||
the latest standard version of ECMAScript (JavaScript), including [Iterators][],
|
||||
[Arrow Functions][], [Classes][], and [Modules][]. It's also inspired by the
|
||||
[Map][] and [Set][] collections added to ES6. The library is "transpiled" to ES3
|
||||
in order to support all modern browsers.
|
||||
|
||||
All examples are presented in ES6. To run in all browsers, they need to be
|
||||
translated to ES3.
|
||||
|
||||
```js
|
||||
// ES6
|
||||
foo.map(x => x * x);
|
||||
// ES3
|
||||
foo.map(function (x) { return x * x; });
|
||||
```
|
||||
|
||||
[Iterators]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol
|
||||
[Arrow Functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
|
||||
[Classes]: http://wiki.ecmascript.org/doku.php?id=strawman:maximally_minimal_classes
|
||||
[Modules]: http://www.2ality.com/2014/09/es6-modules-final.html
|
||||
|
||||
|
||||
Nested Structures
|
||||
-----------------
|
||||
|
||||
The collections in `immutable` are intended to be nested, allowing for deep
|
||||
trees of data, similar to JSON.
|
||||
|
||||
```javascript
|
||||
var nested = Immutable.fromJS({a:{b:{c:[3,4,5]}}});
|
||||
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ] } } }
|
||||
```
|
||||
|
||||
A few power-tools allow for reading and operating on nested data. The
|
||||
most useful are `mergeDeep`, `getIn`, `setIn`, and `updateIn`, found on `List`,
|
||||
`Map` and `OrderedMap`.
|
||||
|
||||
```javascript
|
||||
var nested2 = nested.mergeDeep({a:{b:{d:6}}});
|
||||
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 6 } } }
|
||||
```
|
||||
|
||||
```javascript
|
||||
nested2.getIn(['a', 'b', 'd']); // 6
|
||||
|
||||
var nested3 = nested2.updateIn(['a', 'b', 'd'], value => value + 1);
|
||||
// Map { a: Map { b: Map { c: List [ 3, 4, 5 ], d: 7 } } }
|
||||
|
||||
var nested4 = nested3.updateIn(['a', 'b', 'c'], list => list.push(6));
|
||||
// Map { a: Map { b: Map { c: List [ 3, 4, 5, 6 ], d: 7 } } }
|
||||
```
|
||||
|
||||
|
||||
Lazy Seq
|
||||
--------
|
||||
|
||||
`Seq` describes a lazy operation, allowing them to efficiently chain
|
||||
use of all the Iterable methods (such as `map` and `filter`).
|
||||
|
||||
**Seq is immutable** — Once a Seq is created, it cannot be
|
||||
changed, appended to, rearranged or otherwise modified. Instead, any mutative
|
||||
method called on a Seq will return a new Seq.
|
||||
|
||||
**Seq is lazy** — Seq does as little work as necessary to respond to any
|
||||
method call.
|
||||
|
||||
For example, the following does not perform any work, because the resulting
|
||||
Seq is never used:
|
||||
|
||||
var oddSquares = Immutable.Seq.of(1,2,3,4,5,6,7,8)
|
||||
.filter(x => x % 2).map(x => x * x);
|
||||
|
||||
Once the Seq is used, it performs only the work necessary. In this
|
||||
example, no intermediate arrays are ever created, filter is called three times,
|
||||
and map is only called twice:
|
||||
|
||||
console.log(oddSquares.get(1)); // 9
|
||||
|
||||
Any collection can be converted to a lazy Seq with `.toSeq()`.
|
||||
|
||||
var seq = Immutable.Map({a:1, b:1, c:1}).toSeq();
|
||||
|
||||
Seq allow for the efficient chaining of sequence operations, especially when
|
||||
converting to a different concrete type (such as to a JS object):
|
||||
|
||||
seq.flip().map(key => key.toUpperCase()).flip().toObject();
|
||||
// Map { A: 1, B: 1, C: 1 }
|
||||
|
||||
As well as expressing logic that would otherwise seem memory-limited:
|
||||
|
||||
Immutable.Range(1, Infinity)
|
||||
.skip(1000)
|
||||
.map(n => -n)
|
||||
.filter(n => n % 2 === 0)
|
||||
.take(2)
|
||||
.reduce((r, n) => r * n, 1);
|
||||
// 1006008
|
||||
|
||||
Note: An iterable is always iterated in the same order, however that order may
|
||||
not always be well defined, as is the case for the `Map`.
|
||||
|
||||
|
||||
Equality treats Collections as Data
|
||||
-----------------------------------
|
||||
|
||||
`Immutable` provides equality which treats immutable data structures as pure
|
||||
data, performing a deep equality check if necessary.
|
||||
|
||||
```javascript
|
||||
var map1 = Immutable.Map({a:1, b:1, c:1});
|
||||
var map2 = Immutable.Map({a:1, b:1, c:1});
|
||||
assert(map1 !== map2); // two different instances
|
||||
assert(Immutable.is(map1, map2)); // have equivalent values
|
||||
assert(map1.equals(map2)); // alternatively use the equals method
|
||||
```
|
||||
|
||||
`Immutable.is()` uses the same measure of equality as [Object.is][]
|
||||
including if both are immutable and all keys and values are equal
|
||||
using the same measure of equality.
|
||||
|
||||
[Object.is]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
|
||||
|
||||
|
||||
Batching Mutations
|
||||
------------------
|
||||
|
||||
> If a tree falls in the woods, does it make a sound?
|
||||
>
|
||||
> If a pure function mutates some local data in order to produce an immutable
|
||||
> return value, is that ok?
|
||||
>
|
||||
> — Rich Hickey, Clojure
|
||||
|
||||
Applying a mutation to create a new immutable object results in some overhead,
|
||||
which can add up to a minor performance penalty. If you need to apply a series
|
||||
of mutations locally before returning, `Immutable` gives you the ability to
|
||||
create a temporary mutable (transient) copy of a collection and apply a batch of
|
||||
mutations in a performant manner by using `withMutations`. In fact, this is
|
||||
exactly how `Immutable` applies complex mutations itself.
|
||||
|
||||
As an example, building `list2` results in the creation of 1, not 3, new
|
||||
immutable Lists.
|
||||
|
||||
```javascript
|
||||
var list1 = Immutable.List.of(1,2,3);
|
||||
var list2 = list1.withMutations(function (list) {
|
||||
list.push(4).push(5).push(6);
|
||||
});
|
||||
assert(list1.size === 3);
|
||||
assert(list2.size === 6);
|
||||
```
|
||||
|
||||
Note: `immutable` also provides `asMutable` and `asImmutable`, but only
|
||||
encourages their use when `withMutations` will not suffice. Use caution to not
|
||||
return a mutable copy, which could result in undesired behavior.
|
||||
|
||||
*Important!*: Only a select few methods can be used in `withMutations` including
|
||||
`set`, `push` and `pop`. These methods can be applied directly against a
|
||||
persistent data-structure where other methods like `map`, `filter`, `sort`,
|
||||
and `splice` will always return new immutable data-structures and never mutate
|
||||
a mutable collection.
|
||||
|
||||
|
||||
Documentation
|
||||
-------------
|
||||
|
||||
[Read the docs](http://facebook.github.io/immutable-js/docs/) and eat your vegetables.
|
||||
|
||||
Docs are automatically generated from [Immutable.d.ts](https://github.com/facebook/immutable-js/blob/master/type-definitions/Immutable.d.ts).
|
||||
Please contribute!
|
||||
|
||||
Also, don't miss the [Wiki](https://github.com/facebook/immutable-js/wiki) which
|
||||
contains articles on specific topics. Can't find something? Open an [issue](https://github.com/facebook/immutable-js/issues).
|
||||
|
||||
|
||||
Testing
|
||||
-------
|
||||
|
||||
If you are using the [Chai Assertion Library](http://chaijs.com/), [Chai Immutable](https://github.com/astorije/chai-immutable) provides a set of assertions to use against `Immutable` collections.
|
||||
|
||||
|
||||
Contribution
|
||||
------------
|
||||
|
||||
Use [Github issues](https://github.com/facebook/immutable-js/issues) for requests.
|
||||
|
||||
We actively welcome pull requests, learn how to [contribute](./CONTRIBUTING.md).
|
||||
|
||||
|
||||
Changelog
|
||||
---------
|
||||
|
||||
Changes are tracked as [Github releases](https://github.com/facebook/immutable-js/releases).
|
||||
|
||||
|
||||
Thanks
|
||||
------
|
||||
|
||||
[Phil Bagwell](https://www.youtube.com/watch?v=K2NYwP90bNs), for his inspiration
|
||||
and research in persistent data structures.
|
||||
|
||||
[Hugh Jackson](https://github.com/hughfdjackson/), for providing the npm package
|
||||
name. If you're looking for his unsupported package, see [this repository](https://github.com/hughfdjackson/immutable).
|
||||
|
||||
|
||||
License
|
||||
-------
|
||||
|
||||
Immutable.js is [MIT-licensed](https://github.com/facebook/immutable-js/blob/master/LICENSE).
|
||||
33
node_modules/immutable/contrib/cursor/README.md
generated
vendored
Normal file
33
node_modules/immutable/contrib/cursor/README.md
generated
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
Cursors
|
||||
-------
|
||||
|
||||
Cursors allow you to hold a reference to a path in a nested immutable data
|
||||
structure, allowing you to pass smaller sections of a larger nested
|
||||
collection to portions of your application while maintaining a central point
|
||||
aware of changes to the entire data structure: an `onChange` function which is
|
||||
called whenever a cursor or sub-cursor calls `update`.
|
||||
|
||||
This is particularly useful when used in conjuction with component-based UI
|
||||
libraries like [React](http://facebook.github.io/react/) or to simulate
|
||||
"state" throughout an application while maintaining a single flow of logic.
|
||||
|
||||
|
||||
```javascript
|
||||
var Immutable = require('immutable');
|
||||
var Cursor = require('immutable/contrib/cursor');
|
||||
|
||||
var data = Immutable.fromJS({ a: { b: { c: 1 } } });
|
||||
var cursor = Cursor.from(data, ['a', 'b'], newData => {
|
||||
data = newData;
|
||||
});
|
||||
|
||||
// ... elsewhere ...
|
||||
|
||||
cursor.get('c'); // 1
|
||||
cursor = cursor.update('c', x => x + 1);
|
||||
cursor.get('c'); // 2
|
||||
|
||||
// ... back to data ...
|
||||
|
||||
data.getIn(['a', 'b', 'c']); // 2
|
||||
```
|
||||
400
node_modules/immutable/contrib/cursor/__tests__/Cursor.ts.skip
generated
vendored
Normal file
400
node_modules/immutable/contrib/cursor/__tests__/Cursor.ts.skip
generated
vendored
Normal file
@ -0,0 +1,400 @@
|
||||
/**
|
||||
* Copyright (c) 2014-present, Facebook, Inc.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
///<reference path='../../../resources/jest.d.ts'/>
|
||||
///<reference path='../../../dist/immutable.d.ts'/>
|
||||
///<reference path='../index.d.ts'/>
|
||||
|
||||
jest.autoMockOff();
|
||||
|
||||
import Immutable = require('immutable');
|
||||
import Cursor = require('immutable/contrib/cursor');
|
||||
|
||||
describe('Cursor', () => {
|
||||
|
||||
beforeEach(function () {
|
||||
this.addMatchers({
|
||||
toValueEqual: function (expected) {
|
||||
var actual = this.actual;
|
||||
if (!Immutable.is(expected, this.actual)) {
|
||||
this.message = 'Expected\n' + this.actual + '\nto equal\n' + expected;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
var json = { a: { b: { c: 1 } } };
|
||||
|
||||
it('gets from its path', () => {
|
||||
var data = Immutable.fromJS(json);
|
||||
var cursor = Cursor.from(data);
|
||||
|
||||
expect(cursor.deref()).toBe(data);
|
||||
|
||||
var deepCursor = cursor.cursor(['a', 'b']);
|
||||
expect(deepCursor.deref().toJS()).toEqual(json.a.b);
|
||||
expect(deepCursor.deref()).toBe(data.getIn(['a', 'b']));
|
||||
expect(deepCursor.get('c')).toBe(1);
|
||||
|
||||
var leafCursor = deepCursor.cursor('c');
|
||||
expect(leafCursor.deref()).toBe(1);
|
||||
|
||||
var missCursor = leafCursor.cursor('d');
|
||||
expect(missCursor.deref()).toBe(undefined);
|
||||
});
|
||||
|
||||
it('gets return new cursors', () => {
|
||||
var data = Immutable.fromJS(json);
|
||||
var cursor = Cursor.from(data);
|
||||
var deepCursor = cursor.getIn(['a', 'b']);
|
||||
expect(deepCursor.deref()).toBe(data.getIn(['a', 'b']));
|
||||
});
|
||||
|
||||
it('gets return new cursors using List', () => {
|
||||
var data = Immutable.fromJS(json);
|
||||
var cursor = Cursor.from(data);
|
||||
var deepCursor = cursor.getIn(Immutable.fromJS(['a', 'b']));
|
||||
expect(deepCursor.deref()).toBe(data.getIn(Immutable.fromJS(['a', 'b'])));
|
||||
});
|
||||
|
||||
it('cursor return new cursors of correct type', () => {
|
||||
var data = Immutable.fromJS({ a: [1, 2, 3] });
|
||||
var cursor = Cursor.from(data);
|
||||
var deepCursor = <any>cursor.cursor('a');
|
||||
expect(deepCursor.findIndex).toBeDefined();
|
||||
});
|
||||
|
||||
it('can be treated as a value', () => {
|
||||
var data = Immutable.fromJS(json);
|
||||
var cursor = Cursor.from(data, ['a', 'b']);
|
||||
expect(cursor.toJS()).toEqual(json.a.b);
|
||||
expect(cursor).toValueEqual(data.getIn(['a', 'b']));
|
||||
expect(cursor.size).toBe(1);
|
||||
expect(cursor.get('c')).toBe(1);
|
||||
});
|
||||
|
||||
it('can be value compared to a primitive', () => {
|
||||
var data = Immutable.Map({ a: 'A' });
|
||||
var aCursor = Cursor.from(data, 'a');
|
||||
expect(aCursor.size).toBe(undefined);
|
||||
expect(aCursor.deref()).toBe('A');
|
||||
expect(Immutable.is(aCursor, 'A')).toBe(true);
|
||||
});
|
||||
|
||||
it('updates at its path', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
|
||||
var data = Immutable.fromJS(json);
|
||||
var aCursor = Cursor.from(data, 'a', onChange);
|
||||
|
||||
var deepCursor = aCursor.cursor(['b', 'c']);
|
||||
expect(deepCursor.deref()).toBe(1);
|
||||
|
||||
// cursor edits return new cursors:
|
||||
var newDeepCursor = deepCursor.update(x => x + 1);
|
||||
expect(newDeepCursor.deref()).toBe(2);
|
||||
var call1 = onChange.mock.calls[0];
|
||||
expect(call1[0]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
|
||||
expect(call1[1]).toBe(data);
|
||||
expect(call1[2]).toEqual(['a', 'b', 'c']);
|
||||
|
||||
var newestDeepCursor = newDeepCursor.update(x => x + 1);
|
||||
expect(newestDeepCursor.deref()).toBe(3);
|
||||
var call2 = onChange.mock.calls[1];
|
||||
expect(call2[0]).toValueEqual(Immutable.fromJS({a:{b:{c:3}}}));
|
||||
expect(call2[1]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
|
||||
expect(call2[2]).toEqual(['a', 'b', 'c']);
|
||||
|
||||
// meanwhile, data is still immutable:
|
||||
expect(data.toJS()).toEqual(json);
|
||||
|
||||
// as is the original cursor.
|
||||
expect(deepCursor.deref()).toBe(1);
|
||||
var otherNewDeepCursor = deepCursor.update(x => x + 10);
|
||||
expect(otherNewDeepCursor.deref()).toBe(11);
|
||||
var call3 = onChange.mock.calls[2];
|
||||
expect(call3[0]).toValueEqual(Immutable.fromJS({a:{b:{c:11}}}));
|
||||
expect(call3[1]).toBe(data);
|
||||
expect(call3[2]).toEqual(['a', 'b', 'c']);
|
||||
|
||||
// and update has been called exactly thrice.
|
||||
expect(onChange.mock.calls.length).toBe(3);
|
||||
});
|
||||
|
||||
it('updates with the return value of onChange', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
|
||||
var data = Immutable.fromJS(json);
|
||||
var deepCursor = Cursor.from(data, ['a', 'b', 'c'], onChange);
|
||||
|
||||
onChange.mockReturnValueOnce(undefined);
|
||||
// onChange returning undefined has no effect
|
||||
var newCursor = deepCursor.update(x => x + 1);
|
||||
expect(newCursor.deref()).toBe(2);
|
||||
var call1 = onChange.mock.calls[0];
|
||||
expect(call1[0]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
|
||||
expect(call1[1]).toBe(data);
|
||||
expect(call1[2]).toEqual(['a', 'b', 'c']);
|
||||
|
||||
onChange.mockReturnValueOnce(Immutable.fromJS({a:{b:{c:11}}}));
|
||||
// onChange returning something else has an effect
|
||||
newCursor = newCursor.update(x => 999);
|
||||
expect(newCursor.deref()).toBe(11);
|
||||
var call2 = onChange.mock.calls[1];
|
||||
expect(call2[0]).toValueEqual(Immutable.fromJS({a:{b:{c:999}}}));
|
||||
expect(call2[1]).toValueEqual(Immutable.fromJS({a:{b:{c:2}}}));
|
||||
expect(call2[2]).toEqual(['a', 'b', 'c']);
|
||||
|
||||
// and update has been called exactly twice
|
||||
expect(onChange.mock.calls.length).toBe(2);
|
||||
});
|
||||
|
||||
it('has map API for update shorthand', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
|
||||
var data = Immutable.fromJS(json);
|
||||
var aCursor = Cursor.from(data, 'a', onChange);
|
||||
var bCursor = aCursor.cursor('b');
|
||||
var cCursor = bCursor.cursor('c');
|
||||
|
||||
expect(bCursor.set('c', 10).deref()).toValueEqual(
|
||||
Immutable.fromJS({ c: 10 })
|
||||
);
|
||||
|
||||
var call1 = onChange.mock.calls[0];
|
||||
expect(call1[0]).toValueEqual(Immutable.fromJS({a:{b:{c:10}}}));
|
||||
expect(call1[1]).toBe(data);
|
||||
expect(call1[2]).toEqual(['a', 'b', 'c']);
|
||||
});
|
||||
|
||||
it('creates maps as necessary', () => {
|
||||
var data = Immutable.Map();
|
||||
var cursor = Cursor.from(data, ['a', 'b', 'c']);
|
||||
expect(cursor.deref()).toBe(undefined);
|
||||
cursor = cursor.set('d', 3);
|
||||
expect(cursor.deref()).toValueEqual(Immutable.Map({d: 3}));
|
||||
});
|
||||
|
||||
it('can set undefined', () => {
|
||||
var data = Immutable.Map();
|
||||
var cursor = Cursor.from(data, ['a', 'b', 'c']);
|
||||
expect(cursor.deref()).toBe(undefined);
|
||||
cursor = cursor.set('d', undefined);
|
||||
expect(cursor.toJS()).toEqual({d: undefined});
|
||||
});
|
||||
|
||||
it('has the sequence API', () => {
|
||||
var data = Immutable.Map({a: 1, b: 2, c: 3});
|
||||
var cursor = Cursor.from(data);
|
||||
expect(cursor.map((x: number) => x * x)).toValueEqual(Immutable.Map({a: 1, b: 4, c: 9}));
|
||||
});
|
||||
|
||||
it('can push values on a List', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
|
||||
var cursor = Cursor.from(data, ['a', 'b'], onChange);
|
||||
|
||||
expect(cursor.push(3,4)).toValueEqual(Immutable.List([0, 1, 2, 3, 4]));
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [0, 1, 2, 3, 4]}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a', 'b']);
|
||||
});
|
||||
|
||||
it('can pop values of a List', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
|
||||
var cursor = Cursor.from(data, ['a', 'b'], onChange);
|
||||
|
||||
expect(cursor.pop()).toValueEqual(Immutable.List([0, 1]));
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [0, 1]}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a', 'b']);
|
||||
});
|
||||
|
||||
it('can unshift values on a List', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
|
||||
var cursor = Cursor.from(data, ['a', 'b'], onChange);
|
||||
|
||||
expect(cursor.unshift(-2, -1)).toValueEqual(Immutable.List([-2, -1, 0, 1, 2]));
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [-2, -1, 0, 1, 2]}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a', 'b']);
|
||||
});
|
||||
|
||||
it('can shift values of a List', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a: {b: [0, 1, 2]}});
|
||||
var cursor = Cursor.from(data, ['a', 'b'], onChange);
|
||||
|
||||
expect(cursor.shift()).toValueEqual(Immutable.List([1, 2]));
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a: {b: [1, 2]}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a', 'b']);
|
||||
});
|
||||
|
||||
|
||||
it('returns wrapped values for sequence API', () => {
|
||||
var data = Immutable.fromJS({a: {v: 1}, b: {v: 2}, c: {v: 3}});
|
||||
var onChange = jest.genMockFunction();
|
||||
var cursor = Cursor.from(data, onChange);
|
||||
|
||||
var found = cursor.find(map => map.get('v') === 2);
|
||||
expect(typeof found.deref).toBe('function'); // is a cursor!
|
||||
found = found.set('v', 20);
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a: {v: 1}, b: {v: 20}, c: {v: 3}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['b', 'v']);
|
||||
});
|
||||
|
||||
it('returns wrapped values for iteration API', () => {
|
||||
var jsData = [{val: 0}, {val: 1}, {val: 2}];
|
||||
var data = Immutable.fromJS(jsData);
|
||||
var cursor = Cursor.from(data);
|
||||
cursor.forEach(function (c, i) {
|
||||
expect(typeof c.deref).toBe('function'); // is a cursor!
|
||||
expect(c.get('val')).toBe(i);
|
||||
});
|
||||
});
|
||||
|
||||
it('can map over values to get subcursors', () => {
|
||||
var data = Immutable.fromJS({a: {v: 1}, b: {v: 2}, c: {v: 3}});
|
||||
var cursor = Cursor.from(data);
|
||||
|
||||
var mapped = cursor.map(val => {
|
||||
expect(typeof val.deref).toBe('function'); // mapped values are cursors.
|
||||
return val;
|
||||
}).toMap();
|
||||
// Mapped is not a cursor, but it is a sequence of cursors.
|
||||
expect(typeof (<any>mapped).deref).not.toBe('function');
|
||||
expect(typeof (<any>mapped.get('a')).deref).toBe('function');
|
||||
|
||||
// Same for indexed cursors
|
||||
var data2 = Immutable.fromJS({x: [{v: 1}, {v: 2}, {v: 3}]});
|
||||
var cursor2 = Cursor.from(data2);
|
||||
|
||||
var mapped2 = cursor2.get('x').map(val => {
|
||||
expect(typeof val.deref).toBe('function'); // mapped values are cursors.
|
||||
return val;
|
||||
}).toList();
|
||||
// Mapped is not a cursor, but it is a sequence of cursors.
|
||||
expect(typeof mapped2.deref).not.toBe('function');
|
||||
expect(typeof mapped2.get(0).deref).toBe('function');
|
||||
});
|
||||
|
||||
it('can have mutations apply with a single callback', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({'a': 1});
|
||||
|
||||
var c1 = Cursor.from(data, onChange);
|
||||
var c2 = c1.withMutations(m => m.set('b', 2).set('c', 3).set('d', 4));
|
||||
|
||||
expect(c1.deref().toObject()).toEqual({'a': 1});
|
||||
expect(c2.deref().toObject()).toEqual({'a': 1, 'b': 2, 'c': 3, 'd': 4});
|
||||
expect(onChange.mock.calls.length).toBe(1);
|
||||
});
|
||||
|
||||
it('can use withMutations on an unfulfilled cursor', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({});
|
||||
|
||||
var c1 = Cursor.from(data, ['a', 'b', 'c'], onChange);
|
||||
var c2 = c1.withMutations(m => m.set('x', 1).set('y', 2).set('z', 3));
|
||||
|
||||
expect(c1.deref()).toEqual(undefined);
|
||||
expect(c2.deref()).toValueEqual(Immutable.fromJS(
|
||||
{ x: 1, y: 2, z: 3 }
|
||||
));
|
||||
expect(onChange.mock.calls.length).toBe(1);
|
||||
});
|
||||
|
||||
it('maintains indexed sequences', () => {
|
||||
var data = Immutable.fromJS([]);
|
||||
var c = Cursor.from(data);
|
||||
expect(c.toJS()).toEqual([]);
|
||||
});
|
||||
|
||||
it('properly acts as an iterable', () => {
|
||||
var data = Immutable.fromJS({key: {val: 1}});
|
||||
var c = Cursor.from(data).values();
|
||||
var c1 = c.next().value.get('val');
|
||||
expect(c1).toBe(1);
|
||||
});
|
||||
|
||||
it('can update deeply', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a:{b:{c:1}}});
|
||||
var c = Cursor.from(data, ['a'], onChange);
|
||||
var c1 = c.updateIn(['b', 'c'], x => x * 10);
|
||||
expect(c1.getIn(['b', 'c'])).toBe(10);
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a:{b:{c:10}}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a', 'b', 'c']);
|
||||
});
|
||||
|
||||
it('can set deeply', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a:{b:{c:1}}});
|
||||
var c = Cursor.from(data, ['a'], onChange);
|
||||
var c1 = c.setIn(['b', 'c'], 10);
|
||||
expect(c1.getIn(['b', 'c'])).toBe(10);
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a:{b:{c:10}}}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a', 'b', 'c']);
|
||||
});
|
||||
|
||||
it('can get Record value as a property', () => {
|
||||
var User = Immutable.Record({ name: 'John' });
|
||||
var users = Immutable.List.of(new User());
|
||||
var data = Immutable.Map({'users': users});
|
||||
var cursor = Cursor.from(data, ['users']);
|
||||
expect(cursor.first().name).toBe('John');
|
||||
});
|
||||
|
||||
it('can set value of a cursor directly', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a:1});
|
||||
var c = Cursor.from(data, ['a'], onChange);
|
||||
var c1 = c.set(2);
|
||||
expect(c1.deref()).toBe(2);
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a:2}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a']);
|
||||
});
|
||||
|
||||
it('can set value of a cursor to undefined directly', () => {
|
||||
var onChange = jest.genMockFunction();
|
||||
var data = Immutable.fromJS({a:1});
|
||||
var c = Cursor.from(data, ['a'], onChange);
|
||||
var c1 = c.set(undefined);
|
||||
expect(c1.deref()).toBe(undefined);
|
||||
|
||||
var call = onChange.mock.calls[0];
|
||||
expect(call[0]).toValueEqual(Immutable.fromJS({a:undefined}));
|
||||
expect(call[1]).toBe(data);
|
||||
expect(call[2]).toEqual(['a']);
|
||||
});
|
||||
|
||||
});
|
||||
290
node_modules/immutable/contrib/cursor/index.d.ts
generated
vendored
Normal file
290
node_modules/immutable/contrib/cursor/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,290 @@
|
||||
/**
|
||||
* Copyright (c) 2014-present, Facebook, Inc.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Cursors
|
||||
* -------
|
||||
*
|
||||
* Cursors allow you to hold a reference to a path in a nested immutable data
|
||||
* structure, allowing you to pass smaller sections of a larger nested
|
||||
* collection to portions of your application while maintaining a central point
|
||||
* aware of changes to the entire data structure.
|
||||
*
|
||||
* This is particularly useful when used in conjuction with component-based UI
|
||||
* libraries like [React](http://facebook.github.io/react/) or to simulate
|
||||
* "state" throughout an application while maintaining a single flow of logic.
|
||||
*
|
||||
* Cursors provide a simple API for getting the value at that path
|
||||
* (the equivalent of `this.getIn(keyPath)`), updating the value at that path
|
||||
* (the equivalent of `this.updateIn(keyPath)`), and getting a sub-cursor
|
||||
* starting from that path.
|
||||
*
|
||||
* When updated, a new root collection is created and provided to the `onChange`
|
||||
* function provided to the first call to `Cursor(map, onChange)`.
|
||||
*
|
||||
* When this cursor's (or any of its sub-cursors') `update` method is called,
|
||||
* the resulting new data structure will be provided to the `onChange`
|
||||
* function. Use this callback to keep track of the most current value or
|
||||
* update the rest of your application.
|
||||
*/
|
||||
|
||||
/// <reference path='../../dist/immutable.d.ts'/>
|
||||
|
||||
declare module __Cursor {
|
||||
|
||||
export function from(
|
||||
collection: Immutable.Collection<any, any>,
|
||||
onChange?: (newValue: any, oldValue?: any, keyPath?: Array<any>) => any
|
||||
): Cursor;
|
||||
export function from(
|
||||
collection: Immutable.Collection<any, any>,
|
||||
keyPath: Array<any>,
|
||||
onChange?: (newValue: any, oldValue?: any, keyPath?: Array<any>) => any
|
||||
): Cursor;
|
||||
export function from(
|
||||
collection: Immutable.Collection<any, any>,
|
||||
key: any,
|
||||
onChange?: (newValue: any, oldValue?: any, keyPath?: Array<any>) => any
|
||||
): Cursor;
|
||||
|
||||
|
||||
export interface Cursor extends Immutable.Seq<any, any> {
|
||||
|
||||
/**
|
||||
* Returns a sub-cursor following the key-path starting from this cursor.
|
||||
*/
|
||||
cursor(subKeyPath: Array<any>): Cursor;
|
||||
cursor(subKey: any): Cursor;
|
||||
|
||||
/**
|
||||
* Returns the value at the cursor, if the cursor path does not yet exist,
|
||||
* returns `notSetValue`.
|
||||
*/
|
||||
deref(notSetValue?: any): any;
|
||||
|
||||
/**
|
||||
* Returns the value at the `key` in the cursor, or `notSetValue` if it
|
||||
* does not exist.
|
||||
*
|
||||
* If the key would return a collection, a new Cursor is returned.
|
||||
*/
|
||||
get(key: any, notSetValue?: any): any;
|
||||
|
||||
/**
|
||||
* Returns the value at the `keyPath` in the cursor, or `notSetValue` if it
|
||||
* does not exist.
|
||||
*
|
||||
* If the keyPath would return a collection, a new Cursor is returned.
|
||||
*/
|
||||
getIn(keyPath: Array<any>, notSetValue?: any): any;
|
||||
getIn(keyPath: Immutable.Iterable<any, any>, notSetValue?: any): any;
|
||||
|
||||
/**
|
||||
* Sets `value` at `key` in the cursor, returning a new cursor to the same
|
||||
* point in the new data.
|
||||
*
|
||||
* If only one parameter is provided, it is set directly as the cursor's value.
|
||||
*/
|
||||
set(key: any, value: any): Cursor;
|
||||
set(value: any): Cursor;
|
||||
|
||||
/**
|
||||
* Deletes `key` from the cursor, returning a new cursor to the same
|
||||
* point in the new data.
|
||||
*
|
||||
* Note: `delete` cannot be safely used in IE8
|
||||
* @alias remove
|
||||
*/
|
||||
delete(key: any): Cursor;
|
||||
remove(key: any): Cursor;
|
||||
|
||||
/**
|
||||
* Clears the value at this cursor, returning a new cursor to the same
|
||||
* point in the new data.
|
||||
*/
|
||||
clear(): Cursor;
|
||||
|
||||
/**
|
||||
* Updates the value in the data this cursor points to, triggering the
|
||||
* callback for the root cursor and returning a new cursor pointing to the
|
||||
* new data.
|
||||
*/
|
||||
update(updater: (value: any) => any): Cursor;
|
||||
update(key: any, updater: (value: any) => any): Cursor;
|
||||
update(key: any, notSetValue: any, updater: (value: any) => any): Cursor;
|
||||
|
||||
/**
|
||||
* @see `Map#merge`
|
||||
*/
|
||||
merge(...iterables: Immutable.Iterable<any, any>[]): Cursor;
|
||||
merge(...iterables: {[key: string]: any}[]): Cursor;
|
||||
|
||||
/**
|
||||
* @see `Map#mergeWith`
|
||||
*/
|
||||
mergeWith(
|
||||
merger: (previous?: any, next?: any) => any,
|
||||
...iterables: Immutable.Iterable<any, any>[]
|
||||
): Cursor;
|
||||
mergeWith(
|
||||
merger: (previous?: any, next?: any) => any,
|
||||
...iterables: {[key: string]: any}[]
|
||||
): Cursor;
|
||||
|
||||
/**
|
||||
* @see `Map#mergeDeep`
|
||||
*/
|
||||
mergeDeep(...iterables: Immutable.Iterable<any, any>[]): Cursor;
|
||||
mergeDeep(...iterables: {[key: string]: any}[]): Cursor;
|
||||
|
||||
/**
|
||||
* @see `Map#mergeDeepWith`
|
||||
*/
|
||||
mergeDeepWith(
|
||||
merger: (previous?: any, next?: any) => any,
|
||||
...iterables: Immutable.Iterable<any, any>[]
|
||||
): Cursor;
|
||||
mergeDeepWith(
|
||||
merger: (previous?: any, next?: any) => any,
|
||||
...iterables: {[key: string]: any}[]
|
||||
): Cursor;
|
||||
|
||||
// Deep persistent changes
|
||||
|
||||
/**
|
||||
* Returns a new Cursor having set `value` at this `keyPath`. If any keys in
|
||||
* `keyPath` do not exist, a new immutable Map will be created at that key.
|
||||
*/
|
||||
setIn(keyPath: Array<any>, value: any): Cursor;
|
||||
setIn(keyPath: Immutable.Iterable<any, any>, value: any): Cursor;
|
||||
|
||||
/**
|
||||
* Returns a new Cursor with provided `values` appended
|
||||
*/
|
||||
push(...values: Array<any>): Cursor;
|
||||
|
||||
/**
|
||||
* Returns a new Cursor with a size ones less than this Cursor,
|
||||
* excluding the last index in this Cursor.
|
||||
*/
|
||||
pop(): Cursor;
|
||||
|
||||
/**
|
||||
* Returns a new Cursor with the provided `values` prepended,
|
||||
* shifting other values ahead to higher indices.
|
||||
*/
|
||||
unshift(...values: Array<any>): Cursor;
|
||||
|
||||
/**
|
||||
* Returns a new Cursor with a size ones less than this Cursor, excluding
|
||||
* the first index in this Cursor, shifting all other values to a lower index.
|
||||
*/
|
||||
shift(): Cursor;
|
||||
|
||||
/**
|
||||
* Returns a new Cursor having removed the value at this `keyPath`.
|
||||
*
|
||||
* @alias removeIn
|
||||
*/
|
||||
deleteIn(keyPath: Array<any>): Cursor;
|
||||
deleteIn(keyPath: Immutable.Iterable<any, any>): Cursor;
|
||||
removeIn(keyPath: Array<any>): Cursor;
|
||||
removeIn(keyPath: Immutable.Iterable<any, any>): Cursor;
|
||||
|
||||
/**
|
||||
* Returns a new Cursor having applied the `updater` to the value found at
|
||||
* the keyPath.
|
||||
*
|
||||
* If any keys in `keyPath` do not exist, new Immutable `Map`s will
|
||||
* be created at those keys. If the `keyPath` does not already contain a
|
||||
* value, the `updater` function will be called with `notSetValue`, if
|
||||
* provided, otherwise `undefined`.
|
||||
*
|
||||
* If the `updater` function returns the same value it was called with, then
|
||||
* no change will occur. This is still true if `notSetValue` is provided.
|
||||
*/
|
||||
updateIn(
|
||||
keyPath: Array<any>,
|
||||
updater: (value: any) => any
|
||||
): Cursor;
|
||||
updateIn(
|
||||
keyPath: Array<any>,
|
||||
notSetValue: any,
|
||||
updater: (value: any) => any
|
||||
): Cursor;
|
||||
updateIn(
|
||||
keyPath: Immutable.Iterable<any, any>,
|
||||
updater: (value: any) => any
|
||||
): Cursor;
|
||||
updateIn(
|
||||
keyPath: Immutable.Iterable<any, any>,
|
||||
notSetValue: any,
|
||||
updater: (value: any) => any
|
||||
): Cursor;
|
||||
|
||||
/**
|
||||
* A combination of `updateIn` and `merge`, returning a new Cursor, but
|
||||
* performing the merge at a point arrived at by following the keyPath.
|
||||
* In other words, these two lines are equivalent:
|
||||
*
|
||||
* x.updateIn(['a', 'b', 'c'], abc => abc.merge(y));
|
||||
* x.mergeIn(['a', 'b', 'c'], y);
|
||||
*
|
||||
*/
|
||||
mergeIn(
|
||||
keyPath: Immutable.Iterable<any, any>,
|
||||
...iterables: Immutable.Iterable<any, any>[]
|
||||
): Cursor;
|
||||
mergeIn(
|
||||
keyPath: Array<any>,
|
||||
...iterables: Immutable.Iterable<any, any>[]
|
||||
): Cursor;
|
||||
mergeIn(
|
||||
keyPath: Array<any>,
|
||||
...iterables: {[key: string]: any}[]
|
||||
): Cursor;
|
||||
|
||||
/**
|
||||
* A combination of `updateIn` and `mergeDeep`, returning a new Cursor, but
|
||||
* performing the deep merge at a point arrived at by following the keyPath.
|
||||
* In other words, these two lines are equivalent:
|
||||
*
|
||||
* x.updateIn(['a', 'b', 'c'], abc => abc.mergeDeep(y));
|
||||
* x.mergeDeepIn(['a', 'b', 'c'], y);
|
||||
*
|
||||
*/
|
||||
mergeDeepIn(
|
||||
keyPath: Immutable.Iterable<any, any>,
|
||||
...iterables: Immutable.Iterable<any, any>[]
|
||||
): Cursor;
|
||||
mergeDeepIn(
|
||||
keyPath: Array<any>,
|
||||
...iterables: Immutable.Iterable<any, any>[]
|
||||
): Cursor;
|
||||
mergeDeepIn(
|
||||
keyPath: Array<any>,
|
||||
...iterables: {[key: string]: any}[]
|
||||
): Cursor;
|
||||
|
||||
// Transient changes
|
||||
|
||||
/**
|
||||
* Every time you call one of the above functions, a new immutable value is
|
||||
* created and the callback is triggered. If you need to apply a series of
|
||||
* mutations to a Cursor without triggering the callback repeatedly,
|
||||
* `withMutations()` creates a temporary mutable copy of the value which
|
||||
* can apply mutations in a highly performant manner. Afterwards the
|
||||
* callback is triggered with the final value.
|
||||
*/
|
||||
withMutations(mutator: (mutable: any) => any): Cursor;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
declare module 'immutable/contrib/cursor' {
|
||||
export = __Cursor
|
||||
}
|
||||
341
node_modules/immutable/contrib/cursor/index.js
generated
vendored
Normal file
341
node_modules/immutable/contrib/cursor/index.js
generated
vendored
Normal file
@ -0,0 +1,341 @@
|
||||
/**
|
||||
* Copyright (c) 2014-present, Facebook, Inc.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Cursor is expected to be required in a node or other CommonJS context:
|
||||
*
|
||||
* var Cursor = require('immutable/contrib/cursor');
|
||||
*
|
||||
* If you wish to use it in the browser, please check out Browserify or WebPack!
|
||||
*/
|
||||
|
||||
var Immutable = require('../../');
|
||||
var Iterable = Immutable.Iterable;
|
||||
var Iterator = Iterable.Iterator;
|
||||
var Seq = Immutable.Seq;
|
||||
var Map = Immutable.Map;
|
||||
var Record = Immutable.Record;
|
||||
|
||||
|
||||
function cursorFrom(rootData, keyPath, onChange) {
|
||||
if (arguments.length === 1) {
|
||||
keyPath = [];
|
||||
} else if (typeof keyPath === 'function') {
|
||||
onChange = keyPath;
|
||||
keyPath = [];
|
||||
} else {
|
||||
keyPath = valToKeyPath(keyPath);
|
||||
}
|
||||
return makeCursor(rootData, keyPath, onChange);
|
||||
}
|
||||
|
||||
|
||||
var KeyedCursorPrototype = Object.create(Seq.Keyed.prototype);
|
||||
var IndexedCursorPrototype = Object.create(Seq.Indexed.prototype);
|
||||
|
||||
function KeyedCursor(rootData, keyPath, onChange, size) {
|
||||
this.size = size;
|
||||
this._rootData = rootData;
|
||||
this._keyPath = keyPath;
|
||||
this._onChange = onChange;
|
||||
}
|
||||
KeyedCursorPrototype.constructor = KeyedCursor;
|
||||
|
||||
function IndexedCursor(rootData, keyPath, onChange, size) {
|
||||
this.size = size;
|
||||
this._rootData = rootData;
|
||||
this._keyPath = keyPath;
|
||||
this._onChange = onChange;
|
||||
}
|
||||
IndexedCursorPrototype.constructor = IndexedCursor;
|
||||
|
||||
KeyedCursorPrototype.toString = function() {
|
||||
return this.__toString('Cursor {', '}');
|
||||
}
|
||||
IndexedCursorPrototype.toString = function() {
|
||||
return this.__toString('Cursor [', ']');
|
||||
}
|
||||
|
||||
KeyedCursorPrototype.deref =
|
||||
KeyedCursorPrototype.valueOf =
|
||||
IndexedCursorPrototype.deref =
|
||||
IndexedCursorPrototype.valueOf = function(notSetValue) {
|
||||
return this._rootData.getIn(this._keyPath, notSetValue);
|
||||
}
|
||||
|
||||
KeyedCursorPrototype.get =
|
||||
IndexedCursorPrototype.get = function(key, notSetValue) {
|
||||
return this.getIn([key], notSetValue);
|
||||
}
|
||||
|
||||
KeyedCursorPrototype.getIn =
|
||||
IndexedCursorPrototype.getIn = function(keyPath, notSetValue) {
|
||||
keyPath = listToKeyPath(keyPath);
|
||||
if (keyPath.length === 0) {
|
||||
return this;
|
||||
}
|
||||
var value = this._rootData.getIn(newKeyPath(this._keyPath, keyPath), NOT_SET);
|
||||
return value === NOT_SET ? notSetValue : wrappedValue(this, keyPath, value);
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.set =
|
||||
KeyedCursorPrototype.set = function(key, value) {
|
||||
if(arguments.length === 1) {
|
||||
return updateCursor(this, function() { return key; }, []);
|
||||
} else {
|
||||
return updateCursor(this, function (m) { return m.set(key, value); }, [key]);
|
||||
}
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.push = function(/* values */) {
|
||||
var args = arguments;
|
||||
return updateCursor(this, function (m) {
|
||||
return m.push.apply(m, args);
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.pop = function() {
|
||||
return updateCursor(this, function (m) {
|
||||
return m.pop();
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.unshift = function(/* values */) {
|
||||
var args = arguments;
|
||||
return updateCursor(this, function (m) {
|
||||
return m.unshift.apply(m, args);
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.shift = function() {
|
||||
return updateCursor(this, function (m) {
|
||||
return m.shift();
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.setIn =
|
||||
KeyedCursorPrototype.setIn = Map.prototype.setIn;
|
||||
|
||||
KeyedCursorPrototype.remove =
|
||||
KeyedCursorPrototype['delete'] =
|
||||
IndexedCursorPrototype.remove =
|
||||
IndexedCursorPrototype['delete'] = function(key) {
|
||||
return updateCursor(this, function (m) { return m.remove(key); }, [key]);
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.removeIn =
|
||||
IndexedCursorPrototype.deleteIn =
|
||||
KeyedCursorPrototype.removeIn =
|
||||
KeyedCursorPrototype.deleteIn = Map.prototype.deleteIn;
|
||||
|
||||
KeyedCursorPrototype.clear =
|
||||
IndexedCursorPrototype.clear = function() {
|
||||
return updateCursor(this, function (m) { return m.clear(); });
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.update =
|
||||
KeyedCursorPrototype.update = function(keyOrFn, notSetValue, updater) {
|
||||
return arguments.length === 1 ?
|
||||
updateCursor(this, keyOrFn) :
|
||||
this.updateIn([keyOrFn], notSetValue, updater);
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.updateIn =
|
||||
KeyedCursorPrototype.updateIn = function(keyPath, notSetValue, updater) {
|
||||
return updateCursor(this, function (m) {
|
||||
return m.updateIn(keyPath, notSetValue, updater);
|
||||
}, keyPath);
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.merge =
|
||||
KeyedCursorPrototype.merge = function(/*...iters*/) {
|
||||
var args = arguments;
|
||||
return updateCursor(this, function (m) {
|
||||
return m.merge.apply(m, args);
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.mergeWith =
|
||||
KeyedCursorPrototype.mergeWith = function(merger/*, ...iters*/) {
|
||||
var args = arguments;
|
||||
return updateCursor(this, function (m) {
|
||||
return m.mergeWith.apply(m, args);
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.mergeIn =
|
||||
KeyedCursorPrototype.mergeIn = Map.prototype.mergeIn;
|
||||
|
||||
IndexedCursorPrototype.mergeDeep =
|
||||
KeyedCursorPrototype.mergeDeep = function(/*...iters*/) {
|
||||
var args = arguments;
|
||||
return updateCursor(this, function (m) {
|
||||
return m.mergeDeep.apply(m, args);
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.mergeDeepWith =
|
||||
KeyedCursorPrototype.mergeDeepWith = function(merger/*, ...iters*/) {
|
||||
var args = arguments;
|
||||
return updateCursor(this, function (m) {
|
||||
return m.mergeDeepWith.apply(m, args);
|
||||
});
|
||||
}
|
||||
|
||||
IndexedCursorPrototype.mergeDeepIn =
|
||||
KeyedCursorPrototype.mergeDeepIn = Map.prototype.mergeDeepIn;
|
||||
|
||||
KeyedCursorPrototype.withMutations =
|
||||
IndexedCursorPrototype.withMutations = function(fn) {
|
||||
return updateCursor(this, function (m) {
|
||||
return (m || Map()).withMutations(fn);
|
||||
});
|
||||
}
|
||||
|
||||
KeyedCursorPrototype.cursor =
|
||||
IndexedCursorPrototype.cursor = function(subKeyPath) {
|
||||
subKeyPath = valToKeyPath(subKeyPath);
|
||||
return subKeyPath.length === 0 ? this : subCursor(this, subKeyPath);
|
||||
}
|
||||
|
||||
/**
|
||||
* All iterables need to implement __iterate
|
||||
*/
|
||||
KeyedCursorPrototype.__iterate =
|
||||
IndexedCursorPrototype.__iterate = function(fn, reverse) {
|
||||
var cursor = this;
|
||||
var deref = cursor.deref();
|
||||
return deref && deref.__iterate ? deref.__iterate(
|
||||
function (v, k) { return fn(wrappedValue(cursor, [k], v), k, cursor); },
|
||||
reverse
|
||||
) : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* All iterables need to implement __iterator
|
||||
*/
|
||||
KeyedCursorPrototype.__iterator =
|
||||
IndexedCursorPrototype.__iterator = function(type, reverse) {
|
||||
var deref = this.deref();
|
||||
var cursor = this;
|
||||
var iterator = deref && deref.__iterator &&
|
||||
deref.__iterator(Iterator.ENTRIES, reverse);
|
||||
return new Iterator(function () {
|
||||
if (!iterator) {
|
||||
return { value: undefined, done: true };
|
||||
}
|
||||
var step = iterator.next();
|
||||
if (step.done) {
|
||||
return step;
|
||||
}
|
||||
var entry = step.value;
|
||||
var k = entry[0];
|
||||
var v = wrappedValue(cursor, [k], entry[1]);
|
||||
return {
|
||||
value: type === Iterator.KEYS ? k : type === Iterator.VALUES ? v : [k, v],
|
||||
done: false
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
KeyedCursor.prototype = KeyedCursorPrototype;
|
||||
IndexedCursor.prototype = IndexedCursorPrototype;
|
||||
|
||||
|
||||
var NOT_SET = {}; // Sentinel value
|
||||
|
||||
function makeCursor(rootData, keyPath, onChange, value) {
|
||||
if (arguments.length < 4) {
|
||||
value = rootData.getIn(keyPath);
|
||||
}
|
||||
var size = value && value.size;
|
||||
var CursorClass = Iterable.isIndexed(value) ? IndexedCursor : KeyedCursor;
|
||||
var cursor = new CursorClass(rootData, keyPath, onChange, size);
|
||||
|
||||
if (value instanceof Record) {
|
||||
defineRecordProperties(cursor, value);
|
||||
}
|
||||
|
||||
return cursor;
|
||||
}
|
||||
|
||||
function defineRecordProperties(cursor, value) {
|
||||
try {
|
||||
value._keys.forEach(setProp.bind(undefined, cursor));
|
||||
} catch (error) {
|
||||
// Object.defineProperty failed. Probably IE8.
|
||||
}
|
||||
}
|
||||
|
||||
function setProp(prototype, name) {
|
||||
Object.defineProperty(prototype, name, {
|
||||
get: function() {
|
||||
return this.get(name);
|
||||
},
|
||||
set: function(value) {
|
||||
if (!this.__ownerID) {
|
||||
throw new Error('Cannot set on an immutable record.');
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function wrappedValue(cursor, keyPath, value) {
|
||||
return Iterable.isIterable(value) ? subCursor(cursor, keyPath, value) : value;
|
||||
}
|
||||
|
||||
function subCursor(cursor, keyPath, value) {
|
||||
if (arguments.length < 3) {
|
||||
return makeCursor( // call without value
|
||||
cursor._rootData,
|
||||
newKeyPath(cursor._keyPath, keyPath),
|
||||
cursor._onChange
|
||||
);
|
||||
}
|
||||
return makeCursor(
|
||||
cursor._rootData,
|
||||
newKeyPath(cursor._keyPath, keyPath),
|
||||
cursor._onChange,
|
||||
value
|
||||
);
|
||||
}
|
||||
|
||||
function updateCursor(cursor, changeFn, changeKeyPath) {
|
||||
var deepChange = arguments.length > 2;
|
||||
var newRootData = cursor._rootData.updateIn(
|
||||
cursor._keyPath,
|
||||
deepChange ? Map() : undefined,
|
||||
changeFn
|
||||
);
|
||||
var keyPath = cursor._keyPath || [];
|
||||
var result = cursor._onChange && cursor._onChange.call(
|
||||
undefined,
|
||||
newRootData,
|
||||
cursor._rootData,
|
||||
deepChange ? newKeyPath(keyPath, changeKeyPath) : keyPath
|
||||
);
|
||||
if (result !== undefined) {
|
||||
newRootData = result;
|
||||
}
|
||||
return makeCursor(newRootData, cursor._keyPath, cursor._onChange);
|
||||
}
|
||||
|
||||
function newKeyPath(head, tail) {
|
||||
return head.concat(listToKeyPath(tail));
|
||||
}
|
||||
|
||||
function listToKeyPath(list) {
|
||||
return Array.isArray(list) ? list : Immutable.Iterable(list).toArray();
|
||||
}
|
||||
|
||||
function valToKeyPath(val) {
|
||||
return Array.isArray(val) ? val :
|
||||
Iterable.isIterable(val) ? val.toArray() :
|
||||
[val];
|
||||
}
|
||||
|
||||
exports.from = cursorFrom;
|
||||
2533
node_modules/immutable/dist/immutable-nonambient.d.ts
generated
vendored
Normal file
2533
node_modules/immutable/dist/immutable-nonambient.d.ts
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
2537
node_modules/immutable/dist/immutable.d.ts
generated
vendored
Normal file
2537
node_modules/immutable/dist/immutable.d.ts
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
4977
node_modules/immutable/dist/immutable.js
generated
vendored
Normal file
4977
node_modules/immutable/dist/immutable.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
670
node_modules/immutable/dist/immutable.js.flow
generated
vendored
Normal file
670
node_modules/immutable/dist/immutable.js.flow
generated
vendored
Normal file
@ -0,0 +1,670 @@
|
||||
/**
|
||||
* Copyright (c) 2014-present, Facebook, Inc.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/**
|
||||
* This file provides type definitions for use with the Flow type checker.
|
||||
*
|
||||
* An important caveat when using these definitions is that the types for
|
||||
* `Iterable.Keyed`, `Iterable.Indexed`, `Seq.Keyed`, and so on are stubs.
|
||||
* When referring to those types, you can get the proper definitions by
|
||||
* importing the types `KeyedIterable`, `IndexedIterable`, `KeyedSeq`, etc.
|
||||
* For example,
|
||||
*
|
||||
* import { Seq } from 'immutable'
|
||||
* import type { IndexedIterable, IndexedSeq } from 'immutable'
|
||||
*
|
||||
* const someSeq: IndexedSeq<number> = Seq.Indexed.of(1, 2, 3)
|
||||
*
|
||||
* function takesASeq<T, TS: IndexedIterable<T>>(iter: TS): TS {
|
||||
* return iter.butLast()
|
||||
* }
|
||||
*
|
||||
* takesASeq(someSeq)
|
||||
*
|
||||
* @flow
|
||||
*/
|
||||
|
||||
/*
|
||||
* Alias for ECMAScript `Iterable` type, declared in
|
||||
* https://github.com/facebook/flow/blob/master/lib/core.js
|
||||
*
|
||||
* Note that Immutable values implement the `ESIterable` interface.
|
||||
*/
|
||||
type ESIterable<T> = $Iterable<T,void,void>;
|
||||
|
||||
declare class Iterable<K, V> extends _Iterable<K, V, typeof KeyedIterable, typeof IndexedIterable, typeof SetIterable> {}
|
||||
|
||||
declare class _Iterable<K, V, KI, II, SI> {
|
||||
static Keyed: KI;
|
||||
static Indexed: II;
|
||||
static Set: SI;
|
||||
|
||||
static isIterable(maybeIterable: any): boolean;
|
||||
static isKeyed(maybeKeyed: any): boolean;
|
||||
static isIndexed(maybeIndexed: any): boolean;
|
||||
static isAssociative(maybeAssociative: any): boolean;
|
||||
static isOrdered(maybeOrdered: any): boolean;
|
||||
|
||||
equals(other: Iterable<K,V>): boolean;
|
||||
hashCode(): number;
|
||||
get(key: K): V;
|
||||
get<V_>(key: K, notSetValue: V_): V|V_;
|
||||
has(key: K): boolean;
|
||||
includes(value: V): boolean;
|
||||
contains(value: V): boolean;
|
||||
first(): V;
|
||||
last(): V;
|
||||
|
||||
getIn<T>(searchKeyPath: ESIterable<any>, notSetValue: T): T;
|
||||
getIn<T>(searchKeyPath: ESIterable<any>): T;
|
||||
hasIn(searchKeyPath: ESIterable<any>): boolean;
|
||||
|
||||
toJS(): any;
|
||||
toArray(): V[];
|
||||
toObject(): { [key: string]: V };
|
||||
toMap(): Map<K,V>;
|
||||
toOrderedMap(): Map<K,V>;
|
||||
toSet(): Set<V>;
|
||||
toOrderedSet(): Set<V>;
|
||||
toList(): List<V>;
|
||||
toStack(): Stack<V>;
|
||||
toSeq(): Seq<K,V>;
|
||||
toKeyedSeq(): KeyedSeq<K,V>;
|
||||
toIndexedSeq(): IndexedSeq<V>;
|
||||
toSetSeq(): SetSeq<V>;
|
||||
|
||||
keys(): Iterator<K>;
|
||||
values(): Iterator<V>;
|
||||
entries(): Iterator<[K,V]>;
|
||||
|
||||
keySeq(): IndexedSeq<K>;
|
||||
valueSeq(): IndexedSeq<V>;
|
||||
entrySeq(): IndexedSeq<[K,V]>;
|
||||
|
||||
reverse(): this;
|
||||
sort(comparator?: (valueA: V, valueB: V) => number): this;
|
||||
|
||||
sortBy<C>(
|
||||
comparatorValueMapper: (value: V, key: K, iter: this) => C,
|
||||
comparator?: (valueA: C, valueB: C) => number
|
||||
): this;
|
||||
|
||||
groupBy<G>(
|
||||
grouper: (value: V, key: K, iter: this) => G,
|
||||
context?: any
|
||||
): KeyedSeq<G, this>;
|
||||
|
||||
forEach(
|
||||
sideEffect: (value: V, key: K, iter: this) => any,
|
||||
context?: any
|
||||
): number;
|
||||
|
||||
slice(begin?: number, end?: number): this;
|
||||
rest(): this;
|
||||
butLast(): this;
|
||||
skip(amount: number): this;
|
||||
skipLast(amount: number): this;
|
||||
skipWhile(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
|
||||
skipUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
|
||||
take(amount: number): this;
|
||||
takeLast(amount: number): this;
|
||||
takeWhile(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
|
||||
takeUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
|
||||
flatten(depth?: number): /*this*/Iterable<any,any>;
|
||||
flatten(shallow?: boolean): /*this*/Iterable<any,any>;
|
||||
|
||||
filter(
|
||||
predicate: (value: V, key: K, iter: this) => mixed,
|
||||
context?: any
|
||||
): this;
|
||||
|
||||
filterNot(
|
||||
predicate: (value: V, key: K, iter: this) => mixed,
|
||||
context?: any
|
||||
): this;
|
||||
|
||||
reduce<R>(
|
||||
reducer: (reduction: R, value: V, key: K, iter: this) => R,
|
||||
initialReduction?: R,
|
||||
context?: any,
|
||||
): R;
|
||||
|
||||
reduceRight<R>(
|
||||
reducer: (reduction: R, value: V, key: K, iter: this) => R,
|
||||
initialReduction?: R,
|
||||
context?: any,
|
||||
): R;
|
||||
|
||||
every(predicate: (value: V, key: K, iter: this) => mixed, context?: any): boolean;
|
||||
some(predicate: (value: V, key: K, iter: this) => mixed, context?: any): boolean;
|
||||
join(separator?: string): string;
|
||||
isEmpty(): boolean;
|
||||
count(predicate?: (value: V, key: K, iter: this) => mixed, context?: any): number;
|
||||
countBy<G>(grouper: (value: V, key: K, iter: this) => G, context?: any): Map<G,number>;
|
||||
|
||||
find(
|
||||
predicate: (value: V, key: K, iter: this) => mixed,
|
||||
context?: any,
|
||||
): ?V;
|
||||
find<V_>(
|
||||
predicate: (value: V, key: K, iter: this) => mixed,
|
||||
context: any,
|
||||
notSetValue: V_
|
||||
): V|V_;
|
||||
|
||||
findLast(
|
||||
predicate: (value: V, key: K, iter: this) => mixed,
|
||||
context?: any,
|
||||
): ?V;
|
||||
findLast<V_>(
|
||||
predicate: (value: V, key: K, iter: this) => mixed,
|
||||
context: any,
|
||||
notSetValue: V_
|
||||
): V|V_;
|
||||
|
||||
|
||||
findEntry(predicate: (value: V, key: K, iter: this) => mixed): ?[K,V];
|
||||
findLastEntry(predicate: (value: V, key: K, iter: this) => mixed): ?[K,V];
|
||||
|
||||
findKey(predicate: (value: V, key: K, iter: this) => mixed, context?: any): ?K;
|
||||
findLastKey(predicate: (value: V, key: K, iter: this) => mixed, context?: any): ?K;
|
||||
|
||||
keyOf(searchValue: V): ?K;
|
||||
lastKeyOf(searchValue: V): ?K;
|
||||
|
||||
max(comparator?: (valueA: V, valueB: V) => number): V;
|
||||
maxBy<C>(
|
||||
comparatorValueMapper: (value: V, key: K, iter: this) => C,
|
||||
comparator?: (valueA: C, valueB: C) => number
|
||||
): V;
|
||||
min(comparator?: (valueA: V, valueB: V) => number): V;
|
||||
minBy<C>(
|
||||
comparatorValueMapper: (value: V, key: K, iter: this) => C,
|
||||
comparator?: (valueA: C, valueB: C) => number
|
||||
): V;
|
||||
|
||||
isSubset(iter: Iterable<any, V>): boolean;
|
||||
isSubset(iter: ESIterable<V>): boolean;
|
||||
isSuperset(iter: Iterable<any, V>): boolean;
|
||||
isSuperset(iter: ESIterable<V>): boolean;
|
||||
}
|
||||
|
||||
declare class KeyedIterable<K,V> extends Iterable<K,V> {
|
||||
static <K,V>(iter?: ESIterable<[K,V]>): KeyedIterable<K,V>;
|
||||
static <K,V>(obj?: { [key: K]: V }): KeyedIterable<K,V>;
|
||||
|
||||
@@iterator(): Iterator<[K,V]>;
|
||||
toSeq(): KeyedSeq<K,V>;
|
||||
flip(): /*this*/KeyedIterable<V,K>;
|
||||
|
||||
mapKeys<K_>(
|
||||
mapper: (key: K, value: V, iter: this) => K_,
|
||||
context?: any
|
||||
): /*this*/KeyedIterable<K_,V>;
|
||||
|
||||
mapEntries<K_,V_>(
|
||||
mapper: (entry: [K,V], index: number, iter: this) => [K_,V_],
|
||||
context?: any
|
||||
): /*this*/KeyedIterable<K_,V_>;
|
||||
|
||||
concat(...iters: ESIterable<[K,V]>[]): this;
|
||||
|
||||
map<V_>(
|
||||
mapper: (value: V, key: K, iter: this) => V_,
|
||||
context?: any
|
||||
): /*this*/KeyedIterable<K,V_>;
|
||||
|
||||
flatMap<K_, V_>(
|
||||
mapper: (value: V, key: K, iter: this) => ESIterable<[K_,V_]>,
|
||||
context?: any
|
||||
): /*this*/KeyedIterable<K_,V_>;
|
||||
|
||||
flatten(depth?: number): /*this*/KeyedIterable<any,any>;
|
||||
flatten(shallow?: boolean): /*this*/KeyedIterable<any,any>;
|
||||
}
|
||||
|
||||
declare class IndexedIterable<T> extends Iterable<number,T> {
|
||||
static <T>(iter?: ESIterable<T>): IndexedIterable<T>;
|
||||
|
||||
@@iterator(): Iterator<T>;
|
||||
toSeq(): IndexedSeq<T>;
|
||||
fromEntrySeq<K,V>(): KeyedSeq<K,V>;
|
||||
interpose(separator: T): this;
|
||||
interleave(...iterables: ESIterable<T>[]): this;
|
||||
splice(
|
||||
index: number,
|
||||
removeNum: number,
|
||||
...values: T[]
|
||||
): this;
|
||||
|
||||
zip<A>(
|
||||
a: ESIterable<A>,
|
||||
$?: null
|
||||
): IndexedIterable<[T,A]>;
|
||||
zip<A,B>(
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
$?: null
|
||||
): IndexedIterable<[T,A,B]>;
|
||||
zip<A,B,C>(
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
c: ESIterable<C>,
|
||||
$?: null
|
||||
): IndexedIterable<[T,A,B,C]>;
|
||||
zip<A,B,C,D>(
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
c: ESIterable<C>,
|
||||
d: ESIterable<D>,
|
||||
$?: null
|
||||
): IndexedIterable<[T,A,B,C,D]>;
|
||||
zip<A,B,C,D,E>(
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
c: ESIterable<C>,
|
||||
d: ESIterable<D>,
|
||||
e: ESIterable<E>,
|
||||
$?: null
|
||||
): IndexedIterable<[T,A,B,C,D,E]>;
|
||||
|
||||
zipWith<A,R>(
|
||||
zipper: (value: T, a: A) => R,
|
||||
a: ESIterable<A>,
|
||||
$?: null
|
||||
): IndexedIterable<R>;
|
||||
zipWith<A,B,R>(
|
||||
zipper: (value: T, a: A, b: B) => R,
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
$?: null
|
||||
): IndexedIterable<R>;
|
||||
zipWith<A,B,C,R>(
|
||||
zipper: (value: T, a: A, b: B, c: C) => R,
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
c: ESIterable<C>,
|
||||
$?: null
|
||||
): IndexedIterable<R>;
|
||||
zipWith<A,B,C,D,R>(
|
||||
zipper: (value: T, a: A, b: B, c: C, d: D) => R,
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
c: ESIterable<C>,
|
||||
d: ESIterable<D>,
|
||||
$?: null
|
||||
): IndexedIterable<R>;
|
||||
zipWith<A,B,C,D,E,R>(
|
||||
zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
|
||||
a: ESIterable<A>,
|
||||
b: ESIterable<B>,
|
||||
c: ESIterable<C>,
|
||||
d: ESIterable<D>,
|
||||
e: ESIterable<E>,
|
||||
$?: null
|
||||
): IndexedIterable<R>;
|
||||
|
||||
indexOf(searchValue: T): number;
|
||||
lastIndexOf(searchValue: T): number;
|
||||
findIndex(
|
||||
predicate: (value: T, index: number, iter: this) => mixed,
|
||||
context?: any
|
||||
): number;
|
||||
findLastIndex(
|
||||
predicate: (value: T, index: number, iter: this) => mixed,
|
||||
context?: any
|
||||
): number;
|
||||
|
||||
concat(...iters: ESIterable<T>[]): this;
|
||||
|
||||
map<U>(
|
||||
mapper: (value: T, index: number, iter: this) => U,
|
||||
context?: any
|
||||
): /*this*/IndexedIterable<U>;
|
||||
|
||||
flatMap<U>(
|
||||
mapper: (value: T, index: number, iter: this) => ESIterable<U>,
|
||||
context?: any
|
||||
): /*this*/IndexedIterable<U>;
|
||||
|
||||
flatten(depth?: number): /*this*/IndexedIterable<any>;
|
||||
flatten(shallow?: boolean): /*this*/IndexedIterable<any>;
|
||||
}
|
||||
|
||||
declare class SetIterable<T> extends Iterable<T,T> {
|
||||
static <T>(iter?: ESIterable<T>): SetIterable<T>;
|
||||
|
||||
@@iterator(): Iterator<T>;
|
||||
toSeq(): SetSeq<T>;
|
||||
|
||||
concat(...iters: ESIterable<T>[]): this;
|
||||
|
||||
// `map` and `flatMap` cannot be defined further up the hiearchy, because the
|
||||
// implementation for `KeyedIterable` allows the value type to change without
|
||||
// constraining the key type. That does not work for `SetIterable` - the value
|
||||
// and key types *must* match.
|
||||
map<U>(
|
||||
mapper: (value: T, value: T, iter: this) => U,
|
||||
context?: any
|
||||
): /*this*/SetIterable<U>;
|
||||
|
||||
flatMap<U>(
|
||||
mapper: (value: T, value: T, iter: this) => ESIterable<U>,
|
||||
context?: any
|
||||
): /*this*/SetIterable<U>;
|
||||
|
||||
flatten(depth?: number): /*this*/SetIterable<any>;
|
||||
flatten(shallow?: boolean): /*this*/SetIterable<any>;
|
||||
}
|
||||
|
||||
declare class Collection<K,V> extends _Iterable<K,V, typeof KeyedCollection, typeof IndexedCollection, typeof SetCollection> {
|
||||
size: number;
|
||||
}
|
||||
|
||||
declare class KeyedCollection<K,V> extends Collection<K,V> mixins KeyedIterable<K,V> {
|
||||
toSeq(): KeyedSeq<K,V>;
|
||||
}
|
||||
|
||||
declare class IndexedCollection<T> extends Collection<number,T> mixins IndexedIterable<T> {
|
||||
toSeq(): IndexedSeq<T>;
|
||||
}
|
||||
|
||||
declare class SetCollection<T> extends Collection<T,T> mixins SetIterable<T> {
|
||||
toSeq(): SetSeq<T>;
|
||||
}
|
||||
|
||||
declare class Seq<K,V> extends _Iterable<K,V, typeof KeyedSeq, typeof IndexedSeq, typeof SetSeq> {
|
||||
static <K,V>(iter: KeyedSeq<K,V>): KeyedSeq<K,V>;
|
||||
static <T> (iter: SetSeq<T>): SetSeq<K,V>;
|
||||
static <T> (iter?: ESIterable<T>): IndexedSeq<T>;
|
||||
static <K,V>(iter: { [key: K]: V }): KeyedSeq<K,V>;
|
||||
|
||||
static isSeq(maybeSeq: any): boolean;
|
||||
static of<T>(...values: T[]): IndexedSeq<T>;
|
||||
|
||||
size: ?number;
|
||||
cacheResult(): this;
|
||||
toSeq(): this;
|
||||
}
|
||||
|
||||
declare class KeyedSeq<K,V> extends Seq<K,V> mixins KeyedIterable<K,V> {
|
||||
static <K,V>(iter?: ESIterable<[K,V]>): KeyedSeq<K,V>;
|
||||
static <K,V>(iter?: { [key: K]: V }): KeyedSeq<K,V>;
|
||||
}
|
||||
|
||||
declare class IndexedSeq<T> extends Seq<number,T> mixins IndexedIterable<T> {
|
||||
static <T>(iter?: ESIterable<T>): IndexedSeq<T>;
|
||||
static of<T>(...values: T[]): IndexedSeq<T>;
|
||||
}
|
||||
|
||||
declare class SetSeq<T> extends Seq<T,T> mixins SetIterable<T> {
|
||||
static <T>(iter?: ESIterable<T>): IndexedSeq<T>;
|
||||
static of<T>(...values: T[]): SetSeq<T>;
|
||||
}
|
||||
|
||||
declare class List<T> extends IndexedCollection<T> {
|
||||
static (iterable?: ESIterable<T>): List<T>;
|
||||
|
||||
static isList(maybeList: any): boolean;
|
||||
static of<T>(...values: T[]): List<T>;
|
||||
|
||||
set<U>(index: number, value: U): List<T|U>;
|
||||
delete(index: number): this;
|
||||
remove(index: number): this;
|
||||
insert<U>(index: number, value: U): List<T|U>;
|
||||
clear(): this;
|
||||
push<U>(...values: U[]): List<T|U>;
|
||||
pop(): this;
|
||||
unshift<U>(...values: U[]): List<T|U>;
|
||||
shift(): this;
|
||||
|
||||
update<U>(updater: (value: this) => List<U>): List<U>;
|
||||
update<U>(index: number, updater: (value: T) => U): List<T|U>;
|
||||
update<U>(index: number, notSetValue: U, updater: (value: T) => U): List<T|U>;
|
||||
|
||||
merge<U>(...iterables: ESIterable<U>[]): List<T|U>;
|
||||
|
||||
mergeWith<U,V>(
|
||||
merger: (previous: T, next: U, key: number) => V,
|
||||
...iterables: ESIterable<U>[]
|
||||
): List<T|U|V>;
|
||||
|
||||
mergeDeep<U>(...iterables: ESIterable<U>[]): List<T|U>;
|
||||
|
||||
mergeDeepWith<U,V>(
|
||||
merger: (previous: T, next: U, key: number) => V,
|
||||
...iterables: ESIterable<U>[]
|
||||
): List<T|U|V>;
|
||||
|
||||
setSize(size: number): List<?T>;
|
||||
setIn(keyPath: ESIterable<any>, value: any): List<T>;
|
||||
deleteIn(keyPath: ESIterable<any>, value: any): this;
|
||||
removeIn(keyPath: ESIterable<any>, value: any): this;
|
||||
|
||||
updateIn(keyPath: ESIterable<any>, notSetValue: any, value: any): List<T>;
|
||||
updateIn(keyPath: ESIterable<any>, value: any): List<T>;
|
||||
|
||||
mergeIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): List<T>;
|
||||
mergeDeepIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): List<T>;
|
||||
|
||||
withMutations(mutator: (mutable: this) => any): this;
|
||||
asMutable(): this;
|
||||
asImmutable(): this;
|
||||
|
||||
// Overrides that specialize return types
|
||||
map<M>(
|
||||
mapper: (value: T, index: number, iter: this) => M,
|
||||
context?: any
|
||||
): List<M>;
|
||||
|
||||
flatMap<M>(
|
||||
mapper: (value: T, index: number, iter: this) => ESIterable<M>,
|
||||
context?: any
|
||||
): List<M>;
|
||||
|
||||
flatten(depth?: number): /*this*/List<any>;
|
||||
flatten(shallow?: boolean): /*this*/List<any>;
|
||||
}
|
||||
|
||||
declare class Map<K,V> extends KeyedCollection<K,V> {
|
||||
static <K, V>(): Map<K, V>;
|
||||
static <V>(obj?: {[key: string]: V}): Map<string, V>;
|
||||
static <K, V>(iterable?: ESIterable<[K,V]>): Map<K, V>;
|
||||
|
||||
static isMap(maybeMap: any): boolean;
|
||||
|
||||
set<K_, V_>(key: K_, value: V_): Map<K|K_, V|V_>;
|
||||
delete(key: K): this;
|
||||
remove(key: K): this;
|
||||
clear(): this;
|
||||
|
||||
update<K_,V_>(updater: (value: this) => Map<K_,V_>): Map<K_,V_>;
|
||||
update<V_>(key: K, updater: (value: V) => V_): Map<K,V|V_>;
|
||||
update<V_>(key: K, notSetValue: V_, updater: (value: V) => V_): Map<K,V|V_>;
|
||||
|
||||
merge<K_,V_>(
|
||||
...iterables: (ESIterable<[K_,V_]> | { [key: K_]: V_ })[]
|
||||
): Map<K|K_,V|V_>;
|
||||
|
||||
mergeWith<K_,W,X>(
|
||||
merger: (previous: V, next: W, key: number) => X,
|
||||
...iterables: ESIterable<W>[]
|
||||
): Map<K,V|W|X>;
|
||||
|
||||
mergeDeep<K_,V_>(
|
||||
...iterables: (ESIterable<[K_,V_]> | { [key: K_]: V_ })[]
|
||||
): Map<K|K_,V|V_>;
|
||||
|
||||
mergeDeepWith<K_,W,X>(
|
||||
merger: (previous: V, next: W, key: number) => X,
|
||||
...iterables: ESIterable<W>[]
|
||||
): Map<K,V|W|X>;
|
||||
|
||||
setIn(keyPath: ESIterable<any>, value: any): Map<K,V>;
|
||||
deleteIn(keyPath: ESIterable<any>, value: any): this;
|
||||
removeIn(keyPath: ESIterable<any>, value: any): this;
|
||||
|
||||
updateIn(keyPath: ESIterable<any>, notSetValue: any, value: any): Map<K,V>;
|
||||
updateIn(keyPath: ESIterable<any>, value: any): Map<K,V>;
|
||||
|
||||
mergeIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): Map<K,V>;
|
||||
mergeDeepIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): Map<K,V>;
|
||||
|
||||
withMutations(mutator: (mutable: this) => any): this;
|
||||
asMutable(): this;
|
||||
asImmutable(): this;
|
||||
|
||||
// Overrides that specialize return types
|
||||
|
||||
map<V_>(
|
||||
mapper: (value: V, key: K, iter: this) => V_,
|
||||
context?: any
|
||||
): Map<K,V_>;
|
||||
|
||||
flatMap<K_,V_>(
|
||||
mapper: (value: V, key: K, iter: this) => ESIterable<[K_,V_]>,
|
||||
context?: any
|
||||
): Map<K_,V_>;
|
||||
|
||||
flip(): Map<V,K>;
|
||||
|
||||
mapKeys<K_>(
|
||||
mapper: (key: K, value: V, iter: this) => K_,
|
||||
context?: any
|
||||
): Map<K_,V>;
|
||||
|
||||
flatten(depth?: number): /*this*/Map<any,any>;
|
||||
flatten(shallow?: boolean): /*this*/Map<any,any>;
|
||||
}
|
||||
|
||||
// OrderedMaps have nothing that Maps do not have. We do not need to override constructor & other statics
|
||||
declare class OrderedMap<K,V> extends Map<K,V> {
|
||||
static isOrderedMap(maybeOrderedMap: any): bool;
|
||||
}
|
||||
|
||||
declare class Set<T> extends SetCollection<T> {
|
||||
static <T>(iterable?: ESIterable<T>): Set<T>;
|
||||
|
||||
static isSet(maybeSet: any): boolean;
|
||||
static of<T>(...values: T[]): Set<T>;
|
||||
static fromKeys<T>(iter: ESIterable<[T,any]>): Set<T>;
|
||||
static fromKeys(iter: { [key: string]: any }): Set<string>;
|
||||
|
||||
add<U>(value: U): Set<T|U>;
|
||||
delete(value: T): this;
|
||||
remove(value: T): this;
|
||||
clear(): this;
|
||||
union<U>(...iterables: ESIterable<U>[]): Set<T|U>;
|
||||
merge<U>(...iterables: ESIterable<U>[]): Set<T|U>;
|
||||
intersect<U>(...iterables: ESIterable<U>[]): Set<T&U>;
|
||||
subtract<U>(...iterables: ESIterable<U>[]): Set<T>;
|
||||
|
||||
withMutations(mutator: (mutable: this) => any): this;
|
||||
asMutable(): this;
|
||||
asImmutable(): this;
|
||||
|
||||
// Overrides that specialize return types
|
||||
|
||||
map<M>(
|
||||
mapper: (value: T, value: T, iter: this) => M,
|
||||
context?: any
|
||||
): Set<M>;
|
||||
|
||||
flatMap<M>(
|
||||
mapper: (value: T, value: T, iter: this) => ESIterable<M>,
|
||||
context?: any
|
||||
): Set<M>;
|
||||
|
||||
flatten(depth?: number): /*this*/Set<any>;
|
||||
flatten(shallow?: boolean): /*this*/Set<any>;
|
||||
}
|
||||
|
||||
// OrderedSets have nothing that Sets do not have. We do not need to override constructor & other statics
|
||||
declare class OrderedSet<T> extends Set<T> {
|
||||
static isOrderedSet(maybeOrderedSet: any): bool;
|
||||
}
|
||||
|
||||
declare class Stack<T> extends IndexedCollection<T> {
|
||||
static <T>(iterable?: ESIterable<T>): Stack<T>;
|
||||
|
||||
static isStack(maybeStack: any): boolean;
|
||||
static of<T>(...values: T[]): Stack<T>;
|
||||
|
||||
peek(): T;
|
||||
clear(): this;
|
||||
unshift<U>(...values: U[]): Stack<T|U>;
|
||||
unshiftAll<U>(iter: ESIterable<U>): Stack<T|U>;
|
||||
shift(): this;
|
||||
push<U>(...values: U[]): Stack<T|U>;
|
||||
pushAll<U>(iter: ESIterable<U>): Stack<T|U>;
|
||||
pop(): this;
|
||||
|
||||
withMutations(mutator: (mutable: this) => any): this;
|
||||
asMutable(): this;
|
||||
asImmutable(): this;
|
||||
|
||||
// Overrides that specialize return types
|
||||
|
||||
map<U>(
|
||||
mapper: (value: T, index: number, iter: this) => U,
|
||||
context?: any
|
||||
): Stack<U>;
|
||||
|
||||
flatMap<U>(
|
||||
mapper: (value: T, index: number, iter: this) => ESIterable<U>,
|
||||
context?: any
|
||||
): Stack<U>;
|
||||
|
||||
flatten(depth?: number): /*this*/Stack<any>;
|
||||
flatten(shallow?: boolean): /*this*/Stack<any>;
|
||||
}
|
||||
|
||||
declare function Range(start?: number, end?: number, step?: number): IndexedSeq<number>;
|
||||
declare function Repeat<T>(value: T, times?: number): IndexedSeq<T>;
|
||||
|
||||
//TODO: Once flow can extend normal Objects we can change this back to actually reflect Record behavior.
|
||||
// For now fallback to any to not break existing Code
|
||||
declare class Record<T: Object> {
|
||||
static <T: Object>(spec: T, name?: string): /*T & Record<T>*/any;
|
||||
get<A>(key: $Keys<T>): A;
|
||||
set<A>(key: $Keys<T>, value: A): /*T & Record<T>*/this;
|
||||
remove(key: $Keys<T>): /*T & Record<T>*/this;
|
||||
}
|
||||
|
||||
declare function fromJS(json: any, reviver?: (k: any, v: Iterable<any,any>) => any): any;
|
||||
declare function is(first: any, second: any): boolean;
|
||||
|
||||
export {
|
||||
Iterable,
|
||||
Collection,
|
||||
Seq,
|
||||
|
||||
// These classes do not actually exist under these names. But it is useful to
|
||||
// have the types available.
|
||||
KeyedIterable,
|
||||
IndexedIterable,
|
||||
SetIterable,
|
||||
KeyedCollection,
|
||||
IndexedCollection,
|
||||
SetCollection,
|
||||
KeyedSeq,
|
||||
IndexedSeq,
|
||||
SetSeq,
|
||||
|
||||
List,
|
||||
Map,
|
||||
OrderedMap,
|
||||
OrderedSet,
|
||||
Range,
|
||||
Repeat,
|
||||
Record,
|
||||
Set,
|
||||
Stack,
|
||||
|
||||
fromJS,
|
||||
is,
|
||||
}
|
||||
34
node_modules/immutable/dist/immutable.min.js
generated
vendored
Normal file
34
node_modules/immutable/dist/immutable.min.js
generated
vendored
Normal file
@ -0,0 +1,34 @@
|
||||
/**
|
||||
* Copyright (c) 2014-present, Facebook, Inc.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):t.Immutable=e()}(this,function(){"use strict";function t(t,e){e&&(t.prototype=Object.create(e.prototype)),t.prototype.constructor=t}function e(t){return o(t)?t:O(t)}function r(t){return u(t)?t:x(t)}function n(t){return s(t)?t:k(t)}function i(t){return o(t)&&!a(t)?t:A(t)}function o(t){return!(!t||!t[ar])}function u(t){return!(!t||!t[hr])}function s(t){return!(!t||!t[fr])}function a(t){return u(t)||s(t)}function h(t){return!(!t||!t[cr])}function f(t){return t.value=!1,t}function c(t){t&&(t.value=!0)}function _(){}function p(t,e){e=e||0;for(var r=Math.max(0,t.length-e),n=Array(r),i=0;r>i;i++)n[i]=t[i+e];return n}function v(t){return void 0===t.size&&(t.size=t.__iterate(y)),t.size}function l(t,e){if("number"!=typeof e){var r=e>>>0;if(""+r!==e||4294967295===r)return NaN;e=r}return 0>e?v(t)+e:e}function y(){return!0}function d(t,e,r){return(0===t||void 0!==r&&-r>=t)&&(void 0===e||void 0!==r&&e>=r)}function m(t,e){return w(t,e,0)}function g(t,e){return w(t,e,e)}function w(t,e,r){return void 0===t?r:0>t?Math.max(0,e+t):void 0===e?t:Math.min(e,t)}function S(t){this.next=t}function z(t,e,r,n){var i=0===t?e:1===t?r:[e,r];return n?n.value=i:n={value:i,done:!1},n}function I(){return{value:void 0,done:!0}}function b(t){return!!M(t)}function q(t){return t&&"function"==typeof t.next}function D(t){var e=M(t);return e&&e.call(t)}function M(t){var e=t&&(zr&&t[zr]||t[Ir]);return"function"==typeof e?e:void 0}function E(t){return t&&"number"==typeof t.length}function O(t){return null===t||void 0===t?T():o(t)?t.toSeq():C(t)}function x(t){return null===t||void 0===t?T().toKeyedSeq():o(t)?u(t)?t.toSeq():t.fromEntrySeq():B(t)}function k(t){return null===t||void 0===t?T():o(t)?u(t)?t.entrySeq():t.toIndexedSeq():W(t)}function A(t){return(null===t||void 0===t?T():o(t)?u(t)?t.entrySeq():t:W(t)).toSetSeq()}function j(t){this._array=t,this.size=t.length}function R(t){var e=Object.keys(t);this._object=t,this._keys=e,
|
||||
this.size=e.length}function U(t){this._iterable=t,this.size=t.length||t.size}function K(t){this._iterator=t,this._iteratorCache=[]}function L(t){return!(!t||!t[qr])}function T(){return Dr||(Dr=new j([]))}function B(t){var e=Array.isArray(t)?new j(t).fromEntrySeq():q(t)?new K(t).fromEntrySeq():b(t)?new U(t).fromEntrySeq():"object"==typeof t?new R(t):void 0;if(!e)throw new TypeError("Expected Array or iterable object of [k, v] entries, or keyed object: "+t);return e}function W(t){var e=J(t);if(!e)throw new TypeError("Expected Array or iterable object of values: "+t);return e}function C(t){var e=J(t)||"object"==typeof t&&new R(t);if(!e)throw new TypeError("Expected Array or iterable object of values, or keyed object: "+t);return e}function J(t){return E(t)?new j(t):q(t)?new K(t):b(t)?new U(t):void 0}function N(t,e,r,n){var i=t._cache;if(i){for(var o=i.length-1,u=0;o>=u;u++){var s=i[r?o-u:u];if(e(s[1],n?s[0]:u,t)===!1)return u+1}return u}return t.__iterateUncached(e,r)}function P(t,e,r,n){var i=t._cache;if(i){var o=i.length-1,u=0;return new S(function(){var t=i[r?o-u:u];return u++>o?I():z(e,n?t[0]:u-1,t[1])})}return t.__iteratorUncached(e,r)}function H(t,e){return e?V(e,t,"",{"":t}):Y(t)}function V(t,e,r,n){return Array.isArray(e)?t.call(n,r,k(e).map(function(r,n){return V(t,r,n,e)})):Q(e)?t.call(n,r,x(e).map(function(r,n){return V(t,r,n,e)})):e}function Y(t){return Array.isArray(t)?k(t).map(Y).toList():Q(t)?x(t).map(Y).toMap():t}function Q(t){return t&&(t.constructor===Object||void 0===t.constructor)}function X(t,e){if(t===e||t!==t&&e!==e)return!0;if(!t||!e)return!1;if("function"==typeof t.valueOf&&"function"==typeof e.valueOf){if(t=t.valueOf(),e=e.valueOf(),t===e||t!==t&&e!==e)return!0;if(!t||!e)return!1}return"function"==typeof t.equals&&"function"==typeof e.equals&&t.equals(e)?!0:!1}function F(t,e){if(t===e)return!0;if(!o(e)||void 0!==t.size&&void 0!==e.size&&t.size!==e.size||void 0!==t.__hash&&void 0!==e.__hash&&t.__hash!==e.__hash||u(t)!==u(e)||s(t)!==s(e)||h(t)!==h(e))return!1;if(0===t.size&&0===e.size)return!0;
|
||||
var r=!a(t);if(h(t)){var n=t.entries();return e.every(function(t,e){var i=n.next().value;return i&&X(i[1],t)&&(r||X(i[0],e))})&&n.next().done}var i=!1;if(void 0===t.size)if(void 0===e.size)"function"==typeof t.cacheResult&&t.cacheResult();else{i=!0;var f=t;t=e,e=f}var c=!0,_=e.__iterate(function(e,n){return(r?t.has(e):i?X(e,t.get(n,yr)):X(t.get(n,yr),e))?void 0:(c=!1,!1)});return c&&t.size===_}function G(t,e){if(!(this instanceof G))return new G(t,e);if(this._value=t,this.size=void 0===e?1/0:Math.max(0,e),0===this.size){if(Mr)return Mr;Mr=this}}function Z(t,e){if(!t)throw Error(e)}function $(t,e,r){if(!(this instanceof $))return new $(t,e,r);if(Z(0!==r,"Cannot step a Range by 0"),t=t||0,void 0===e&&(e=1/0),r=void 0===r?1:Math.abs(r),t>e&&(r=-r),this._start=t,this._end=e,this._step=r,this.size=Math.max(0,Math.ceil((e-t)/r-1)+1),0===this.size){if(Er)return Er;Er=this}}function tt(){throw TypeError("Abstract")}function et(){}function rt(){}function nt(){}function it(t){return t>>>1&1073741824|3221225471&t}function ot(t){if(t===!1||null===t||void 0===t)return 0;if("function"==typeof t.valueOf&&(t=t.valueOf(),t===!1||null===t||void 0===t))return 0;if(t===!0)return 1;var e=typeof t;if("number"===e){if(t!==t||t===1/0)return 0;var r=0|t;for(r!==t&&(r^=4294967295*t);t>4294967295;)t/=4294967295,r^=t;return it(r)}if("string"===e)return t.length>Kr?ut(t):st(t);if("function"==typeof t.hashCode)return t.hashCode();if("object"===e)return at(t);if("function"==typeof t.toString)return st(""+t);throw Error("Value type "+e+" cannot be hashed.")}function ut(t){var e=Br[t];return void 0===e&&(e=st(t),Tr===Lr&&(Tr=0,Br={}),Tr++,Br[t]=e),e}function st(t){for(var e=0,r=0;t.length>r;r++)e=31*e+t.charCodeAt(r)|0;return it(e)}function at(t){var e;if(jr&&(e=Or.get(t),void 0!==e))return e;if(e=t[Ur],void 0!==e)return e;if(!Ar){if(e=t.propertyIsEnumerable&&t.propertyIsEnumerable[Ur],void 0!==e)return e;if(e=ht(t),void 0!==e)return e}if(e=++Rr,1073741824&Rr&&(Rr=0),jr)Or.set(t,e);else{if(void 0!==kr&&kr(t)===!1)throw Error("Non-extensible objects are not allowed as keys.");
|
||||
if(Ar)Object.defineProperty(t,Ur,{enumerable:!1,configurable:!1,writable:!1,value:e});else if(void 0!==t.propertyIsEnumerable&&t.propertyIsEnumerable===t.constructor.prototype.propertyIsEnumerable)t.propertyIsEnumerable=function(){return this.constructor.prototype.propertyIsEnumerable.apply(this,arguments)},t.propertyIsEnumerable[Ur]=e;else{if(void 0===t.nodeType)throw Error("Unable to set a non-enumerable property on object.");t[Ur]=e}}return e}function ht(t){if(t&&t.nodeType>0)switch(t.nodeType){case 1:return t.uniqueID;case 9:return t.documentElement&&t.documentElement.uniqueID}}function ft(t){Z(t!==1/0,"Cannot perform this action with an infinite size.")}function ct(t){return null===t||void 0===t?zt():_t(t)&&!h(t)?t:zt().withMutations(function(e){var n=r(t);ft(n.size),n.forEach(function(t,r){return e.set(r,t)})})}function _t(t){return!(!t||!t[Wr])}function pt(t,e){this.ownerID=t,this.entries=e}function vt(t,e,r){this.ownerID=t,this.bitmap=e,this.nodes=r}function lt(t,e,r){this.ownerID=t,this.count=e,this.nodes=r}function yt(t,e,r){this.ownerID=t,this.keyHash=e,this.entries=r}function dt(t,e,r){this.ownerID=t,this.keyHash=e,this.entry=r}function mt(t,e,r){this._type=e,this._reverse=r,this._stack=t._root&&wt(t._root)}function gt(t,e){return z(t,e[0],e[1])}function wt(t,e){return{node:t,index:0,__prev:e}}function St(t,e,r,n){var i=Object.create(Cr);return i.size=t,i._root=e,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function zt(){return Jr||(Jr=St(0))}function It(t,e,r){var n,i;if(t._root){var o=f(dr),u=f(mr);if(n=bt(t._root,t.__ownerID,0,void 0,e,r,o,u),!u.value)return t;i=t.size+(o.value?r===yr?-1:1:0)}else{if(r===yr)return t;i=1,n=new pt(t.__ownerID,[[e,r]])}return t.__ownerID?(t.size=i,t._root=n,t.__hash=void 0,t.__altered=!0,t):n?St(i,n):zt()}function bt(t,e,r,n,i,o,u,s){return t?t.update(e,r,n,i,o,u,s):o===yr?t:(c(s),c(u),new dt(e,n,[i,o]))}function qt(t){return t.constructor===dt||t.constructor===yt}function Dt(t,e,r,n,i){if(t.keyHash===n)return new yt(e,n,[t.entry,i]);var o,u=(0===r?t.keyHash:t.keyHash>>>r)&lr,s=(0===r?n:n>>>r)&lr,a=u===s?[Dt(t,e,r+pr,n,i)]:(o=new dt(e,n,i),
|
||||
s>u?[t,o]:[o,t]);return new vt(e,1<<u|1<<s,a)}function Mt(t,e,r,n){t||(t=new _);for(var i=new dt(t,ot(r),[r,n]),o=0;e.length>o;o++){var u=e[o];i=i.update(t,0,void 0,u[0],u[1])}return i}function Et(t,e,r,n){for(var i=0,o=0,u=Array(r),s=0,a=1,h=e.length;h>s;s++,a<<=1){var f=e[s];void 0!==f&&s!==n&&(i|=a,u[o++]=f)}return new vt(t,i,u)}function Ot(t,e,r,n,i){for(var o=0,u=Array(vr),s=0;0!==r;s++,r>>>=1)u[s]=1&r?e[o++]:void 0;return u[n]=i,new lt(t,o+1,u)}function xt(t,e,n){for(var i=[],u=0;n.length>u;u++){var s=n[u],a=r(s);o(s)||(a=a.map(function(t){return H(t)})),i.push(a)}return jt(t,e,i)}function kt(t,e,r){return t&&t.mergeDeep&&o(e)?t.mergeDeep(e):X(t,e)?t:e}function At(t){return function(e,r,n){if(e&&e.mergeDeepWith&&o(r))return e.mergeDeepWith(t,r);var i=t(e,r,n);return X(e,i)?e:i}}function jt(t,e,r){return r=r.filter(function(t){return 0!==t.size}),0===r.length?t:0!==t.size||t.__ownerID||1!==r.length?t.withMutations(function(t){for(var n=e?function(r,n){t.update(n,yr,function(t){return t===yr?r:e(t,r,n)})}:function(e,r){t.set(r,e)},i=0;r.length>i;i++)r[i].forEach(n)}):t.constructor(r[0])}function Rt(t,e,r,n){var i=t===yr,o=e.next();if(o.done){var u=i?r:t,s=n(u);return s===u?t:s}Z(i||t&&t.set,"invalid keyPath");var a=o.value,h=i?yr:t.get(a,yr),f=Rt(h,e,r,n);return f===h?t:f===yr?t.remove(a):(i?zt():t).set(a,f)}function Ut(t){return t-=t>>1&1431655765,t=(858993459&t)+(t>>2&858993459),t=t+(t>>4)&252645135,t+=t>>8,t+=t>>16,127&t}function Kt(t,e,r,n){var i=n?t:p(t);return i[e]=r,i}function Lt(t,e,r,n){var i=t.length+1;if(n&&e+1===i)return t[e]=r,t;for(var o=Array(i),u=0,s=0;i>s;s++)s===e?(o[s]=r,u=-1):o[s]=t[s+u];return o}function Tt(t,e,r){var n=t.length-1;if(r&&e===n)return t.pop(),t;for(var i=Array(n),o=0,u=0;n>u;u++)u===e&&(o=1),i[u]=t[u+o];return i}function Bt(t){var e=Pt();if(null===t||void 0===t)return e;if(Wt(t))return t;var r=n(t),i=r.size;return 0===i?e:(ft(i),i>0&&vr>i?Nt(0,i,pr,null,new Ct(r.toArray())):e.withMutations(function(t){t.setSize(i),r.forEach(function(e,r){return t.set(r,e)})}))}function Wt(t){
|
||||
return!(!t||!t[Vr])}function Ct(t,e){this.array=t,this.ownerID=e}function Jt(t,e){function r(t,e,r){return 0===e?n(t,r):i(t,e,r)}function n(t,r){var n=r===s?a&&a.array:t&&t.array,i=r>o?0:o-r,h=u-r;return h>vr&&(h=vr),function(){if(i===h)return Xr;var t=e?--h:i++;return n&&n[t]}}function i(t,n,i){var s,a=t&&t.array,h=i>o?0:o-i>>n,f=(u-i>>n)+1;return f>vr&&(f=vr),function(){for(;;){if(s){var t=s();if(t!==Xr)return t;s=null}if(h===f)return Xr;var o=e?--f:h++;s=r(a&&a[o],n-pr,i+(o<<n))}}}var o=t._origin,u=t._capacity,s=Gt(u),a=t._tail;return r(t._root,t._level,0)}function Nt(t,e,r,n,i,o,u){var s=Object.create(Yr);return s.size=e-t,s._origin=t,s._capacity=e,s._level=r,s._root=n,s._tail=i,s.__ownerID=o,s.__hash=u,s.__altered=!1,s}function Pt(){return Qr||(Qr=Nt(0,0,pr))}function Ht(t,e,r){if(e=l(t,e),e!==e)return t;if(e>=t.size||0>e)return t.withMutations(function(t){0>e?Xt(t,e).set(0,r):Xt(t,0,e+1).set(e,r)});e+=t._origin;var n=t._tail,i=t._root,o=f(mr);return e>=Gt(t._capacity)?n=Vt(n,t.__ownerID,0,e,r,o):i=Vt(i,t.__ownerID,t._level,e,r,o),o.value?t.__ownerID?(t._root=i,t._tail=n,t.__hash=void 0,t.__altered=!0,t):Nt(t._origin,t._capacity,t._level,i,n):t}function Vt(t,e,r,n,i,o){var u=n>>>r&lr,s=t&&t.array.length>u;if(!s&&void 0===i)return t;var a;if(r>0){var h=t&&t.array[u],f=Vt(h,e,r-pr,n,i,o);return f===h?t:(a=Yt(t,e),a.array[u]=f,a)}return s&&t.array[u]===i?t:(c(o),a=Yt(t,e),void 0===i&&u===a.array.length-1?a.array.pop():a.array[u]=i,a)}function Yt(t,e){return e&&t&&e===t.ownerID?t:new Ct(t?t.array.slice():[],e)}function Qt(t,e){if(e>=Gt(t._capacity))return t._tail;if(1<<t._level+pr>e){for(var r=t._root,n=t._level;r&&n>0;)r=r.array[e>>>n&lr],n-=pr;return r}}function Xt(t,e,r){void 0!==e&&(e=0|e),void 0!==r&&(r=0|r);var n=t.__ownerID||new _,i=t._origin,o=t._capacity,u=i+e,s=void 0===r?o:0>r?o+r:i+r;if(u===i&&s===o)return t;if(u>=s)return t.clear();for(var a=t._level,h=t._root,f=0;0>u+f;)h=new Ct(h&&h.array.length?[void 0,h]:[],n),a+=pr,f+=1<<a;f&&(u+=f,i+=f,s+=f,o+=f);for(var c=Gt(o),p=Gt(s);p>=1<<a+pr;)h=new Ct(h&&h.array.length?[h]:[],n),
|
||||
a+=pr;var v=t._tail,l=c>p?Qt(t,s-1):p>c?new Ct([],n):v;if(v&&p>c&&o>u&&v.array.length){h=Yt(h,n);for(var y=h,d=a;d>pr;d-=pr){var m=c>>>d&lr;y=y.array[m]=Yt(y.array[m],n)}y.array[c>>>pr&lr]=v}if(o>s&&(l=l&&l.removeAfter(n,0,s)),u>=p)u-=p,s-=p,a=pr,h=null,l=l&&l.removeBefore(n,0,u);else if(u>i||c>p){for(f=0;h;){var g=u>>>a&lr;if(g!==p>>>a&lr)break;g&&(f+=(1<<a)*g),a-=pr,h=h.array[g]}h&&u>i&&(h=h.removeBefore(n,a,u-f)),h&&c>p&&(h=h.removeAfter(n,a,p-f)),f&&(u-=f,s-=f)}return t.__ownerID?(t.size=s-u,t._origin=u,t._capacity=s,t._level=a,t._root=h,t._tail=l,t.__hash=void 0,t.__altered=!0,t):Nt(u,s,a,h,l)}function Ft(t,e,r){for(var i=[],u=0,s=0;r.length>s;s++){var a=r[s],h=n(a);h.size>u&&(u=h.size),o(a)||(h=h.map(function(t){return H(t)})),i.push(h)}return u>t.size&&(t=t.setSize(u)),jt(t,e,i)}function Gt(t){return vr>t?0:t-1>>>pr<<pr}function Zt(t){return null===t||void 0===t?ee():$t(t)?t:ee().withMutations(function(e){var n=r(t);ft(n.size),n.forEach(function(t,r){return e.set(r,t)})})}function $t(t){return _t(t)&&h(t)}function te(t,e,r,n){var i=Object.create(Zt.prototype);return i.size=t?t.size:0,i._map=t,i._list=e,i.__ownerID=r,i.__hash=n,i}function ee(){return Fr||(Fr=te(zt(),Pt()))}function re(t,e,r){var n,i,o=t._map,u=t._list,s=o.get(e),a=void 0!==s;if(r===yr){if(!a)return t;u.size>=vr&&u.size>=2*o.size?(i=u.filter(function(t,e){return void 0!==t&&s!==e}),n=i.toKeyedSeq().map(function(t){return t[0]}).flip().toMap(),t.__ownerID&&(n.__ownerID=i.__ownerID=t.__ownerID)):(n=o.remove(e),i=s===u.size-1?u.pop():u.set(s,void 0))}else if(a){if(r===u.get(s)[1])return t;n=o,i=u.set(s,[e,r])}else n=o.set(e,u.size),i=u.set(u.size,[e,r]);return t.__ownerID?(t.size=n.size,t._map=n,t._list=i,t.__hash=void 0,t):te(n,i)}function ne(t,e){this._iter=t,this._useKeys=e,this.size=t.size}function ie(t){this._iter=t,this.size=t.size}function oe(t){this._iter=t,this.size=t.size}function ue(t){this._iter=t,this.size=t.size}function se(t){var e=Ee(t);return e._iter=t,e.size=t.size,e.flip=function(){return t},e.reverse=function(){var e=t.reverse.apply(this);
|
||||
return e.flip=function(){return t.reverse()},e},e.has=function(e){return t.includes(e)},e.includes=function(e){return t.has(e)},e.cacheResult=Oe,e.__iterateUncached=function(e,r){var n=this;return t.__iterate(function(t,r){return e(r,t,n)!==!1},r)},e.__iteratorUncached=function(e,r){if(e===Sr){var n=t.__iterator(e,r);return new S(function(){var t=n.next();if(!t.done){var e=t.value[0];t.value[0]=t.value[1],t.value[1]=e}return t})}return t.__iterator(e===wr?gr:wr,r)},e}function ae(t,e,r){var n=Ee(t);return n.size=t.size,n.has=function(e){return t.has(e)},n.get=function(n,i){var o=t.get(n,yr);return o===yr?i:e.call(r,o,n,t)},n.__iterateUncached=function(n,i){var o=this;return t.__iterate(function(t,i,u){return n(e.call(r,t,i,u),i,o)!==!1},i)},n.__iteratorUncached=function(n,i){var o=t.__iterator(Sr,i);return new S(function(){var i=o.next();if(i.done)return i;var u=i.value,s=u[0];return z(n,s,e.call(r,u[1],s,t),i)})},n}function he(t,e){var r=Ee(t);return r._iter=t,r.size=t.size,r.reverse=function(){return t},t.flip&&(r.flip=function(){var e=se(t);return e.reverse=function(){return t.flip()},e}),r.get=function(r,n){return t.get(e?r:-1-r,n)},r.has=function(r){return t.has(e?r:-1-r)},r.includes=function(e){return t.includes(e)},r.cacheResult=Oe,r.__iterate=function(e,r){var n=this;return t.__iterate(function(t,r){return e(t,r,n)},!r)},r.__iterator=function(e,r){return t.__iterator(e,!r)},r}function fe(t,e,r,n){var i=Ee(t);return n&&(i.has=function(n){var i=t.get(n,yr);return i!==yr&&!!e.call(r,i,n,t)},i.get=function(n,i){var o=t.get(n,yr);return o!==yr&&e.call(r,o,n,t)?o:i}),i.__iterateUncached=function(i,o){var u=this,s=0;return t.__iterate(function(t,o,a){return e.call(r,t,o,a)?(s++,i(t,n?o:s-1,u)):void 0},o),s},i.__iteratorUncached=function(i,o){var u=t.__iterator(Sr,o),s=0;return new S(function(){for(;;){var o=u.next();if(o.done)return o;var a=o.value,h=a[0],f=a[1];if(e.call(r,f,h,t))return z(i,n?h:s++,f,o)}})},i}function ce(t,e,r){var n=ct().asMutable();return t.__iterate(function(i,o){n.update(e.call(r,i,o,t),0,function(t){
|
||||
return t+1})}),n.asImmutable()}function _e(t,e,r){var n=u(t),i=(h(t)?Zt():ct()).asMutable();t.__iterate(function(o,u){i.update(e.call(r,o,u,t),function(t){return t=t||[],t.push(n?[u,o]:o),t})});var o=Me(t);return i.map(function(e){return be(t,o(e))})}function pe(t,e,r,n){var i=t.size;if(void 0!==e&&(e=0|e),void 0!==r&&(r=r===1/0?i:0|r),d(e,r,i))return t;var o=m(e,i),u=g(r,i);if(o!==o||u!==u)return pe(t.toSeq().cacheResult(),e,r,n);var s,a=u-o;a===a&&(s=0>a?0:a);var h=Ee(t);return h.size=0===s?s:t.size&&s||void 0,!n&&L(t)&&s>=0&&(h.get=function(e,r){return e=l(this,e),e>=0&&s>e?t.get(e+o,r):r}),h.__iterateUncached=function(e,r){var i=this;if(0===s)return 0;if(r)return this.cacheResult().__iterate(e,r);var u=0,a=!0,h=0;return t.__iterate(function(t,r){return a&&(a=u++<o)?void 0:(h++,e(t,n?r:h-1,i)!==!1&&h!==s)}),h},h.__iteratorUncached=function(e,r){if(0!==s&&r)return this.cacheResult().__iterator(e,r);var i=0!==s&&t.__iterator(e,r),u=0,a=0;return new S(function(){for(;u++<o;)i.next();if(++a>s)return I();var t=i.next();return n||e===wr?t:e===gr?z(e,a-1,void 0,t):z(e,a-1,t.value[1],t)})},h}function ve(t,e,r){var n=Ee(t);return n.__iterateUncached=function(n,i){var o=this;if(i)return this.cacheResult().__iterate(n,i);var u=0;return t.__iterate(function(t,i,s){return e.call(r,t,i,s)&&++u&&n(t,i,o)}),u},n.__iteratorUncached=function(n,i){var o=this;if(i)return this.cacheResult().__iterator(n,i);var u=t.__iterator(Sr,i),s=!0;return new S(function(){if(!s)return I();var t=u.next();if(t.done)return t;var i=t.value,a=i[0],h=i[1];return e.call(r,h,a,o)?n===Sr?t:z(n,a,h,t):(s=!1,I())})},n}function le(t,e,r,n){var i=Ee(t);return i.__iterateUncached=function(i,o){var u=this;if(o)return this.cacheResult().__iterate(i,o);var s=!0,a=0;return t.__iterate(function(t,o,h){return s&&(s=e.call(r,t,o,h))?void 0:(a++,i(t,n?o:a-1,u))}),a},i.__iteratorUncached=function(i,o){var u=this;if(o)return this.cacheResult().__iterator(i,o);var s=t.__iterator(Sr,o),a=!0,h=0;return new S(function(){var t,o,f;do{if(t=s.next(),t.done)return n||i===wr?t:i===gr?z(i,h++,void 0,t):z(i,h++,t.value[1],t);
|
||||
var c=t.value;o=c[0],f=c[1],a&&(a=e.call(r,f,o,u))}while(a);return i===Sr?t:z(i,o,f,t)})},i}function ye(t,e){var n=u(t),i=[t].concat(e).map(function(t){return o(t)?n&&(t=r(t)):t=n?B(t):W(Array.isArray(t)?t:[t]),t}).filter(function(t){return 0!==t.size});if(0===i.length)return t;if(1===i.length){var a=i[0];if(a===t||n&&u(a)||s(t)&&s(a))return a}var h=new j(i);return n?h=h.toKeyedSeq():s(t)||(h=h.toSetSeq()),h=h.flatten(!0),h.size=i.reduce(function(t,e){if(void 0!==t){var r=e.size;if(void 0!==r)return t+r}},0),h}function de(t,e,r){var n=Ee(t);return n.__iterateUncached=function(n,i){function u(t,h){var f=this;t.__iterate(function(t,i){return(!e||e>h)&&o(t)?u(t,h+1):n(t,r?i:s++,f)===!1&&(a=!0),!a},i)}var s=0,a=!1;return u(t,0),s},n.__iteratorUncached=function(n,i){var u=t.__iterator(n,i),s=[],a=0;return new S(function(){for(;u;){var t=u.next();if(t.done===!1){var h=t.value;if(n===Sr&&(h=h[1]),e&&!(e>s.length)||!o(h))return r?t:z(n,a++,h,t);s.push(u),u=h.__iterator(n,i)}else u=s.pop()}return I()})},n}function me(t,e,r){var n=Me(t);return t.toSeq().map(function(i,o){return n(e.call(r,i,o,t))}).flatten(!0)}function ge(t,e){var r=Ee(t);return r.size=t.size&&2*t.size-1,r.__iterateUncached=function(r,n){var i=this,o=0;return t.__iterate(function(t,n){return(!o||r(e,o++,i)!==!1)&&r(t,o++,i)!==!1},n),o},r.__iteratorUncached=function(r,n){var i,o=t.__iterator(wr,n),u=0;return new S(function(){return(!i||u%2)&&(i=o.next(),i.done)?i:u%2?z(r,u++,e):z(r,u++,i.value,i)})},r}function we(t,e,r){e||(e=xe);var n=u(t),i=0,o=t.toSeq().map(function(e,n){return[n,e,i++,r?r(e,n,t):e]}).toArray();return o.sort(function(t,r){return e(t[3],r[3])||t[2]-r[2]}).forEach(n?function(t,e){o[e].length=2}:function(t,e){o[e]=t[1]}),n?x(o):s(t)?k(o):A(o)}function Se(t,e,r){if(e||(e=xe),r){var n=t.toSeq().map(function(e,n){return[e,r(e,n,t)]}).reduce(function(t,r){return ze(e,t[1],r[1])?r:t});return n&&n[0]}return t.reduce(function(t,r){return ze(e,t,r)?r:t})}function ze(t,e,r){var n=t(r,e);return 0===n&&r!==e&&(void 0===r||null===r||r!==r)||n>0}function Ie(t,r,n){
|
||||
var i=Ee(t);return i.size=new j(n).map(function(t){return t.size}).min(),i.__iterate=function(t,e){for(var r,n=this.__iterator(wr,e),i=0;!(r=n.next()).done&&t(r.value,i++,this)!==!1;);return i},i.__iteratorUncached=function(t,i){var o=n.map(function(t){return t=e(t),D(i?t.reverse():t)}),u=0,s=!1;return new S(function(){var e;return s||(e=o.map(function(t){return t.next()}),s=e.some(function(t){return t.done})),s?I():z(t,u++,r.apply(null,e.map(function(t){return t.value})))})},i}function be(t,e){return L(t)?e:t.constructor(e)}function qe(t){if(t!==Object(t))throw new TypeError("Expected [K, V] tuple: "+t)}function De(t){return ft(t.size),v(t)}function Me(t){return u(t)?r:s(t)?n:i}function Ee(t){return Object.create((u(t)?x:s(t)?k:A).prototype)}function Oe(){return this._iter.cacheResult?(this._iter.cacheResult(),this.size=this._iter.size,this):O.prototype.cacheResult.call(this)}function xe(t,e){return t>e?1:e>t?-1:0}function ke(t){var r=D(t);if(!r){if(!E(t))throw new TypeError("Expected iterable or array-like: "+t);r=D(e(t))}return r}function Ae(t,e){var r,n=function(o){if(o instanceof n)return o;if(!(this instanceof n))return new n(o);if(!r){r=!0;var u=Object.keys(t);Ue(i,u),i.size=u.length,i._name=e,i._keys=u,i._defaultValues=t}this._map=ct(o)},i=n.prototype=Object.create(Gr);return i.constructor=n,n}function je(t,e,r){var n=Object.create(Object.getPrototypeOf(t));return n._map=e,n.__ownerID=r,n}function Re(t){return t._name||t.constructor.name||"Record"}function Ue(t,e){try{e.forEach(Ke.bind(void 0,t))}catch(r){}}function Ke(t,e){Object.defineProperty(t,e,{get:function(){return this.get(e)},set:function(t){Z(this.__ownerID,"Cannot set on an immutable record."),this.set(e,t)}})}function Le(t){return null===t||void 0===t?Ce():Te(t)&&!h(t)?t:Ce().withMutations(function(e){var r=i(t);ft(r.size),r.forEach(function(t){return e.add(t)})})}function Te(t){return!(!t||!t[Zr])}function Be(t,e){return t.__ownerID?(t.size=e.size,t._map=e,t):e===t._map?t:0===e.size?t.__empty():t.__make(e)}function We(t,e){var r=Object.create($r);
|
||||
return r.size=t?t.size:0,r._map=t,r.__ownerID=e,r}function Ce(){return tn||(tn=We(zt()))}function Je(t){return null===t||void 0===t?He():Ne(t)?t:He().withMutations(function(e){var r=i(t);ft(r.size),r.forEach(function(t){return e.add(t)})})}function Ne(t){return Te(t)&&h(t)}function Pe(t,e){var r=Object.create(en);return r.size=t?t.size:0,r._map=t,r.__ownerID=e,r}function He(){return rn||(rn=Pe(ee()))}function Ve(t){return null===t||void 0===t?Xe():Ye(t)?t:Xe().unshiftAll(t)}function Ye(t){return!(!t||!t[nn])}function Qe(t,e,r,n){var i=Object.create(on);return i.size=t,i._head=e,i.__ownerID=r,i.__hash=n,i.__altered=!1,i}function Xe(){return un||(un=Qe(0))}function Fe(t,e){var r=function(r){t.prototype[r]=e[r]};return Object.keys(e).forEach(r),Object.getOwnPropertySymbols&&Object.getOwnPropertySymbols(e).forEach(r),t}function Ge(t,e){return e}function Ze(t,e){return[e,t]}function $e(t){return function(){return!t.apply(this,arguments)}}function tr(t){return function(){return-t.apply(this,arguments)}}function er(t){return"string"==typeof t?JSON.stringify(t):t+""}function rr(){return p(arguments)}function nr(t,e){return e>t?1:t>e?-1:0}function ir(t){if(t.size===1/0)return 0;var e=h(t),r=u(t),n=e?1:0,i=t.__iterate(r?e?function(t,e){n=31*n+ur(ot(t),ot(e))|0}:function(t,e){n=n+ur(ot(t),ot(e))|0}:e?function(t){n=31*n+ot(t)|0}:function(t){n=n+ot(t)|0});return or(i,n)}function or(t,e){return e=xr(e,3432918353),e=xr(e<<15|e>>>-15,461845907),e=xr(e<<13|e>>>-13,5),e=(e+3864292196|0)^t,e=xr(e^e>>>16,2246822507),e=xr(e^e>>>13,3266489909),e=it(e^e>>>16)}function ur(t,e){return t^e+2654435769+(t<<6)+(t>>2)|0}var sr=Array.prototype.slice;t(r,e),t(n,e),t(i,e),e.isIterable=o,e.isKeyed=u,e.isIndexed=s,e.isAssociative=a,e.isOrdered=h,e.Keyed=r,e.Indexed=n,e.Set=i;var ar="@@__IMMUTABLE_ITERABLE__@@",hr="@@__IMMUTABLE_KEYED__@@",fr="@@__IMMUTABLE_INDEXED__@@",cr="@@__IMMUTABLE_ORDERED__@@",_r="delete",pr=5,vr=1<<pr,lr=vr-1,yr={},dr={value:!1},mr={value:!1},gr=0,wr=1,Sr=2,zr="function"==typeof Symbol&&Symbol.iterator,Ir="@@iterator",br=zr||Ir;
|
||||
S.prototype.toString=function(){return"[Iterator]"},S.KEYS=gr,S.VALUES=wr,S.ENTRIES=Sr,S.prototype.inspect=S.prototype.toSource=function(){return""+this},S.prototype[br]=function(){return this},t(O,e),O.of=function(){return O(arguments)},O.prototype.toSeq=function(){return this},O.prototype.toString=function(){return this.__toString("Seq {","}")},O.prototype.cacheResult=function(){return!this._cache&&this.__iterateUncached&&(this._cache=this.entrySeq().toArray(),this.size=this._cache.length),this},O.prototype.__iterate=function(t,e){return N(this,t,e,!0)},O.prototype.__iterator=function(t,e){return P(this,t,e,!0)},t(x,O),x.prototype.toKeyedSeq=function(){return this},t(k,O),k.of=function(){return k(arguments)},k.prototype.toIndexedSeq=function(){return this},k.prototype.toString=function(){return this.__toString("Seq [","]")},k.prototype.__iterate=function(t,e){return N(this,t,e,!1)},k.prototype.__iterator=function(t,e){return P(this,t,e,!1)},t(A,O),A.of=function(){return A(arguments)},A.prototype.toSetSeq=function(){return this},O.isSeq=L,O.Keyed=x,O.Set=A,O.Indexed=k;var qr="@@__IMMUTABLE_SEQ__@@";O.prototype[qr]=!0,t(j,k),j.prototype.get=function(t,e){return this.has(t)?this._array[l(this,t)]:e},j.prototype.__iterate=function(t,e){for(var r=this._array,n=r.length-1,i=0;n>=i;i++)if(t(r[e?n-i:i],i,this)===!1)return i+1;return i},j.prototype.__iterator=function(t,e){var r=this._array,n=r.length-1,i=0;return new S(function(){return i>n?I():z(t,i,r[e?n-i++:i++])})},t(R,x),R.prototype.get=function(t,e){return void 0===e||this.has(t)?this._object[t]:e},R.prototype.has=function(t){return this._object.hasOwnProperty(t)},R.prototype.__iterate=function(t,e){for(var r=this._object,n=this._keys,i=n.length-1,o=0;i>=o;o++){var u=n[e?i-o:o];if(t(r[u],u,this)===!1)return o+1}return o},R.prototype.__iterator=function(t,e){var r=this._object,n=this._keys,i=n.length-1,o=0;return new S(function(){var u=n[e?i-o:o];return o++>i?I():z(t,u,r[u])})},R.prototype[cr]=!0,t(U,k),U.prototype.__iterateUncached=function(t,e){if(e)return this.cacheResult().__iterate(t,e);
|
||||
var r=this._iterable,n=D(r),i=0;if(q(n))for(var o;!(o=n.next()).done&&t(o.value,i++,this)!==!1;);return i},U.prototype.__iteratorUncached=function(t,e){if(e)return this.cacheResult().__iterator(t,e);var r=this._iterable,n=D(r);if(!q(n))return new S(I);var i=0;return new S(function(){var e=n.next();return e.done?e:z(t,i++,e.value)})},t(K,k),K.prototype.__iterateUncached=function(t,e){if(e)return this.cacheResult().__iterate(t,e);for(var r=this._iterator,n=this._iteratorCache,i=0;n.length>i;)if(t(n[i],i++,this)===!1)return i;for(var o;!(o=r.next()).done;){var u=o.value;if(n[i]=u,t(u,i++,this)===!1)break}return i},K.prototype.__iteratorUncached=function(t,e){if(e)return this.cacheResult().__iterator(t,e);var r=this._iterator,n=this._iteratorCache,i=0;return new S(function(){if(i>=n.length){var e=r.next();if(e.done)return e;n[i]=e.value}return z(t,i,n[i++])})};var Dr;t(G,k),G.prototype.toString=function(){return 0===this.size?"Repeat []":"Repeat [ "+this._value+" "+this.size+" times ]"},G.prototype.get=function(t,e){return this.has(t)?this._value:e},G.prototype.includes=function(t){return X(this._value,t)},G.prototype.slice=function(t,e){var r=this.size;return d(t,e,r)?this:new G(this._value,g(e,r)-m(t,r))},G.prototype.reverse=function(){return this},G.prototype.indexOf=function(t){return X(this._value,t)?0:-1},G.prototype.lastIndexOf=function(t){return X(this._value,t)?this.size:-1},G.prototype.__iterate=function(t,e){for(var r=0;this.size>r;r++)if(t(this._value,r,this)===!1)return r+1;return r},G.prototype.__iterator=function(t,e){var r=this,n=0;return new S(function(){return r.size>n?z(t,n++,r._value):I()})},G.prototype.equals=function(t){return t instanceof G?X(this._value,t._value):F(t)};var Mr;t($,k),$.prototype.toString=function(){return 0===this.size?"Range []":"Range [ "+this._start+"..."+this._end+(1!==this._step?" by "+this._step:"")+" ]"},$.prototype.get=function(t,e){return this.has(t)?this._start+l(this,t)*this._step:e},$.prototype.includes=function(t){var e=(t-this._start)/this._step;return e>=0&&this.size>e&&e===Math.floor(e);
|
||||
},$.prototype.slice=function(t,e){return d(t,e,this.size)?this:(t=m(t,this.size),e=g(e,this.size),t>=e?new $(0,0):new $(this.get(t,this._end),this.get(e,this._end),this._step))},$.prototype.indexOf=function(t){var e=t-this._start;if(e%this._step===0){var r=e/this._step;if(r>=0&&this.size>r)return r}return-1},$.prototype.lastIndexOf=function(t){return this.indexOf(t)},$.prototype.__iterate=function(t,e){for(var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,o=0;r>=o;o++){if(t(i,o,this)===!1)return o+1;i+=e?-n:n}return o},$.prototype.__iterator=function(t,e){var r=this.size-1,n=this._step,i=e?this._start+r*n:this._start,o=0;return new S(function(){var u=i;return i+=e?-n:n,o>r?I():z(t,o++,u)})},$.prototype.equals=function(t){return t instanceof $?this._start===t._start&&this._end===t._end&&this._step===t._step:F(this,t)};var Er;t(tt,e),t(et,tt),t(rt,tt),t(nt,tt),tt.Keyed=et,tt.Indexed=rt,tt.Set=nt;var Or,xr="function"==typeof Math.imul&&-2===Math.imul(4294967295,2)?Math.imul:function(t,e){t=0|t,e=0|e;var r=65535&t,n=65535&e;return r*n+((t>>>16)*n+r*(e>>>16)<<16>>>0)|0},kr=Object.isExtensible,Ar=function(){try{return Object.defineProperty({},"@",{}),!0}catch(t){return!1}}(),jr="function"==typeof WeakMap;jr&&(Or=new WeakMap);var Rr=0,Ur="__immutablehash__";"function"==typeof Symbol&&(Ur=Symbol(Ur));var Kr=16,Lr=255,Tr=0,Br={};t(ct,et),ct.of=function(){var t=sr.call(arguments,0);return zt().withMutations(function(e){for(var r=0;t.length>r;r+=2){if(r+1>=t.length)throw Error("Missing value for key: "+t[r]);e.set(t[r],t[r+1])}})},ct.prototype.toString=function(){return this.__toString("Map {","}")},ct.prototype.get=function(t,e){return this._root?this._root.get(0,void 0,t,e):e},ct.prototype.set=function(t,e){return It(this,t,e)},ct.prototype.setIn=function(t,e){return this.updateIn(t,yr,function(){return e})},ct.prototype.remove=function(t){return It(this,t,yr)},ct.prototype.deleteIn=function(t){return this.updateIn(t,function(){return yr})},ct.prototype.update=function(t,e,r){return 1===arguments.length?t(this):this.updateIn([t],e,r);
|
||||
},ct.prototype.updateIn=function(t,e,r){r||(r=e,e=void 0);var n=Rt(this,ke(t),e,r);return n===yr?void 0:n},ct.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._root=null,this.__hash=void 0,this.__altered=!0,this):zt()},ct.prototype.merge=function(){return xt(this,void 0,arguments)},ct.prototype.mergeWith=function(t){var e=sr.call(arguments,1);return xt(this,t,e)},ct.prototype.mergeIn=function(t){var e=sr.call(arguments,1);return this.updateIn(t,zt(),function(t){return"function"==typeof t.merge?t.merge.apply(t,e):e[e.length-1]})},ct.prototype.mergeDeep=function(){return xt(this,kt,arguments)},ct.prototype.mergeDeepWith=function(t){var e=sr.call(arguments,1);return xt(this,At(t),e)},ct.prototype.mergeDeepIn=function(t){var e=sr.call(arguments,1);return this.updateIn(t,zt(),function(t){return"function"==typeof t.mergeDeep?t.mergeDeep.apply(t,e):e[e.length-1]})},ct.prototype.sort=function(t){return Zt(we(this,t))},ct.prototype.sortBy=function(t,e){return Zt(we(this,e,t))},ct.prototype.withMutations=function(t){var e=this.asMutable();return t(e),e.wasAltered()?e.__ensureOwner(this.__ownerID):this},ct.prototype.asMutable=function(){return this.__ownerID?this:this.__ensureOwner(new _)},ct.prototype.asImmutable=function(){return this.__ensureOwner()},ct.prototype.wasAltered=function(){return this.__altered},ct.prototype.__iterator=function(t,e){return new mt(this,t,e)},ct.prototype.__iterate=function(t,e){var r=this,n=0;return this._root&&this._root.iterate(function(e){return n++,t(e[1],e[0],r)},e),n},ct.prototype.__ensureOwner=function(t){return t===this.__ownerID?this:t?St(this.size,this._root,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)},ct.isMap=_t;var Wr="@@__IMMUTABLE_MAP__@@",Cr=ct.prototype;Cr[Wr]=!0,Cr[_r]=Cr.remove,Cr.removeIn=Cr.deleteIn,pt.prototype.get=function(t,e,r,n){for(var i=this.entries,o=0,u=i.length;u>o;o++)if(X(r,i[o][0]))return i[o][1];return n},pt.prototype.update=function(t,e,r,n,i,o,u){for(var s=i===yr,a=this.entries,h=0,f=a.length;f>h&&!X(n,a[h][0]);h++);
|
||||
var _=f>h;if(_?a[h][1]===i:s)return this;if(c(u),(s||!_)&&c(o),!s||1!==a.length){if(!_&&!s&&a.length>=Nr)return Mt(t,a,n,i);var v=t&&t===this.ownerID,l=v?a:p(a);return _?s?h===f-1?l.pop():l[h]=l.pop():l[h]=[n,i]:l.push([n,i]),v?(this.entries=l,this):new pt(t,l)}},vt.prototype.get=function(t,e,r,n){void 0===e&&(e=ot(r));var i=1<<((0===t?e:e>>>t)&lr),o=this.bitmap;return 0===(o&i)?n:this.nodes[Ut(o&i-1)].get(t+pr,e,r,n)},vt.prototype.update=function(t,e,r,n,i,o,u){void 0===r&&(r=ot(n));var s=(0===e?r:r>>>e)&lr,a=1<<s,h=this.bitmap,f=0!==(h&a);if(!f&&i===yr)return this;var c=Ut(h&a-1),_=this.nodes,p=f?_[c]:void 0,v=bt(p,t,e+pr,r,n,i,o,u);if(v===p)return this;if(!f&&v&&_.length>=Pr)return Ot(t,_,h,s,v);if(f&&!v&&2===_.length&&qt(_[1^c]))return _[1^c];if(f&&v&&1===_.length&&qt(v))return v;var l=t&&t===this.ownerID,y=f?v?h:h^a:h|a,d=f?v?Kt(_,c,v,l):Tt(_,c,l):Lt(_,c,v,l);return l?(this.bitmap=y,this.nodes=d,this):new vt(t,y,d)},lt.prototype.get=function(t,e,r,n){void 0===e&&(e=ot(r));var i=(0===t?e:e>>>t)&lr,o=this.nodes[i];return o?o.get(t+pr,e,r,n):n},lt.prototype.update=function(t,e,r,n,i,o,u){void 0===r&&(r=ot(n));var s=(0===e?r:r>>>e)&lr,a=i===yr,h=this.nodes,f=h[s];if(a&&!f)return this;var c=bt(f,t,e+pr,r,n,i,o,u);if(c===f)return this;var _=this.count;if(f){if(!c&&(_--,Hr>_))return Et(t,h,_,s)}else _++;var p=t&&t===this.ownerID,v=Kt(h,s,c,p);return p?(this.count=_,this.nodes=v,this):new lt(t,_,v)},yt.prototype.get=function(t,e,r,n){for(var i=this.entries,o=0,u=i.length;u>o;o++)if(X(r,i[o][0]))return i[o][1];return n},yt.prototype.update=function(t,e,r,n,i,o,u){void 0===r&&(r=ot(n));var s=i===yr;if(r!==this.keyHash)return s?this:(c(u),c(o),Dt(this,t,e,r,[n,i]));for(var a=this.entries,h=0,f=a.length;f>h&&!X(n,a[h][0]);h++);var _=f>h;if(_?a[h][1]===i:s)return this;if(c(u),(s||!_)&&c(o),s&&2===f)return new dt(t,this.keyHash,a[1^h]);var v=t&&t===this.ownerID,l=v?a:p(a);return _?s?h===f-1?l.pop():l[h]=l.pop():l[h]=[n,i]:l.push([n,i]),v?(this.entries=l,this):new yt(t,this.keyHash,l)},dt.prototype.get=function(t,e,r,n){return X(r,this.entry[0])?this.entry[1]:n;
|
||||
},dt.prototype.update=function(t,e,r,n,i,o,u){var s=i===yr,a=X(n,this.entry[0]);return(a?i===this.entry[1]:s)?this:(c(u),s?void c(o):a?t&&t===this.ownerID?(this.entry[1]=i,this):new dt(t,this.keyHash,[n,i]):(c(o),Dt(this,t,e,ot(n),[n,i])))},pt.prototype.iterate=yt.prototype.iterate=function(t,e){for(var r=this.entries,n=0,i=r.length-1;i>=n;n++)if(t(r[e?i-n:n])===!1)return!1},vt.prototype.iterate=lt.prototype.iterate=function(t,e){for(var r=this.nodes,n=0,i=r.length-1;i>=n;n++){var o=r[e?i-n:n];if(o&&o.iterate(t,e)===!1)return!1}},dt.prototype.iterate=function(t,e){return t(this.entry)},t(mt,S),mt.prototype.next=function(){for(var t=this._type,e=this._stack;e;){var r,n=e.node,i=e.index++;if(n.entry){if(0===i)return gt(t,n.entry)}else if(n.entries){if(r=n.entries.length-1,r>=i)return gt(t,n.entries[this._reverse?r-i:i])}else if(r=n.nodes.length-1,r>=i){var o=n.nodes[this._reverse?r-i:i];if(o){if(o.entry)return gt(t,o.entry);e=this._stack=wt(o,e)}continue}e=this._stack=this._stack.__prev}return I()};var Jr,Nr=vr/4,Pr=vr/2,Hr=vr/4;t(Bt,rt),Bt.of=function(){return this(arguments)},Bt.prototype.toString=function(){return this.__toString("List [","]")},Bt.prototype.get=function(t,e){if(t=l(this,t),t>=0&&this.size>t){t+=this._origin;var r=Qt(this,t);return r&&r.array[t&lr]}return e},Bt.prototype.set=function(t,e){return Ht(this,t,e)},Bt.prototype.remove=function(t){return this.has(t)?0===t?this.shift():t===this.size-1?this.pop():this.splice(t,1):this},Bt.prototype.insert=function(t,e){return this.splice(t,0,e)},Bt.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=this._origin=this._capacity=0,this._level=pr,this._root=this._tail=null,this.__hash=void 0,this.__altered=!0,this):Pt()},Bt.prototype.push=function(){var t=arguments,e=this.size;return this.withMutations(function(r){Xt(r,0,e+t.length);for(var n=0;t.length>n;n++)r.set(e+n,t[n])})},Bt.prototype.pop=function(){return Xt(this,0,-1)},Bt.prototype.unshift=function(){var t=arguments;return this.withMutations(function(e){Xt(e,-t.length);for(var r=0;t.length>r;r++)e.set(r,t[r]);
|
||||
})},Bt.prototype.shift=function(){return Xt(this,1)},Bt.prototype.merge=function(){return Ft(this,void 0,arguments)},Bt.prototype.mergeWith=function(t){var e=sr.call(arguments,1);return Ft(this,t,e)},Bt.prototype.mergeDeep=function(){return Ft(this,kt,arguments)},Bt.prototype.mergeDeepWith=function(t){var e=sr.call(arguments,1);return Ft(this,At(t),e)},Bt.prototype.setSize=function(t){return Xt(this,0,t)},Bt.prototype.slice=function(t,e){var r=this.size;return d(t,e,r)?this:Xt(this,m(t,r),g(e,r))},Bt.prototype.__iterator=function(t,e){var r=0,n=Jt(this,e);return new S(function(){var e=n();return e===Xr?I():z(t,r++,e)})},Bt.prototype.__iterate=function(t,e){for(var r,n=0,i=Jt(this,e);(r=i())!==Xr&&t(r,n++,this)!==!1;);return n},Bt.prototype.__ensureOwner=function(t){return t===this.__ownerID?this:t?Nt(this._origin,this._capacity,this._level,this._root,this._tail,t,this.__hash):(this.__ownerID=t,this)},Bt.isList=Wt;var Vr="@@__IMMUTABLE_LIST__@@",Yr=Bt.prototype;Yr[Vr]=!0,Yr[_r]=Yr.remove,Yr.setIn=Cr.setIn,Yr.deleteIn=Yr.removeIn=Cr.removeIn,Yr.update=Cr.update,Yr.updateIn=Cr.updateIn,Yr.mergeIn=Cr.mergeIn,Yr.mergeDeepIn=Cr.mergeDeepIn,Yr.withMutations=Cr.withMutations,Yr.asMutable=Cr.asMutable,Yr.asImmutable=Cr.asImmutable,Yr.wasAltered=Cr.wasAltered,Ct.prototype.removeBefore=function(t,e,r){if(r===e?1<<e:0===this.array.length)return this;var n=r>>>e&lr;if(n>=this.array.length)return new Ct([],t);var i,o=0===n;if(e>0){var u=this.array[n];if(i=u&&u.removeBefore(t,e-pr,r),i===u&&o)return this}if(o&&!i)return this;var s=Yt(this,t);if(!o)for(var a=0;n>a;a++)s.array[a]=void 0;return i&&(s.array[n]=i),s},Ct.prototype.removeAfter=function(t,e,r){if(r===(e?1<<e:0)||0===this.array.length)return this;var n=r-1>>>e&lr;if(n>=this.array.length)return this;var i;if(e>0){var o=this.array[n];if(i=o&&o.removeAfter(t,e-pr,r),i===o&&n===this.array.length-1)return this}var u=Yt(this,t);return u.array.splice(n+1),i&&(u.array[n]=i),u};var Qr,Xr={};t(Zt,ct),Zt.of=function(){return this(arguments)},Zt.prototype.toString=function(){return this.__toString("OrderedMap {","}");
|
||||
},Zt.prototype.get=function(t,e){var r=this._map.get(t);return void 0!==r?this._list.get(r)[1]:e},Zt.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._map.clear(),this._list.clear(),this):ee()},Zt.prototype.set=function(t,e){return re(this,t,e)},Zt.prototype.remove=function(t){return re(this,t,yr)},Zt.prototype.wasAltered=function(){return this._map.wasAltered()||this._list.wasAltered()},Zt.prototype.__iterate=function(t,e){var r=this;return this._list.__iterate(function(e){return e&&t(e[1],e[0],r)},e)},Zt.prototype.__iterator=function(t,e){return this._list.fromEntrySeq().__iterator(t,e)},Zt.prototype.__ensureOwner=function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t),r=this._list.__ensureOwner(t);return t?te(e,r,t,this.__hash):(this.__ownerID=t,this._map=e,this._list=r,this)},Zt.isOrderedMap=$t,Zt.prototype[cr]=!0,Zt.prototype[_r]=Zt.prototype.remove;var Fr;t(ne,x),ne.prototype.get=function(t,e){return this._iter.get(t,e)},ne.prototype.has=function(t){return this._iter.has(t)},ne.prototype.valueSeq=function(){return this._iter.valueSeq()},ne.prototype.reverse=function(){var t=this,e=he(this,!0);return this._useKeys||(e.valueSeq=function(){return t._iter.toSeq().reverse()}),e},ne.prototype.map=function(t,e){var r=this,n=ae(this,t,e);return this._useKeys||(n.valueSeq=function(){return r._iter.toSeq().map(t,e)}),n},ne.prototype.__iterate=function(t,e){var r,n=this;return this._iter.__iterate(this._useKeys?function(e,r){return t(e,r,n)}:(r=e?De(this):0,function(i){return t(i,e?--r:r++,n)}),e)},ne.prototype.__iterator=function(t,e){if(this._useKeys)return this._iter.__iterator(t,e);var r=this._iter.__iterator(wr,e),n=e?De(this):0;return new S(function(){var i=r.next();return i.done?i:z(t,e?--n:n++,i.value,i)})},ne.prototype[cr]=!0,t(ie,k),ie.prototype.includes=function(t){return this._iter.includes(t)},ie.prototype.__iterate=function(t,e){var r=this,n=0;return this._iter.__iterate(function(e){return t(e,n++,r)},e)},ie.prototype.__iterator=function(t,e){var r=this._iter.__iterator(wr,e),n=0;
|
||||
return new S(function(){var e=r.next();return e.done?e:z(t,n++,e.value,e)})},t(oe,A),oe.prototype.has=function(t){return this._iter.includes(t)},oe.prototype.__iterate=function(t,e){var r=this;return this._iter.__iterate(function(e){return t(e,e,r)},e)},oe.prototype.__iterator=function(t,e){var r=this._iter.__iterator(wr,e);return new S(function(){var e=r.next();return e.done?e:z(t,e.value,e.value,e)})},t(ue,x),ue.prototype.entrySeq=function(){return this._iter.toSeq()},ue.prototype.__iterate=function(t,e){var r=this;return this._iter.__iterate(function(e){if(e){qe(e);var n=o(e);return t(n?e.get(1):e[1],n?e.get(0):e[0],r)}},e)},ue.prototype.__iterator=function(t,e){var r=this._iter.__iterator(wr,e);return new S(function(){for(;;){var e=r.next();if(e.done)return e;var n=e.value;if(n){qe(n);var i=o(n);return z(t,i?n.get(0):n[0],i?n.get(1):n[1],e)}}})},ie.prototype.cacheResult=ne.prototype.cacheResult=oe.prototype.cacheResult=ue.prototype.cacheResult=Oe,t(Ae,et),Ae.prototype.toString=function(){return this.__toString(Re(this)+" {","}")},Ae.prototype.has=function(t){return this._defaultValues.hasOwnProperty(t)},Ae.prototype.get=function(t,e){if(!this.has(t))return e;var r=this._defaultValues[t];return this._map?this._map.get(t,r):r},Ae.prototype.clear=function(){if(this.__ownerID)return this._map&&this._map.clear(),this;var t=this.constructor;return t._empty||(t._empty=je(this,zt()))},Ae.prototype.set=function(t,e){if(!this.has(t))throw Error('Cannot set unknown key "'+t+'" on '+Re(this));if(this._map&&!this._map.has(t)){var r=this._defaultValues[t];if(e===r)return this}var n=this._map&&this._map.set(t,e);return this.__ownerID||n===this._map?this:je(this,n)},Ae.prototype.remove=function(t){if(!this.has(t))return this;var e=this._map&&this._map.remove(t);return this.__ownerID||e===this._map?this:je(this,e)},Ae.prototype.wasAltered=function(){return this._map.wasAltered()},Ae.prototype.__iterator=function(t,e){var n=this;return r(this._defaultValues).map(function(t,e){return n.get(e)}).__iterator(t,e)},Ae.prototype.__iterate=function(t,e){
|
||||
var n=this;return r(this._defaultValues).map(function(t,e){return n.get(e)}).__iterate(t,e)},Ae.prototype.__ensureOwner=function(t){if(t===this.__ownerID)return this;var e=this._map&&this._map.__ensureOwner(t);return t?je(this,e,t):(this.__ownerID=t,this._map=e,this)};var Gr=Ae.prototype;Gr[_r]=Gr.remove,Gr.deleteIn=Gr.removeIn=Cr.removeIn,Gr.merge=Cr.merge,Gr.mergeWith=Cr.mergeWith,Gr.mergeIn=Cr.mergeIn,Gr.mergeDeep=Cr.mergeDeep,Gr.mergeDeepWith=Cr.mergeDeepWith,Gr.mergeDeepIn=Cr.mergeDeepIn,Gr.setIn=Cr.setIn,Gr.update=Cr.update,Gr.updateIn=Cr.updateIn,Gr.withMutations=Cr.withMutations,Gr.asMutable=Cr.asMutable,Gr.asImmutable=Cr.asImmutable,t(Le,nt),Le.of=function(){return this(arguments)},Le.fromKeys=function(t){return this(r(t).keySeq())},Le.prototype.toString=function(){return this.__toString("Set {","}")},Le.prototype.has=function(t){return this._map.has(t)},Le.prototype.add=function(t){return Be(this,this._map.set(t,!0))},Le.prototype.remove=function(t){return Be(this,this._map.remove(t))},Le.prototype.clear=function(){return Be(this,this._map.clear())},Le.prototype.union=function(){var t=sr.call(arguments,0);return t=t.filter(function(t){return 0!==t.size}),0===t.length?this:0!==this.size||this.__ownerID||1!==t.length?this.withMutations(function(e){for(var r=0;t.length>r;r++)i(t[r]).forEach(function(t){return e.add(t)})}):this.constructor(t[0])},Le.prototype.intersect=function(){var t=sr.call(arguments,0);if(0===t.length)return this;t=t.map(function(t){return i(t)});var e=this;return this.withMutations(function(r){e.forEach(function(e){t.every(function(t){return t.includes(e)})||r.remove(e)})})},Le.prototype.subtract=function(){var t=sr.call(arguments,0);if(0===t.length)return this;t=t.map(function(t){return i(t)});var e=this;return this.withMutations(function(r){e.forEach(function(e){t.some(function(t){return t.includes(e)})&&r.remove(e)})})},Le.prototype.merge=function(){return this.union.apply(this,arguments)},Le.prototype.mergeWith=function(t){var e=sr.call(arguments,1);return this.union.apply(this,e)},
|
||||
Le.prototype.sort=function(t){return Je(we(this,t))},Le.prototype.sortBy=function(t,e){return Je(we(this,e,t))},Le.prototype.wasAltered=function(){return this._map.wasAltered()},Le.prototype.__iterate=function(t,e){var r=this;return this._map.__iterate(function(e,n){return t(n,n,r)},e)},Le.prototype.__iterator=function(t,e){return this._map.map(function(t,e){return e}).__iterator(t,e)},Le.prototype.__ensureOwner=function(t){if(t===this.__ownerID)return this;var e=this._map.__ensureOwner(t);return t?this.__make(e,t):(this.__ownerID=t,this._map=e,this)},Le.isSet=Te;var Zr="@@__IMMUTABLE_SET__@@",$r=Le.prototype;$r[Zr]=!0,$r[_r]=$r.remove,$r.mergeDeep=$r.merge,$r.mergeDeepWith=$r.mergeWith,$r.withMutations=Cr.withMutations,$r.asMutable=Cr.asMutable,$r.asImmutable=Cr.asImmutable,$r.__empty=Ce,$r.__make=We;var tn;t(Je,Le),Je.of=function(){return this(arguments)},Je.fromKeys=function(t){return this(r(t).keySeq())},Je.prototype.toString=function(){return this.__toString("OrderedSet {","}")},Je.isOrderedSet=Ne;var en=Je.prototype;en[cr]=!0,en.__empty=He,en.__make=Pe;var rn;t(Ve,rt),Ve.of=function(){return this(arguments)},Ve.prototype.toString=function(){return this.__toString("Stack [","]")},Ve.prototype.get=function(t,e){var r=this._head;for(t=l(this,t);r&&t--;)r=r.next;return r?r.value:e},Ve.prototype.peek=function(){return this._head&&this._head.value},Ve.prototype.push=function(){if(0===arguments.length)return this;for(var t=this.size+arguments.length,e=this._head,r=arguments.length-1;r>=0;r--)e={value:arguments[r],next:e};return this.__ownerID?(this.size=t,this._head=e,this.__hash=void 0,this.__altered=!0,this):Qe(t,e)},Ve.prototype.pushAll=function(t){if(t=n(t),0===t.size)return this;ft(t.size);var e=this.size,r=this._head;return t.reverse().forEach(function(t){e++,r={value:t,next:r}}),this.__ownerID?(this.size=e,this._head=r,this.__hash=void 0,this.__altered=!0,this):Qe(e,r)},Ve.prototype.pop=function(){return this.slice(1)},Ve.prototype.unshift=function(){return this.push.apply(this,arguments)},Ve.prototype.unshiftAll=function(t){
|
||||
return this.pushAll(t)},Ve.prototype.shift=function(){return this.pop.apply(this,arguments)},Ve.prototype.clear=function(){return 0===this.size?this:this.__ownerID?(this.size=0,this._head=void 0,this.__hash=void 0,this.__altered=!0,this):Xe()},Ve.prototype.slice=function(t,e){if(d(t,e,this.size))return this;var r=m(t,this.size),n=g(e,this.size);if(n!==this.size)return rt.prototype.slice.call(this,t,e);for(var i=this.size-r,o=this._head;r--;)o=o.next;return this.__ownerID?(this.size=i,this._head=o,this.__hash=void 0,this.__altered=!0,this):Qe(i,o)},Ve.prototype.__ensureOwner=function(t){return t===this.__ownerID?this:t?Qe(this.size,this._head,t,this.__hash):(this.__ownerID=t,this.__altered=!1,this)},Ve.prototype.__iterate=function(t,e){if(e)return this.reverse().__iterate(t);for(var r=0,n=this._head;n&&t(n.value,r++,this)!==!1;)n=n.next;return r},Ve.prototype.__iterator=function(t,e){if(e)return this.reverse().__iterator(t);var r=0,n=this._head;return new S(function(){if(n){var e=n.value;return n=n.next,z(t,r++,e)}return I()})},Ve.isStack=Ye;var nn="@@__IMMUTABLE_STACK__@@",on=Ve.prototype;on[nn]=!0,on.withMutations=Cr.withMutations,on.asMutable=Cr.asMutable,on.asImmutable=Cr.asImmutable,on.wasAltered=Cr.wasAltered;var un;e.Iterator=S,Fe(e,{toArray:function(){ft(this.size);var t=Array(this.size||0);return this.valueSeq().__iterate(function(e,r){t[r]=e}),t},toIndexedSeq:function(){return new ie(this)},toJS:function(){return this.toSeq().map(function(t){return t&&"function"==typeof t.toJS?t.toJS():t}).__toJS()},toJSON:function(){return this.toSeq().map(function(t){return t&&"function"==typeof t.toJSON?t.toJSON():t}).__toJS()},toKeyedSeq:function(){return new ne(this,!0)},toMap:function(){return ct(this.toKeyedSeq())},toObject:function(){ft(this.size);var t={};return this.__iterate(function(e,r){t[r]=e}),t},toOrderedMap:function(){return Zt(this.toKeyedSeq())},toOrderedSet:function(){return Je(u(this)?this.valueSeq():this)},toSet:function(){return Le(u(this)?this.valueSeq():this)},toSetSeq:function(){return new oe(this);
|
||||
},toSeq:function(){return s(this)?this.toIndexedSeq():u(this)?this.toKeyedSeq():this.toSetSeq()},toStack:function(){return Ve(u(this)?this.valueSeq():this)},toList:function(){return Bt(u(this)?this.valueSeq():this)},toString:function(){return"[Iterable]"},__toString:function(t,e){return 0===this.size?t+e:t+" "+this.toSeq().map(this.__toStringMapper).join(", ")+" "+e},concat:function(){var t=sr.call(arguments,0);return be(this,ye(this,t))},includes:function(t){return this.some(function(e){return X(e,t)})},entries:function(){return this.__iterator(Sr)},every:function(t,e){ft(this.size);var r=!0;return this.__iterate(function(n,i,o){return t.call(e,n,i,o)?void 0:(r=!1,!1)}),r},filter:function(t,e){return be(this,fe(this,t,e,!0))},find:function(t,e,r){var n=this.findEntry(t,e);return n?n[1]:r},forEach:function(t,e){return ft(this.size),this.__iterate(e?t.bind(e):t)},join:function(t){ft(this.size),t=void 0!==t?""+t:",";var e="",r=!0;return this.__iterate(function(n){r?r=!1:e+=t,e+=null!==n&&void 0!==n?""+n:""}),e},keys:function(){return this.__iterator(gr)},map:function(t,e){return be(this,ae(this,t,e))},reduce:function(t,e,r){ft(this.size);var n,i;return arguments.length<2?i=!0:n=e,this.__iterate(function(e,o,u){i?(i=!1,n=e):n=t.call(r,n,e,o,u)}),n},reduceRight:function(t,e,r){var n=this.toKeyedSeq().reverse();return n.reduce.apply(n,arguments)},reverse:function(){return be(this,he(this,!0))},slice:function(t,e){return be(this,pe(this,t,e,!0))},some:function(t,e){return!this.every($e(t),e)},sort:function(t){return be(this,we(this,t))},values:function(){return this.__iterator(wr)},butLast:function(){return this.slice(0,-1)},isEmpty:function(){return void 0!==this.size?0===this.size:!this.some(function(){return!0})},count:function(t,e){return v(t?this.toSeq().filter(t,e):this)},countBy:function(t,e){return ce(this,t,e)},equals:function(t){return F(this,t)},entrySeq:function(){var t=this;if(t._cache)return new j(t._cache);var e=t.toSeq().map(Ze).toIndexedSeq();return e.fromEntrySeq=function(){return t.toSeq()},e},filterNot:function(t,e){
|
||||
return this.filter($e(t),e)},findEntry:function(t,e,r){var n=r;return this.__iterate(function(r,i,o){return t.call(e,r,i,o)?(n=[i,r],!1):void 0}),n},findKey:function(t,e){var r=this.findEntry(t,e);return r&&r[0]},findLast:function(t,e,r){return this.toKeyedSeq().reverse().find(t,e,r)},findLastEntry:function(t,e,r){return this.toKeyedSeq().reverse().findEntry(t,e,r)},findLastKey:function(t,e){return this.toKeyedSeq().reverse().findKey(t,e)},first:function(){return this.find(y)},flatMap:function(t,e){return be(this,me(this,t,e))},flatten:function(t){return be(this,de(this,t,!0))},fromEntrySeq:function(){return new ue(this)},get:function(t,e){return this.find(function(e,r){return X(r,t)},void 0,e)},getIn:function(t,e){for(var r,n=this,i=ke(t);!(r=i.next()).done;){var o=r.value;if(n=n&&n.get?n.get(o,yr):yr,n===yr)return e}return n},groupBy:function(t,e){return _e(this,t,e)},has:function(t){return this.get(t,yr)!==yr},hasIn:function(t){return this.getIn(t,yr)!==yr},isSubset:function(t){return t="function"==typeof t.includes?t:e(t),this.every(function(e){return t.includes(e)})},isSuperset:function(t){return t="function"==typeof t.isSubset?t:e(t),t.isSubset(this)},keyOf:function(t){return this.findKey(function(e){return X(e,t)})},keySeq:function(){return this.toSeq().map(Ge).toIndexedSeq()},last:function(){return this.toSeq().reverse().first()},lastKeyOf:function(t){return this.toKeyedSeq().reverse().keyOf(t)},max:function(t){return Se(this,t)},maxBy:function(t,e){return Se(this,e,t)},min:function(t){return Se(this,t?tr(t):nr)},minBy:function(t,e){return Se(this,e?tr(e):nr,t)},rest:function(){return this.slice(1)},skip:function(t){return this.slice(Math.max(0,t))},skipLast:function(t){return be(this,this.toSeq().reverse().skip(t).reverse())},skipWhile:function(t,e){return be(this,le(this,t,e,!0))},skipUntil:function(t,e){return this.skipWhile($e(t),e)},sortBy:function(t,e){return be(this,we(this,e,t))},take:function(t){return this.slice(0,Math.max(0,t))},takeLast:function(t){return be(this,this.toSeq().reverse().take(t).reverse());
|
||||
},takeWhile:function(t,e){return be(this,ve(this,t,e))},takeUntil:function(t,e){return this.takeWhile($e(t),e)},valueSeq:function(){return this.toIndexedSeq()},hashCode:function(){return this.__hash||(this.__hash=ir(this))}});var sn=e.prototype;sn[ar]=!0,sn[br]=sn.values,sn.__toJS=sn.toArray,sn.__toStringMapper=er,sn.inspect=sn.toSource=function(){return""+this},sn.chain=sn.flatMap,sn.contains=sn.includes,Fe(r,{flip:function(){return be(this,se(this))},mapEntries:function(t,e){var r=this,n=0;return be(this,this.toSeq().map(function(i,o){return t.call(e,[o,i],n++,r)}).fromEntrySeq())},mapKeys:function(t,e){var r=this;return be(this,this.toSeq().flip().map(function(n,i){return t.call(e,n,i,r)}).flip())}});var an=r.prototype;an[hr]=!0,an[br]=sn.entries,an.__toJS=sn.toObject,an.__toStringMapper=function(t,e){return JSON.stringify(e)+": "+er(t)},Fe(n,{toKeyedSeq:function(){return new ne(this,!1)},filter:function(t,e){return be(this,fe(this,t,e,!1))},findIndex:function(t,e){var r=this.findEntry(t,e);return r?r[0]:-1},indexOf:function(t){var e=this.keyOf(t);return void 0===e?-1:e},lastIndexOf:function(t){var e=this.lastKeyOf(t);return void 0===e?-1:e},reverse:function(){return be(this,he(this,!1))},slice:function(t,e){return be(this,pe(this,t,e,!1))},splice:function(t,e){var r=arguments.length;if(e=Math.max(0|e,0),0===r||2===r&&!e)return this;t=m(t,0>t?this.count():this.size);var n=this.slice(0,t);return be(this,1===r?n:n.concat(p(arguments,2),this.slice(t+e)))},findLastIndex:function(t,e){var r=this.findLastEntry(t,e);return r?r[0]:-1},first:function(){return this.get(0)},flatten:function(t){return be(this,de(this,t,!1))},get:function(t,e){return t=l(this,t),0>t||this.size===1/0||void 0!==this.size&&t>this.size?e:this.find(function(e,r){return r===t},void 0,e)},has:function(t){return t=l(this,t),t>=0&&(void 0!==this.size?this.size===1/0||this.size>t:-1!==this.indexOf(t))},interpose:function(t){return be(this,ge(this,t))},interleave:function(){var t=[this].concat(p(arguments)),e=Ie(this.toSeq(),k.of,t),r=e.flatten(!0);return e.size&&(r.size=e.size*t.length),
|
||||
be(this,r)},keySeq:function(){return $(0,this.size)},last:function(){return this.get(-1)},skipWhile:function(t,e){return be(this,le(this,t,e,!1))},zip:function(){var t=[this].concat(p(arguments));return be(this,Ie(this,rr,t))},zipWith:function(t){var e=p(arguments);return e[0]=this,be(this,Ie(this,t,e))}}),n.prototype[fr]=!0,n.prototype[cr]=!0,Fe(i,{get:function(t,e){return this.has(t)?t:e},includes:function(t){return this.has(t)},keySeq:function(){return this.valueSeq()}}),i.prototype.has=sn.includes,i.prototype.contains=i.prototype.includes,Fe(x,r.prototype),Fe(k,n.prototype),Fe(A,i.prototype),Fe(et,r.prototype),Fe(rt,n.prototype),Fe(nt,i.prototype);var hn={Iterable:e,Seq:O,Collection:tt,Map:ct,OrderedMap:Zt,List:Bt,Stack:Ve,Set:Le,OrderedSet:Je,Record:Ae,Range:$,Repeat:G,is:X,fromJS:H};return hn});
|
||||
111
node_modules/immutable/package.json
generated
vendored
Normal file
111
node_modules/immutable/package.json
generated
vendored
Normal file
@ -0,0 +1,111 @@
|
||||
{
|
||||
"name": "immutable",
|
||||
"version": "3.8.2",
|
||||
"description": "Immutable Data Collections",
|
||||
"license": "MIT",
|
||||
"homepage": "https://facebook.github.com/immutable-js",
|
||||
"author": {
|
||||
"name": "Lee Byron",
|
||||
"url": "https://github.com/leebyron"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/facebook/immutable-js.git"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/facebook/immutable-js/issues"
|
||||
},
|
||||
"main": "dist/immutable.js",
|
||||
"typings": "dist/immutable-nonambient.d.ts",
|
||||
"typescript": {
|
||||
"definition": "dist/immutable.d.ts"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "grunt default && gulp default",
|
||||
"lint": "eslint src/ && grunt lint && gulp lint",
|
||||
"testonly": "./resources/node_test.sh",
|
||||
"test": "npm run lint && npm run testonly",
|
||||
"perf": "node ./resources/bench.js",
|
||||
"start": "npm run build && node ./pages/resources/start.js",
|
||||
"deploy": "(cd ./pages/out && git init && git config user.name \"Travis CI\" && git config user.email \"github@fb.com\" && git add . && git commit -m \"Deploy to GitHub Pages\" && git push --force --quiet \"https://${GH_TOKEN}@github.com/facebook/immutable-js.git\" master:gh-pages > /dev/null 2>1)"
|
||||
},
|
||||
"jest": {
|
||||
"scriptPreprocessor": "resources/jestPreprocessor.js",
|
||||
"testFileExtensions": [
|
||||
"js",
|
||||
"ts"
|
||||
],
|
||||
"persistModuleRegistryBetweenSpecs": true
|
||||
},
|
||||
"devDependencies": {
|
||||
"acorn": "0.11.x",
|
||||
"babel-eslint": "^4.1.8",
|
||||
"benchmark": "^1.0.0",
|
||||
"bluebird": "3.1.1",
|
||||
"browser-sync": "2.11.0",
|
||||
"browserify": "^5.11.2",
|
||||
"colors": "1.1.2",
|
||||
"del": "2.2.0",
|
||||
"es6-transpiler": "0.7.18",
|
||||
"eslint": "^1.10.3",
|
||||
"estraverse": "1.9.3",
|
||||
"express": "^4.13.4",
|
||||
"fbjs-scripts": "^0.5.0",
|
||||
"grunt": "0.4.5",
|
||||
"grunt-cli": "0.1.13",
|
||||
"grunt-contrib-clean": "0.7.0",
|
||||
"grunt-contrib-copy": "0.8.2",
|
||||
"grunt-contrib-jshint": "0.11.3",
|
||||
"grunt-release": "0.13.0",
|
||||
"gulp": "3.9.0",
|
||||
"gulp-concat": "2.6.0",
|
||||
"gulp-filter": "3.0.1",
|
||||
"gulp-header": "1.7.1",
|
||||
"gulp-jest": "^0.2.1",
|
||||
"gulp-jshint": "^1.8.4",
|
||||
"gulp-less": "3.0.5",
|
||||
"gulp-size": "2.0.0",
|
||||
"gulp-sourcemaps": "1.6.0",
|
||||
"gulp-uglify": "1.5.1",
|
||||
"gulp-util": "3.0.7",
|
||||
"harmonize": "1.4.4",
|
||||
"jasmine-check": "^0.1.2",
|
||||
"jest-cli": "^0.5.10",
|
||||
"jshint-stylish": "^0.4.0",
|
||||
"magic-string": "0.10.2",
|
||||
"marked": "0.3.5",
|
||||
"microtime": "^2.0.0",
|
||||
"node-jsx": "^0.12.4",
|
||||
"react": "^0.12.0",
|
||||
"react-router": "^0.11.2",
|
||||
"react-tools": "^0.12.0",
|
||||
"rollup": "0.24.0",
|
||||
"run-sequence": "1.1.5",
|
||||
"through2": "2.0.0",
|
||||
"typescript": "1.7.5",
|
||||
"uglify-js": "2.6.1",
|
||||
"vinyl-buffer": "1.0.0",
|
||||
"vinyl-source-stream": "1.1.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=0.10.0"
|
||||
},
|
||||
"files": [
|
||||
"dist",
|
||||
"contrib",
|
||||
"README.md",
|
||||
"LICENSE"
|
||||
],
|
||||
"keywords": [
|
||||
"immutable",
|
||||
"persistent",
|
||||
"lazy",
|
||||
"data",
|
||||
"datastructure",
|
||||
"functional",
|
||||
"collection",
|
||||
"stateless",
|
||||
"sequence",
|
||||
"iteration"
|
||||
]
|
||||
}
|
||||
Reference in New Issue
Block a user