diff --git a/.circleci/config.yml b/.circleci/config.yml deleted file mode 100644 index 5225ed31f..000000000 --- a/.circleci/config.yml +++ /dev/null @@ -1,39 +0,0 @@ -version: 2.1 - -jobs: - code: - docker: - - image: circleci/golang:1.13 - steps: - - checkout - - update_submodules - - run: - name: "Test code (Generate, Build, Test)" - command: make test - - run: - name: "Check code is formatted" - command: | - make fmt-code - git diff --exit-code - website: - docker: - - image: cibuilds/hugo:0.58.0 - steps: - - checkout - - run: - name: "Build website" - command: make website - -workflows: - version: 2.1 - test_all: - jobs: - - code - - website - -commands: - update_submodules: - steps: - - run: - name: Update submodules - command: git submodule update --init --recursive diff --git a/.gitignore b/.gitignore index d9de10541..59d74f04b 100644 --- a/.gitignore +++ b/.gitignore @@ -13,3 +13,5 @@ hugo/content/codeGen/main hugo/data/version.yml pkg/ tools/codeGen/codeGen +yarn.lock +node_modules \ No newline at end of file diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index e69de29bb..000000000 diff --git a/Makefile b/Makefile deleted file mode 100644 index fdb45aab2..000000000 --- a/Makefile +++ /dev/null @@ -1,274 +0,0 @@ -# guidelines for editing this makefile: -# -# - keep it simple -- put complicated commands into scripts inside bin/ (eg install-deps.sh) -# - document targets in the 'help' target -# - distinguish main targets (meant for users) from intermediate targets -# - if you write a new tool that requires compilation: -# add a compilation target here and move the binary into bin/ -# - if you add a dependency on another tool: -# make sure you edit install-deps.sh to install or prompt to install it -# - keep diagrams/builsys/buildsys.dot in sync with the targets here -# that is a diagram that is meant to make it easy to understand everything here. - -help: - @echo "SYNOPSIS" - @echo " make -- filecoin spec build toolchain commands" - @echo "" - @echo "USAGE" - @echo " make deps-ga run this once, to instlal & build partial dependencies for Github Actions" - @echo " make deps-basic run this once, to install & build basic dependencies" - @echo " make build run this every time you want to re-build artifacts" - @echo "" - @echo "MAIN TARGETS" - @echo " make help description of the targets (this message)" - @echo " make build build all final artifacts (website only for now)" - @echo " make test run all test cases (test-code only for now)" - @echo " make drafts publish artifacts to ipfs and show an address" - @echo " make publish publish final artifacts to spec website (github pages)" - @echo " make clean removes all build artifacts. you shouldn't need this" - @echo " make serve start hugo in serving mode -- must run 'make build' on changes manually" - @echo "" - @echo "INSTALL DEPENDENCIES" - @echo " make deps install ALL dependencies of this tool chain" - @echo " make deps-ga install Github Action specific dependencies" - @echo " make deps-basic install minimal dependencies of this tool chain" - @echo " make deps-diag install dependencies for rendering diagrams" - @echo " make deps-orient install dependencies for running orient" - @echo " make deps-ouser install dependencies for orient user-environment tooling" - @echo " make bins compile some build tools whose source is in this repo" - @echo "" - @echo "INTERMEDIATE TARGETS" - @echo " make website build the website artifact" - @#echo " make pdf build the pdf artifact" - @echo " make diagrams build diagram artifacts ({dot, mmd} -> svg)" - @echo " make org2md run org mode to markdown compilation" - @echo "" - @echo "HUGO TARGETS" - @echo " make hugo-src copy sources into hugo dir" - @echo " make build-hugo run the hugo part of the pipeline" - @echo " make watch-hugo watch and rebuild hugo" - @echo "" - @echo "CODE TARGETS" - @echo " make gen-code generate code artifacts (eg id -> go)" - @echo " make test-code run test cases in code artifacts" - @echo " make build-code build all src go code (test it)" - @echo " make clean-code remove build code artifacts" - @echo " make watch-code watch and rebuild code" - @echo "" - @echo "CLEAN TARGETS" - @echo " make clean remove all build artifacts" - @echo " make clean-deps remove (some of) the dependencies installed in this repo" - @echo " make clean-hugo remove intermediate hugo artifacts" - @echo " make clean-code remove build code artifacts" - @echo "" - @echo "WATCH TARGETS" - @echo " make serve-and-watch -j2 serve, watch, and rebuild all - works for live edit" - @echo " make watch-code watch and rebuild code" - @echo " make watch-hugo watch and rebuild hugo" - @echo "" - -# main Targets -build: diagrams build-code website - -test: test-code test-codeGen - -drafts: website - bin/publish-to-ipfs.sh - -publish: website - bin/publish-to-gh-pages.sh - -clean: .PHONY - rm -rf build - -# install dependencies - -deps: deps-basic deps-diag deps-orient - @# make bins last, after installing other deps - @# so we re-invoke make. - make bins - -deps-ga: - bin/install-deps-ga.sh -y - -deps-basic: - bin/install-deps-basic.sh -y - -deps-ouser: - bin/install-deps-orient-user.sh -y - -deps-orient: submodules - bin/install-deps-orient.sh -y - -deps-diag: - bin/install-deps-diagrams.sh -y - -submodules: - git submodule update --init --recursive - -clean-deps: .PHONY - @echo "WARNING: this does not uninstall global packages, sorry." - @echo " If you would like to remove them, see bin/install-deps.sh" - -rm -r deps - -git checkout ./deps/package.json - -rm -r .slime - -rm -r bin/.emacs - -# intermediate targets -# NOTE: For now, disable org2md — must manually generate until batch-mode build issues are resolved. -website: diagrams build-hugo # org2md - mkdir -p build/website - -rm -rf build/website/* - mv hugo/public/* build/website - @echo TODO: add generate-code to this target - -pdf: diagrams build-hugo # org2md - @echo TODO: add generate-code to this target - bin/build-pdf.sh - -build-hugo: hugo-src $(shell find hugo/content | grep '.md') - cd hugo && hugo - -hugo-src: $(shell find src | grep '.md') hugo/data/version.yml - rm -rf hugo/content/docs - cp -r src hugo/content/docs - # ox-hugo exports to src/content, so we need to copy that also. - cp -R src/content/ hugo/content/docs - mkdir -p hugo/content/ox-hugo - cp src/static/ox-hugo/* hugo/content/ox-hugo - -# run this every time. -hugo/data/version.yml: src/version.yml .PHONY - bin/write-spec-version.sh <$< >$@ - -# this is used to get "serve-and-watch" working. trick is to use -hugo-src-rsync: $(shell find src | grep '.md') gen-code diagrams - @mkdir -p hugo/content/docs - rsync -av --inplace src/ hugo/content/docs - printf " " >> hugo/content/_index.md # force reload - printf " " >> hugo/content/menu/index.md # force reload - -watch-hugo: .PHONY - bin/watcher --cmd="make hugo-src-rsync" --startcmd src 2>/dev/null - -clean-hugo: .PHONY - rm -rf hugo/content/docs - -all-orient: .PHONY orient - bin/build-spec-orient.sh - -ORIENT_FILES=$(shell find src -name '*.orient') -ORIENT_INPUT_FILES= $(patsubst %.orient, %.json, $(ORIENT_FILES)) -ORIENT_OUTPUT_FILES=$(patsubst src/%.orient, build/%.orient.json, $(ORIENT_FILES)) -orient: $(ORIENT_OUTPUT_FILES) - -$(ORIENT_OUTPUT_FILES): build/%.orient.json: src/%.orient src/%.json - bin/solve-orient.sh $+ $@ - -# convert orgmode to markdown -ORG_FILES=$(shell find src | grep .org) -ORG_MD_FILES=$(patsubst %.org, %.md, $(ORG_FILES)) -org2md: $(ORG_MD_FILES) -%.md: %.org - # use emacs to compile. - # cd to each target's directory, run there - # this should invoke orient - # this should produce hugo markdown output - - # Skip this until batch-mode build issues are resolve. - # bin/org2hugomd.el <$< >$@ - - -# building our tools -bins: bin/codeGen bin/watcher - -bin/codeGen: $(shell find tools/codeGen | grep .go) - cd tools/codeGen && go build -o ../../bin/codeGen - -bin/watcher: - go get -u github.com/radovskyb/watcher/... - go build -o $@ github.com/radovskyb/watcher/cmd/watcher - -test-codeGen: bin/codeGen - cd tools/codeGen && go build && go test ./... - # cd tools/codeGen/test_cases && make test # this is broken - -# other - -serve: build-hugo .PHONY - echo "run 'make website' and refresh to update" - cd hugo && hugo serve --noHTTPCache - -serve-website: website .PHONY - # use this if `make serve` breaks - echo "run 'make website' and refresh to update" - cd build/website && python -m SimpleHTTPServer 1313 - -serve-and-watch: serve watch-hugo - echo "make sure you run this with 'make -j2'" - -.PHONY: - -# code generation and building targets - -GO_INPUT_FILES=$(shell find src -iname '*.go' | grep -v ^src/actors) -GO_OUTPUT_FILES=$(patsubst src/%.go, build/code/%.go, $(GO_INPUT_FILES)) - -GO_UTIL_INPUT_FILE=tools/codeGen/util/util.go -GO_UTIL_OUTPUT_FILE=build/code/util/util.go - -$(GO_UTIL_OUTPUT_FILE): $(GO_UTIL_INPUT_FILE) - mkdir -p $(dir $@) - cp $< $@ - -build/code/%.go: src/%.go - mkdir -p $(dir $@) - cp $< $@ - -ID_FILES=$(shell find src -name '*.id') -GEN_GO_FILES=$(patsubst src/%.id, build/code/%.gen.go, $(ID_FILES)) -build/code/%.gen.go: src/%.id bin/codeGen - mkdir -p $(dir $@) - -bin/codeGen gen $< $@ - -gen-code: bin/codeGen build/code/go.mod $(GEN_GO_FILES) $(GO_OUTPUT_FILES) $(GO_UTIL_OUTPUT_FILE) - -build/code/go.mod: src/build_go.mod - mkdir -p $(dir $@) - cp $< $@ - -build-code: gen-code - cd build/code && go build -gcflags="-e" ./... - -test-code: build-code - cd build/code && go test ./... - -clean-code: - rm -rf build/code - -fmt-code: bin/codeGen - bin/codeGen fmt ./src/... - go fmt ./src/... - go fmt ./tools/... - go fmt ./build/code/... - -watch-code: .PHONY - bin/watcher --cmd="make build-code" --startcmd src 2>/dev/null - -## diagrams - -DOTs=$(shell find src -name '*.dot') -MMDs=$(shell find src -name '*.mmd') -SVGs=$(DOTs:%=%.svg) $(MMDs:%=%.svg) - -diagrams: ${SVGs} - -watch-diagrams: diagrams - bin/watcher --cmd="make diagrams" --startcmd src 2>/dev/null - -%.dot.svg: %.dot - @which dot >/dev/null || echo "requires dot (graphviz) -- run make deps" && exit - dot -Tsvg $< >$@ - -%.mmd.svg: %.mmd %.mmd.css - deps/node_modules/.bin/mmdc -i $< -o $@ --cssFile $(word 2,$^) diff --git a/README.md b/README.md index a8ff4e26c..7bcd5841b 100644 --- a/README.md +++ b/README.md @@ -1,166 +1,208 @@ -# Filecoin Specification +## Install -[![CircleCI](https://circleci.com/gh/filecoin-project/specs/tree/master.svg?style=svg)](https://circleci.com/gh/filecoin-project/specs/tree/master) - -This is the [Filecoin Specification](https://github.com/filecoin-project/specs), a repository that contains documents, code, models, and diagrams that constitute the specification of the [Filecoin Protocol](https://filecoin.io). This repository is the singular source of truth for the Filecoin Protocol. All implementations of the Filecoin Protocol should match and comply with the descriptions, interfaces, code, and models defined in this specification. - -Note that the `master` branch of the specs moves quickly. We work to merge PRs as fast as possible into master, which means changes or reversals are possible here. Accordingly, we periodically compile swaths of spec along with a high-level difflog into the `release` branch. As the spec stabilizes, this practice will change. - -## View Website - -https://filecoin-project.github.io/specs is the user-friendly website rendering, which we recommend for reading this repository. The website is updated automatically with every merge to `master`. - -## Contributing - -Please [read the spec process](https://filecoin-project.github.io/specs/#intro__process). Please file PRs on github with fixes. +```sh +git clone https://github.com/filecoin-project/specs.git +cd next # until we move this top level +yarn install +``` ## Develop -### Install - -- Make sure you have installed `go` on your machine. - +### Update submodules +```sh +git submodule update --init ``` -git clone https://github.com/filecoin-project/specs filecoin-specs -cd filecoin-specs -make deps-basic -``` - -### Build +### Serve with Live Reload +```sh +yarn serve +# open http://localhost:1313/ in the browser ``` -make build +# Shortcodes +### `Mermaid` +Inline mermaid syntax rendering +```html +{{< mermaid >}} +graph TD + A[Christmas] -->|Get money| B(Go shopping) + B --> C{Let me think} + C -->|One| D[Laptop] + C -->|Two| E[iPhone] + C -->|Three| F[fa:fa-car Car] + +{{}} ``` -### Serve +### `svg` +This shortcode includes zoom and pad features. +```html + +{{< svg src="pull-flow.mmd.svg" title="Data Transfer - Pull Flow" >}} + +{{< svg src="/systems/pull-flow.mmd.svg" title="Data Transfer - Pull Flow" >}} ``` -make serve -``` - -This will write out an HTTP address to check out with your browser. Most likely: http://localhost:1313 - -### Update actors - -The actor code lives in https://github.com/filecoin-project/specs-actors. It is imported: - -- into the compilation as a Go module, configured in src/build_go.mod -- into the webside as a Git submodule at src/actors - -To change the code, edit in the home repository and then update _both_ the build_go.mod and submodule to point to the new ref. -You should probably make a release of the specs-actors repo for ease of referring to it as a Go module. - -### Website +### `hint` +```md + +{{< hint info >}} +**Markdown content** +Lorem markdownum insigne. Olympo signis Delphis! Retexi Nereius nova develat +stringit, frustra Saturnius uteroque inter! Oculis non ritibus Telethusa +{{< /hint >}} ``` -make website +### `figure` +```md +{{< figure src="diagrams/pieces.png" title="Pieces, Proving Trees, and Piece Data Structures" zoom="true">}} ``` -### Diagrams - -Install dependencies for diagram making +### `embed` +```md +# src relative to the page +{{}} -``` -make deps-diag +# src relative to content folder +{{}} ``` -Render diagrams -``` -make diagrams +# Frontmatter +```md +title: Libraries +description: Libraries used from Filecoin +weight: 3 +bookCollapseSection: true +bookhidden: true +dashboardAudit: 1 +dashboardState: wip +dashboardInterface: stable ``` -Make sure to check in your rendered output (`*.dot.svg` and `*.mmd.svg`) so that others dont need to install diagram building deps. +# Code fences -### Orient and Org mode - -Install dependencies for org mode and orient - -``` -make deps-orient -``` +They should **always** have a lang, if you don't know or don't care just use `text` -Without these, you won't be able to compile `.org` files, and they may be missing from the document output. +```text -## Overviews +```text +Random plain text context ... +`` -### Build System Overview +``` +# Document header +The first heading should be # Head with `---` like below and should refer to the overall title of the document. The right nav **only** starts on the second level of headings. -Given the complexity of the protocol, a build system is introduced to leverage the power of modern programs and improve understanding, efficiency, consistency, and velocity of Filecoin spec development. The Filecoin spec is organized into subcomponents as defined in `src/` with high-level and introductory sections in `Introduction` and `Algorithmns`, detailed spec on different Filecoin systems in `Systems`, followed by `Listings`, `Glossary`, and `Appendix`. +```md +--- +title: Storage Power Actor +--- -For every subsystem in the Filecoin spec, it must always have a markdown file that specifies the component. Wherever possible and necessary, an `.id` file should be included to automatically generate compiled `.go` files that can be tested to ensure build consistency and served from `hugo`. Similarly, contributors should include an `.orient` file that describes mathematical constraints in a component of the system. `Orient`, a language created to write constraints and models about the system, is used to perform ubercalc and generate artifacts about the system. To facilitate in line code display, an `.org` file can also be included to interweave output from ubercalc and markdown. +# Storage Power Actor +--- - +## Header for a section in this document +Some text -#### Adding new sections +### Sub header for the a nested section -The specification is broken down into 5 levels (`#.#.#.#.#`). The L1 and L2 numbers in this sequence are determined by the first two directories extending from `/src/`; for example, `/src/systems/filecoin_mining/` resolves to `2.6.`. +## Another top level header +``` -The L3 number is generated by creating an additional directory within a L2 directory, containing its own appropriately formatted `index.md`. This new directory name must then be added to the `entries` field of the L2 `index.md` file, sequentially ordered as they are to be within the specification. -Further L4 and L5 subsections are added using the `##` and `###` headers respectively within a the content of a L3 section's `index.md` file. +# References +## Markdown links **(Recommended)** +These links use "portable links" just like `relref` so you can just give it the name of the file and it will fetch the correct relative link and title for the `` automatically. +You can override the `` title by passing a second `string` in the link definition. -### System Overview +**Note**: When using anchors the title can't be fetched automatically. +```md +[Storage Power](storage_power_consensus) +# Storage Power - +[Storage Power](storage_power_consensus "Title to override the page original title") +# Storage Power -## Detailed Build Usage +[Tickets](storage_power_consensus#the-ticket-chain-and-drawing-randomness "The Ticket chain and drawing randomness") +# Tickets -```makefile -> make help -SYNOPSIS - make -- filecoin spec build toolchain commands +``` -USAGE - make deps-basic run this once, to install & build basic dependencies - make build run this every time you want to re-build artifacts +## Hugo Cross Refs +Check Hugo's documentation [here](https://gohugo.io/content-management/shortcodes/#ref-and-relref) +```md +[Random]({{}}) +[Pledge Collateral]({{}}) +``` +## Link shortcode +Theres also `link` shortcode which will fetch the title of the page automatically and use it for the `` text and title, but **DOES NOT** work with anchors (`#anchor-id`) +```md +{{}} +# Storage Power Consensus +``` -MAIN TARGETS - make help description of the targets (this message) - make build build all final artifacts (website only for now) - make test run all test cases (test-code only for now) - make drafts publish artifacts to ipfs and show an address - make publish publish final artifacts to spec website (github pages) - make clean removes all build artifacts. you shouldn't need this - make serve start hugo in serving mode -- must run 'make build' on changes manually +## Math mode +For short snippets of math text you can just use the `{{}}` shortcode, but if you need to write lots of math in a page you can just use `math-mode` and avoid writting the katex shortcode everywhere. -INSTALL DEPENDENCIES - make deps install ALL dependencies of this tool chain - make deps-basic install minimal dependencies of this tool chain - make deps-diag install dependencies for rendering diagrams - make deps-orient install dependencies for running orient - make deps-ouser install dependencies for orient user-environment tooling - make bins compile some build tools whose source is in this repo +Parses math typesetting with [KaTeX](https://katex.org/docs/api.html) -INTERMEDIATE TARGETS - make website build the website artifact - make diagrams build diagram artifacts ({dot, mmd} -> svg) - make org2md run org mode to markdown compilation +Check this example [example](https://deploy-preview-969--fil-spec-staging.netlify.app/math-mode/) -HUGO TARGETS - make hugo-src copy sources into hugo dir - make build-hugo run the hugo part of the pipeline - make watch-hugo watch and rebuild hugo +> Some syntax like `\_` can't go through HUGO markdown parser and for that reason we need to wrap math text with code blocks, code fendes or the shortcode `{{}}`. See examples below. +### Add `math-mode` prop to the Frontmatter +```md +--- +title: Math Mode +math-mode: true +--- +``` -CODE TARGETS - make gen-code generate code artifacts (eg id -> go) - make test-code run test cases in code artifacts - make build-code build all src go code (test it) - make clean-code remove build code artifacts - make watch-code watch and rebuild code +### Wrap `def`, `gdef`, etc. +Math text needs to be wrapped to avoid Hugo's Markdown parser. When wrapping defs or any math block that doesn't need to be rendered the recommended option is to use the shortcode `{{}} +``` -CLEAN TARGETS - make clean remove all build artifacts - make clean-deps remove (some of) the dependencies installed in this repo - make clean-hugo remove intermediate hugo artifacts - make clean-code remove build code artifacts +### Wrap inline math text with code blocks +```md +The index of a node in a `$\BinTree$` layer `$l$`. The leftmost node in a tree has `$\index_l = 0$`. +``` -WATCH TARGETS - make serve-and-watch -j2 serve, watch, and rebuild all - works for live edit - make watch-code watch and rebuild code - make watch-hugo watch and rebuild hugo +### Wrap math blocks with code fences +~~~md +```text +$\overline{\underline{\Function \BinTree\dot\createproof(c: \NodeIndex) \rightarrow \BinTreeProof_c}}$ +$\line{1}{\bi}{\leaf: \Safe = \BinTree\dot\leaves[c]}$ +$\line{2}{\bi}{\root: \Safe = \BinTree\dot\root}$ + +$\line{3}{\bi}{\path: \BinPathElement^{[\BinTreeDepth]}= [\ ]}$ +$\line{4}{\bi}{\for l \in [\BinTreeDepth]:}$ +$\line{5}{\bi}{\quad \index_l: [\len(\BinTree\dot\layer_l)] = c \gg l}$ +$\line{6}{\bi}{\quad \missing: \Bit = \index_l \AND 1}$ +$\line{7}{\bi}{\quad \sibling: \Safe = \if \missing = 0:}$ +$\quad\quad\quad \BinTree\dot\layer_l[\index_l + 1]$ +$\quad\quad\thin \else:$ +$\quad\quad\quad \BinTree\dot\layer_l[\index_l - 1]$ +$\line{8}{\bi}{\quad \path\dot\push(\BinPathElement \thin \{\ \sibling, \thin \missing\ \} \thin )}$ + +$\line{9}{\bi}{\return \BinTreeProof_c \thin \{\ \leaf, \thin \root, \thin \path\ \}}$ ``` +~~~ + +## References +- [hugo theme book](https://themes.gohugo.io//theme/hugo-book/docs/shortcodes/columns/) +- [Katex](https://katex.org/) +- [Mermaid](https://mermaid-js.github.io/mermaid/#/) + - [config](https://github.com/mermaid-js/mermaid/blob/master/docs/mermaidAPI.md#mermaidapi-configuration-defaults) + - [editor](https://mermaid-js.github.io/mermaid-live-editor) +- [Pan/Zoom for SVG](https://github.com/anvaka/panzoom) +- [Icons](https://css.gg/) +- [Working with submodules](https://github.blog/2016-02-01-working-with-submodules/) \ No newline at end of file diff --git a/README_OLD.md b/README_OLD.md new file mode 100644 index 000000000..a8ff4e26c --- /dev/null +++ b/README_OLD.md @@ -0,0 +1,166 @@ +# Filecoin Specification + +[![CircleCI](https://circleci.com/gh/filecoin-project/specs/tree/master.svg?style=svg)](https://circleci.com/gh/filecoin-project/specs/tree/master) + +This is the [Filecoin Specification](https://github.com/filecoin-project/specs), a repository that contains documents, code, models, and diagrams that constitute the specification of the [Filecoin Protocol](https://filecoin.io). This repository is the singular source of truth for the Filecoin Protocol. All implementations of the Filecoin Protocol should match and comply with the descriptions, interfaces, code, and models defined in this specification. + +Note that the `master` branch of the specs moves quickly. We work to merge PRs as fast as possible into master, which means changes or reversals are possible here. Accordingly, we periodically compile swaths of spec along with a high-level difflog into the `release` branch. As the spec stabilizes, this practice will change. + +## View Website + +https://filecoin-project.github.io/specs is the user-friendly website rendering, which we recommend for reading this repository. The website is updated automatically with every merge to `master`. + +## Contributing + +Please [read the spec process](https://filecoin-project.github.io/specs/#intro__process). Please file PRs on github with fixes. + +## Develop + +### Install + +- Make sure you have installed `go` on your machine. + +``` +git clone https://github.com/filecoin-project/specs filecoin-specs +cd filecoin-specs +make deps-basic +``` + +### Build + +``` +make build +``` + +### Serve + +``` +make serve +``` + +This will write out an HTTP address to check out with your browser. Most likely: http://localhost:1313 + +### Update actors + +The actor code lives in https://github.com/filecoin-project/specs-actors. It is imported: + +- into the compilation as a Go module, configured in src/build_go.mod +- into the webside as a Git submodule at src/actors + +To change the code, edit in the home repository and then update _both_ the build_go.mod and submodule to point to the new ref. +You should probably make a release of the specs-actors repo for ease of referring to it as a Go module. + +### Website + +``` +make website +``` + +### Diagrams + +Install dependencies for diagram making + +``` +make deps-diag +``` + +Render diagrams + +``` +make diagrams +``` + +Make sure to check in your rendered output (`*.dot.svg` and `*.mmd.svg`) so that others dont need to install diagram building deps. + +### Orient and Org mode + +Install dependencies for org mode and orient + +``` +make deps-orient +``` + +Without these, you won't be able to compile `.org` files, and they may be missing from the document output. + +## Overviews + +### Build System Overview + +Given the complexity of the protocol, a build system is introduced to leverage the power of modern programs and improve understanding, efficiency, consistency, and velocity of Filecoin spec development. The Filecoin spec is organized into subcomponents as defined in `src/` with high-level and introductory sections in `Introduction` and `Algorithmns`, detailed spec on different Filecoin systems in `Systems`, followed by `Listings`, `Glossary`, and `Appendix`. + +For every subsystem in the Filecoin spec, it must always have a markdown file that specifies the component. Wherever possible and necessary, an `.id` file should be included to automatically generate compiled `.go` files that can be tested to ensure build consistency and served from `hugo`. Similarly, contributors should include an `.orient` file that describes mathematical constraints in a component of the system. `Orient`, a language created to write constraints and models about the system, is used to perform ubercalc and generate artifacts about the system. To facilitate in line code display, an `.org` file can also be included to interweave output from ubercalc and markdown. + + + +#### Adding new sections + +The specification is broken down into 5 levels (`#.#.#.#.#`). The L1 and L2 numbers in this sequence are determined by the first two directories extending from `/src/`; for example, `/src/systems/filecoin_mining/` resolves to `2.6.`. + +The L3 number is generated by creating an additional directory within a L2 directory, containing its own appropriately formatted `index.md`. This new directory name must then be added to the `entries` field of the L2 `index.md` file, sequentially ordered as they are to be within the specification. + +Further L4 and L5 subsections are added using the `##` and `###` headers respectively within a the content of a L3 section's `index.md` file. + +### System Overview + + + +## Detailed Build Usage + +```makefile +> make help +SYNOPSIS + make -- filecoin spec build toolchain commands + +USAGE + make deps-basic run this once, to install & build basic dependencies + make build run this every time you want to re-build artifacts + +MAIN TARGETS + make help description of the targets (this message) + make build build all final artifacts (website only for now) + make test run all test cases (test-code only for now) + make drafts publish artifacts to ipfs and show an address + make publish publish final artifacts to spec website (github pages) + make clean removes all build artifacts. you shouldn't need this + make serve start hugo in serving mode -- must run 'make build' on changes manually + +INSTALL DEPENDENCIES + make deps install ALL dependencies of this tool chain + make deps-basic install minimal dependencies of this tool chain + make deps-diag install dependencies for rendering diagrams + make deps-orient install dependencies for running orient + make deps-ouser install dependencies for orient user-environment tooling + make bins compile some build tools whose source is in this repo + +INTERMEDIATE TARGETS + make website build the website artifact + make diagrams build diagram artifacts ({dot, mmd} -> svg) + make org2md run org mode to markdown compilation + +HUGO TARGETS + make hugo-src copy sources into hugo dir + make build-hugo run the hugo part of the pipeline + make watch-hugo watch and rebuild hugo + +CODE TARGETS + make gen-code generate code artifacts (eg id -> go) + make test-code run test cases in code artifacts + make build-code build all src go code (test it) + make clean-code remove build code artifacts + make watch-code watch and rebuild code + +CLEAN TARGETS + make clean remove all build artifacts + make clean-deps remove (some of) the dependencies installed in this repo + make clean-hugo remove intermediate hugo artifacts + make clean-code remove build code artifacts + +WATCH TARGETS + make serve-and-watch -j2 serve, watch, and rebuild all - works for live edit + make watch-code watch and rebuild code + make watch-hugo watch and rebuild hugo +``` diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/big/int.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/big/int.go new file mode 100644 index 000000000..15f687bd0 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/big/int.go @@ -0,0 +1,321 @@ +package big + +import ( + "encoding/json" + "fmt" + "io" + "math/big" + + cbg "github.com/whyrusleeping/cbor-gen" +) + +// BigIntMaxSerializedLen is the max length of a byte slice representing a CBOR serialized big. +const BigIntMaxSerializedLen = 128 + +type Int struct { + *big.Int +} + +func NewInt(i int64) Int { + return Int{big.NewInt(0).SetInt64(i)} +} + +func NewIntUnsigned(i uint64) Int { + return Int{big.NewInt(0).SetUint64(i)} +} + +func Zero() Int { + return NewInt(0) +} + +// PositiveFromUnsignedBytes interprets b as the bytes of a big-endian unsigned +// integer and returns a positive Int with this absolute value. +func PositiveFromUnsignedBytes(b []byte) Int { + i := big.NewInt(0).SetBytes(b) + return Int{i} +} + +func FromString(s string) (Int, error) { + v, ok := big.NewInt(0).SetString(s, 10) + if !ok { + return Int{}, fmt.Errorf("failed to parse string as a big int") + } + + return Int{v}, nil +} + +func (bi Int) Copy() Int { + cpy := Int{} + cpy.Int.Set(bi.Int) + return cpy +} + +func Product(ints ...Int) Int { + p := NewInt(1) + for _, i := range ints { + p = Mul(p, i) + } + return p +} + +func Mul(a, b Int) Int { + return Int{big.NewInt(0).Mul(a.Int, b.Int)} +} + +func Div(a, b Int) Int { + return Int{big.NewInt(0).Div(a.Int, b.Int)} +} + +func Mod(a, b Int) Int { + return Int{big.NewInt(0).Mod(a.Int, b.Int)} +} + +func Add(a, b Int) Int { + return Int{big.NewInt(0).Add(a.Int, b.Int)} +} + +func Sum(ints ...Int) Int { + sum := Zero() + for _, i := range ints { + sum = Add(sum, i) + } + return sum +} + +func Subtract(num1 Int, ints ...Int) Int { + sub := num1 + for _, i := range ints { + sub = Sub(sub, i) + } + return sub +} + +func Sub(a, b Int) Int { + return Int{big.NewInt(0).Sub(a.Int, b.Int)} +} + +// Returns a**e unless e <= 0 (in which case returns 1). +func Exp(a Int, e Int) Int { + return Int{big.NewInt(0).Exp(a.Int, e.Int, nil)} +} + +// Returns x << n +func Lsh(a Int, n uint) Int { + return Int{big.NewInt(0).Lsh(a.Int, n)} +} + +// Returns x >> n +func Rsh(a Int, n uint) Int { + return Int{big.NewInt(0).Rsh(a.Int, n)} +} + +func BitLen(a Int) uint { + return uint(a.Int.BitLen()) +} + +func Max(x, y Int) Int { + // taken from max.Max() + if x.Equals(Zero()) && x.Equals(y) { + if x.Sign() != 0 { + return y + } + return x + } + if x.GreaterThan(y) { + return x + } + return y +} + +func Min(x, y Int) Int { + // taken from max.Min() + if x.Equals(Zero()) && x.Equals(y) { + if x.Sign() != 0 { + return x + } + return y + } + if x.LessThan(y) { + return x + } + return y +} + +func Cmp(a, b Int) int { + return a.Int.Cmp(b.Int) +} + +// LessThan returns true if bi < o +func (bi Int) LessThan(o Int) bool { + return Cmp(bi, o) < 0 +} + +// LessThanEqual returns true if bi <= o +func (bi Int) LessThanEqual(o Int) bool { + return bi.LessThan(o) || bi.Equals(o) +} + +// GreaterThan returns true if bi > o +func (bi Int) GreaterThan(o Int) bool { + return Cmp(bi, o) > 0 +} + +// GreaterThanEqual returns true if bi >= o +func (bi Int) GreaterThanEqual(o Int) bool { + return bi.GreaterThan(o) || bi.Equals(o) +} + +// Neg returns the negative of bi. +func (bi Int) Neg() Int { + return Int{big.NewInt(0).Neg(bi.Int)} +} + +// Equals returns true if bi == o +func (bi Int) Equals(o Int) bool { + return Cmp(bi, o) == 0 +} + +func (bi *Int) MarshalJSON() ([]byte, error) { + if bi.Int == nil { + zero := Zero() + return json.Marshal(zero) + } + return json.Marshal(bi.String()) +} + +func (bi *Int) UnmarshalJSON(b []byte) error { + var s string + if err := json.Unmarshal(b, &s); err != nil { + return err + } + + i, ok := big.NewInt(0).SetString(s, 10) + if !ok { + return fmt.Errorf("failed to parse big string: '%s'", string(b)) + } + + bi.Int = i + return nil +} + +func (bi *Int) Bytes() ([]byte, error) { + if bi.Int == nil { + return []byte{}, fmt.Errorf("failed to convert to bytes, big is nil") + } + + switch { + case bi.Sign() > 0: + return append([]byte{0}, bi.Int.Bytes()...), nil + case bi.Sign() < 0: + return append([]byte{1}, bi.Int.Bytes()...), nil + default: // bi.Sign() == 0: + return []byte{}, nil + } +} + +func FromBytes(buf []byte) (Int, error) { + if len(buf) == 0 { + return NewInt(0), nil + } + + var negative bool + switch buf[0] { + case 0: + negative = false + case 1: + negative = true + default: + return Zero(), fmt.Errorf("big int prefix should be either 0 or 1, got %d", buf[0]) + } + + i := big.NewInt(0).SetBytes(buf[1:]) + if negative { + i.Neg(i) + } + + return Int{i}, nil +} + +func (bi *Int) MarshalBinary() ([]byte, error) { + if bi.Int == nil { + zero := Zero() + return zero.Bytes() + } + return bi.Bytes() +} + +func (bi *Int) UnmarshalBinary(buf []byte) error { + i, err := FromBytes(buf) + if err != nil { + return err + } + + *bi = i + + return nil +} + +func (bi *Int) MarshalCBOR(w io.Writer) error { + if bi.Int == nil { + zero := Zero() + return zero.MarshalCBOR(w) + } + + enc, err := bi.Bytes() + if err != nil { + return err + } + + header := cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(enc))) + if _, err := w.Write(header); err != nil { + return err + } + + if _, err := w.Write(enc); err != nil { + return err + } + + return nil +} + +func (bi *Int) UnmarshalCBOR(br io.Reader) error { + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + + if maj != cbg.MajByteString { + return fmt.Errorf("cbor input for fil big int was not a byte string (%x)", maj) + } + + if extra == 0 { + bi.Int = big.NewInt(0) + return nil + } + + if extra > BigIntMaxSerializedLen { + return fmt.Errorf("big integer byte array too long") + } + + buf := make([]byte, extra) + if _, err := io.ReadFull(br, buf); err != nil { + return err + } + + i, err := FromBytes(buf) + if err != nil { + return err + } + + *bi = i + + return nil +} + +func (bi *Int) IsZero() bool { + return bi.Int.Sign() == 0 +} + +func (bi *Int) Nil() bool { + return bi.Int == nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/big/int_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/big/int_test.go new file mode 100644 index 000000000..da3d5b34b --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/big/int_test.go @@ -0,0 +1,179 @@ +package big + +import ( + "bytes" + "fmt" + "math/big" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestBigIntSerializationRoundTrip(t *testing.T) { + testValues := []string{ + "0", "1", "10", "-10", "9999", "12345678901234567891234567890123456789012345678901234567890", + } + + for _, v := range testValues { + bi, err := FromString(v) + if err != nil { + t.Fatal(err) + } + + buf := new(bytes.Buffer) + if err := bi.MarshalCBOR(buf); err != nil { + t.Fatal(err) + } + + var out Int + if err := out.UnmarshalCBOR(buf); err != nil { + t.Fatal(err) + } + + if Cmp(out, bi) != 0 { + t.Fatal("failed to round trip Int through cbor") + } + + } + + // nil check + bi := Int{} + var buf bytes.Buffer + err := bi.MarshalCBOR(&buf) + require.NoError(t, err) + + assert.Equal(t, "@", buf.String()) + +} + +func TestNewInt(t *testing.T) { + a := int64(999) + ta := NewInt(a) + b := big.NewInt(999) + tb := Int{Int: b} + assert.True(t, ta.Equals(tb)) + assert.Equal(t, "999", ta.String()) +} + +func TestInt_MarshalUnmarshalJSON(t *testing.T) { + ta := NewInt(54321) + tb := NewInt(0) + + res, err := ta.MarshalJSON() + require.NoError(t, err) + assert.Equal(t, "\"54321\"", string(res[:])) + + require.NoError(t, tb.UnmarshalJSON(res)) + assert.Equal(t, ta, tb) + + assert.EqualError(t, tb.UnmarshalJSON([]byte("123garbage"[:])), "invalid character 'g' after top-level value") + + tnil := Int{} + s, err := tnil.MarshalJSON() + require.NoError(t, err) + assert.Equal(t, "\"0\"", string(s)) +} + +func TestOperations(t *testing.T) { + testCases := []struct { + name string + f func(Int, Int) Int + expected Int + }{ + {name: "Sum", f: Add, expected: NewInt(7000)}, + {name: "Sub", f: Sub, expected: NewInt(3000)}, + {name: "Mul", f: Mul, expected: NewInt(10000000)}, + {name: "Div", f: Div, expected: NewInt(2)}, + {name: "Mod", f: Mod, expected: NewInt(1000)}, + } + for _, testCase := range testCases { + t.Run(testCase.name, func(t *testing.T) { + ta := Int{Int: big.NewInt(5000)} + tb := Int{Int: big.NewInt(2000)} + assert.Equal(t, testCase.expected, testCase.f(ta, tb)) + }) + } + + ta := NewInt(5000) + tb := NewInt(2000) + tc := NewInt(2000) + assert.Equal(t, Cmp(ta, tb), 1) + assert.Equal(t, Cmp(tb, ta), -1) + assert.Equal(t, Cmp(tb, tc), 0) + assert.True(t, ta.GreaterThan(tb)) + assert.False(t, ta.LessThan(tb)) + assert.True(t, tb.Equals(tc)) + + ta = Int{} + assert.True(t, ta.Nil()) +} + +func TestSum(t *testing.T) { + b1 := NewInt(1) + b2 := NewInt(2) + b3 := NewInt(3) + b4 := NewInt(4) + + require.EqualValues(t, NewInt(10), Sum(b1, b2, b3, b4)) + + require.EqualValues(t, NewInt(20), Sum(NewInt(20))) +} + +func TestProduct(t *testing.T) { + b1 := NewInt(1) + b2 := NewInt(2) + b3 := NewInt(3) + b4 := NewInt(4) + + require.EqualValues(t, NewInt(24), Product(b1, b2, b3, b4)) + + require.EqualValues(t, NewInt(20), Product(NewInt(20))) +} + +func TestSubtract(t *testing.T) { + b1 := NewInt(100) + b2 := NewInt(20) + b3 := NewInt(10) + b4 := NewInt(5) + + require.EqualValues(t, NewInt(65), Subtract(b1, b2, b3, b4)) + + require.EqualValues(t, NewInt(20), Subtract(NewInt(20))) +} + +func TestInt_Format(t *testing.T) { + ta := NewInt(33333000000) + + s := fmt.Sprintf("%s", ta) // nolint: gosimple + assert.Equal(t, "33333000000", s) + + s1 := fmt.Sprintf("%v", ta) // nolint: gosimple + assert.Equal(t, "33333000000", s1) + + s2 := fmt.Sprintf("%-15d", ta) // nolint: gosimple + assert.Equal(t, "33333000000 ", s2) +} + +func TestPositveFromUnsignedBytes(t *testing.T) { + res := PositiveFromUnsignedBytes([]byte("garbage"[:])) + // garbage in, garbage out + expected := Int{Int: big.NewInt(29099066505914213)} + assert.Equal(t, expected, res) + + expected2 := Int{Int: big.NewInt(12345)} + expectedRes := expected2.Int.Bytes() + res = PositiveFromUnsignedBytes(expectedRes) + assert.Equal(t, expected2, res) + assert.Equal(t, 1, res.Sign()) // positive +} + +func TestFromString(t *testing.T) { + _, err := FromString("garbage") + assert.EqualError(t, err, "failed to parse string as a big int") + + res, err := FromString("12345") + require.NoError(t, err) + expected := Int{Int: big.NewInt(12345)} + assert.Equal(t, expected, res) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/bitfield.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/bitfield.go new file mode 100644 index 000000000..25eb825e9 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/bitfield.go @@ -0,0 +1,79 @@ +package abi + +import ( + "fmt" + + "github.com/filecoin-project/go-bitfield" + "github.com/filecoin-project/go-bitfield/rle" +) + +type BitField = bitfield.BitField + +func NewBitField() *BitField { + bf, err := bitfield.NewFromBytes([]byte{}) + if err != nil { + panic(fmt.Sprintf("creating empty rle: %+v", err)) + } + return &bf +} + +func isEmpty(iter rlepluslazy.RunIterator) (bool, error) { + // Look for the first non-zero bit. + for iter.HasNext() { + r, err := iter.NextRun() + if err != nil { + return false, err + } + if r.Val { + return false, nil + } + } + return true, nil +} + +// Checks whether bitfield `a` contains any bit that is set in bitfield `b`. +func BitFieldContainsAny(a, b *BitField) (bool, error) { + aruns, err := a.RunIterator() + if err != nil { + return false, err + } + + bruns, err := b.RunIterator() + if err != nil { + return false, err + } + + // Take the intersection of the two bitfields. + combined, err := rlepluslazy.And(aruns, bruns) + if err != nil { + return false, err + } + + // Look for the first non-zero bit. + empty, err := isEmpty(combined) + if err != nil { + return false, err + } + return !empty, nil +} + +// Checks whether bitfield `a` contains all bits set in bitfield `b`. +func BitFieldContainsAll(a, b *BitField) (bool, error) { + aruns, err := a.RunIterator() + if err != nil { + return false, err + } + + bruns, err := b.RunIterator() + if err != nil { + return false, err + } + + // Remove any elements in a from b. If b contains bits not in a, some + // bits will remain. + combined, err := rlepluslazy.Subtract(bruns, aruns) + if err != nil { + return false, err + } + return isEmpty(combined) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/bitfield_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/bitfield_test.go new file mode 100644 index 000000000..1faea73a0 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/bitfield_test.go @@ -0,0 +1,95 @@ +package abi_test + +import ( + "bytes" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/abi" +) + +func TestBitFieldUnset(t *testing.T) { + bf := abi.NewBitField() + bf.Set(1) + bf.Set(2) + bf.Set(3) + bf.Set(4) + bf.Set(5) + + bf.Unset(3) + + m, err := bf.AllMap(100) + assert.NoError(t, err) + _, found := m[3] + assert.False(t, found) + + cnt, err := bf.Count() + assert.NoError(t, err) + assert.Equal(t, uint64(4), cnt) + + bf2 := roundtripMarshal(t, bf) + + cnt, err = bf2.Count() + assert.NoError(t, err) + assert.Equal(t, uint64(4), cnt) + + m, err = bf.AllMap(100) + assert.NoError(t, err) + _, found = m[3] + assert.False(t, found) +} + +func roundtripMarshal(t *testing.T, in *abi.BitField) *abi.BitField { + buf := new(bytes.Buffer) + err := in.MarshalCBOR(buf) + assert.NoError(t, err) + + bf2 := abi.NewBitField() + err = bf2.UnmarshalCBOR(buf) + assert.NoError(t, err) + return bf2 +} + +func TestBitFieldContains(t *testing.T) { + a := abi.NewBitField() + a.Set(2) + a.Set(4) + a.Set(5) + + b := abi.NewBitField() + b.Set(3) + b.Set(4) + + c := abi.NewBitField() + c.Set(2) + c.Set(5) + + assertContainsAny := func(a, b *abi.BitField, expected bool) { + t.Helper() + actual, err := abi.BitFieldContainsAny(a, b) + assert.NoError(t, err) + assert.Equal(t, expected, actual) + } + + assertContainsAll := func(a, b *abi.BitField, expected bool) { + t.Helper() + actual, err := abi.BitFieldContainsAll(a, b) + assert.NoError(t, err) + assert.Equal(t, expected, actual) + } + + assertContainsAny(a, b, true) + assertContainsAny(b, a, true) + assertContainsAny(a, c, true) + assertContainsAny(c, a, true) + assertContainsAny(b, c, false) + assertContainsAny(c, b, false) + + assertContainsAll(a, b, false) + assertContainsAll(b, a, false) + assertContainsAll(a, c, true) + assertContainsAll(c, a, false) + assertContainsAll(b, c, false) + assertContainsAll(c, b, false) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/cbor_gen.go new file mode 100644 index 000000000..24d86e0dd --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/cbor_gen.go @@ -0,0 +1,929 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package abi + +import ( + "fmt" + "io" + + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *PieceInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Size (abi.PaddedPieceSize) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Size))); err != nil { + return err + } + + // t.PieceCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.PieceCID); err != nil { + return xerrors.Errorf("failed to write cid field t.PieceCID: %w", err) + } + + return nil +} + +func (t *PieceInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Size (abi.PaddedPieceSize) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Size = PaddedPieceSize(extra) + + } + // t.PieceCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.PieceCID: %w", err) + } + + t.PieceCID = c + + } + return nil +} + +func (t *SectorID) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Miner (abi.ActorID) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Miner))); err != nil { + return err + } + + // t.Number (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Number))); err != nil { + return err + } + + return nil +} + +func (t *SectorID) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Miner (abi.ActorID) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Miner = ActorID(extra) + + } + // t.Number (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Number = SectorNumber(extra) + + } + return nil +} + +func (t *SectorInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + if t.SealProof >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProof))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProof)-1)); err != nil { + return err + } + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { + return err + } + + // t.SealedCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.SealedCID); err != nil { + return xerrors.Errorf("failed to write cid field t.SealedCID: %w", err) + } + + return nil +} + +func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProof = RegisteredSealProof(extraI) + } + // t.SectorNumber (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorNumber = SectorNumber(extra) + + } + // t.SealedCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.SealedCID: %w", err) + } + + t.SealedCID = c + + } + return nil +} + +func (t *SealVerifyInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{136}); err != nil { + return err + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + if t.SealProof >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProof))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProof)-1)); err != nil { + return err + } + } + + // t.SectorID (abi.SectorID) (struct) + if err := t.SectorID.MarshalCBOR(w); err != nil { + return err + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.Randomness (abi.SealRandomness) (slice) + if len(t.Randomness) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Randomness was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Randomness)))); err != nil { + return err + } + if _, err := w.Write(t.Randomness); err != nil { + return err + } + + // t.InteractiveRandomness (abi.InteractiveSealRandomness) (slice) + if len(t.InteractiveRandomness) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.InteractiveRandomness was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.InteractiveRandomness)))); err != nil { + return err + } + if _, err := w.Write(t.InteractiveRandomness); err != nil { + return err + } + + // t.Proof ([]uint8) (slice) + if len(t.Proof) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Proof was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil { + return err + } + if _, err := w.Write(t.Proof); err != nil { + return err + } + + // t.SealedCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.SealedCID); err != nil { + return xerrors.Errorf("failed to write cid field t.SealedCID: %w", err) + } + + // t.UnsealedCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.UnsealedCID); err != nil { + return xerrors.Errorf("failed to write cid field t.UnsealedCID: %w", err) + } + + return nil +} + +func (t *SealVerifyInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 8 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProof = RegisteredSealProof(extraI) + } + // t.SectorID (abi.SectorID) (struct) + + { + + if err := t.SectorID.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.SectorID: %w", err) + } + + } + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = DealID(val) + } + + // t.Randomness (abi.SealRandomness) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Randomness: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Randomness = make([]byte, extra) + if _, err := io.ReadFull(br, t.Randomness); err != nil { + return err + } + // t.InteractiveRandomness (abi.InteractiveSealRandomness) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.InteractiveRandomness: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.InteractiveRandomness = make([]byte, extra) + if _, err := io.ReadFull(br, t.InteractiveRandomness); err != nil { + return err + } + // t.Proof ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Proof: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Proof = make([]byte, extra) + if _, err := io.ReadFull(br, t.Proof); err != nil { + return err + } + // t.SealedCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.SealedCID: %w", err) + } + + t.SealedCID = c + + } + // t.UnsealedCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.UnsealedCID: %w", err) + } + + t.UnsealedCID = c + + } + return nil +} + +func (t *PoStProof) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.PoStProof (abi.RegisteredPoStProof) (int64) + if t.PoStProof >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.PoStProof))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.PoStProof)-1)); err != nil { + return err + } + } + + // t.ProofBytes ([]uint8) (slice) + if len(t.ProofBytes) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.ProofBytes was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.ProofBytes)))); err != nil { + return err + } + if _, err := w.Write(t.ProofBytes); err != nil { + return err + } + return nil +} + +func (t *PoStProof) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.PoStProof (abi.RegisteredPoStProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.PoStProof = RegisteredPoStProof(extraI) + } + // t.ProofBytes ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.ProofBytes: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.ProofBytes = make([]byte, extra) + if _, err := io.ReadFull(br, t.ProofBytes); err != nil { + return err + } + return nil +} + +func (t *WindowPoStVerifyInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.Randomness (abi.PoStRandomness) (slice) + if len(t.Randomness) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Randomness was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Randomness)))); err != nil { + return err + } + if _, err := w.Write(t.Randomness); err != nil { + return err + } + + // t.Proofs ([]abi.PoStProof) (slice) + if len(t.Proofs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Proofs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Proofs)))); err != nil { + return err + } + for _, v := range t.Proofs { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.ChallengedSectors ([]abi.SectorInfo) (slice) + if len(t.ChallengedSectors) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.ChallengedSectors was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.ChallengedSectors)))); err != nil { + return err + } + for _, v := range t.ChallengedSectors { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.Prover (abi.ActorID) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Prover))); err != nil { + return err + } + + return nil +} + +func (t *WindowPoStVerifyInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Randomness (abi.PoStRandomness) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Randomness: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Randomness = make([]byte, extra) + if _, err := io.ReadFull(br, t.Randomness); err != nil { + return err + } + // t.Proofs ([]abi.PoStProof) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Proofs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Proofs = make([]PoStProof, extra) + } + + for i := 0; i < int(extra); i++ { + + var v PoStProof + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Proofs[i] = v + } + + // t.ChallengedSectors ([]abi.SectorInfo) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.ChallengedSectors: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.ChallengedSectors = make([]SectorInfo, extra) + } + + for i := 0; i < int(extra); i++ { + + var v SectorInfo + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.ChallengedSectors[i] = v + } + + // t.Prover (abi.ActorID) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Prover = ActorID(extra) + + } + return nil +} + +func (t *WinningPoStVerifyInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.Randomness (abi.PoStRandomness) (slice) + if len(t.Randomness) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Randomness was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Randomness)))); err != nil { + return err + } + if _, err := w.Write(t.Randomness); err != nil { + return err + } + + // t.Proofs ([]abi.PoStProof) (slice) + if len(t.Proofs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Proofs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Proofs)))); err != nil { + return err + } + for _, v := range t.Proofs { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.ChallengedSectors ([]abi.SectorInfo) (slice) + if len(t.ChallengedSectors) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.ChallengedSectors was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.ChallengedSectors)))); err != nil { + return err + } + for _, v := range t.ChallengedSectors { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.Prover (abi.ActorID) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Prover))); err != nil { + return err + } + + return nil +} + +func (t *WinningPoStVerifyInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Randomness (abi.PoStRandomness) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Randomness: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Randomness = make([]byte, extra) + if _, err := io.ReadFull(br, t.Randomness); err != nil { + return err + } + // t.Proofs ([]abi.PoStProof) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Proofs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Proofs = make([]PoStProof, extra) + } + + for i := 0; i < int(extra); i++ { + + var v PoStProof + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Proofs[i] = v + } + + // t.ChallengedSectors ([]abi.SectorInfo) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.ChallengedSectors: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.ChallengedSectors = make([]SectorInfo, extra) + } + + for i := 0; i < int(extra); i++ { + + var v SectorInfo + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.ChallengedSectors[i] = v + } + + // t.Prover (abi.ActorID) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Prover = ActorID(extra) + + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/constants.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/constants.go new file mode 100644 index 000000000..cf885e702 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/constants.go @@ -0,0 +1,11 @@ +package abi + +import "github.com/filecoin-project/specs-actors/actors/abi/big" + +// Number of token units in an abstract "FIL" token. +// The network works purely in the indivisible token amounts. This constant converts to a fixed decimal with more +// human-friendly scale. +var TokenPrecision = big.NewIntUnsigned(1_000_000_000_000_000_000) + +// The maximum supply of Filecoin that will ever exist (in token units) +var TotalFilecoin = big.Mul(big.NewIntUnsigned(2_000_000_000), TokenPrecision) diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/deal.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/deal.go new file mode 100644 index 000000000..9e791c463 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/deal.go @@ -0,0 +1,9 @@ +package abi + +import big "github.com/filecoin-project/specs-actors/actors/abi/big" + +type DealID uint64 + +// BigInt types are aliases rather than new types because the latter introduce incredible amounts of noise converting to +// and from types in order to manipulate values. We give up some type safety for ergonomics. +type DealWeight = big.Int // units: byte-epochs diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/invokee.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/invokee.go new file mode 100644 index 000000000..c4aca44e3 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/invokee.go @@ -0,0 +1,5 @@ +package abi + +type Invokee interface { + Exports() []interface{} +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/piece.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/piece.go new file mode 100644 index 000000000..f54ce568e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/piece.go @@ -0,0 +1,50 @@ +package abi + +import ( + "math/bits" + + cid "github.com/ipfs/go-cid" + "github.com/pkg/errors" +) + +// UnpaddedPieceSize is the size of a piece, in bytes +type UnpaddedPieceSize uint64 +type PaddedPieceSize uint64 + +func (s UnpaddedPieceSize) Padded() PaddedPieceSize { + return PaddedPieceSize(s + (s / 127)) +} + +func (s UnpaddedPieceSize) Validate() error { + if s < 127 { + return errors.New("minimum piece size is 127 bytes") + } + + // is 127 * 2^n + if uint64(s)>>bits.TrailingZeros64(uint64(s)) != 127 { + return errors.New("unpadded piece size must be a power of 2 multiple of 127") + } + + return nil +} + +func (s PaddedPieceSize) Unpadded() UnpaddedPieceSize { + return UnpaddedPieceSize(s - (s / 128)) +} + +func (s PaddedPieceSize) Validate() error { + if s < 128 { + return errors.New("minimum padded piece size is 128 bytes") + } + + if bits.OnesCount64(uint64(s)) != 1 { + return errors.New("padded piece size must be a power of 2") + } + + return nil +} + +type PieceInfo struct { + Size PaddedPieceSize // Size in nodes. For BLS12-381 (capacity 254 bits), must be >= 16. (16 * 8 = 128) + PieceCID cid.Cid +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/piece_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/piece_test.go new file mode 100644 index 000000000..3952bb6be --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/piece_test.go @@ -0,0 +1,57 @@ +package abi + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestPieceSize(t *testing.T) { + // happy + require.NoError(t, UnpaddedPieceSize(127).Validate()) + require.NoError(t, UnpaddedPieceSize(1016).Validate()) + require.NoError(t, UnpaddedPieceSize(34091302912).Validate()) + + require.NoError(t, PaddedPieceSize(128).Validate()) + require.NoError(t, PaddedPieceSize(1024).Validate()) + require.NoError(t, PaddedPieceSize(34359738368).Validate()) + + // convert + require.Equal(t, PaddedPieceSize(128), UnpaddedPieceSize(127).Padded()) + require.Equal(t, PaddedPieceSize(1024), UnpaddedPieceSize(1016).Padded()) + require.Equal(t, PaddedPieceSize(34359738368), UnpaddedPieceSize(34091302912).Padded()) + + require.Equal(t, UnpaddedPieceSize(127), PaddedPieceSize(128).Unpadded()) + require.Equal(t, UnpaddedPieceSize(1016), PaddedPieceSize(1024).Unpadded()) + require.Equal(t, UnpaddedPieceSize(34091302912), PaddedPieceSize(34359738368).Unpadded()) + + // swap + require.NoError(t, UnpaddedPieceSize(127).Padded().Validate()) + require.NoError(t, UnpaddedPieceSize(1016).Padded().Validate()) + require.NoError(t, UnpaddedPieceSize(34091302912).Padded().Validate()) + + require.NoError(t, PaddedPieceSize(128).Unpadded().Validate()) + require.NoError(t, PaddedPieceSize(1024).Unpadded().Validate()) + require.NoError(t, PaddedPieceSize(34359738368).Unpadded().Validate()) + + // roundtrip + require.NoError(t, UnpaddedPieceSize(127).Padded().Unpadded().Validate()) + require.NoError(t, UnpaddedPieceSize(1016).Padded().Unpadded().Validate()) + require.NoError(t, UnpaddedPieceSize(34091302912).Padded().Unpadded().Validate()) + + require.NoError(t, PaddedPieceSize(128).Unpadded().Padded().Validate()) + require.NoError(t, PaddedPieceSize(1024).Unpadded().Padded().Validate()) + require.NoError(t, PaddedPieceSize(34359738368).Unpadded().Padded().Validate()) + + // unhappy + require.Error(t, UnpaddedPieceSize(9).Validate()) + require.Error(t, UnpaddedPieceSize(128).Validate()) + require.Error(t, UnpaddedPieceSize(99453687).Validate()) + require.Error(t, UnpaddedPieceSize(1016+0x1000000).Validate()) + + require.Error(t, PaddedPieceSize(8).Validate()) + require.Error(t, PaddedPieceSize(127).Validate()) + require.Error(t, PaddedPieceSize(99453687).Validate()) + require.Error(t, PaddedPieceSize(0xc00).Validate()) + require.Error(t, PaddedPieceSize(1025).Validate()) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/primitives.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/primitives.go new file mode 100644 index 000000000..8b892bcd7 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/primitives.go @@ -0,0 +1,68 @@ +package abi + +import ( + "strconv" + + "github.com/filecoin-project/specs-actors/actors/abi/big" +) + +// The abi package contains definitions of all types that cross the VM boundary and are used +// within actor code. +// +// Primitive types include numerics and opaque array types. + +// Epoch number of the chain state, which acts as a proxy for time within the VM. +type ChainEpoch int64 + +func (e ChainEpoch) String() string { + return strconv.FormatInt(int64(e), 10) +} + +// A sequential number assigned to an actor when created by the InitActor. +// This ID is embedded in ID-type addresses. +type ActorID uint64 + +func (e ActorID) String() string { + return strconv.FormatInt(int64(e), 10) +} + +// MethodNum is an integer that represents a particular method +// in an actor's function table. These numbers are used to compress +// invocation of actor code, and to decouple human language concerns +// about method names from the ability to uniquely refer to a particular +// method. +// +// Consider MethodNum numbers to be similar in concerns as for +// offsets in function tables (in programming languages), and for +// tags in ProtocolBuffer fields. Tags in ProtocolBuffers recommend +// assigning a unique tag to a field and never reusing that tag. +// If a field is no longer used, the field name may change but should +// still remain defined in the code to ensure the tag number is not +// reused accidentally. The same should apply to the MethodNum +// associated with methods in Filecoin VM Actors. +type MethodNum uint64 + +func (e MethodNum) String() string { + return strconv.FormatInt(int64(e), 10) +} + +// TokenAmount is an amount of Filecoin tokens. This type is used within +// the VM in message execution, to account movement of tokens, payment +// of VM gas, and more. +// +// BigInt types are aliases rather than new types because the latter introduce incredible amounts of noise converting to +// and from types in order to manipulate values. We give up some type safety for ergonomics. +type TokenAmount = big.Int + +func NewTokenAmount(t int64) TokenAmount { + return big.NewInt(t) +} + +// Randomness is a string of random bytes +type Randomness []byte + +// Multiaddrs is a byte array representing a Libp2p MultiAddress +type Multiaddrs = []byte + +// PeerID is a byte array representing a Libp2p PeerID +type PeerID = []byte diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/sector.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/sector.go new file mode 100644 index 000000000..b8c77d097 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/sector.go @@ -0,0 +1,265 @@ +package abi + +import ( + "fmt" + "strconv" + + cid "github.com/ipfs/go-cid" + "github.com/pkg/errors" + + big "github.com/filecoin-project/specs-actors/actors/abi/big" +) + +// SectorNumber is a numeric identifier for a sector. It is usually relative to a miner. +type SectorNumber uint64 + +func (s SectorNumber) String() string { + return strconv.FormatUint(uint64(s), 10) +} + +// SectorSize indicates one of a set of possible sizes in the network. +// Ideally, SectorSize would be an enum +// type SectorSize enum { +// 1KiB = 1024 +// 1MiB = 1048576 +// 1GiB = 1073741824 +// 1TiB = 1099511627776 +// 1PiB = 1125899906842624 +// 1EiB = 1152921504606846976 +// max = 18446744073709551615 +// } +type SectorSize uint64 + +// Formats the size as a decimal string. +func (s SectorSize) String() string { + return strconv.FormatUint(uint64(s), 10) +} + +// Abbreviates the size as a human-scale number. +// This approximates (truncates) the size unless it is a power of 1024. +func (s SectorSize) ShortString() string { + var biUnits = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"} + unit := 0 + for s >= 1024 && unit < len(biUnits)-1 { + s /= 1024 + unit++ + } + return fmt.Sprintf("%d%s", s, biUnits[unit]) +} + +type SectorID struct { + Miner ActorID + Number SectorNumber +} + +// The unit of storage power (measured in bytes) +type StoragePower = big.Int + +type SectorQuality = big.Int + +func NewStoragePower(n int64) StoragePower { + return big.NewInt(n) +} + +type RegisteredProof = int64 + +// This ordering, defines mappings to UInt in a way which MUST never change. +type RegisteredSealProof RegisteredProof + +const ( + RegisteredSealProof_StackedDrg2KiBV1 = RegisteredSealProof(0) + RegisteredSealProof_StackedDrg8MiBV1 = RegisteredSealProof(1) + RegisteredSealProof_StackedDrg512MiBV1 = RegisteredSealProof(2) + RegisteredSealProof_StackedDrg32GiBV1 = RegisteredSealProof(3) + RegisteredSealProof_StackedDrg64GiBV1 = RegisteredSealProof(4) +) + +type RegisteredPoStProof RegisteredProof + +const ( + RegisteredPoStProof_StackedDrgWinning2KiBV1 = RegisteredPoStProof(0) + RegisteredPoStProof_StackedDrgWinning8MiBV1 = RegisteredPoStProof(1) + RegisteredPoStProof_StackedDrgWinning512MiBV1 = RegisteredPoStProof(2) + RegisteredPoStProof_StackedDrgWinning32GiBV1 = RegisteredPoStProof(3) + RegisteredPoStProof_StackedDrgWinning64GiBV1 = RegisteredPoStProof(4) + RegisteredPoStProof_StackedDrgWindow2KiBV1 = RegisteredPoStProof(5) + RegisteredPoStProof_StackedDrgWindow8MiBV1 = RegisteredPoStProof(6) + RegisteredPoStProof_StackedDrgWindow512MiBV1 = RegisteredPoStProof(7) + RegisteredPoStProof_StackedDrgWindow32GiBV1 = RegisteredPoStProof(8) + RegisteredPoStProof_StackedDrgWindow64GiBV1 = RegisteredPoStProof(9) +) + +func (p RegisteredPoStProof) RegisteredSealProof() (RegisteredSealProof, error) { + switch p { + case RegisteredPoStProof_StackedDrgWinning2KiBV1, RegisteredPoStProof_StackedDrgWindow2KiBV1: + return RegisteredSealProof_StackedDrg2KiBV1, nil + case RegisteredPoStProof_StackedDrgWinning8MiBV1, RegisteredPoStProof_StackedDrgWindow8MiBV1: + return RegisteredSealProof_StackedDrg8MiBV1, nil + case RegisteredPoStProof_StackedDrgWinning512MiBV1, RegisteredPoStProof_StackedDrgWindow512MiBV1: + return RegisteredSealProof_StackedDrg512MiBV1, nil + case RegisteredPoStProof_StackedDrgWinning32GiBV1, RegisteredPoStProof_StackedDrgWindow32GiBV1: + return RegisteredSealProof_StackedDrg32GiBV1, nil + case RegisteredPoStProof_StackedDrgWinning64GiBV1, RegisteredPoStProof_StackedDrgWindow64GiBV1: + return RegisteredSealProof_StackedDrg64GiBV1, nil + default: + return 0, errors.Errorf("unsupported PoSt proof type: %v", p) + } +} + +func (p RegisteredSealProof) SectorSize() (SectorSize, error) { + switch p { + case RegisteredSealProof_StackedDrg2KiBV1: + return 2 << 10, nil + case RegisteredSealProof_StackedDrg8MiBV1: + return 8 << 20, nil + case RegisteredSealProof_StackedDrg512MiBV1: + return 512 << 20, nil + case RegisteredSealProof_StackedDrg32GiBV1: + return 32 << 30, nil + case RegisteredSealProof_StackedDrg64GiBV1: + return 2 * (32 << 30), nil + default: + return 0, errors.Errorf("unsupported proof type: %v", p) + } +} + +func (p RegisteredPoStProof) SectorSize() (SectorSize, error) { + // Resolve to seal proof and then compute size from that. + sp, err := p.RegisteredSealProof() + if err != nil { + return 0, err + } + return sp.SectorSize() +} + +// Returns the partition size, in sectors, associated with a proof type. +// The partition size is the number of sectors proved in a single PoSt proof. +func (p RegisteredSealProof) WindowPoStPartitionSectors() (uint64, error) { + // These numbers must match those used by the proofs library. + // See https://github.com/filecoin-project/rust-fil-proofs/blob/master/filecoin-proofs/src/constants.rs#L85 + switch p { + case RegisteredSealProof_StackedDrg64GiBV1: + return 2300, nil + case RegisteredSealProof_StackedDrg32GiBV1: + return 2349, nil + case RegisteredSealProof_StackedDrg2KiBV1: + return 2, nil + case RegisteredSealProof_StackedDrg8MiBV1: + return 2, nil + case RegisteredSealProof_StackedDrg512MiBV1: + return 2, nil + default: + return 0, errors.Errorf("unsupported proof type: %v", p) + } +} + +// Returns the partition size, in sectors, associated with a proof type. +// The partition size is the number of sectors proved in a single PoSt proof. +func (p RegisteredPoStProof) WindowPoStPartitionSectors() (uint64, error) { + // Resolve to seal proof and then compute size from that. + sp, err := p.RegisteredSealProof() + if err != nil { + return 0, err + } + return sp.WindowPoStPartitionSectors() +} + +// RegisteredWinningPoStProof produces the PoSt-specific RegisteredProof corresponding +// to the receiving RegisteredProof. +func (p RegisteredSealProof) RegisteredWinningPoStProof() (RegisteredPoStProof, error) { + switch p { + case RegisteredSealProof_StackedDrg64GiBV1: + return RegisteredPoStProof_StackedDrgWinning64GiBV1, nil + case RegisteredSealProof_StackedDrg32GiBV1: + return RegisteredPoStProof_StackedDrgWinning32GiBV1, nil + case RegisteredSealProof_StackedDrg2KiBV1: + return RegisteredPoStProof_StackedDrgWinning2KiBV1, nil + case RegisteredSealProof_StackedDrg8MiBV1: + return RegisteredPoStProof_StackedDrgWinning8MiBV1, nil + case RegisteredSealProof_StackedDrg512MiBV1: + return RegisteredPoStProof_StackedDrgWinning512MiBV1, nil + default: + return 0, errors.Errorf("unsupported mapping from %+v to PoSt-specific RegisteredProof", p) + } +} + +// RegisteredWindowPoStProof produces the PoSt-specific RegisteredProof corresponding +// to the receiving RegisteredProof. +func (p RegisteredSealProof) RegisteredWindowPoStProof() (RegisteredPoStProof, error) { + switch p { + case RegisteredSealProof_StackedDrg64GiBV1: + return RegisteredPoStProof_StackedDrgWindow64GiBV1, nil + case RegisteredSealProof_StackedDrg32GiBV1: + return RegisteredPoStProof_StackedDrgWindow32GiBV1, nil + case RegisteredSealProof_StackedDrg2KiBV1: + return RegisteredPoStProof_StackedDrgWindow2KiBV1, nil + case RegisteredSealProof_StackedDrg8MiBV1: + return RegisteredPoStProof_StackedDrgWindow8MiBV1, nil + case RegisteredSealProof_StackedDrg512MiBV1: + return RegisteredPoStProof_StackedDrgWindow512MiBV1, nil + default: + return 0, errors.Errorf("unsupported mapping from %+v to PoSt-specific RegisteredProof", p) + } +} + +// SectorMaximumLifetime is the maximum duration a sector sealed with this proof may exist between activation and expiration +func (p RegisteredSealProof) SectorMaximumLifetime() ChainEpoch { + // For all Stacked DRG sectors, the max is 5 years + epochsPerYear := 1_262_277 + fiveYears := 5 * epochsPerYear + return ChainEpoch(fiveYears) +} + +/// +/// Sealing +/// + +type SealRandomness Randomness +type InteractiveSealRandomness Randomness + +// Information needed to verify a seal proof. +type SealVerifyInfo struct { + SealProof RegisteredSealProof + SectorID + DealIDs []DealID + Randomness SealRandomness + InteractiveRandomness InteractiveSealRandomness + Proof []byte + SealedCID cid.Cid // CommR + UnsealedCID cid.Cid // CommD +} + +/// +/// PoSting +/// + +type PoStRandomness Randomness + +// Information about a sector necessary for PoSt verification. +type SectorInfo struct { + SealProof RegisteredSealProof // RegisteredProof used when sealing - needs to be mapped to PoSt registered proof when used to verify a PoSt + SectorNumber SectorNumber + SealedCID cid.Cid // CommR +} + +type PoStProof struct { + PoStProof RegisteredPoStProof + ProofBytes []byte +} + +// Information needed to verify a Winning PoSt attached to a block header. +// Note: this is not used within the state machine, but by the consensus/election mechanisms. +type WinningPoStVerifyInfo struct { + Randomness PoStRandomness + Proofs []PoStProof + ChallengedSectors []SectorInfo + Prover ActorID // used to derive 32-byte prover ID +} + +// Information needed to verify a Window PoSt submitted directly to a miner actor. +type WindowPoStVerifyInfo struct { + Randomness PoStRandomness + Proofs []PoStProof + ChallengedSectors []SectorInfo + Prover ActorID // used to derive 32-byte prover ID +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/abi/sector_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/sector_test.go new file mode 100644 index 000000000..41576c97f --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/abi/sector_test.go @@ -0,0 +1,38 @@ +package abi_test + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/abi" +) + +func TestSectorSizeString(t *testing.T) { + assert.Equal(t, "0", abi.SectorSize(0).String()) + assert.Equal(t, "1", abi.SectorSize(1).String()) + assert.Equal(t, "1024", abi.SectorSize(1024).String()) + assert.Equal(t, "1234", abi.SectorSize(1234).String()) + assert.Equal(t, "1125899906842624", abi.SectorSize(1125899906842624).String()) +} + +func TestSectorSizeShortString(t *testing.T) { + kib := uint64(1024) + pib := uint64(1125899906842624) + + assert.Equal(t, "0B", abi.SectorSize(0).ShortString()) + assert.Equal(t, "1B", abi.SectorSize(1).ShortString()) + assert.Equal(t, "1023B", abi.SectorSize(1023).ShortString()) + assert.Equal(t, "1KiB", abi.SectorSize(kib).ShortString()) + assert.Equal(t, "1KiB", abi.SectorSize(kib+1).ShortString()) // truncated + assert.Equal(t, "1KiB", abi.SectorSize(kib*2-1).ShortString()) // truncated + assert.Equal(t, "2KiB", abi.SectorSize(kib*2).ShortString()) + assert.Equal(t, "2KiB", abi.SectorSize(kib*2+1).ShortString()) // truncated + assert.Equal(t, "1023KiB", abi.SectorSize(kib*1023).ShortString()) + assert.Equal(t, "1MiB", abi.SectorSize(1048576).ShortString()) + assert.Equal(t, "1GiB", abi.SectorSize(1073741824).ShortString()) + assert.Equal(t, "1TiB", abi.SectorSize(1099511627776).ShortString()) + assert.Equal(t, "1PiB", abi.SectorSize(pib).ShortString()) + assert.Equal(t, "1EiB", abi.SectorSize(pib*kib).ShortString()) + assert.Equal(t, "10EiB", abi.SectorSize(pib*kib*10).ShortString()) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/account_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/account_actor.go new file mode 100644 index 000000000..ef335b5be --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/account_actor.go @@ -0,0 +1,50 @@ +package account + +import ( + addr "github.com/filecoin-project/go-address" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + 1: a.Constructor, + 2: a.PubkeyAddress, + } +} + +var _ abi.Invokee = Actor{} + +type State struct { + Address addr.Address +} + +func (a Actor) Constructor(rt vmr.Runtime, address *addr.Address) *adt.EmptyValue { + // Account actors are created implicitly by sending a message to a pubkey-style address. + // This constructor is not invoked by the InitActor, but by the system. + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + switch address.Protocol() { + case addr.SECP256K1: + case addr.BLS: + break // ok + default: + rt.Abortf(exitcode.ErrIllegalArgument, "address must use BLS or SECP protocol, got %v", address.Protocol()) + } + st := State{Address: *address} + rt.State().Create(&st) + return nil +} + +// Fetches the pubkey-type address from this actor. +func (a Actor) PubkeyAddress(rt vmr.Runtime, _ *adt.EmptyValue) addr.Address { + rt.ValidateImmediateCallerAcceptAny() + var st State + rt.State().Readonly(&st) + return st.Address +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/account_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/account_test.go new file mode 100644 index 000000000..678d3b5e8 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/account_test.go @@ -0,0 +1,78 @@ +package account_test + +import ( + "context" + "testing" + + "github.com/filecoin-project/go-address" + "github.com/stretchr/testify/assert" + + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + account "github.com/filecoin-project/specs-actors/actors/builtin/account" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + mock "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +type constructorTestCase struct { + desc string + addr address.Address + exitCode exitcode.ExitCode +} + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, account.Actor{}) +} + +func TestAccountactor(t *testing.T) { + actor := account.Actor{} + + receiver := tutil.NewIDAddr(t, 100) + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + testCases := []constructorTestCase{ + { + desc: "happy path construct SECP256K1 address", + addr: tutil.NewSECP256K1Addr(t, "secpaddress"), + exitCode: exitcode.Ok, + }, + { + desc: "happy path construct BLS address", + addr: tutil.NewBLSAddr(t, 1), + exitCode: exitcode.Ok, + }, + { + desc: "fail to construct account actor using ID address", + addr: tutil.NewIDAddr(t, 1), + exitCode: exitcode.ErrIllegalArgument, + }, + { + desc: "fail to construct account actor using Actor address", + addr: tutil.NewActorAddr(t, "actoraddress"), + exitCode: exitcode.ErrIllegalArgument, + }, + } + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + rt := builder.Build(t) + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + + if tc.exitCode.IsSuccess() { + rt.Call(actor.Constructor, &tc.addr) + + var st account.State + rt.GetState(&st) + assert.Equal(t, tc.addr, st.Address) + + rt.ExpectValidateCallerAny() + pubkeyAddress := rt.Call(actor.PubkeyAddress, nil).(address.Address) + assert.Equal(t, tc.addr, pubkeyAddress) + } else { + rt.ExpectAbort(tc.exitCode, func() { + rt.Call(actor.Constructor, &tc.addr) + }) + } + rt.Verify() + }) + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/cbor_gen.go new file mode 100644 index 000000000..b6df873b9 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/account/cbor_gen.go @@ -0,0 +1,56 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package account + +import ( + "fmt" + "io" + + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Address (address.Address) (struct) + if err := t.Address.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Address (address.Address) (struct) + + { + + if err := t.Address.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Address: %w", err) + } + + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cbor_gen.go new file mode 100644 index 000000000..b16cddcbe --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cbor_gen.go @@ -0,0 +1,147 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package builtin + +import ( + "fmt" + "io" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *MinerAddrs) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Owner (address.Address) (struct) + if err := t.Owner.MarshalCBOR(w); err != nil { + return err + } + + // t.Worker (address.Address) (struct) + if err := t.Worker.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *MinerAddrs) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Owner (address.Address) (struct) + + { + + if err := t.Owner.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Owner: %w", err) + } + + } + // t.Worker (address.Address) (struct) + + { + + if err := t.Worker.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Worker: %w", err) + } + + } + return nil +} + +func (t *ConfirmSectorProofsParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Sectors ([]abi.SectorNumber) (slice) + if len(t.Sectors) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Sectors was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Sectors)))); err != nil { + return err + } + for _, v := range t.Sectors { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + return nil +} + +func (t *ConfirmSectorProofsParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Sectors ([]abi.SectorNumber) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Sectors: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Sectors = make([]abi.SectorNumber, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.Sectors slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.Sectors was not a uint, instead got %d", maj) + } + + t.Sectors[i] = abi.SectorNumber(val) + } + + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/codes.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/codes.go new file mode 100644 index 000000000..95180474a --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/codes.go @@ -0,0 +1,100 @@ +package builtin + +import ( + "github.com/ipfs/go-cid" + mh "github.com/multiformats/go-multihash" +) + +// The built-in actor code IDs +var ( + SystemActorCodeID cid.Cid + InitActorCodeID cid.Cid + CronActorCodeID cid.Cid + AccountActorCodeID cid.Cid + StoragePowerActorCodeID cid.Cid + StorageMinerActorCodeID cid.Cid + StorageMarketActorCodeID cid.Cid + PaymentChannelActorCodeID cid.Cid + MultisigActorCodeID cid.Cid + RewardActorCodeID cid.Cid + VerifiedRegistryActorCodeID cid.Cid + CallerTypesSignable []cid.Cid +) + +func init() { + builder := cid.V1Builder{Codec: cid.Raw, MhType: mh.IDENTITY} + makeBuiltin := func(s string) cid.Cid { + c, err := builder.Sum([]byte(s)) + if err != nil { + panic(err) + } + return c + } + + SystemActorCodeID = makeBuiltin("fil/1/system") + InitActorCodeID = makeBuiltin("fil/1/init") + CronActorCodeID = makeBuiltin("fil/1/cron") + AccountActorCodeID = makeBuiltin("fil/1/account") + StoragePowerActorCodeID = makeBuiltin("fil/1/storagepower") + StorageMinerActorCodeID = makeBuiltin("fil/1/storageminer") + StorageMarketActorCodeID = makeBuiltin("fil/1/storagemarket") + PaymentChannelActorCodeID = makeBuiltin("fil/1/paymentchannel") + MultisigActorCodeID = makeBuiltin("fil/1/multisig") + RewardActorCodeID = makeBuiltin("fil/1/reward") + VerifiedRegistryActorCodeID = makeBuiltin("fil/1/verifiedregistry") + + // Set of actor code types that can represent external signing parties. + CallerTypesSignable = []cid.Cid{AccountActorCodeID, MultisigActorCodeID} +} + +// IsBuiltinActor returns true if the code belongs to an actor defined in this repo. +func IsBuiltinActor(code cid.Cid) bool { + return code.Equals(SystemActorCodeID) || + code.Equals(InitActorCodeID) || + code.Equals(CronActorCodeID) || + code.Equals(AccountActorCodeID) || + code.Equals(StoragePowerActorCodeID) || + code.Equals(StorageMinerActorCodeID) || + code.Equals(StorageMarketActorCodeID) || + code.Equals(PaymentChannelActorCodeID) || + code.Equals(MultisigActorCodeID) || + code.Equals(RewardActorCodeID) || + code.Equals(VerifiedRegistryActorCodeID) +} + +// ActorNameByCode returns the (string) name of the actor given a cid code. +func ActorNameByCode(code cid.Cid) string { + if !code.Defined() { + return "" + } + + names := map[cid.Cid]string{ + SystemActorCodeID: "fil/1/system", + InitActorCodeID: "fil/1/init", + CronActorCodeID: "fil/1/cron", + AccountActorCodeID: "fil/1/account", + StoragePowerActorCodeID: "fil/1/storagepower", + StorageMinerActorCodeID: "fil/1/storageminer", + StorageMarketActorCodeID: "fil/1/storagemarket", + PaymentChannelActorCodeID: "fil/1/paymentchannel", + MultisigActorCodeID: "fil/1/multisig", + RewardActorCodeID: "fil/1/reward", + VerifiedRegistryActorCodeID: "fil/1/verifiedregistry", + } + name, ok := names[code] + if !ok { + return "" + } + return name +} + +// Tests whether a code CID represents an actor that can be an external principal: i.e. an account or multisig. +// We could do something more sophisticated here: https://github.com/filecoin-project/specs-actors/issues/178 +func IsPrincipal(code cid.Cid) bool { + for _, c := range CallerTypesSignable { + if c.Equals(code) { + return true + } + } + return false +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cbor_gen.go new file mode 100644 index 000000000..c581b37fb --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cbor_gen.go @@ -0,0 +1,222 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package cron + +import ( + "fmt" + "io" + + "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Entries ([]cron.Entry) (slice) + if len(t.Entries) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Entries was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Entries)))); err != nil { + return err + } + for _, v := range t.Entries { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Entries ([]cron.Entry) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Entries: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Entries = make([]Entry, extra) + } + + for i := 0; i < int(extra); i++ { + + var v Entry + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Entries[i] = v + } + + return nil +} + +func (t *Entry) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Receiver (address.Address) (struct) + if err := t.Receiver.MarshalCBOR(w); err != nil { + return err + } + + // t.MethodNum (abi.MethodNum) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MethodNum))); err != nil { + return err + } + + return nil +} + +func (t *Entry) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Receiver (address.Address) (struct) + + { + + if err := t.Receiver.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Receiver: %w", err) + } + + } + // t.MethodNum (abi.MethodNum) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.MethodNum = abi.MethodNum(extra) + + } + return nil +} + +func (t *ConstructorParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Entries ([]cron.Entry) (slice) + if len(t.Entries) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Entries was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Entries)))); err != nil { + return err + } + for _, v := range t.Entries { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *ConstructorParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Entries ([]cron.Entry) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Entries: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Entries = make([]Entry, extra) + } + + for i := 0; i < int(extra); i++ { + + var v Entry + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Entries[i] = v + } + + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_actor.go new file mode 100644 index 000000000..3cccafd2a --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_actor.go @@ -0,0 +1,44 @@ +package cron + +import ( + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// The cron actor is a built-in singleton that sends messages to other registered actors at the end of each epoch. +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.EpochTick, + } +} + +var _ abi.Invokee = Actor{} + +type ConstructorParams struct { + Entries []Entry +} + +func (a Actor) Constructor(rt vmr.Runtime, params *ConstructorParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + rt.State().Create(ConstructState(params.Entries)) + return nil +} + +// Invoked by the system after all other messages in the epoch have been processed. +func (a Actor) EpochTick(rt vmr.Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + + var st State + rt.State().Readonly(&st) + for _, entry := range st.Entries { + _, _ = rt.Send(entry.Receiver, entry.MethodNum, nil, abi.NewTokenAmount(0)) + // Any error and return value are ignored. + } + + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_state.go new file mode 100644 index 000000000..b82c5758f --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_state.go @@ -0,0 +1,35 @@ +package cron + +import ( + addr "github.com/filecoin-project/go-address" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/builtin" +) + +type State struct { + Entries []Entry +} + +type Entry struct { + Receiver addr.Address // The actor to call (must be an ID-address) + MethodNum abi.MethodNum // The method number to call (must accept empty parameters) +} + +func ConstructState(entries []Entry) *State { + return &State{Entries: entries} +} + +// The default entries to install in the cron actor's state at genesis. +func BuiltInEntries() []Entry { + return []Entry{ + { + Receiver: builtin.StoragePowerActorAddr, + MethodNum: builtin.MethodsPower.OnEpochTickEnd, + }, + { + Receiver: builtin.StorageMarketActorAddr, + MethodNum: builtin.MethodsMarket.CronTick, + }, + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_test.go new file mode 100644 index 000000000..675a33c3d --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/cron/cron_test.go @@ -0,0 +1,107 @@ +package cron_test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + cron "github.com/filecoin-project/specs-actors/actors/builtin/cron" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + mock "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, cron.Actor{}) +} + +func TestConstructor(t *testing.T) { + actor := cronHarness{cron.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 100) + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("construct with empty entries", func(t *testing.T) { + rt := builder.Build(t) + + var nilCronEntries = []cron.Entry(nil) + actor.constructAndVerify(rt, nilCronEntries...) + + var st cron.State + rt.GetState(&st) + assert.Equal(t, nilCronEntries, st.Entries) + }) + + t.Run("construct with non-empty entries", func(t *testing.T) { + rt := builder.Build(t) + + var cronEntries = []cron.Entry{ + {Receiver: tutil.NewIDAddr(t, 1001), MethodNum: abi.MethodNum(1001)}, + {Receiver: tutil.NewIDAddr(t, 1002), MethodNum: abi.MethodNum(1002)}, + {Receiver: tutil.NewIDAddr(t, 1003), MethodNum: abi.MethodNum(1003)}, + {Receiver: tutil.NewIDAddr(t, 1004), MethodNum: abi.MethodNum(1004)}, + } + actor.constructAndVerify(rt, cronEntries...) + + var st cron.State + rt.GetState(&st) + assert.Equal(t, cronEntries, st.Entries) + }) +} + +func TestEpochTick(t *testing.T) { + actor := cronHarness{cron.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 100) + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("epoch tick with empty entries", func(t *testing.T) { + rt := builder.Build(t) + + var nilCronEntries = []cron.Entry(nil) + actor.constructAndVerify(rt, nilCronEntries...) + actor.epochTickAndVerify(rt) + }) + + t.Run("epoch tick with non-empty entries", func(t *testing.T) { + rt := builder.Build(t) + + entry1 := cron.Entry{Receiver: tutil.NewIDAddr(t, 1001), MethodNum: abi.MethodNum(1001)} + entry2 := cron.Entry{Receiver: tutil.NewIDAddr(t, 1002), MethodNum: abi.MethodNum(1002)} + entry3 := cron.Entry{Receiver: tutil.NewIDAddr(t, 1003), MethodNum: abi.MethodNum(1003)} + entry4 := cron.Entry{Receiver: tutil.NewIDAddr(t, 1004), MethodNum: abi.MethodNum(1004)} + + actor.constructAndVerify(rt, entry1, entry2, entry3, entry4) + // exit code should not matter + rt.ExpectSend(entry1.Receiver, entry1.MethodNum, nil, big.Zero(), nil, exitcode.Ok) + rt.ExpectSend(entry2.Receiver, entry2.MethodNum, nil, big.Zero(), nil, exitcode.ErrIllegalArgument) + rt.ExpectSend(entry3.Receiver, entry3.MethodNum, nil, big.Zero(), nil, exitcode.ErrInsufficientFunds) + rt.ExpectSend(entry4.Receiver, entry4.MethodNum, nil, big.Zero(), nil, exitcode.ErrForbidden) + actor.epochTickAndVerify(rt) + }) + +} + +type cronHarness struct { + cron.Actor + t testing.TB +} + +func (h *cronHarness) constructAndVerify(rt *mock.Runtime, entries ...cron.Entry) { + params := cron.ConstructorParams{Entries: entries} + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + ret := rt.Call(h.Constructor, ¶ms) + assert.Nil(h.t, ret) + rt.Verify() +} + +func (h *cronHarness) epochTickAndVerify(rt *mock.Runtime) { + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + ret := rt.Call(h.EpochTick, nil) + assert.Nil(h.t, ret) + rt.Verify() +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/exported/actors.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/exported/actors.go new file mode 100644 index 000000000..1bb7f3cc0 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/exported/actors.go @@ -0,0 +1,85 @@ +package exported + +import ( + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/builtin" + cid "github.com/ipfs/go-cid" + + "github.com/filecoin-project/specs-actors/actors/builtin/account" + "github.com/filecoin-project/specs-actors/actors/builtin/cron" + init_ "github.com/filecoin-project/specs-actors/actors/builtin/init" + "github.com/filecoin-project/specs-actors/actors/builtin/market" + "github.com/filecoin-project/specs-actors/actors/builtin/miner" + "github.com/filecoin-project/specs-actors/actors/builtin/multisig" + "github.com/filecoin-project/specs-actors/actors/builtin/paych" + "github.com/filecoin-project/specs-actors/actors/builtin/power" + "github.com/filecoin-project/specs-actors/actors/builtin/reward" + "github.com/filecoin-project/specs-actors/actors/builtin/system" + "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" +) + +var _ abi.Invokee = BuiltinActor{} + +type BuiltinActor struct { + actor abi.Invokee + code cid.Cid +} + +// Code is the CodeID (cid) of the actor. +func (b BuiltinActor) Code() cid.Cid { + return b.code +} + +// Exports returns a slice of callable Actor methods. +func (b BuiltinActor) Exports() []interface{} { + return b.actor.Exports() +} + +func BuiltinActors() []BuiltinActor { + return []BuiltinActor{ + { + actor: account.Actor{}, + code: builtin.AccountActorCodeID, + }, + { + actor: cron.Actor{}, + code: builtin.CronActorCodeID, + }, + { + actor: init_.Actor{}, + code: builtin.InitActorCodeID, + }, + { + actor: market.Actor{}, + code: builtin.StorageMarketActorCodeID, + }, + { + actor: miner.Actor{}, + code: builtin.StorageMinerActorCodeID, + }, + { + actor: multisig.Actor{}, + code: builtin.MultisigActorCodeID, + }, + { + actor: paych.Actor{}, + code: builtin.PaymentChannelActorCodeID, + }, + { + actor: power.Actor{}, + code: builtin.StoragePowerActorCodeID, + }, + { + actor: reward.Actor{}, + code: builtin.RewardActorCodeID, + }, + { + actor: system.Actor{}, + code: builtin.SystemActorCodeID, + }, + { + actor: verifreg.Actor{}, + code: builtin.VerifiedRegistryActorCodeID, + }, + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/cbor_gen.go new file mode 100644 index 000000000..551fb3161 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/cbor_gen.go @@ -0,0 +1,287 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package init + +import ( + "fmt" + "io" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.AddressMap (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.AddressMap); err != nil { + return xerrors.Errorf("failed to write cid field t.AddressMap: %w", err) + } + + // t.NextID (abi.ActorID) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextID))); err != nil { + return err + } + + // t.NetworkName (string) (string) + if len(t.NetworkName) > cbg.MaxLength { + return xerrors.Errorf("Value in field t.NetworkName was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.NetworkName)))); err != nil { + return err + } + if _, err := w.Write([]byte(t.NetworkName)); err != nil { + return err + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.AddressMap (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.AddressMap: %w", err) + } + + t.AddressMap = c + + } + // t.NextID (abi.ActorID) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.NextID = abi.ActorID(extra) + + } + // t.NetworkName (string) (string) + + { + sval, err := cbg.ReadString(br) + if err != nil { + return err + } + + t.NetworkName = string(sval) + } + return nil +} + +func (t *ConstructorParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.NetworkName (string) (string) + if len(t.NetworkName) > cbg.MaxLength { + return xerrors.Errorf("Value in field t.NetworkName was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.NetworkName)))); err != nil { + return err + } + if _, err := w.Write([]byte(t.NetworkName)); err != nil { + return err + } + return nil +} + +func (t *ConstructorParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.NetworkName (string) (string) + + { + sval, err := cbg.ReadString(br) + if err != nil { + return err + } + + t.NetworkName = string(sval) + } + return nil +} + +func (t *ExecParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.CodeCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.CodeCID); err != nil { + return xerrors.Errorf("failed to write cid field t.CodeCID: %w", err) + } + + // t.ConstructorParams ([]uint8) (slice) + if len(t.ConstructorParams) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.ConstructorParams was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.ConstructorParams)))); err != nil { + return err + } + if _, err := w.Write(t.ConstructorParams); err != nil { + return err + } + return nil +} + +func (t *ExecParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.CodeCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.CodeCID: %w", err) + } + + t.CodeCID = c + + } + // t.ConstructorParams ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.ConstructorParams: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.ConstructorParams = make([]byte, extra) + if _, err := io.ReadFull(br, t.ConstructorParams); err != nil { + return err + } + return nil +} + +func (t *ExecReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.IDAddress (address.Address) (struct) + if err := t.IDAddress.MarshalCBOR(w); err != nil { + return err + } + + // t.RobustAddress (address.Address) (struct) + if err := t.RobustAddress.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *ExecReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.IDAddress (address.Address) (struct) + + { + + if err := t.IDAddress.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.IDAddress: %w", err) + } + + } + // t.RobustAddress (address.Address) (struct) + + { + + if err := t.RobustAddress.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RobustAddress: %w", err) + } + + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_actor.go new file mode 100644 index 000000000..a4111c57b --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_actor.go @@ -0,0 +1,101 @@ +package init + +import ( + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + runtime "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + autil "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// The init actor uniquely has the power to create new actors. +// It maintains a table resolving pubkey and temporary actor addresses to the canonical ID-addresses. +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.Exec, + } +} + +var _ abi.Invokee = Actor{} + +type ConstructorParams struct { + NetworkName string +} + +func (a Actor) Constructor(rt runtime.Runtime, params *ConstructorParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + emptyMap, err := adt.MakeEmptyMap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to construct state: %v", err) + } + + st := ConstructState(emptyMap, params.NetworkName) + rt.State().Create(st) + return nil +} + +type ExecParams struct { + CodeCID cid.Cid + ConstructorParams []byte +} + +type ExecReturn struct { + IDAddress addr.Address // The canonical ID-based address for the actor. + RobustAddress addr.Address // A more expensive but re-org-safe address for the newly created actor. +} + +func (a Actor) Exec(rt runtime.Runtime, params *ExecParams) *ExecReturn { + rt.ValidateImmediateCallerAcceptAny() + callerCodeCID, ok := rt.GetActorCodeCID(rt.Message().Caller()) + autil.AssertMsg(ok, "no code for actor at %s", rt.Message().Caller()) + if !canExec(callerCodeCID, params.CodeCID) { + rt.Abortf(exitcode.ErrForbidden, "caller type %v cannot exec actor type %v", callerCodeCID, params.CodeCID) + } + + // Compute a re-org-stable address. + // This address exists for use by messages coming from outside the system, in order to + // stably address the newly created actor even if a chain re-org causes it to end up with + // a different ID. + uniqueAddress := rt.NewActorAddress() + + // Allocate an ID for this actor. + // Store mapping of pubkey or actor address to actor ID + var st State + idAddr := rt.State().Transaction(&st, func() interface{} { + idAddr, err := st.MapAddressToNewID(adt.AsStore(rt), uniqueAddress) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "exec failed: %v", err) + } + return idAddr + }).(addr.Address) + + // Create an empty actor. + rt.CreateActor(params.CodeCID, idAddr) + + // Invoke constructor. + _, code := rt.Send(idAddr, builtin.MethodConstructor, runtime.CBORBytes(params.ConstructorParams), rt.Message().ValueReceived()) + builtin.RequireSuccess(rt, code, "constructor failed") + + return &ExecReturn{idAddr, uniqueAddress} +} + +func canExec(callerCodeID cid.Cid, execCodeID cid.Cid) bool { + switch execCodeID { + case builtin.StorageMinerActorCodeID: + if callerCodeID == builtin.StoragePowerActorCodeID { + return true + } + return false + case builtin.PaymentChannelActorCodeID, builtin.MultisigActorCodeID: + return true + default: + return false + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_actor_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_actor_state.go new file mode 100644 index 000000000..66b08c31a --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_actor_state.go @@ -0,0 +1,91 @@ +package init + +import ( + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + autil "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +var ErrAddressNotFound = errors.New("address not found") + +type AddrKey = adt.AddrKey + +type State struct { + AddressMap cid.Cid // HAMT[addr.Address]abi.ActorID + NextID abi.ActorID + NetworkName string +} + +func ConstructState(addressMapRoot cid.Cid, networkName string) *State { + return &State{ + AddressMap: addressMapRoot, + NextID: abi.ActorID(builtin.FirstNonSingletonActorId), + NetworkName: networkName, + } +} + +// ResolveAddress resolves an address to an ID-address, if possible. +// If the provided address is an ID address, it is returned as-is. +// This means that ID-addresses (which should only appear as values, not keys) and singleton actor addresses +// pass through unchanged. +// +// Post-condition: all addresses succesfully returned by this method satisfy `addr.Protocol() == addr.ID`. +func (s *State) ResolveAddress(store adt.Store, address addr.Address) (addr.Address, error) { + // Short-circuit ID address resolution. + if address.Protocol() == addr.ID { + return address, nil + } + + // Lookup address. + m, err := adt.AsMap(store, s.AddressMap) + if err != nil { + return addr.Undef, xerrors.Errorf("failed to load address map: %w", err) + } + + var actorID cbg.CborInt + found, err := m.Get(AddrKey(address), &actorID) + if err != nil { + return addr.Undef, errors.Wrapf(err, "resolve address failed to look up map") + } + if found { + // Reconstruct address from the ActorID. + idAddr, err2 := addr.NewIDAddress(uint64(actorID)) + autil.Assert(err2 == nil) + return idAddr, nil + } + + // Not found. + return addr.Undef, ErrAddressNotFound +} + +// Allocates a new ID address and stores a mapping of the argument address to it. +// Returns the newly-allocated address. +func (s *State) MapAddressToNewID(store adt.Store, address addr.Address) (addr.Address, error) { + actorID := cbg.CborInt(s.NextID) + s.NextID++ + + m, err := adt.AsMap(store, s.AddressMap) + if err != nil { + return addr.Undef, xerrors.Errorf("failed to load address map: %w", err) + } + err = m.Put(AddrKey(address), &actorID) + if err != nil { + return addr.Undef, xerrors.Errorf("map address failed to store entry: %w", err) + } + amr, err := m.Root() + if err != nil { + return addr.Undef, xerrors.Errorf("failed to get address map root: %w", err) + } + s.AddressMap = amr + + idAddr, err := addr.NewIDAddress(uint64(actorID)) + autil.Assert(err == nil) + return idAddr, nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_test.go new file mode 100644 index 000000000..9e530e5d7 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/init/init_test.go @@ -0,0 +1,232 @@ +package init_test + +import ( + "context" + "testing" + + cid "github.com/ipfs/go-cid" + assert "github.com/stretchr/testify/assert" + + addr "github.com/filecoin-project/go-address" + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + init_ "github.com/filecoin-project/specs-actors/actors/builtin/init" + runtime "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" + mock "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, init_.Actor{}) +} + +func TestConstructor(t *testing.T) { + actor := initHarness{init_.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 1000) + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + rt := builder.Build(t) + actor.constructAndVerify(rt) +} + +func TestExec(t *testing.T) { + actor := initHarness{init_.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 1000) + anne := tutil.NewIDAddr(t, 1001) + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("abort actors that cannot call exec", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + actor.execAndVerify(rt, builtin.StoragePowerActorCodeID, []byte{}) + }) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + actor.execAndVerify(rt, cid.Undef, []byte{}) + }) + }) + + var fakeParams = runtime.CBORBytes([]byte{'D', 'E', 'A', 'D', 'B', 'E', 'E', 'F'}) + var balance = abi.NewTokenAmount(100) + + t.Run("happy path exec create 2 payment channels", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt) + // anne execs a payment channel actor with 100 FIL. + rt.SetCaller(anne, builtin.AccountActorCodeID) + + rt.SetBalance(balance) + rt.SetReceived(balance) + + // re-org-stable address of the payment channel actor + uniqueAddr1 := tutil.NewActorAddr(t, "paych") + rt.SetNewActorAddress(uniqueAddr1) + + // next id address + expectedIdAddr1 := tutil.NewIDAddr(t, 100) + rt.ExpectCreateActor(builtin.PaymentChannelActorCodeID, expectedIdAddr1) + + // expect anne creating a payment channel to trigger a send to the payment channels constructor + rt.ExpectSend(expectedIdAddr1, builtin.MethodConstructor, fakeParams, balance, nil, exitcode.Ok) + execRet1 := actor.execAndVerify(rt, builtin.PaymentChannelActorCodeID, fakeParams) + assert.Equal(t, uniqueAddr1, execRet1.RobustAddress) + assert.Equal(t, expectedIdAddr1, execRet1.IDAddress) + + var st init_.State + rt.GetState(&st) + actualIdAddr, err := st.ResolveAddress(adt.AsStore(rt), uniqueAddr1) + assert.NoError(t, err) + assert.Equal(t, expectedIdAddr1, actualIdAddr) + + // creating another actor should get a different address, the below logic is a repeat of the above to insure + // the next ID address created is incremented. 100 -> 101 + rt.SetBalance(balance) + rt.SetReceived(balance) + uniqueAddr2 := tutil.NewActorAddr(t, "paych2") + rt.SetNewActorAddress(uniqueAddr2) + // the incremented ID address. + expectedIdAddr2 := tutil.NewIDAddr(t, 101) + rt.ExpectCreateActor(builtin.PaymentChannelActorCodeID, expectedIdAddr2) + + // expect anne creating a payment channel to trigger a send to the payment channels constructor + rt.ExpectSend(expectedIdAddr2, builtin.MethodConstructor, fakeParams, balance, nil, exitcode.Ok) + execRet2 := actor.execAndVerify(rt, builtin.PaymentChannelActorCodeID, fakeParams) + assert.Equal(t, uniqueAddr2, execRet2.RobustAddress) + assert.Equal(t, expectedIdAddr2, execRet2.IDAddress) + + var st2 init_.State + rt.GetState(&st2) + actualIdAddr2, err := st2.ResolveAddress(adt.AsStore(rt), uniqueAddr2) + assert.NoError(t, err) + assert.Equal(t, expectedIdAddr2, actualIdAddr2) + }) + + t.Run("happy path exec create storage miner", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt) + + // only the storage power actor can create a miner + rt.SetCaller(builtin.StoragePowerActorAddr, builtin.StoragePowerActorCodeID) + + // re-org-stable address of the storage miner actor + uniqueAddr := tutil.NewActorAddr(t, "miner") + rt.SetNewActorAddress(uniqueAddr) + + // next id address + expectedIdAddr := tutil.NewIDAddr(t, 100) + rt.ExpectCreateActor(builtin.StorageMinerActorCodeID, expectedIdAddr) + + // expect storage power actor creating a storage miner actor to trigger a send to the storage miner actors constructor + rt.ExpectSend(expectedIdAddr, builtin.MethodConstructor, fakeParams, big.Zero(), nil, exitcode.Ok) + execRet := actor.execAndVerify(rt, builtin.StorageMinerActorCodeID, fakeParams) + assert.Equal(t, uniqueAddr, execRet.RobustAddress) + assert.Equal(t, expectedIdAddr, execRet.IDAddress) + + var st init_.State + rt.GetState(&st) + actualIdAddr, err := st.ResolveAddress(adt.AsStore(rt), uniqueAddr) + assert.NoError(t, err) + assert.Equal(t, expectedIdAddr, actualIdAddr) + + // returns error if not able to resolve + expUnknowAddr := tutil.NewActorAddr(t, "flurbo") + actualUnknownAddr, err := st.ResolveAddress(adt.AsStore(rt), expUnknowAddr) + assert.Error(t, err) + assert.Equal(t, addr.Undef, actualUnknownAddr) + }) + + t.Run("happy path create multisig actor", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt) + + // actor creating the multisig actor + someAccountActor := tutil.NewIDAddr(t, 1234) + rt.SetCaller(someAccountActor, builtin.AccountActorCodeID) + + uniqueAddr := tutil.NewActorAddr(t, "multisig") + rt.SetNewActorAddress(uniqueAddr) + + // next id address + expectedIdAddr := tutil.NewIDAddr(t, 100) + rt.ExpectCreateActor(builtin.MultisigActorCodeID, expectedIdAddr) + + // expect a send to the multisig actor constructor + rt.ExpectSend(expectedIdAddr, builtin.MethodConstructor, fakeParams, big.Zero(), nil, exitcode.Ok) + execRet := actor.execAndVerify(rt, builtin.MultisigActorCodeID, fakeParams) + assert.Equal(t, uniqueAddr, execRet.RobustAddress) + assert.Equal(t, expectedIdAddr, execRet.IDAddress) + }) + + t.Run("sending to constructor failure", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt) + + // only the storage power actor can create a miner + rt.SetCaller(builtin.StoragePowerActorAddr, builtin.StoragePowerActorCodeID) + + // re-org-stable address of the storage miner actor + uniqueAddr := tutil.NewActorAddr(t, "miner") + rt.SetNewActorAddress(uniqueAddr) + + // next id address + expectedIdAddr := tutil.NewIDAddr(t, 100) + rt.ExpectCreateActor(builtin.StorageMinerActorCodeID, expectedIdAddr) + + // expect storage power actor creating a storage miner actor to trigger a send to the storage miner actors constructor + rt.ExpectSend(expectedIdAddr, builtin.MethodConstructor, fakeParams, big.Zero(), nil, exitcode.ErrIllegalState) + var execRet *init_.ExecReturn + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + execRet = actor.execAndVerify(rt, builtin.StorageMinerActorCodeID, fakeParams) + assert.Nil(t, execRet) + }) + + // since the send failed the uniqueAddr not resolve + var st init_.State + rt.GetState(&st) + noResoAddr, err := st.ResolveAddress(adt.AsStore(rt), uniqueAddr) + assert.Error(t, err) + assert.Equal(t, addr.Undef, noResoAddr) + + }) + +} + +type initHarness struct { + init_.Actor + t testing.TB +} + +func (h *initHarness) constructAndVerify(rt *mock.Runtime) { + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + ret := rt.Call(h.Constructor, &init_.ConstructorParams{NetworkName: "mock"}) + assert.Nil(h.t, ret) + rt.Verify() + + var st init_.State + rt.GetState(&st) + emptyMap, err := adt.AsMap(adt.AsStore(rt), st.AddressMap) + assert.NoError(h.t, err) + assert.Equal(h.t, tutil.MustRoot(h.t, emptyMap), st.AddressMap) + assert.Equal(h.t, abi.ActorID(builtin.FirstNonSingletonActorId), st.NextID) + assert.Equal(h.t, "mock", st.NetworkName) +} + +func (h *initHarness) execAndVerify(rt *mock.Runtime, codeID cid.Cid, constructorParams []byte) *init_.ExecReturn { + rt.ExpectValidateCallerAny() + ret := rt.Call(h.Exec, &init_.ExecParams{ + CodeCID: codeID, + ConstructorParams: constructorParams, + }).(*init_.ExecReturn) + rt.Verify() + return ret +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/cbor_gen.go new file mode 100644 index 000000000..a13c9c255 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/cbor_gen.go @@ -0,0 +1,1406 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package market + +import ( + "fmt" + "io" + + "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{139}); err != nil { + return err + } + + // t.Proposals (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.Proposals); err != nil { + return xerrors.Errorf("failed to write cid field t.Proposals: %w", err) + } + + // t.States (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.States); err != nil { + return xerrors.Errorf("failed to write cid field t.States: %w", err) + } + + // t.PendingProposals (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.PendingProposals); err != nil { + return xerrors.Errorf("failed to write cid field t.PendingProposals: %w", err) + } + + // t.EscrowTable (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.EscrowTable); err != nil { + return xerrors.Errorf("failed to write cid field t.EscrowTable: %w", err) + } + + // t.LockedTable (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.LockedTable); err != nil { + return xerrors.Errorf("failed to write cid field t.LockedTable: %w", err) + } + + // t.NextID (abi.DealID) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextID))); err != nil { + return err + } + + // t.DealOpsByEpoch (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.DealOpsByEpoch); err != nil { + return xerrors.Errorf("failed to write cid field t.DealOpsByEpoch: %w", err) + } + + // t.LastCron (abi.ChainEpoch) (int64) + if t.LastCron >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.LastCron))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.LastCron)-1)); err != nil { + return err + } + } + + // t.TotalClientLockedCollateral (big.Int) (struct) + if err := t.TotalClientLockedCollateral.MarshalCBOR(w); err != nil { + return err + } + + // t.TotalProviderLockedCollateral (big.Int) (struct) + if err := t.TotalProviderLockedCollateral.MarshalCBOR(w); err != nil { + return err + } + + // t.TotalClientStorageFee (big.Int) (struct) + if err := t.TotalClientStorageFee.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 11 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Proposals (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.Proposals: %w", err) + } + + t.Proposals = c + + } + // t.States (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.States: %w", err) + } + + t.States = c + + } + // t.PendingProposals (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.PendingProposals: %w", err) + } + + t.PendingProposals = c + + } + // t.EscrowTable (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.EscrowTable: %w", err) + } + + t.EscrowTable = c + + } + // t.LockedTable (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.LockedTable: %w", err) + } + + t.LockedTable = c + + } + // t.NextID (abi.DealID) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.NextID = abi.DealID(extra) + + } + // t.DealOpsByEpoch (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.DealOpsByEpoch: %w", err) + } + + t.DealOpsByEpoch = c + + } + // t.LastCron (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.LastCron = abi.ChainEpoch(extraI) + } + // t.TotalClientLockedCollateral (big.Int) (struct) + + { + + if err := t.TotalClientLockedCollateral.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalClientLockedCollateral: %w", err) + } + + } + // t.TotalProviderLockedCollateral (big.Int) (struct) + + { + + if err := t.TotalProviderLockedCollateral.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalProviderLockedCollateral: %w", err) + } + + } + // t.TotalClientStorageFee (big.Int) (struct) + + { + + if err := t.TotalClientStorageFee.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalClientStorageFee: %w", err) + } + + } + return nil +} + +func (t *WithdrawBalanceParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.ProviderOrClientAddress (address.Address) (struct) + if err := t.ProviderOrClientAddress.MarshalCBOR(w); err != nil { + return err + } + + // t.Amount (big.Int) (struct) + if err := t.Amount.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *WithdrawBalanceParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.ProviderOrClientAddress (address.Address) (struct) + + { + + if err := t.ProviderOrClientAddress.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.ProviderOrClientAddress: %w", err) + } + + } + // t.Amount (big.Int) (struct) + + { + + if err := t.Amount.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Amount: %w", err) + } + + } + return nil +} + +func (t *PublishStorageDealsParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Deals ([]market.ClientDealProposal) (slice) + if len(t.Deals) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Deals was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Deals)))); err != nil { + return err + } + for _, v := range t.Deals { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *PublishStorageDealsParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Deals ([]market.ClientDealProposal) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Deals: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Deals = make([]ClientDealProposal, extra) + } + + for i := 0; i < int(extra); i++ { + + var v ClientDealProposal + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Deals[i] = v + } + + return nil +} + +func (t *ActivateDealsParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.SectorExpiry (abi.ChainEpoch) (int64) + if t.SectorExpiry >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorExpiry))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SectorExpiry)-1)); err != nil { + return err + } + } + return nil +} + +func (t *ActivateDealsParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = abi.DealID(val) + } + + // t.SectorExpiry (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SectorExpiry = abi.ChainEpoch(extraI) + } + return nil +} + +func (t *VerifyDealsForActivationParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.SectorExpiry (abi.ChainEpoch) (int64) + if t.SectorExpiry >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorExpiry))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SectorExpiry)-1)); err != nil { + return err + } + } + + // t.SectorStart (abi.ChainEpoch) (int64) + if t.SectorStart >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorStart))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SectorStart)-1)); err != nil { + return err + } + } + return nil +} + +func (t *VerifyDealsForActivationParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = abi.DealID(val) + } + + // t.SectorExpiry (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SectorExpiry = abi.ChainEpoch(extraI) + } + // t.SectorStart (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SectorStart = abi.ChainEpoch(extraI) + } + return nil +} + +func (t *VerifyDealsForActivationReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.DealWeight (big.Int) (struct) + if err := t.DealWeight.MarshalCBOR(w); err != nil { + return err + } + + // t.VerifiedDealWeight (big.Int) (struct) + if err := t.VerifiedDealWeight.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *VerifyDealsForActivationReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.DealWeight (big.Int) (struct) + + { + + if err := t.DealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.DealWeight: %w", err) + } + + } + // t.VerifiedDealWeight (big.Int) (struct) + + { + + if err := t.VerifiedDealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.VerifiedDealWeight: %w", err) + } + + } + return nil +} + +func (t *ComputeDataCommitmentParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.SectorType (abi.RegisteredSealProof) (int64) + if t.SectorType >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorType))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SectorType)-1)); err != nil { + return err + } + } + return nil +} + +func (t *ComputeDataCommitmentParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = abi.DealID(val) + } + + // t.SectorType (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SectorType = abi.RegisteredSealProof(extraI) + } + return nil +} + +func (t *OnMinerSectorsTerminateParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + return nil +} + +func (t *OnMinerSectorsTerminateParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = abi.DealID(val) + } + + return nil +} + +func (t *PublishStorageDealsReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.IDs ([]abi.DealID) (slice) + if len(t.IDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.IDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.IDs)))); err != nil { + return err + } + for _, v := range t.IDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + return nil +} + +func (t *PublishStorageDealsReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.IDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.IDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.IDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.IDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.IDs was not a uint, instead got %d", maj) + } + + t.IDs[i] = abi.DealID(val) + } + + return nil +} + +func (t *DealProposal) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{139}); err != nil { + return err + } + + // t.PieceCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.PieceCID); err != nil { + return xerrors.Errorf("failed to write cid field t.PieceCID: %w", err) + } + + // t.PieceSize (abi.PaddedPieceSize) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.PieceSize))); err != nil { + return err + } + + // t.VerifiedDeal (bool) (bool) + if err := cbg.WriteBool(w, t.VerifiedDeal); err != nil { + return err + } + + // t.Client (address.Address) (struct) + if err := t.Client.MarshalCBOR(w); err != nil { + return err + } + + // t.Provider (address.Address) (struct) + if err := t.Provider.MarshalCBOR(w); err != nil { + return err + } + + // t.Label (string) (string) + if len(t.Label) > cbg.MaxLength { + return xerrors.Errorf("Value in field t.Label was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Label)))); err != nil { + return err + } + if _, err := w.Write([]byte(t.Label)); err != nil { + return err + } + + // t.StartEpoch (abi.ChainEpoch) (int64) + if t.StartEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.StartEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.StartEpoch)-1)); err != nil { + return err + } + } + + // t.EndEpoch (abi.ChainEpoch) (int64) + if t.EndEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.EndEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.EndEpoch)-1)); err != nil { + return err + } + } + + // t.StoragePricePerEpoch (big.Int) (struct) + if err := t.StoragePricePerEpoch.MarshalCBOR(w); err != nil { + return err + } + + // t.ProviderCollateral (big.Int) (struct) + if err := t.ProviderCollateral.MarshalCBOR(w); err != nil { + return err + } + + // t.ClientCollateral (big.Int) (struct) + if err := t.ClientCollateral.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *DealProposal) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 11 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.PieceCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.PieceCID: %w", err) + } + + t.PieceCID = c + + } + // t.PieceSize (abi.PaddedPieceSize) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.PieceSize = abi.PaddedPieceSize(extra) + + } + // t.VerifiedDeal (bool) (bool) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.VerifiedDeal = false + case 21: + t.VerifiedDeal = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + // t.Client (address.Address) (struct) + + { + + if err := t.Client.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Client: %w", err) + } + + } + // t.Provider (address.Address) (struct) + + { + + if err := t.Provider.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Provider: %w", err) + } + + } + // t.Label (string) (string) + + { + sval, err := cbg.ReadString(br) + if err != nil { + return err + } + + t.Label = string(sval) + } + // t.StartEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.StartEpoch = abi.ChainEpoch(extraI) + } + // t.EndEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.EndEpoch = abi.ChainEpoch(extraI) + } + // t.StoragePricePerEpoch (big.Int) (struct) + + { + + if err := t.StoragePricePerEpoch.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.StoragePricePerEpoch: %w", err) + } + + } + // t.ProviderCollateral (big.Int) (struct) + + { + + if err := t.ProviderCollateral.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.ProviderCollateral: %w", err) + } + + } + // t.ClientCollateral (big.Int) (struct) + + { + + if err := t.ClientCollateral.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.ClientCollateral: %w", err) + } + + } + return nil +} + +func (t *ClientDealProposal) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Proposal (market.DealProposal) (struct) + if err := t.Proposal.MarshalCBOR(w); err != nil { + return err + } + + // t.ClientSignature (crypto.Signature) (struct) + if err := t.ClientSignature.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *ClientDealProposal) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Proposal (market.DealProposal) (struct) + + { + + if err := t.Proposal.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Proposal: %w", err) + } + + } + // t.ClientSignature (crypto.Signature) (struct) + + { + + if err := t.ClientSignature.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.ClientSignature: %w", err) + } + + } + return nil +} + +func (t *DealState) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.SectorStartEpoch (abi.ChainEpoch) (int64) + if t.SectorStartEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorStartEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SectorStartEpoch)-1)); err != nil { + return err + } + } + + // t.LastUpdatedEpoch (abi.ChainEpoch) (int64) + if t.LastUpdatedEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.LastUpdatedEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.LastUpdatedEpoch)-1)); err != nil { + return err + } + } + + // t.SlashEpoch (abi.ChainEpoch) (int64) + if t.SlashEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SlashEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SlashEpoch)-1)); err != nil { + return err + } + } + return nil +} + +func (t *DealState) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SectorStartEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SectorStartEpoch = abi.ChainEpoch(extraI) + } + // t.LastUpdatedEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.LastUpdatedEpoch = abi.ChainEpoch(extraI) + } + // t.SlashEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SlashEpoch = abi.ChainEpoch(extraI) + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/deal.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/deal.go new file mode 100644 index 000000000..2d9680fba --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/deal.go @@ -0,0 +1,91 @@ +package market + +import ( + "bytes" + + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + mh "github.com/multiformats/go-multihash" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + acrypto "github.com/filecoin-project/specs-actors/actors/crypto" +) + +// Note: Deal Collateral is only released and returned to clients and miners +// when the storage deal stops counting towards power. In the current iteration, +// it will be released when the sector containing the storage deals expires, +// even though some storage deals can expire earlier than the sector does. +// Collaterals are denominated in PerEpoch to incur a cost for self dealing or +// minimal deals that last for a long time. +// Note: ClientCollateralPerEpoch may not be needed and removed pending future confirmation. +// There will be a Minimum value for both client and provider deal collateral. +type DealProposal struct { + PieceCID cid.Cid // CommP + PieceSize abi.PaddedPieceSize + VerifiedDeal bool + Client addr.Address + Provider addr.Address + + // Label is an arbitrary client chosen label to apply to the deal + Label string + + // Nominal start epoch. Deal payment is linear between StartEpoch and EndEpoch, + // with total amount StoragePricePerEpoch * (EndEpoch - StartEpoch). + // Storage deal must appear in a sealed (proven) sector no later than StartEpoch, + // otherwise it is invalid. + StartEpoch abi.ChainEpoch + EndEpoch abi.ChainEpoch + StoragePricePerEpoch abi.TokenAmount + + ProviderCollateral abi.TokenAmount + ClientCollateral abi.TokenAmount +} + +// ClientDealProposal is a DealProposal signed by a client +type ClientDealProposal struct { + Proposal DealProposal + ClientSignature acrypto.Signature +} + +func (p *DealProposal) Duration() abi.ChainEpoch { + return p.EndEpoch - p.StartEpoch +} + +func (p *DealProposal) TotalStorageFee() abi.TokenAmount { + return big.Mul(p.StoragePricePerEpoch, big.NewInt(int64(p.Duration()))) +} + +func (p *DealProposal) ClientBalanceRequirement() abi.TokenAmount { + return big.Add(p.ClientCollateral, p.TotalStorageFee()) +} + +func (p *DealProposal) ProviderBalanceRequirement() abi.TokenAmount { + return p.ProviderCollateral +} + +func (p *DealProposal) Cid() (cid.Cid, error) { + buf := new(bytes.Buffer) + if err := p.MarshalCBOR(buf); err != nil { + return cid.Undef, err + } + b := buf.Bytes() + + mhType := uint64(mh.BLAKE2B_MIN + 31) + mhLen := -1 + + hash, err := mh.Sum(b, mhType, mhLen) + if err != nil { + return cid.Undef, err + } + + c := cid.NewCidV1(cid.DagCBOR, hash) + + return c, nil +} + +type DealState struct { + SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector + LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated + SlashEpoch abi.ChainEpoch // -1 if deal never slashed +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_actor.go new file mode 100644 index 000000000..d6a81581f --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_actor.go @@ -0,0 +1,772 @@ +package market + +import ( + "fmt" + + addr "github.com/filecoin-project/go-address" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + verifreg "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + . "github.com/filecoin-project/specs-actors/actors/util" + "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Actor struct{} + +type Runtime = vmr.Runtime + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.AddBalance, + 3: a.WithdrawBalance, + 4: a.PublishStorageDeals, + 5: a.VerifyDealsForActivation, + 6: a.ActivateDeals, + 7: a.OnMinerSectorsTerminate, + 8: a.ComputeDataCommitment, + 9: a.CronTick, + } +} + +var _ abi.Invokee = Actor{} + +//////////////////////////////////////////////////////////////////////////////// +// Actor methods +//////////////////////////////////////////////////////////////////////////////// + +func (a Actor) Constructor(rt Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + + emptyArray, err := adt.MakeEmptyArray(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to create storage market state: %v", err) + } + + emptyMap, err := adt.MakeEmptyMap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to create storage market state: %v", err) + } + + emptyMSet, err := MakeEmptySetMultimap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to create storage market state: %v", err) + } + + st := ConstructState(emptyArray, emptyMap, emptyMSet) + rt.State().Create(st) + return nil +} + +type WithdrawBalanceParams struct { + ProviderOrClientAddress addr.Address + Amount abi.TokenAmount +} + +// Attempt to withdraw the specified amount from the balance held in escrow. +// If less than the specified amount is available, yields the entire available balance. +func (a Actor) WithdrawBalance(rt Runtime, params *WithdrawBalanceParams) *adt.EmptyValue { + if params.Amount.LessThan(big.Zero()) { + rt.Abortf(exitcode.ErrIllegalArgument, "negative amount %v", params.Amount) + } + + nominal, recipient := escrowAddress(rt, params.ProviderOrClientAddress) + + amountExtracted := abi.NewTokenAmount(0) + var st State + rt.State().Transaction(&st, func() interface{} { + // The withdrawable amount might be slightly less than nominal + // depending on whether or not all relevant entries have been processed + // by cron + + minBalance := st.GetLockedBalance(rt, nominal) + + et, err := adt.AsBalanceTable(adt.AsStore(rt), st.EscrowTable) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "load escrow table: %v", err) + } + ex, err := et.SubtractWithMinimum(nominal, params.Amount, minBalance) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "subtract form escrow table: %v", err) + } + + etc, err := et.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush escrow table: %w", err) + } + st.EscrowTable = etc + amountExtracted = ex + return nil + }) + + _, code := rt.Send(recipient, builtin.MethodSend, nil, amountExtracted) + builtin.RequireSuccess(rt, code, "failed to send funds") + return nil +} + +// Deposits the received value into the balance held in escrow. +func (a Actor) AddBalance(rt Runtime, providerOrClientAddress *addr.Address) *adt.EmptyValue { + msgValue := rt.Message().ValueReceived() + + nominal, _ := escrowAddress(rt, *providerOrClientAddress) + + var st State + rt.State().Transaction(&st, func() interface{} { + + err := st.AddEscrowBalance(adt.AsStore(rt), nominal, msgValue) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "adding to escrow table: %v", err) + } + + // ensure there is an entry in the locked table + err = st.AddLockedBalance(adt.AsStore(rt), nominal, big.Zero()) + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "adding to locked table: %v", err) + } + + return nil + }) + return nil +} + +type PublishStorageDealsParams struct { + Deals []ClientDealProposal +} + +type PublishStorageDealsReturn struct { + IDs []abi.DealID +} + +// Publish a new set of storage deals (not yet included in a sector). +func (a Actor) PublishStorageDeals(rt Runtime, params *PublishStorageDealsParams) *PublishStorageDealsReturn { + + // Deal message must have a From field identical to the provider of all the deals. + // This allows us to retain and verify only the client's signature in each deal proposal itself. + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + if len(params.Deals) == 0 { + rt.Abortf(exitcode.ErrIllegalArgument, "empty deals parameter") + } + + // All deals should have the same provider so get worker once + providerRaw := params.Deals[0].Proposal.Provider + provider, ok := rt.ResolveAddress(providerRaw) + if !ok { + rt.Abortf(exitcode.ErrNotFound, "failed to resolve provider address %v", providerRaw) + } + + _, worker := builtin.RequestMinerControlAddrs(rt, provider) + if worker != rt.Message().Caller() { + rt.Abortf(exitcode.ErrForbidden, "caller is not provider %v", provider) + } + + for _, deal := range params.Deals { + // Check VerifiedClient allowed cap and deduct PieceSize from cap. + // Either the DealSize is within the available DataCap of the VerifiedClient + // or this message will fail. We do not allow a deal that is partially verified. + if deal.Proposal.VerifiedDeal { + _, code := rt.Send( + builtin.VerifiedRegistryActorAddr, + builtin.MethodsVerifiedRegistry.UseBytes, + &verifreg.UseBytesParams{ + Address: deal.Proposal.Client, + DealSize: big.NewIntUnsigned(uint64(deal.Proposal.PieceSize)), + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to add verified deal for client: %v", deal.Proposal.Client) + } + } + + var newDealIds []abi.DealID + var st State + rt.State().Transaction(&st, func() interface{} { + proposals, err := AsDealProposalArray(adt.AsStore(rt), st.Proposals) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to load proposals array: %s", err) + } + + pending, err := adt.AsMap(adt.AsStore(rt), st.PendingProposals) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load pending proposals map: %s", err) + + dealOps, err := AsSetMultimap(adt.AsStore(rt), st.DealOpsByEpoch) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to load deal ids set: %s", err) + } + + // All storage proposals will be added in an atomic transaction; this operation will be unrolled if any of them fails. + for di, deal := range params.Deals { + validateDeal(rt, deal) + + if deal.Proposal.Provider != provider && deal.Proposal.Provider != providerRaw { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot publish deals from different providers at the same time") + } + + client, ok := rt.ResolveAddress(deal.Proposal.Client) + if !ok { + rt.Abortf(exitcode.ErrNotFound, "failed to resolve client address %v", deal.Proposal.Client) + } + // Normalise provider and client addresses in the proposal stored on chain (after signature verification). + deal.Proposal.Provider = provider + deal.Proposal.Client = client + + st.lockBalanceOrAbort(rt, client, deal.Proposal.ClientCollateral, ClientCollateral) + st.lockBalanceOrAbort(rt, client, deal.Proposal.TotalStorageFee(), ClientStorageFee) + st.lockBalanceOrAbort(rt, provider, deal.Proposal.ProviderCollateral, ProviderCollateral) + + id := st.generateStorageDealID() + + pcid, err := deal.Proposal.Cid() + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "failed to take cid of proposal %d: %s", di, err) + } + + has, err := pending.Get(adt.CidKey(pcid), nil) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to check for existence of deal proposal: %v", err) + } + + if has { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot publish duplicate deals") + } + + if err := pending.Put(adt.CidKey(pcid), &deal.Proposal); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "set deal in pending: %v", err) + } + + if err := proposals.Set(id, &deal.Proposal); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "set deal: %v", err) + } + + if err := dealOps.Put(deal.Proposal.StartEpoch, id); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "set deal in ops set: %v", err) + } + + newDealIds = append(newDealIds, id) + } + pendc, err := pending.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush pending proposal set: %w", err) + } + st.PendingProposals = pendc + + propc, err := proposals.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush proposal set: %w", err) + } + st.Proposals = propc + + dipc, err := dealOps.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush deal ids map: %w", err) + } + + st.DealOpsByEpoch = dipc + return nil + }) + + return &PublishStorageDealsReturn{newDealIds} +} + +type VerifyDealsForActivationParams struct { + DealIDs []abi.DealID + SectorExpiry abi.ChainEpoch + SectorStart abi.ChainEpoch +} + +type VerifyDealsForActivationReturn struct { + DealWeight abi.DealWeight + VerifiedDealWeight abi.DealWeight +} + +// Verify that a given set of storage deals is valid for a sector currently being PreCommitted +// and return DealWeight of the set of storage deals given. +// The weight is defined as the sum, over all deals in the set, of the product of deal size and duration. +func (A Actor) VerifyDealsForActivation(rt Runtime, params *VerifyDealsForActivationParams) *VerifyDealsForActivationReturn { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + minerAddr := rt.Message().Caller() + + var st State + rt.State().Readonly(&st) + store := adt.AsStore(rt) + + dealWeight, verifiedWeight, err := ValidateDealsForActivation(&st, store, params.DealIDs, minerAddr, params.SectorExpiry, params.SectorStart) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to validate proposals for activation") + + return &VerifyDealsForActivationReturn{ + DealWeight: dealWeight, + VerifiedDealWeight: verifiedWeight, + } +} + +type ActivateDealsParams struct { + DealIDs []abi.DealID + SectorExpiry abi.ChainEpoch +} + +// Verify that a given set of storage deals is valid for a sector currently being ProveCommitted, +// update the market's internal state accordingly. +func (a Actor) ActivateDeals(rt Runtime, params *ActivateDealsParams) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + minerAddr := rt.Message().Caller() + currEpoch := rt.CurrEpoch() + + var st State + store := adt.AsStore(rt) + + // Update deal states. + rt.State().Transaction(&st, func() interface{} { + _, _, err := ValidateDealsForActivation(&st, store, params.DealIDs, minerAddr, params.SectorExpiry, currEpoch) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to validate proposals for activation") + + states, err := AsDealStateArray(store, st.States) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deal states") + + pending, err := adt.AsMap(adt.AsStore(rt), st.PendingProposals) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "load pending %v", err) + + proposals, err := AsDealProposalArray(adt.AsStore(rt), st.Proposals) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "load proposals %v", err) + + for _, dealID := range params.DealIDs { + // This construction could be replaced with a single "update deal state" state method, possibly batched + // over all deal ids at once. + _, found, err := states.Get(dealID) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to get state for dealId %d", dealID) + if found { + rt.Abortf(exitcode.ErrIllegalArgument, "deal %d already included in another sector", dealID) + } + + proposal, found, err := proposals.Get(dealID) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load proposal for dealId %d", dealID) + if !found { + rt.Abortf(exitcode.ErrNotFound, "dealId %d not found", dealID) + } + + propc, err := proposal.Cid() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get proposal cid %v", err) + } + + has, err := pending.Get(adt.CidKey(propc), nil) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "no pending proposal for %v", err) + } + + if !has { + rt.Abortf(exitcode.ErrIllegalState, "tried to active deal that was not in the pending set (%s)", propc) + } + + err = states.Set(dealID, &DealState{ + SectorStartEpoch: currEpoch, + LastUpdatedEpoch: epochUndefined, + SlashEpoch: epochUndefined, + }) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to set deal state %d", dealID) + } + + st.States, err = states.Root() + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to flush deal states") + return nil + }) + + return nil +} + +type ComputeDataCommitmentParams struct { + DealIDs []abi.DealID + SectorType abi.RegisteredSealProof +} + +func (a Actor) ComputeDataCommitment(rt Runtime, params *ComputeDataCommitmentParams) *cbg.CborCid { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + + pieces := make([]abi.PieceInfo, 0) + var st State + rt.State().Transaction(&st, func() interface{} { + for _, dealID := range params.DealIDs { + deal := st.mustGetDeal(rt, dealID) + pieces = append(pieces, abi.PieceInfo{ + PieceCID: deal.PieceCID, + Size: deal.PieceSize, + }) + } + return nil + }) + + commd, err := rt.Syscalls().ComputeUnsealedSectorCID(params.SectorType, pieces) + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "failed to compute unsealed sector CID: %s", err) + } + + return (*cbg.CborCid)(&commd) +} + +type OnMinerSectorsTerminateParams struct { + DealIDs []abi.DealID +} + +// Terminate a set of deals in response to their containing sector being terminated. +// Slash provider collateral, refund client collateral, and refund partial unpaid escrow +// amount to client. +func (a Actor) OnMinerSectorsTerminate(rt Runtime, params *OnMinerSectorsTerminateParams) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + minerAddr := rt.Message().Caller() + + var st State + rt.State().Transaction(&st, func() interface{} { + proposals, err := AsDealProposalArray(adt.AsStore(rt), st.Proposals) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "load proposals: %v", err) + } + + states, err := AsDealStateArray(adt.AsStore(rt), st.States) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "load states: %v", err) + } + + for _, dealID := range params.DealIDs { + deal, found, err := proposals.Get(dealID) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get deal: %v", err) + } + // deal could have terminated and hence deleted before the sector is terminated. + // we should simply continue instead of aborting execution here if a deal is not found. + if !found { + continue + } + + AssertMsg(deal.Provider == minerAddr, "caller is not the provider of the deal") + + // do not slash expired deals + if deal.EndEpoch <= rt.CurrEpoch() { + continue + } + + state, found, err := states.Get(dealID) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get deal: %v", err) + } + if !found { + rt.Abortf(exitcode.ErrIllegalArgument, "no state found for deal in sector being terminated") + } + + // if a deal is already slashed, we don't need to do anything here. + if state.SlashEpoch != epochUndefined { + continue + } + + // mark the deal for slashing here. + // actual releasing of locked funds for the client and slashing of provider collateral happens in CronTick. + state.SlashEpoch = rt.CurrEpoch() + + if err := states.Set(dealID, state); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "set deal: %v", err) + } + } + + st.States, err = states.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush states: %s", err) + } + return nil + }) + return nil +} + +func (a Actor) CronTick(rt Runtime, params *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.CronActorAddr) + amountSlashed := big.Zero() + + var timedOutVerifiedDeals []*DealProposal + + var st State + rt.State().Transaction(&st, func() interface{} { + dbe, err := AsSetMultimap(adt.AsStore(rt), st.DealOpsByEpoch) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deal opts set") + + updatesNeeded := make(map[abi.ChainEpoch][]abi.DealID) + + states, err := AsDealStateArray(adt.AsStore(rt), st.States) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to get state state") + + proposals, err := AsDealProposalArray(adt.AsStore(rt), st.Proposals) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to get state proposals") + + et, err := adt.AsBalanceTable(adt.AsStore(rt), st.EscrowTable) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load escrow table") + + lt, err := adt.AsBalanceTable(adt.AsStore(rt), st.LockedTable) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load locked balance table") + + pending, err := adt.AsMap(adt.AsStore(rt), st.PendingProposals) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load pending proposals map") + + for i := st.LastCron + 1; i <= rt.CurrEpoch(); i++ { + if err := dbe.ForEach(i, func(dealID abi.DealID) error { + deal := st.mustGetDeal(rt, dealID) + dcid, err := deal.Cid() + if err != nil { + return xerrors.Errorf("failed to get cid for deal proposal: %w", err) + } + + builtin.RequireNoErr(rt, pending.Delete(adt.CidKey(dcid)), exitcode.ErrIllegalState, "failed to delete pending proposal") + + state, found, err := states.Get(dealID) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to get deal state") + + // deal has been published but not activated yet -> terminate it as it has timed out + if !found { + // Not yet appeared in proven sector; check for timeout. + AssertMsg(rt.CurrEpoch() >= deal.StartEpoch, "if sector start is not set, we must be in a timed out state") + + slashed := st.processDealInitTimedOut(rt, et, lt, deal) + if !slashed.IsZero() { + amountSlashed = big.Add(amountSlashed, slashed) + } + if deal.VerifiedDeal { + timedOutVerifiedDeals = append(timedOutVerifiedDeals, deal) + } + + // we should not attempt to delete the DealState because it does NOT exist + if err := deleteDealProposalAndState(dealID, states, proposals, true, false); err != nil { + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to delete deal") + } + return nil + } + + slashAmount, nextEpoch, removeDeal := st.updatePendingDealState(rt, state, deal, dealID, et, lt, rt.CurrEpoch()) + if removeDeal { + if err := deleteDealProposalAndState(dealID, states, proposals, true, true); err != nil { + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to delete deal") + } + } + if !slashAmount.IsZero() { + amountSlashed = big.Add(amountSlashed, slashAmount) + } + + if nextEpoch != epochUndefined { + Assert(nextEpoch > rt.CurrEpoch()) + + // TODO: can we avoid having this field? + // https://github.com/filecoin-project/specs-actors/issues/463 + state.LastUpdatedEpoch = rt.CurrEpoch() + + if err := states.Set(dealID, state); err != nil { + rt.Abortf(exitcode.ErrPlaceholder, "failed to get deal: %v", err) + } + + updatesNeeded[nextEpoch] = append(updatesNeeded[nextEpoch], dealID) + } + + return nil + }); err != nil { + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to iterate deals for epoch") + } + builtin.RequireNoErr(rt, dbe.RemoveAll(i), exitcode.ErrIllegalState, "failed to delete deals from set") + } + + // NB: its okay that we're doing a 'random' golang map iteration here + // because HAMTs and AMTs are insertion order independent, the same set of + // data inserted will always produce the same structure, no matter the order + for epoch, deals := range updatesNeeded { + if err := dbe.PutMany(epoch, deals); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to reinsert deal IDs into epoch set: %s", err) + } + } + + ndbec, err := dbe.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to get root of deals by epoch set: %s", err) + } + + ltc, err := lt.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush locked table: %s", err) + } + etc, err := et.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush escrow table: %s", err) + } + st.LockedTable = ltc + st.EscrowTable = etc + + st.DealOpsByEpoch = ndbec + + st.LastCron = rt.CurrEpoch() + + st.States, err = states.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush deal states: %s", err) + } + + st.Proposals, err = proposals.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush deal proposals: %s", err) + } + + return nil + }) + + for _, d := range timedOutVerifiedDeals { + _, code := rt.Send( + builtin.VerifiedRegistryActorAddr, + builtin.MethodsVerifiedRegistry.RestoreBytes, + &verifreg.RestoreBytesParams{ + Address: d.Client, + DealSize: big.NewIntUnsigned(uint64(d.PieceSize)), + }, + abi.NewTokenAmount(0), + ) + + builtin.RequireSuccess(rt, code, "failed to restore bytes for verified client: %v", d.Client) + } + + if !amountSlashed.IsZero() { + _, e := rt.Send(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, amountSlashed) + builtin.RequireSuccess(rt, e, "expected send to burnt funds actor to succeed") + } + + return nil +} + +func deleteDealProposalAndState(dealId abi.DealID, states *DealMetaArray, proposals *DealArray, removeProposal bool, + removeState bool) error { + if removeProposal { + if err := proposals.Delete(uint64(dealId)); err != nil { + return fmt.Errorf("failed to delete deal proposal: %w", err) + } + + } + + if removeState { + if err := states.Delete(dealId); err != nil { + return fmt.Errorf("failed to delete deal state: %w", err) + } + } + + return nil +} + +// +// Exported functions +// + +// Validates a collection of deal proposals for activation, and returns their combined weight, +// split into regular deal weight and verified deal weight. +func ValidateDealsForActivation(st *State, store adt.Store, dealIDs []abi.DealID, minerAddr addr.Address, + sectorExpiry, currEpoch abi.ChainEpoch) (big.Int, big.Int, error) { + + proposals, err := AsDealProposalArray(store, st.Proposals) + if err != nil { + return big.Int{}, big.Int{}, fmt.Errorf("failed to load proposals: %w", err) + } + + totalDealSpaceTime := big.Zero() + totalVerifiedSpaceTime := big.Zero() + for _, dealID := range dealIDs { + proposal, found, err := proposals.Get(dealID) + if err != nil { + return big.Int{}, big.Int{}, fmt.Errorf("failed to load deal %d: %w", dealID, err) + } + if !found { + return big.Int{}, big.Int{}, fmt.Errorf("dealId %d not found", dealID) + } + if err = validateDealCanActivate(proposal, minerAddr, sectorExpiry, currEpoch); err != nil { + return big.Int{}, big.Int{}, fmt.Errorf("cannot activate deal %d: %w", dealID, err) + } + + // Compute deal weight + dealSpaceTime := DealWeight(proposal) + if proposal.VerifiedDeal { + totalVerifiedSpaceTime = big.Add(totalVerifiedSpaceTime, dealSpaceTime) + } else { + totalDealSpaceTime = big.Add(totalDealSpaceTime, dealSpaceTime) + } + } + return totalDealSpaceTime, totalVerifiedSpaceTime, nil +} + +//////////////////////////////////////////////////////////////////////////////// +// Checks +//////////////////////////////////////////////////////////////////////////////// + +func validateDealCanActivate(proposal *DealProposal, minerAddr addr.Address, sectorExpiration, currEpoch abi.ChainEpoch) error { + if proposal.Provider != minerAddr { + return fmt.Errorf("proposal has provider %v, must be %v", proposal.Provider, minerAddr) + } + if currEpoch > proposal.StartEpoch { + return fmt.Errorf("proposal start epoch %d has already elapsed at %d", proposal.StartEpoch, currEpoch) + } + if proposal.EndEpoch > sectorExpiration { + return fmt.Errorf("proposal expiration %d exceeds sector expiration %d", proposal.EndEpoch, sectorExpiration) + } + return nil +} + +func validateDeal(rt Runtime, deal ClientDealProposal) { + if err := dealProposalIsInternallyValid(rt, deal); err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "Invalid deal proposal: %s", err) + } + + proposal := deal.Proposal + + if proposal.EndEpoch <= proposal.StartEpoch { + rt.Abortf(exitcode.ErrIllegalArgument, "proposal end before proposal start") + } + + if rt.CurrEpoch() > proposal.StartEpoch { + rt.Abortf(exitcode.ErrIllegalArgument, "Deal start epoch has already elapsed.") + } + + minDuration, maxDuration := dealDurationBounds(proposal.PieceSize) + if proposal.Duration() < minDuration || proposal.Duration() > maxDuration { + rt.Abortf(exitcode.ErrIllegalArgument, "Deal duration out of bounds.") + } + + minPrice, maxPrice := dealPricePerEpochBounds(proposal.PieceSize, proposal.Duration()) + if proposal.StoragePricePerEpoch.LessThan(minPrice) || proposal.StoragePricePerEpoch.GreaterThan(maxPrice) { + rt.Abortf(exitcode.ErrIllegalArgument, "Storage price out of bounds.") + } + + minProviderCollateral, maxProviderCollateral := dealProviderCollateralBounds(proposal.PieceSize, proposal.Duration()) + if proposal.ProviderCollateral.LessThan(minProviderCollateral) || proposal.ProviderCollateral.GreaterThan(maxProviderCollateral) { + rt.Abortf(exitcode.ErrIllegalArgument, "Provider collateral out of bounds.") + } + + minClientCollateral, maxClientCollateral := dealClientCollateralBounds(proposal.PieceSize, proposal.Duration()) + if proposal.ClientCollateral.LessThan(minClientCollateral) || proposal.ClientCollateral.GreaterThan(maxClientCollateral) { + rt.Abortf(exitcode.ErrIllegalArgument, "Client collateral out of bounds.") + } +} + +// Resolves a provider or client address to the canonical form against which a balance should be held, and +// the designated recipient address of withdrawals (which is the same, for simple account parties). +func escrowAddress(rt Runtime, addr addr.Address) (nominal addr.Address, recipient addr.Address) { + // Resolve the provided address to the canonical form against which the balance is held. + nominal, ok := rt.ResolveAddress(addr) + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "failed to resolve address %v", addr) + } + + codeID, ok := rt.GetActorCodeCID(nominal) + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "no code for address %v", nominal) + } + + if codeID.Equals(builtin.StorageMinerActorCodeID) { + // Storage miner actor entry; implied funds recipient is the associated owner address. + ownerAddr, workerAddr := builtin.RequestMinerControlAddrs(rt, nominal) + rt.ValidateImmediateCallerIs(ownerAddr, workerAddr) + return nominal, ownerAddr + } + + // Ordinary account-style actor entry; funds recipient is just the entry address itself. + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + return nominal, nominal +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_state.go new file mode 100644 index 000000000..510b14c5f --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_state.go @@ -0,0 +1,409 @@ +package market + +import ( + "bytes" + + addr "github.com/filecoin-project/go-address" + "github.com/filecoin-project/specs-actors/actors/builtin" + "github.com/ipfs/go-cid" + xerrors "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + . "github.com/filecoin-project/specs-actors/actors/util" + "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +const epochUndefined = abi.ChainEpoch(-1) + +// Market mutations +// add / rm balance +// pub deal (always provider) +// activate deal (miner) +// end deal (miner terminate, expire(no activation)) + +// BalanceLockingReason is the reason behind locking an amount. +type BalanceLockingReason int + +const ( + ClientCollateral BalanceLockingReason = iota + ClientStorageFee + ProviderCollateral +) + +type State struct { + Proposals cid.Cid // AMT[DealID]DealProposal + States cid.Cid // AMT[DealID]DealState + + // PendingProposals tracks proposals that have not yet reached their deal start date. + // We track them here to ensure that miners can't publish the same deal proposal twice + PendingProposals cid.Cid // HAMT[DealCid]DealProposal + + // Total amount held in escrow, indexed by actor address (including both locked and unlocked amounts). + EscrowTable cid.Cid // BalanceTable + + // Amount locked, indexed by actor address. + // Note: the amounts in this table do not affect the overall amount in escrow: + // only the _portion_ of the total escrow amount that is locked. + LockedTable cid.Cid // BalanceTable + + NextID abi.DealID + + // Metadata cached for efficient iteration over deals. + DealOpsByEpoch cid.Cid // SetMultimap, HAMT[epoch]Set + LastCron abi.ChainEpoch + + // Total Client Collateral that is locked -> unlocked when deal is terminated + TotalClientLockedCollateral abi.TokenAmount + // Total Provider Collateral that is locked -> unlocked when deal is terminated + TotalProviderLockedCollateral abi.TokenAmount + // Total storage fee that is locked in escrow -> unlocked when payments are made + TotalClientStorageFee abi.TokenAmount +} + +func ConstructState(emptyArrayCid, emptyMapCid, emptyMSetCid cid.Cid) *State { + return &State{ + Proposals: emptyArrayCid, + States: emptyArrayCid, + PendingProposals: emptyMapCid, + EscrowTable: emptyMapCid, + LockedTable: emptyMapCid, + NextID: abi.DealID(0), + DealOpsByEpoch: emptyMSetCid, + LastCron: abi.ChainEpoch(-1), + + TotalClientLockedCollateral: abi.NewTokenAmount(0), + TotalProviderLockedCollateral: abi.NewTokenAmount(0), + TotalClientStorageFee: abi.NewTokenAmount(0), + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Deal state operations +//////////////////////////////////////////////////////////////////////////////// + +func (st *State) updatePendingDealState(rt Runtime, state *DealState, deal *DealProposal, dealID abi.DealID, et, lt *adt.BalanceTable, epoch abi.ChainEpoch) (amountSlashed abi.TokenAmount, + nextEpoch abi.ChainEpoch, removeDeal bool) { + amountSlashed = abi.NewTokenAmount(0) + + everUpdated := state.LastUpdatedEpoch != epochUndefined + everSlashed := state.SlashEpoch != epochUndefined + + Assert(!everUpdated || (state.LastUpdatedEpoch <= epoch)) // if the deal was ever updated, make sure it didn't happen in the future + + // This would be the case that the first callback somehow triggers before it is scheduled to + // This is expected not to be able to happen + if deal.StartEpoch > epoch { + return amountSlashed, epochUndefined, false + } + + paymentEndEpoch := deal.EndEpoch + if everSlashed { + AssertMsg(epoch >= state.SlashEpoch, "current epoch less than slash epoch") + Assert(state.SlashEpoch <= deal.EndEpoch) + paymentEndEpoch = state.SlashEpoch + } else if epoch < paymentEndEpoch { + paymentEndEpoch = epoch + } + + paymentStartEpoch := deal.StartEpoch + if everUpdated && state.LastUpdatedEpoch > paymentStartEpoch { + paymentStartEpoch = state.LastUpdatedEpoch + } + + numEpochsElapsed := paymentEndEpoch - paymentStartEpoch + + { + // Process deal payment for the elapsed epochs. + totalPayment := big.Mul(big.NewInt(int64(numEpochsElapsed)), deal.StoragePricePerEpoch) + + // the transfer amount can be less than or equal to zero if a deal is slashed before or at the deal's start epoch. + if totalPayment.GreaterThan(big.Zero()) { + st.transferBalance(rt, deal.Client, deal.Provider, totalPayment, et, lt) + } + } + + if everSlashed { + // unlock client collateral and locked storage fee + paymentRemaining := dealGetPaymentRemaining(deal, state.SlashEpoch) + + // unlock remaining storage fee + if err := st.unlockBalance(lt, deal.Client, paymentRemaining, ClientStorageFee); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to unlock remaining client storage fee: %s", err) + } + // unlock client collateral + if err := st.unlockBalance(lt, deal.Client, deal.ClientCollateral, ClientCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to unlock client collateral: %s", err) + } + + // slash provider collateral + amountSlashed = deal.ProviderCollateral + if err := st.slashBalance(et, lt, deal.Provider, amountSlashed, ProviderCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "slashing balance: %s", err) + } + + return amountSlashed, epochUndefined, true + } + + if epoch >= deal.EndEpoch { + st.processDealExpired(rt, deal, state, lt, dealID) + return amountSlashed, epochUndefined, true + } + + nextEpoch = epoch + DealUpdatesInterval + if nextEpoch > deal.EndEpoch { + nextEpoch = deal.EndEpoch + } + + return amountSlashed, nextEpoch, false +} + +// Deal start deadline elapsed without appearing in a proven sector. +// Delete deal, slash a portion of provider's collateral, and unlock remaining collaterals +// for both provider and client. +func (st *State) processDealInitTimedOut(rt Runtime, et, lt *adt.BalanceTable, deal *DealProposal) abi.TokenAmount { + if err := st.unlockBalance(lt, deal.Client, deal.TotalStorageFee(), ClientStorageFee); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failure unlocking client storage fee: %s", err) + } + if err := st.unlockBalance(lt, deal.Client, deal.ClientCollateral, ClientCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failure unlocking client collateral: %s", err) + } + + amountSlashed := collateralPenaltyForDealActivationMissed(deal.ProviderCollateral) + amountRemaining := big.Sub(deal.ProviderBalanceRequirement(), amountSlashed) + + if err := st.slashBalance(et, lt, deal.Provider, amountSlashed, ProviderCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to slash balance: %s", err) + } + + if err := st.unlockBalance(lt, deal.Provider, amountRemaining, ProviderCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to unlock deal provider balance: %s", err) + } + + return amountSlashed +} + +// Normal expiration. Delete deal and unlock collaterals for both miner and client. +func (st *State) processDealExpired(rt Runtime, deal *DealProposal, state *DealState, lt *adt.BalanceTable, dealID abi.DealID) { + Assert(state.SectorStartEpoch != epochUndefined) + + // Note: payment has already been completed at this point (_rtProcessDealPaymentEpochsElapsed) + if err := st.unlockBalance(lt, deal.Provider, deal.ProviderCollateral, ProviderCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed unlocking deal provider balance: %s", err) + } + + if err := st.unlockBalance(lt, deal.Client, deal.ClientCollateral, ClientCollateral); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed unlocking deal client balance: %s", err) + } +} + +func (st *State) generateStorageDealID() abi.DealID { + ret := st.NextID + st.NextID = st.NextID + abi.DealID(1) + return ret +} + +//////////////////////////////////////////////////////////////////////////////// +// Balance table operations +//////////////////////////////////////////////////////////////////////////////// + +func (st *State) MutateBalanceTable(s adt.Store, c *cid.Cid, f func(t *adt.BalanceTable) error) error { + t, err := adt.AsBalanceTable(s, *c) + if err != nil { + return err + } + + if err := f(t); err != nil { + return err + } + + rc, err := t.Root() + if err != nil { + return err + } + + *c = rc + return nil +} + +func (st *State) AddEscrowBalance(s adt.Store, a addr.Address, amount abi.TokenAmount) error { + return st.MutateBalanceTable(s, &st.EscrowTable, func(et *adt.BalanceTable) error { + err := et.AddCreate(a, amount) + if err != nil { + return xerrors.Errorf("failed to add %s to balance table: %w", a, err) + } + return nil + }) +} + +func (st *State) AddLockedBalance(s adt.Store, a addr.Address, amount abi.TokenAmount) error { + return st.MutateBalanceTable(s, &st.LockedTable, func(lt *adt.BalanceTable) error { + err := lt.AddCreate(a, amount) + if err != nil { + return err + } + return nil + }) +} + +func (st *State) GetEscrowBalance(rt Runtime, a addr.Address) abi.TokenAmount { + bt, err := adt.AsBalanceTable(adt.AsStore(rt), st.EscrowTable) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get escrow balance: %v", err) + } + ret, err := bt.Get(a) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get escrow balance: %v", err) + } + return ret +} + +func (st *State) GetLockedBalance(rt Runtime, a addr.Address) abi.TokenAmount { + lt, err := adt.AsBalanceTable(adt.AsStore(rt), st.LockedTable) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get locked balance: %v", err) + } + ret, err := lt.Get(a) + if _, ok := err.(adt.ErrNotFound); ok { + rt.Abortf(exitcode.ErrInsufficientFunds, "failed to get locked balance: %v", err) + } + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get locked balance: %v", err) + } + return ret +} + +func (st *State) maybeLockBalance(rt Runtime, addr addr.Address, amount abi.TokenAmount) error { + Assert(amount.GreaterThanEqual(big.Zero())) + + prevLocked := st.GetLockedBalance(rt, addr) + escrowBalance := st.GetEscrowBalance(rt, addr) + if big.Add(prevLocked, amount).GreaterThan(st.GetEscrowBalance(rt, addr)) { + return xerrors.Errorf("not enough balance to lock for addr %s: %s < %s + %s", addr, escrowBalance, prevLocked, amount) + } + + return st.MutateBalanceTable(adt.AsStore(rt), &st.LockedTable, func(lt *adt.BalanceTable) error { + err := lt.Add(addr, amount) + if err != nil { + return xerrors.Errorf("adding locked balance: %w", err) + } + return nil + }) +} + +// TODO: all these balance table mutations need to happen at the top level and be batched (no flushing after each!) +// https://github.com/filecoin-project/specs-actors/issues/464 +func (st *State) unlockBalance(lt *adt.BalanceTable, addr addr.Address, amount abi.TokenAmount, lockReason BalanceLockingReason) error { + Assert(amount.GreaterThanEqual(big.Zero())) + + err := lt.MustSubtract(addr, amount) + if err != nil { + return xerrors.Errorf("subtracting from locked balance: %v", err) + } + + switch lockReason { + case ClientCollateral: + st.TotalClientLockedCollateral = big.Sub(st.TotalClientLockedCollateral, amount) + case ClientStorageFee: + st.TotalClientStorageFee = big.Sub(st.TotalClientStorageFee, amount) + case ProviderCollateral: + st.TotalProviderLockedCollateral = big.Sub(st.TotalProviderLockedCollateral, amount) + } + + return nil +} + +// move funds from locked in client to available in provider +func (st *State) transferBalance(rt Runtime, fromAddr addr.Address, toAddr addr.Address, amount abi.TokenAmount, et, lt *adt.BalanceTable) { + Assert(amount.GreaterThanEqual(big.Zero())) + + if err := et.MustSubtract(fromAddr, amount); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "subtract from escrow: %v", err) + } + + if err := st.unlockBalance(lt, fromAddr, amount, ClientStorageFee); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "subtract from locked: %v", err) + } + + if err := et.Add(toAddr, amount); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "add to escrow: %v", err) + } +} + +func (st *State) slashBalance(et, lt *adt.BalanceTable, addr addr.Address, amount abi.TokenAmount, reason BalanceLockingReason) error { + Assert(amount.GreaterThanEqual(big.Zero())) + + if err := et.MustSubtract(addr, amount); err != nil { + return xerrors.Errorf("subtract from escrow: %v", err) + } + + return st.unlockBalance(lt, addr, amount, reason) +} + +//////////////////////////////////////////////////////////////////////////////// +// Method utility functions +//////////////////////////////////////////////////////////////////////////////// + +func (st *State) mustGetDeal(rt Runtime, dealID abi.DealID) *DealProposal { + proposals, err := AsDealProposalArray(adt.AsStore(rt), st.Proposals) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "get proposal: %v", err) + } + + proposal, found, err := proposals.Get(dealID) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load proposal for dealId %d", dealID) + if !found { + rt.Abortf(exitcode.ErrIllegalState, "dealId %d not found", dealID) + } + + return proposal +} + +func (st *State) lockBalanceOrAbort(rt Runtime, addr addr.Address, amount abi.TokenAmount, reason BalanceLockingReason) { + if err := st.maybeLockBalance(rt, addr, amount); err != nil { + rt.Abortf(exitcode.ErrInsufficientFunds, "Insufficient funds available to lock: %s", err) + } + + switch reason { + case ClientCollateral: + st.TotalClientLockedCollateral = big.Add(st.TotalClientLockedCollateral, amount) + case ClientStorageFee: + st.TotalClientStorageFee = big.Add(st.TotalClientStorageFee, amount) + case ProviderCollateral: + st.TotalProviderLockedCollateral = big.Add(st.TotalProviderLockedCollateral, amount) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// State utility functions +//////////////////////////////////////////////////////////////////////////////// + +func dealProposalIsInternallyValid(rt Runtime, proposal ClientDealProposal) error { + // Note: we do not verify the provider signature here, since this is implicit in the + // authenticity of the on-chain message publishing the deal. + buf := bytes.Buffer{} + err := proposal.Proposal.MarshalCBOR(&buf) + if err != nil { + return xerrors.Errorf("proposal signature verification failed to marshal proposal: %w", err) + } + err = rt.Syscalls().VerifySignature(proposal.ClientSignature, proposal.Proposal.Client, buf.Bytes()) + if err != nil { + return xerrors.Errorf("signature proposal invalid: %w", err) + } + return nil +} + +func dealGetPaymentRemaining(deal *DealProposal, slashEpoch abi.ChainEpoch) abi.TokenAmount { + Assert(slashEpoch <= deal.EndEpoch) + + // Payments are always for start -> end epoch irrespective of when the deal is slashed. + if slashEpoch < deal.StartEpoch { + slashEpoch = deal.StartEpoch + } + + durationRemaining := deal.EndEpoch - slashEpoch + Assert(durationRemaining > 0) + + return big.Mul(big.NewInt(int64(durationRemaining)), deal.StoragePricePerEpoch) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_test.go new file mode 100644 index 000000000..afdd3be2e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/market_test.go @@ -0,0 +1,2166 @@ +package market_test + +import ( + "bytes" + "context" + "errors" + "testing" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" + "github.com/filecoin-project/specs-actors/actors/builtin/market" + "github.com/filecoin-project/specs-actors/actors/builtin/miner" + "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" + "github.com/filecoin-project/specs-actors/actors/crypto" + "github.com/filecoin-project/specs-actors/actors/runtime" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + "github.com/filecoin-project/specs-actors/actors/util/adt" + "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func mustCbor(o runtime.CBORMarshaler) []byte { + buf := new(bytes.Buffer) + if err := o.MarshalCBOR(buf); err != nil { + panic(err) + } + + return buf.Bytes() +} + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, market.Actor{}) +} + +func TestRemoveAllError(t *testing.T) { + marketActor := tutil.NewIDAddr(t, 100) + builder := mock.NewBuilder(context.Background(), marketActor) + rt := builder.Build(t) + store := adt.AsStore(rt) + + smm := market.MakeEmptySetMultimap(store) + + if err := smm.RemoveAll(42); err != nil { + t.Fatalf("expected no error, got: %s", err) + } +} + +func TestMarketActor(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + minerAddrs := &minerAddrs{owner, worker, provider} + + var st market.State + + t.Run("simple construction", func(t *testing.T) { + actor := market.Actor{} + receiver := tutil.NewIDAddr(t, 100) + builder := mock.NewBuilder(context.Background(), receiver). + WithCaller(builtin.SystemActorAddr, builtin.InitActorCodeID) + + rt := builder.Build(t) + + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + + ret := rt.Call(actor.Constructor, nil).(*adt.EmptyValue) + assert.Nil(t, ret) + rt.Verify() + + store := adt.AsStore(rt) + + emptyMap, err := adt.MakeEmptyMap(store).Root() + assert.NoError(t, err) + + emptyArray, err := adt.MakeEmptyArray(store).Root() + assert.NoError(t, err) + + emptyMultiMap, err := market.MakeEmptySetMultimap(store).Root() + assert.NoError(t, err) + + var state market.State + rt.GetState(&state) + + assert.Equal(t, emptyArray, state.Proposals) + assert.Equal(t, emptyArray, state.States) + assert.Equal(t, emptyMap, state.EscrowTable) + assert.Equal(t, emptyMap, state.LockedTable) + assert.Equal(t, abi.DealID(0), state.NextID) + assert.Equal(t, emptyMultiMap, state.DealOpsByEpoch) + assert.Equal(t, abi.ChainEpoch(-1), state.LastCron) + }) + + t.Run("AddBalance", func(t *testing.T) { + t.Run("adds to provider escrow funds", func(t *testing.T) { + testCases := []struct { + delta int64 + total int64 + }{ + {10, 10}, + {20, 30}, + {40, 70}, + } + + // Test adding provider funds from both worker and owner address + for _, callerAddr := range []address.Address{owner, worker} { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + for _, tc := range testCases { + rt.SetCaller(callerAddr, builtin.AccountActorCodeID) + rt.SetReceived(abi.NewTokenAmount(tc.delta)) + actor.expectProviderControlAddressesAndValidateCaller(rt, provider, owner, worker) + + rt.Call(actor.AddBalance, &provider) + + rt.Verify() + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(tc.total), st.GetEscrowBalance(rt, provider)) + } + } + }) + + t.Run("fails unless called by an account actor", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + rt.SetReceived(abi.NewTokenAmount(10)) + actor.expectProviderControlAddressesAndValidateCaller(rt, provider, owner, worker) + + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + rt.Call(actor.AddBalance, &provider) + }) + + rt.Verify() + }) + + t.Run("adds to non-provider escrow funds", func(t *testing.T) { + testCases := []struct { + delta int64 + total int64 + }{ + {10, 10}, + {20, 30}, + {40, 70}, + } + + // Test adding non-provider funds from both worker and client addresses + for _, callerAddr := range []address.Address{client, worker} { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + for _, tc := range testCases { + rt.SetCaller(callerAddr, builtin.AccountActorCodeID) + rt.SetReceived(abi.NewTokenAmount(tc.delta)) + rt.ExpectValidateCallerType(builtin.CallerTypesSignable...) + + rt.Call(actor.AddBalance, &callerAddr) + + rt.Verify() + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(tc.total), st.GetEscrowBalance(rt, callerAddr)) + } + } + }) + }) + + t.Run("WithdrawBalance", func(t *testing.T) { + startEpoch := abi.ChainEpoch(10) + endEpoch := abi.ChainEpoch(20) + publishEpoch := abi.ChainEpoch(5) + + t.Run("fails with a negative withdraw amount", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + params := market.WithdrawBalanceParams{ + ProviderOrClientAddress: provider, + Amount: abi.NewTokenAmount(-1), + } + + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.WithdrawBalance, ¶ms) + }) + + rt.Verify() + }) + + t.Run("withdraws from provider escrow funds and sends to owner", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + actor.addProviderFunds(rt, abi.NewTokenAmount(20), minerAddrs) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(20), st.GetEscrowBalance(rt, provider)) + + // worker calls WithdrawBalance, balance is transferred to owner + withdrawAmount := abi.NewTokenAmount(1) + actor.withdrawProviderBalance(rt, withdrawAmount, withdrawAmount, minerAddrs) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(19), st.GetEscrowBalance(rt, provider)) + }) + + t.Run("withdraws from non-provider escrow funds", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + actor.addParticipantFunds(rt, client, abi.NewTokenAmount(20)) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(20), st.GetEscrowBalance(rt, client)) + + withdrawAmount := abi.NewTokenAmount(1) + actor.withdrawClientBalance(rt, client, withdrawAmount, withdrawAmount) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(19), st.GetEscrowBalance(rt, client)) + }) + + t.Run("client withdrawing more than escrow balance limits to available funds", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + actor.addParticipantFunds(rt, client, abi.NewTokenAmount(20)) + + // withdraw amount greater than escrow balance + withdrawAmount := abi.NewTokenAmount(25) + expectedAmount := abi.NewTokenAmount(20) + actor.withdrawClientBalance(rt, client, withdrawAmount, expectedAmount) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(0), st.GetEscrowBalance(rt, client)) + }) + + t.Run("worker withdrawing more than escrow balance limits to available funds", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + actor.addProviderFunds(rt, abi.NewTokenAmount(20), minerAddrs) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(20), st.GetEscrowBalance(rt, provider)) + + // withdraw amount greater than escrow balance + withdrawAmount := abi.NewTokenAmount(25) + actualWithdrawn := abi.NewTokenAmount(20) + actor.withdrawProviderBalance(rt, withdrawAmount, actualWithdrawn, minerAddrs) + + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(0), st.GetEscrowBalance(rt, provider)) + }) + + t.Run("balance after withdrawal must ALWAYS be greater than or equal to locked amount", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + // create the deal to publish + deal := actor.generateDealAndAddFunds(rt, client, minerAddrs, startEpoch, endEpoch) + + // publish the deal so that client AND provider collateral is locked + rt.SetEpoch(publishEpoch) + actor.publishDeals(rt, minerAddrs, deal) + rt.GetState(&st) + require.Equal(t, deal.ProviderCollateral, st.GetLockedBalance(rt, provider)) + require.Equal(t, deal.ClientBalanceRequirement(), st.GetLockedBalance(rt, client)) + + withDrawAmt := abi.NewTokenAmount(1) + withDrawableAmt := abi.NewTokenAmount(0) + // client cannot withdraw any funds since all it's balance is locked + actor.withdrawClientBalance(rt, client, withDrawAmt, withDrawableAmt) + // provider cannot withdraw any funds since all it's balance is locked + actor.withdrawProviderBalance(rt, withDrawAmt, withDrawableAmt, minerAddrs) + + // add some more funds to the provider & ensure withdrawal is limited by the locked funds + withDrawAmt = abi.NewTokenAmount(30) + withDrawableAmt = abi.NewTokenAmount(25) + actor.addProviderFunds(rt, withDrawableAmt, minerAddrs) + actor.withdrawProviderBalance(rt, withDrawAmt, withDrawableAmt, minerAddrs) + + // add some more funds to the client & ensure withdrawal is limited by the locked funds + actor.addParticipantFunds(rt, client, withDrawableAmt) + actor.withdrawClientBalance(rt, client, withDrawAmt, withDrawableAmt) + }) + + t.Run("worker balance after withdrawal must account for slashed funds", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + // create the deal to publish + deal := actor.generateDealAndAddFunds(rt, client, minerAddrs, startEpoch, endEpoch) + + // publish the deal + rt.SetEpoch(publishEpoch) + dealID := actor.publishDeals(rt, minerAddrs, deal)[0] + + // activate the deal + actor.activateDeals(rt, endEpoch+1, provider, publishEpoch, dealID) + st := actor.getDealState(rt, dealID) + require.EqualValues(t, publishEpoch, st.SectorStartEpoch) + + // slash the deal + newEpoch := publishEpoch + 1 + rt.SetEpoch(newEpoch) + actor.terminateDeals(rt, provider, dealID) + st = actor.getDealState(rt, dealID) + require.EqualValues(t, publishEpoch+1, st.SlashEpoch) + + // provider cannot withdraw any funds since all it's balance is locked + withDrawAmt := abi.NewTokenAmount(1) + actualWithdrawn := abi.NewTokenAmount(0) + actor.withdrawProviderBalance(rt, withDrawAmt, actualWithdrawn, minerAddrs) + + // add some more funds to the provider & ensure withdrawal is limited by the locked funds + actor.addProviderFunds(rt, abi.NewTokenAmount(25), minerAddrs) + withDrawAmt = abi.NewTokenAmount(30) + actualWithdrawn = abi.NewTokenAmount(25) + + actor.withdrawProviderBalance(rt, withDrawAmt, actualWithdrawn, minerAddrs) + }) + }) +} + +func TestPublishStorageDeals(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddr := &minerAddrs{owner, worker, provider} + var st market.State + + t.Run("publish a deal after activating a previous deal which has a start epoch far in the future", func(t *testing.T) { + startEpoch := abi.ChainEpoch(1000) + endEpoch := abi.ChainEpoch(2000) + publishEpoch := abi.ChainEpoch(1) + + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + deal1 := actor.generateDealAndAddFunds(rt, client, mAddr, startEpoch, endEpoch) + + // publish the deal and activate it + rt.SetEpoch(publishEpoch) + deal1ID := actor.publishDeals(rt, mAddr, deal1)[0] + actor.activateDeals(rt, endEpoch, provider, publishEpoch, deal1ID) + st := actor.getDealState(rt, deal1ID) + require.EqualValues(t, publishEpoch, st.SectorStartEpoch) + + // now publish a second deal and activate it + newEpoch := publishEpoch + 1 + deal2 := actor.generateDealAndAddFunds(rt, client, mAddr, startEpoch+1, endEpoch+1) + rt.SetEpoch(newEpoch) + deal2ID := actor.publishDeals(rt, mAddr, deal2)[0] + actor.activateDeals(rt, endEpoch+1, provider, newEpoch, deal2ID) + }) + + t.Run("publish multiple deals for different clients and ensure balances are correct", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + client1 := tutil.NewIDAddr(t, 900) + client2 := tutil.NewIDAddr(t, 901) + client3 := tutil.NewIDAddr(t, 902) + + // generate first deal for + deal1 := actor.generateDealAndAddFunds(rt, client1, mAddr, abi.ChainEpoch(42), abi.ChainEpoch(100)) + + // generate second deal + deal2 := actor.generateDealAndAddFunds(rt, client2, mAddr, abi.ChainEpoch(42), abi.ChainEpoch(100)) + + // generate third deal + deal3 := actor.generateDealAndAddFunds(rt, client3, mAddr, abi.ChainEpoch(42), abi.ChainEpoch(100)) + + actor.publishDeals(rt, mAddr, deal1, deal2, deal3) + + // assert locked balance for all clients and provider + providerLocked := big.Sum(deal1.ProviderCollateral, deal2.ProviderCollateral, deal3.ProviderCollateral) + client1Locked := actor.getLockedBalance(rt, client1) + client2Locked := actor.getLockedBalance(rt, client2) + client3Locked := actor.getLockedBalance(rt, client3) + require.EqualValues(t, deal1.ClientBalanceRequirement(), client1Locked) + require.EqualValues(t, deal2.ClientBalanceRequirement(), client2Locked) + require.EqualValues(t, deal3.ClientBalanceRequirement(), client3Locked) + require.EqualValues(t, providerLocked, actor.getLockedBalance(rt, provider)) + + // assert locked funds states + rt.GetState(&st) + totalClientCollateralLocked := big.Sum(deal3.ClientCollateral, deal1.ClientCollateral, deal2.ClientCollateral) + require.EqualValues(t, totalClientCollateralLocked, st.TotalClientLockedCollateral) + require.EqualValues(t, providerLocked, st.TotalProviderLockedCollateral) + totalStorageFee := big.Sum(deal1.TotalStorageFee(), deal2.TotalStorageFee(), deal3.TotalStorageFee()) + require.EqualValues(t, totalStorageFee, st.TotalClientStorageFee) + + // publish two more deals for same clients with same provider + deal4 := actor.generateDealAndAddFunds(rt, client3, mAddr, abi.ChainEpoch(1000), abi.ChainEpoch(10000)) + deal5 := actor.generateDealAndAddFunds(rt, client3, mAddr, abi.ChainEpoch(100), abi.ChainEpoch(1000)) + actor.publishDeals(rt, mAddr, deal4, deal5) + + // assert locked balances for clients and provider + rt.GetState(&st) + providerLocked = big.Sum(providerLocked, deal4.ProviderCollateral, deal5.ProviderCollateral) + require.EqualValues(t, providerLocked, actor.getLockedBalance(rt, provider)) + + client3LockedUpdated := actor.getLockedBalance(rt, client3) + require.EqualValues(t, big.Sum(client3Locked, deal4.ClientBalanceRequirement(), deal5.ClientBalanceRequirement()), client3LockedUpdated) + + client1Locked = actor.getLockedBalance(rt, client1) + client2Locked = actor.getLockedBalance(rt, client2) + require.EqualValues(t, deal1.ClientBalanceRequirement(), client1Locked) + require.EqualValues(t, deal2.ClientBalanceRequirement(), client2Locked) + + // assert locked funds states + totalClientCollateralLocked = big.Sum(totalClientCollateralLocked, deal4.ClientCollateral, deal5.ClientCollateral) + require.EqualValues(t, totalClientCollateralLocked, st.TotalClientLockedCollateral) + require.EqualValues(t, providerLocked, st.TotalProviderLockedCollateral) + + totalStorageFee = big.Sum(totalStorageFee, deal4.TotalStorageFee(), deal5.TotalStorageFee()) + require.EqualValues(t, totalStorageFee, st.TotalClientStorageFee) + + // PUBLISH DEALS with a different provider + provider2 := tutil.NewIDAddr(t, 109) + miner := &minerAddrs{owner, worker, provider2} + + // generate first deal for second provider + deal6 := actor.generateDealAndAddFunds(rt, client1, miner, abi.ChainEpoch(20), abi.ChainEpoch(50)) + + // generate second deal for second provider + deal7 := actor.generateDealAndAddFunds(rt, client1, miner, abi.ChainEpoch(25), abi.ChainEpoch(60)) + + // publish both the deals for the second provider + actor.publishDeals(rt, miner, deal6, deal7) + + // assertions + rt.GetState(&st) + provider2Locked := big.Add(deal6.ProviderCollateral, deal7.ProviderCollateral) + require.EqualValues(t, provider2Locked, actor.getLockedBalance(rt, provider2)) + client1LockedUpdated := actor.getLockedBalance(rt, client1) + require.EqualValues(t, big.Add(deal7.ClientBalanceRequirement(), big.Add(client1Locked, deal6.ClientBalanceRequirement())), client1LockedUpdated) + + // assert first provider's balance as well + require.EqualValues(t, providerLocked, actor.getLockedBalance(rt, provider)) + + totalClientCollateralLocked = big.Add(totalClientCollateralLocked, big.Add(deal6.ClientCollateral, deal7.ClientCollateral)) + require.EqualValues(t, totalClientCollateralLocked, st.TotalClientLockedCollateral) + require.EqualValues(t, big.Add(providerLocked, provider2Locked), st.TotalProviderLockedCollateral) + totalStorageFee = big.Add(totalStorageFee, big.Add(deal6.TotalStorageFee(), deal7.TotalStorageFee())) + require.EqualValues(t, totalStorageFee, st.TotalClientStorageFee) + }) +} + +func TestPublishStorageDealsFailures(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + currentEpoch := abi.ChainEpoch(5) + startEpoch := abi.ChainEpoch(10) + endEpoch := abi.ChainEpoch(20) + + // simple failures because of invalid deal params + { + tcs := map[string]struct { + setup func(*mock.Runtime, *marketActorTestHarness, *market.DealProposal) + exitCode exitcode.ExitCode + signatureVerificationError error + }{ + "deal end after deal start": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.StartEpoch = 10 + d.EndEpoch = 9 + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "current epoch greater than start epoch": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.StartEpoch = currentEpoch - 1 + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "deal duration greater than max deal duration": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.StartEpoch = abi.ChainEpoch(10) + d.EndEpoch = d.StartEpoch + (1 * builtin.EpochsInYear) + 1 + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "negative price per epoch": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.StoragePricePerEpoch = abi.NewTokenAmount(-1) + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "price per epoch greater than total filecoin": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.StoragePricePerEpoch = big.Add(abi.TotalFilecoin, big.NewInt(1)) + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "negative provider collateral": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.ProviderCollateral = big.NewInt(-1) + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "provider collateral greater than max collateral": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.ProviderCollateral = big.Add(abi.TotalFilecoin, big.NewInt(1)) + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "negative client collateral": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.ClientCollateral = big.NewInt(-1) + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "client collateral greater than max collateral": { + setup: func(_ *mock.Runtime, _ *marketActorTestHarness, d *market.DealProposal) { + d.ClientCollateral = big.Add(abi.TotalFilecoin, big.NewInt(1)) + }, + exitCode: exitcode.ErrIllegalArgument, + }, + "client does not have enough balance for collateral": { + setup: func(rt *mock.Runtime, a *marketActorTestHarness, d *market.DealProposal) { + a.addParticipantFunds(rt, client, big.Sub(d.ClientBalanceRequirement(), big.NewInt(1))) + a.addProviderFunds(rt, d.ProviderCollateral, mAddrs) + }, + exitCode: exitcode.ErrInsufficientFunds, + }, + "provider does not have enough balance for collateral": { + setup: func(rt *mock.Runtime, a *marketActorTestHarness, d *market.DealProposal) { + a.addParticipantFunds(rt, client, d.ClientBalanceRequirement()) + a.addProviderFunds(rt, big.Sub(d.ProviderCollateral, big.NewInt(1)), mAddrs) + }, + exitCode: exitcode.ErrInsufficientFunds, + }, + "unable to resolve client address": { + setup: func(_ *mock.Runtime, a *marketActorTestHarness, d *market.DealProposal) { + d.Client = tutil.NewBLSAddr(t, 1) + }, + exitCode: exitcode.ErrNotFound, + }, + "signature is invalid": { + setup: func(_ *mock.Runtime, a *marketActorTestHarness, d *market.DealProposal) { + + }, + exitCode: exitcode.ErrIllegalArgument, + signatureVerificationError: errors.New("error"), + }, + "no entry for client in locked balance table": { + setup: func(rt *mock.Runtime, a *marketActorTestHarness, d *market.DealProposal) { + a.addProviderFunds(rt, d.ProviderCollateral, mAddrs) + }, + exitCode: exitcode.ErrInsufficientFunds, + }, + "no entry for provider in locked balance table": { + setup: func(rt *mock.Runtime, a *marketActorTestHarness, d *market.DealProposal) { + a.addParticipantFunds(rt, client, d.ClientBalanceRequirement()) + }, + exitCode: exitcode.ErrInsufficientFunds, + }, + } + + for name, tc := range tcs { + t.Run(name, func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealProposal := generateDealProposal(client, provider, startEpoch, endEpoch) + rt.SetEpoch(currentEpoch) + tc.setup(rt, actor, &dealProposal) + params := mkPublishStorageParams(dealProposal) + + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(provider, builtin.MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0), &miner.GetControlAddressesReturn{Worker: worker, Owner: owner}, 0) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectVerifySignature(crypto.Signature{}, dealProposal.Client, mustCbor(&dealProposal), tc.signatureVerificationError) + rt.ExpectAbort(tc.exitCode, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + + rt.Verify() + }) + } + } + + // fails when client or provider has some funds but not enough to cover a deal + { + t.Run("fail when client has some funds but not enough for a deal", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + // + actor.addParticipantFunds(rt, client, abi.NewTokenAmount(100)) + deal1 := generateDealProposal(client, provider, abi.ChainEpoch(42), abi.ChainEpoch(100)) + actor.addProviderFunds(rt, deal1.ProviderCollateral, mAddrs) + params := mkPublishStorageParams(deal1) + + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(provider, builtin.MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0), &miner.GetControlAddressesReturn{Worker: worker, Owner: owner}, 0) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectVerifySignature(crypto.Signature{}, deal1.Client, mustCbor(&deal1), nil) + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + + rt.Verify() + }) + + t.Run("fail when provider has some funds but not enough for a deal", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + actor.addProviderFunds(rt, abi.NewTokenAmount(1), mAddrs) + deal1 := generateDealProposal(client, provider, abi.ChainEpoch(42), abi.ChainEpoch(100)) + actor.addParticipantFunds(rt, client, deal1.ClientBalanceRequirement()) + + params := mkPublishStorageParams(deal1) + + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(provider, builtin.MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0), &miner.GetControlAddressesReturn{Worker: worker, Owner: owner}, 0) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectVerifySignature(crypto.Signature{}, deal1.Client, mustCbor(&deal1), nil) + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + + rt.Verify() + }) + } + + // fail when deals have different providers + { + t.Run("fail when deals have different providers", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + deal1 := actor.generateDealAndAddFunds(rt, client, mAddrs, abi.ChainEpoch(42), abi.ChainEpoch(100)) + m2 := &minerAddrs{owner, worker, tutil.NewIDAddr(t, 1000)} + + deal2 := actor.generateDealAndAddFunds(rt, client, m2, abi.ChainEpoch(1), abi.ChainEpoch(5)) + + params := mkPublishStorageParams(deal1, deal2) + + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(provider, builtin.MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0), &miner.GetControlAddressesReturn{Worker: worker, Owner: owner}, 0) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectVerifySignature(crypto.Signature{}, deal1.Client, mustCbor(&deal1), nil) + rt.ExpectVerifySignature(crypto.Signature{}, deal2.Client, mustCbor(&deal2), nil) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + + rt.Verify() + }) + + // failures because of incorrect call params + t.Run("fail when caller is not of signable type", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + params := mkPublishStorageParams(generateDealProposal(client, provider, abi.ChainEpoch(1), abi.ChainEpoch(5))) + w := tutil.NewIDAddr(t, 1000) + rt.SetCaller(w, builtin.StorageMinerActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + }) + + t.Run("fail when no deals in params", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + params := mkPublishStorageParams() + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + }) + + t.Run("fail to resolve provider address", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + deal := generateDealProposal(client, provider, abi.ChainEpoch(1), abi.ChainEpoch(5)) + deal.Provider = tutil.NewBLSAddr(t, 100) + + params := mkPublishStorageParams(deal) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrNotFound, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + }) + + t.Run("caller is not the same as the worker address for miner", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + deal := generateDealProposal(client, provider, abi.ChainEpoch(1), abi.ChainEpoch(5)) + params := mkPublishStorageParams(deal) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(provider, builtin.MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0), &miner.GetControlAddressesReturn{Worker: tutil.NewIDAddr(t, 999), Owner: owner}, 0) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + + rt.Verify() + }) + } +} + +func TestActivateDeals(t *testing.T) { + + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + startEpoch := abi.ChainEpoch(10) + endEpoch := abi.ChainEpoch(20) + currentEpoch := abi.ChainEpoch(5) + sectorExpiry := abi.ChainEpoch(100) + + t.Run("active deals multiple times with different providers", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // provider 1 publishes deals1 and deals2 and deal3 + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + dealId3 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+2) + + // provider2 publishes deal4 and deal5 + provider2 := tutil.NewIDAddr(t, 401) + mAddrs.provider = provider2 + dealId4 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + dealId5 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + + // provider1 activates deal 1 and deal2 but that does not activate deal3 to deal5 + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1, dealId2) + actor.assertDealsNotActivated(rt, currentEpoch, dealId3, dealId4, dealId5) + + // provider3 activates deal5 but that does not activate deal3 or deal4 + actor.activateDeals(rt, sectorExpiry, provider2, currentEpoch, dealId5) + actor.assertDealsNotActivated(rt, currentEpoch, dealId3, dealId4) + + // provider1 activates deal3 + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId3) + actor.assertDealsNotActivated(rt, currentEpoch, dealId4) + }) +} + +func TestActivateDealFailures(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + startEpoch := abi.ChainEpoch(10) + endEpoch := abi.ChainEpoch(20) + sectorExpiry := abi.ChainEpoch(100) + + // caller is not the provider + { + t.Run("fail when caller is not the provider of the deal", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + provider2 := tutil.NewIDAddr(t, 201) + mAddrs2 := &minerAddrs{owner, worker, provider2} + dealId := actor.generateAndPublishDeal(rt, client, mAddrs2, startEpoch, endEpoch) + + params := mkActivateDealParams(sectorExpiry, dealId) + + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + rt.Call(actor.ActivateDeals, params) + }) + + rt.Verify() + }) + } + + // caller is not a StorageMinerActor + { + t.Run("fail when caller is not a StorageMinerActor", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.AccountActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + rt.Call(actor.ActivateDeals, &market.ActivateDealsParams{}) + }) + + rt.Verify() + }) + } + + // deal has not been published before + { + t.Run("fail when deal has not been published before", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + params := mkActivateDealParams(sectorExpiry, abi.DealID(42)) + + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + rt.Call(actor.ActivateDeals, params) + }) + + rt.Verify() + }) + } + + // deal has ALREADY been activated + { + t.Run("fail when deal has already been activated", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, 0, dealId) + + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.ActivateDeals, mkActivateDealParams(sectorExpiry, dealId)) + }) + + rt.Verify() + }) + } + + // deal has invalid params + { + t.Run("fail when current epoch greater than start epoch of deal", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.SetEpoch(startEpoch + 1) + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + rt.Call(actor.ActivateDeals, mkActivateDealParams(sectorExpiry, dealId)) + }) + + rt.Verify() + }) + + t.Run("fail when end epoch of deal greater than sector expiry", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + rt.Call(actor.ActivateDeals, mkActivateDealParams(endEpoch-1, dealId)) + }) + + rt.Verify() + }) + } + + // all fail if one fails + { + t.Run("fail to activate all deals if one deal fails", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + // activate deal1 so it fails later + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, 0, dealId1) + + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.ActivateDeals, mkActivateDealParams(sectorExpiry, dealId1, dealId2)) + }) + rt.Verify() + + // no state for deal2 means deal2 activation has failed + var st market.State + rt.GetState(&st) + + states, err := market.AsDealStateArray(adt.AsStore(rt), st.States) + require.NoError(t, err) + + _, found, err := states.Get(dealId2) + require.NoError(t, err) + require.False(t, found) + }) + } + +} + +func TestOnMinerSectorsTerminate(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + startEpoch := abi.ChainEpoch(10) + endEpoch := abi.ChainEpoch(20) + currentEpoch := abi.ChainEpoch(5) + sectorExpiry := abi.ChainEpoch(100) + + t.Run("terminate multiple deals from multiple providers", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // provider1 publishes deal1,2 and 3 + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + dealId3 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+2) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1, dealId2, dealId3) + + // provider2 publishes deal4 and deal5 + provider2 := tutil.NewIDAddr(t, 501) + maddrs2 := &minerAddrs{owner, worker, provider2} + dealId4 := actor.generateAndPublishDeal(rt, client, maddrs2, startEpoch, endEpoch) + dealId5 := actor.generateAndPublishDeal(rt, client, maddrs2, startEpoch, endEpoch+1) + actor.activateDeals(rt, sectorExpiry, provider2, currentEpoch, dealId4, dealId5) + + // provider1 terminates deal1 but that does not terminate deals2-5 + actor.terminateDeals(rt, provider, dealId1) + actor.assertDealsTerminated(rt, currentEpoch, dealId1) + actor.assertDeaslNotTerminated(rt, dealId2, dealId3, dealId4, dealId5) + + // provider2 terminates deal5 but that does not terminate delals 2-4 + actor.terminateDeals(rt, provider2, dealId5) + actor.assertDealsTerminated(rt, currentEpoch, dealId5) + actor.assertDeaslNotTerminated(rt, dealId2, dealId3, dealId4) + + // provider1 terminates deal2 and deal3 + actor.terminateDeals(rt, provider, dealId2, dealId3) + actor.assertDealsTerminated(rt, currentEpoch, dealId2, dealId3) + actor.assertDeaslNotTerminated(rt, dealId4) + + // provider2 terminates deal4 + actor.terminateDeals(rt, provider2, dealId4) + actor.assertDealsTerminated(rt, currentEpoch, dealId4) + }) + + t.Run("ignore deal proposal that does not exist", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // deal1 will be terminated and the other deal will be ignored because it does not exist + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1) + + actor.terminateDeals(rt, provider, dealId1, abi.DealID(42)) + st := actor.getDealState(rt, dealId1) + require.EqualValues(t, currentEpoch, st.SlashEpoch) + }) + + t.Run("terminate valid deals along with expired deals - only valid deals are terminated", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // provider1 publishes deal1 and 2 and deal3 -> deal3 has the lowest endepoch + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + dealId3 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch-1) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1, dealId2, dealId3) + + // set current epoch such that deal3 expires but the other two do not + newEpoch := endEpoch - 1 + rt.SetEpoch(newEpoch) + + // terminating all three deals ONLY terminates deal1 and deal2 because deal3 has expired + actor.terminateDeals(rt, provider, dealId1, dealId2, dealId3) + actor.assertDealsTerminated(rt, newEpoch, dealId1, dealId2) + actor.assertDeaslNotTerminated(rt, dealId3) + + }) + + t.Run("terminating a deal the second time does not change it's slash epoch", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1) + + // terminating the deal so slash epoch is the current epoch + actor.terminateDeals(rt, provider, dealId1) + + // set a new epoch and terminate again -> however slash epoch will still be the old epoch. + newEpoch := currentEpoch + 1 + rt.SetEpoch(newEpoch) + actor.terminateDeals(rt, provider, dealId1) + st := actor.getDealState(rt, dealId1) + require.EqualValues(t, currentEpoch, st.SlashEpoch) + }) + + t.Run("terminating new deals and an already terminated deal only terminates the new deals", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // provider1 publishes deal1 and 2 and deal3 -> deal3 has the lowest endepoch + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + dealId3 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch-1) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1, dealId2, dealId3) + + // terminating the deal so slash epoch is the current epoch + actor.terminateDeals(rt, provider, dealId1) + + // set a new epoch and terminate again -> however slash epoch will still be the old epoch. + newEpoch := currentEpoch + 1 + rt.SetEpoch(newEpoch) + actor.terminateDeals(rt, provider, dealId1, dealId2, dealId3) + + st := actor.getDealState(rt, dealId1) + require.EqualValues(t, currentEpoch, st.SlashEpoch) + + st2 := actor.getDealState(rt, dealId2) + require.EqualValues(t, newEpoch, st2.SlashEpoch) + + st3 := actor.getDealState(rt, dealId3) + require.EqualValues(t, newEpoch, st3.SlashEpoch) + }) + + t.Run("do not terminate deal if end epoch is equal to or less than current epoch", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // deal1 has endepoch equal to current epoch when terminate is called + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1) + rt.SetEpoch(endEpoch) + actor.terminateDeals(rt, provider, dealId1) + actor.assertDeaslNotTerminated(rt, dealId1) + + // deal2 has end epoch less than current epoch when terminate is called + rt.SetEpoch(currentEpoch) + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch+1, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId2) + rt.SetEpoch(endEpoch + 1) + actor.terminateDeals(rt, provider, dealId2) + actor.assertDeaslNotTerminated(rt, dealId2) + }) + + t.Run("fail when caller is not a StorageMinerActor", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.AccountActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + rt.Call(actor.OnMinerSectorsTerminate, &market.OnMinerSectorsTerminateParams{}) + }) + + rt.Verify() + }) + + t.Run("fail when caller is not the provider of the deal", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + dealId := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId) + + params := mkTerminateDealParams(dealId) + + provider2 := tutil.NewIDAddr(t, 501) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider2, builtin.StorageMinerActorCodeID) + rt.ExpectAssertionFailure("caller is not the provider of the deal", func() { + rt.Call(actor.OnMinerSectorsTerminate, params) + }) + + rt.Verify() + }) + + t.Run("fail when deal has been published but not activated", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + dealId := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + + params := mkTerminateDealParams(dealId) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.OnMinerSectorsTerminate, params) + }) + + rt.Verify() + }) + + t.Run("termination of all deals should fail when one deal fails", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + rt.SetEpoch(currentEpoch) + + // deal1 would terminate but deal2 will fail because deal2 has not been activated + dealId1 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + actor.activateDeals(rt, sectorExpiry, provider, currentEpoch, dealId1) + dealId2 := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch+1) + + params := mkTerminateDealParams(dealId1, dealId2) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.OnMinerSectorsTerminate, params) + }) + + rt.Verify() + + // verify deal1 has not been terminated + actor.assertDeaslNotTerminated(rt, dealId1) + }) +} + +func TestCronTick(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + startEpoch := abi.ChainEpoch(50) + endEpoch := abi.ChainEpoch(300) + sectorExpiry := abi.ChainEpoch(400) + + t.Run("fail when deal is activated but proposal is not found", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + + // delete the deal proposal + actor.deleteDealProposal(rt, dealId) + + // move the current epoch to the start epoch of the deal + rt.SetEpoch(startEpoch) + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + actor.cronTick(rt) + }) + }) + + t.Run("fail when deal update epoch is in the future", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + + // move the current epoch such that the deal's last updated field is set to the start epoch of the deal + // and the next tick for it is scheduled at the endepoch. + rt.SetEpoch(startEpoch) + actor.cronTick(rt) + + // update last updated to some time in the future + actor.updateLastUpdated(rt, dealId, startEpoch+1000) + + // set current epoch of the deal to the end epoch so it's picked up for "processing" in the next cron tick. + rt.SetEpoch(endEpoch) + + rt.ExpectAssertionFailure("assertion failed", func() { + actor.cronTick(rt) + }) + }) + + t.Run("crontick for a deal at it's start epoch results in zero payment and no slashing", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + + // move the current epoch to startEpoch + current := startEpoch + rt.SetEpoch(current) + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, big.Zero(), pay) + require.EqualValues(t, big.Zero(), slashed) + + // deal proposal and state should NOT be deleted + require.NotNil(t, actor.getDealProposal(rt, dealId)) + require.NotNil(t, actor.getDealState(rt, dealId)) + }) +} + +func TestLockedFundTrackingStates(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + worker := tutil.NewIDAddr(t, 103) + + p1 := tutil.NewIDAddr(t, 201) + p2 := tutil.NewIDAddr(t, 202) + p3 := tutil.NewIDAddr(t, 203) + + c1 := tutil.NewIDAddr(t, 104) + c2 := tutil.NewIDAddr(t, 105) + c3 := tutil.NewIDAddr(t, 106) + + m1 := &minerAddrs{owner, worker, p1} + m2 := &minerAddrs{owner, worker, p2} + m3 := &minerAddrs{owner, worker, p3} + + startEpoch := abi.ChainEpoch(50) + endEpoch := abi.ChainEpoch(300) + sectorExpiry := abi.ChainEpoch(400) + + var st market.State + + // assert values are zero + rt, actor := basicMarketSetup(t, owner, p1, worker, c1) + rt.GetState(&st) + require.True(t, st.TotalClientLockedCollateral.IsZero()) + require.True(t, st.TotalProviderLockedCollateral.IsZero()) + require.True(t, st.TotalClientStorageFee.IsZero()) + + // Publish deal1, deal2 and deal3 with different client and provider + dealId1 := actor.generateAndPublishDeal(rt, c1, m1, startEpoch, endEpoch) + d1 := actor.getDealProposal(rt, dealId1) + + dealId2 := actor.generateAndPublishDeal(rt, c2, m2, startEpoch, endEpoch) + d2 := actor.getDealProposal(rt, dealId2) + + dealId3 := actor.generateAndPublishDeal(rt, c3, m3, startEpoch, endEpoch) + d3 := actor.getDealProposal(rt, dealId3) + + csf := big.Sum(d1.TotalStorageFee(), d2.TotalStorageFee(), d3.TotalStorageFee()) + plc := big.Sum(d1.ProviderCollateral, d2.ProviderCollateral, d3.ProviderCollateral) + clc := big.Sum(d1.ClientCollateral, d2.ClientCollateral, d3.ClientCollateral) + + actor.assertLockedFundStates(rt, csf, plc, clc) + + // activation dosen't change anything + curr := startEpoch - 1 + rt.SetEpoch(curr) + actor.activateDeals(rt, sectorExpiry, p1, curr, dealId1) + actor.activateDeals(rt, sectorExpiry, p2, curr, dealId2) + + actor.assertLockedFundStates(rt, csf, plc, clc) + + // make payment for p1 and p2, p3 times out as it has not been activated + curr = 51 // startEpoch + 1 + rt.SetEpoch(curr) + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, d3.ProviderCollateral, nil, exitcode.Ok) + actor.cronTick(rt) + payment := big.Product(big.NewInt(2), d1.StoragePricePerEpoch) + csf = big.Sub(big.Sub(csf, payment), d3.TotalStorageFee()) + plc = big.Sub(plc, d3.ProviderCollateral) + clc = big.Sub(clc, d3.ClientCollateral) + actor.assertLockedFundStates(rt, csf, plc, clc) + + // deal1 and deal2 will now be charged at epoch = 51 + 100 = 151, so nothing changes before that + rt.SetEpoch(150) + actor.cronTick(rt) + actor.assertLockedFundStates(rt, csf, plc, clc) + + // one more round of payment for deal1 and deal2 + rt.SetEpoch(200) + payment = big.Product(big.NewInt(2), d1.StoragePricePerEpoch, big.NewInt(149)) // 149 = 200 - 51 (epoch when payment was last made) + csf = big.Sub(csf, payment) + actor.cronTick(rt) + actor.assertLockedFundStates(rt, csf, plc, clc) + + // slash deal1 at 201 + rt.SetEpoch(201) + actor.terminateDeals(rt, m1.provider, dealId1) + + // cron tick at 300 to slash deal1 and expire deal2 + rt.SetEpoch(300) + csf = big.Zero() + clc = big.Zero() + plc = big.Zero() + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, d1.ProviderCollateral, nil, exitcode.Ok) + actor.cronTick(rt) + actor.assertLockedFundStates(rt, csf, plc, clc) +} + +func TestCronTickTimedoutDeals(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + startEpoch := abi.ChainEpoch(50) + endEpoch := abi.ChainEpoch(300) + + t.Run("timed out deal is slashed and deleted", func(t *testing.T) { + // publish a deal but do NOT activate it + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.generateAndPublishDeal(rt, client, mAddrs, startEpoch, endEpoch) + d := actor.getDealProposal(rt, dealId) + + cEscrow := actor.getEscrowBalance(rt, client) + + // do a cron tick for it -> should time out and get slashed + rt.SetEpoch(startEpoch) + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, d.ProviderCollateral, nil, exitcode.Ok) + actor.cronTick(rt) + + require.Equal(t, cEscrow, actor.getEscrowBalance(rt, client)) + require.Equal(t, big.Zero(), actor.getLockedBalance(rt, client)) + require.Equal(t, big.Zero(), actor.getEscrowBalance(rt, provider)) + require.Equal(t, big.Zero(), actor.getLockedBalance(rt, provider)) + + actor.assertDealDeleted(rt, dealId) + }) + + t.Run("timed out and verified deals are slashed, deleted AND sent to the Registry actor", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + // deal1 and deal2 are verified + deal1 := actor.generateDealAndAddFunds(rt, client, mAddrs, startEpoch, endEpoch) + deal1.VerifiedDeal = true + deal2 := actor.generateDealAndAddFunds(rt, client, mAddrs, startEpoch, endEpoch+1) + deal2.VerifiedDeal = true + + // deal3 is NOT verified + deal3 := actor.generateDealAndAddFunds(rt, client, mAddrs, startEpoch, endEpoch+2) + + // publishing verified deals + dealIds := actor.publishDeals(rt, mAddrs, deal1, deal2, deal3) + + // do a cron tick for it -> all should time out and get slashed + // ONLY deal1 and deal2 should be sent to the Registry actor + rt.SetEpoch(startEpoch) + + // expected sends to the registry actor + param1 := &verifreg.RestoreBytesParams{ + Address: deal1.Client, + DealSize: big.NewIntUnsigned(uint64(deal1.PieceSize)), + } + param2 := &verifreg.RestoreBytesParams{ + Address: deal2.Client, + DealSize: big.NewIntUnsigned(uint64(deal2.PieceSize)), + } + + rt.ExpectSend(builtin.VerifiedRegistryActorAddr, builtin.MethodsVerifiedRegistry.RestoreBytes, param1, + abi.NewTokenAmount(0), nil, exitcode.Ok) + rt.ExpectSend(builtin.VerifiedRegistryActorAddr, builtin.MethodsVerifiedRegistry.RestoreBytes, param2, + abi.NewTokenAmount(0), nil, exitcode.Ok) + + expectedBurn := big.Mul(big.NewInt(3), deal1.ProviderCollateral) + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, expectedBurn, nil, exitcode.Ok) + actor.cronTick(rt) + + actor.assertDealDeleted(rt, dealIds[0]) + actor.assertDealDeleted(rt, dealIds[1]) + actor.assertDealDeleted(rt, dealIds[2]) + }) +} + +func TestCronTickDealExpiry(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + + startEpoch := abi.ChainEpoch(50) + endEpoch := abi.ChainEpoch(300) + sectorExpiry := abi.ChainEpoch(400) + + t.Run("deal expiry -> regular payments till deal expires and then locked funds are unlocked", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + d := actor.getDealProposal(rt, dealId) + + // move the current epoch to startEpoch + 5 so payment is made + current := startEpoch + 5 // 55 + rt.SetEpoch(current) + + // assert payment + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(5), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // The next epoch for this deal's cron schedule is 155 (50 + 5 + 100). + // Setting the current epoch to anything less than that wont make any payment + current = 154 + rt.SetEpoch(current) + actor.cronTickNoChangeBalances(rt, client, provider) + + // however setting the current epoch to 155 will make the payment + current = 155 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(100), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // next epoch for cron schedule is 155 + 100 = 255 + current = 255 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(100), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // next epoch for cron schedule is deal end i.e. 300. An epoch less than that wont do anything + current = 299 + rt.SetEpoch(current) + actor.cronTickNoChangeBalances(rt, client, provider) + + // however setting epoch to 300 will expire the deal, make the payment and unlock all funds + current = 300 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(45), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // deal should be deleted as it should have expired + actor.assertDealDeleted(rt, dealId) + }) + + t.Run("deal expiry -> payment for a deal if deal is already expired before a cron tick", func(t *testing.T) { + start := abi.ChainEpoch(5) + end := abi.ChainEpoch(20) + + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, start, end, 0, sectorExpiry) + d := actor.getDealProposal(rt, dealId) + + current := abi.ChainEpoch(25) + rt.SetEpoch(current) + + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(15), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + actor.assertDealDeleted(rt, dealId) + + // running cron tick again dosen't do anything + actor.cronTickNoChangeBalances(rt, client, provider) + }) + + t.Run("expired deal should unlock the remaining client and provider locked balance after payment and deal should be deleted", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + deal := actor.getDealProposal(rt, dealId) + + cEscrow := actor.getEscrowBalance(rt, client) + pEscrow := actor.getEscrowBalance(rt, provider) + + // move the current epoch so that deal is expired + rt.SetEpoch(startEpoch + 1000) + actor.cronTick(rt) + + // assert balances + payment := deal.TotalStorageFee() + + require.EqualValues(t, big.Sub(cEscrow, payment), actor.getEscrowBalance(rt, client)) + require.EqualValues(t, big.Zero(), actor.getLockedBalance(rt, client)) + + require.EqualValues(t, big.Add(pEscrow, payment), actor.getEscrowBalance(rt, provider)) + require.EqualValues(t, big.Zero(), actor.getLockedBalance(rt, provider)) + + // deal should be deleted + actor.assertDealDeleted(rt, dealId) + }) +} + +func TestCronTickDealSlashing(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + mAddrs := &minerAddrs{owner, worker, provider} + sectorExpiry := abi.ChainEpoch(400) + + // hairy edge cases + { + + tcs := map[string]struct { + dealStart abi.ChainEpoch + dealEnd abi.ChainEpoch + activationEpoch abi.ChainEpoch + terminationEpoch abi.ChainEpoch + cronTickEpoch abi.ChainEpoch + payment abi.TokenAmount + assertionMsg string + }{ + "deal is slashed after the startepoch and then the first crontick happens": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(15), + cronTickEpoch: abi.ChainEpoch(16), + payment: abi.NewTokenAmount(50), // (15 - 10) * 10 as deal storage fee is 10 per epoch + }, + "deal is slashed at the startepoch and then the first crontick happens": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(10), + cronTickEpoch: abi.ChainEpoch(11), + payment: abi.NewTokenAmount(0), // (10 - 10) * 10 + }, + "deal is slashed before the startepoch and then the first crontick happens": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(6), + cronTickEpoch: abi.ChainEpoch(10), + payment: abi.NewTokenAmount(0), // (10 - 10) * 10 + }, + "deal is terminated at the activation epoch and then the first crontick happens": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(5), + cronTickEpoch: abi.ChainEpoch(10), + payment: abi.NewTokenAmount(0), // (10 - 10) * 10 + }, + "deal is slashed and then deal expiry happens on crontick, but slashing still occurs": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(15), + cronTickEpoch: abi.ChainEpoch(25), // deal has expired + payment: abi.NewTokenAmount(50), + }, + "deal slash epoch must NOT be greater than current epoch": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(15), + cronTickEpoch: abi.ChainEpoch(10), // deal has expired + payment: abi.NewTokenAmount(50), + assertionMsg: "current epoch less than slash epoch", + }, + "deal is slashed just BEFORE the end epoch": { + dealStart: abi.ChainEpoch(10), + dealEnd: abi.ChainEpoch(20), + activationEpoch: abi.ChainEpoch(5), + terminationEpoch: abi.ChainEpoch(19), + cronTickEpoch: abi.ChainEpoch(19), + payment: abi.NewTokenAmount(90), // (19 - 10) * 10 + }, + } + + for n, tc := range tcs { + t.Run(n, func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + + // publish and activate + rt.SetEpoch(tc.activationEpoch) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, tc.dealStart, tc.dealEnd, tc.activationEpoch, sectorExpiry) + d := actor.getDealProposal(rt, dealId) + + // terminate + rt.SetEpoch(tc.terminationEpoch) + actor.terminateDeals(rt, provider, dealId) + + // cron tick + rt.SetEpoch(tc.cronTickEpoch) + + if len(tc.assertionMsg) == 0 { + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, tc.cronTickEpoch, dealId) + require.EqualValues(t, tc.payment, pay) + require.EqualValues(t, d.ProviderCollateral, slashed) + actor.assertDealDeleted(rt, dealId) + + // running cron tick again dosen't do anything + actor.cronTickNoChangeBalances(rt, client, provider) + } else { + rt.ExpectAssertionFailure(tc.assertionMsg, func() { + rt.ExpectValidateCallerAddr(builtin.CronActorAddr) + rt.SetCaller(builtin.CronActorAddr, builtin.CronActorCodeID) + param := adt.EmptyValue{} + rt.Call(actor.CronTick, ¶m) + rt.Verify() + }) + } + }) + } + } + + startEpoch := abi.ChainEpoch(50) + endEpoch := abi.ChainEpoch(300) + + t.Run("deal is slashed AT the end epoch -> should NOT be slashed and should be considered expired", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + d := actor.getDealProposal(rt, dealId) + + // set current epoch to deal end epoch and attempt to slash it -> should not be slashed + // as deal is considered to be expired. + current := endEpoch + rt.SetEpoch(current) + actor.terminateDeals(rt, provider, dealId) + + // on the next cron tick, it will be processed as expired + current = 300 + rt.SetEpoch(current) + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + duration := big.NewInt(250) // end - start + require.EqualValues(t, big.Mul(duration, d.StoragePricePerEpoch), pay) + require.EqualValues(t, big.Zero(), slashed) + + // deal should be deleted as it should have expired + actor.assertDealDeleted(rt, dealId) + }) + + // end-end test for slashing + t.Run("regular payments till deal is slashed and then slashing is processed", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + d := actor.getDealProposal(rt, dealId) + + // move the current epoch to startEpoch + 5 so payment is made + current := abi.ChainEpoch(55) + rt.SetEpoch(current) + + // assert payment + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(5), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // Setting the current epoch to less than 155 will NOT make any changes as the deal + // is still not scheduled + current = 154 + rt.SetEpoch(current) + actor.cronTickNoChangeBalances(rt, client, provider) + + // Setting the current epoch to 155 will make another payment (5 + 100 epochs) + current = 155 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(100), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // now terminate the deal + current = 200 + rt.SetEpoch(current) + actor.terminateDeals(rt, provider, dealId) + + // Setting the epoch to anything less than 255 will NOT make any changes even though the deal is slashed (155 + 100) + current = 254 + rt.SetEpoch(current) + actor.cronTickNoChangeBalances(rt, client, provider) + + // next epoch for cron schedule is 155 + 100 = 255 -> payment will be made and deal will be slashed + current = 255 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + // payment will only be made till the 200th epoch as the deal was slashed at that epoch. + // so duration = 200 - 155(epoch of last payment) = 45. + require.EqualValues(t, pay, big.Mul(big.NewInt(45), d.StoragePricePerEpoch)) + require.EqualValues(t, d.ProviderCollateral, slashed) + + // deal should be deleted as it should have expired + actor.assertDealDeleted(rt, dealId) + }) + + // expired deals should NOT be slashed + t.Run("regular payments till deal expires and then we attempt to slash it but it will NOT be slashed", func(t *testing.T) { + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + dealId := actor.publishAndActivateDeal(rt, client, mAddrs, startEpoch, endEpoch, 0, sectorExpiry) + d := actor.getDealProposal(rt, dealId) + + // move the current epoch to startEpoch + 5 so payment is made and assert payment + current := startEpoch + 5 // 55 + rt.SetEpoch(current) + pay, slashed := actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(5), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // Setting the current epoch to 155 will make another payment + current = 155 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + require.EqualValues(t, pay, big.Mul(big.NewInt(100), d.StoragePricePerEpoch)) + require.EqualValues(t, big.Zero(), slashed) + + // set current epoch to deal end epoch and attempt to slash it -> should not be slashed + // as deal is considered to be expired. + current = endEpoch + rt.SetEpoch(current) + actor.terminateDeals(rt, provider, dealId) + + // next epoch for cron schedule is 155 + 100 = 255 -> + // setting epoch to higher than that will cause deal to be expired, payment will be made + // and deal will NOT be slashed + current = 300 + rt.SetEpoch(current) + pay, slashed = actor.cronTickAndAssertBalances(rt, client, provider, current, dealId) + duration := big.NewInt(145) // 300 which is the end epoch MINUS the previous payment epoch i.e. 155 + require.EqualValues(t, big.Mul(duration, d.StoragePricePerEpoch), pay) + require.EqualValues(t, big.Zero(), slashed) + + // deal should be deleted as it should have expired + actor.assertDealDeleted(rt, dealId) + }) +} + +func TestMarketActorDeals(t *testing.T) { + owner := tutil.NewIDAddr(t, 101) + provider := tutil.NewIDAddr(t, 102) + worker := tutil.NewIDAddr(t, 103) + client := tutil.NewIDAddr(t, 104) + minerAddrs := &minerAddrs{owner, worker, provider} + + var st market.State + + // Test adding provider funds from both worker and owner address + rt, actor := basicMarketSetup(t, owner, provider, worker, client) + actor.addProviderFunds(rt, abi.NewTokenAmount(10000), minerAddrs) + rt.GetState(&st) + assert.Equal(t, abi.NewTokenAmount(10000), st.GetEscrowBalance(rt, provider)) + + actor.addParticipantFunds(rt, client, abi.NewTokenAmount(10000)) + + dealProposal := generateDealProposal(client, provider, abi.ChainEpoch(1), abi.ChainEpoch(5)) + params := &market.PublishStorageDealsParams{Deals: []market.ClientDealProposal{market.ClientDealProposal{Proposal: dealProposal}}} + + // First attempt at publishing the deal should work + { + actor.publishDeals(rt, minerAddrs, dealProposal) + } + + // Second attempt at publishing the same deal should fail + { + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(provider, builtin.MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0), &miner.GetControlAddressesReturn{Worker: worker, Owner: owner}, 0) + + rt.ExpectVerifySignature(crypto.Signature{}, client, mustCbor(¶ms.Deals[0].Proposal), nil) + rt.SetCaller(worker, builtin.AccountActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.PublishStorageDeals, params) + }) + + rt.Verify() + } + + dealProposal.Label = "foo" + + // Same deal with a different label should work + { + actor.publishDeals(rt, minerAddrs, dealProposal) + } +} + +type marketActorTestHarness struct { + market.Actor + t testing.TB +} + +func (h *marketActorTestHarness) constructAndVerify(rt *mock.Runtime) { + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + ret := rt.Call(h.Constructor, nil) + assert.Nil(h.t, ret) + rt.Verify() +} + +type minerAddrs struct { + owner address.Address + worker address.Address + provider address.Address +} + +// addProviderFunds is a helper method to setup provider market funds +func (h *marketActorTestHarness) addProviderFunds(rt *mock.Runtime, amount abi.TokenAmount, minerAddrs *minerAddrs) { + rt.SetReceived(amount) + rt.SetAddressActorType(minerAddrs.provider, builtin.StorageMinerActorCodeID) + rt.SetCaller(minerAddrs.owner, builtin.AccountActorCodeID) + h.expectProviderControlAddressesAndValidateCaller(rt, minerAddrs.provider, minerAddrs.owner, minerAddrs.worker) + + rt.Call(h.AddBalance, &minerAddrs.provider) + + rt.Verify() + + rt.SetBalance(big.Add(rt.Balance(), amount)) +} + +// addParticipantFunds is a helper method to setup non-provider storage market participant funds +func (h *marketActorTestHarness) addParticipantFunds(rt *mock.Runtime, addr address.Address, amount abi.TokenAmount) { + rt.SetReceived(amount) + rt.SetCaller(addr, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.CallerTypesSignable...) + + rt.Call(h.AddBalance, &addr) + + rt.Verify() + + rt.SetBalance(big.Add(rt.Balance(), amount)) +} + +func (h *marketActorTestHarness) expectProviderControlAddressesAndValidateCaller(rt *mock.Runtime, provider address.Address, owner address.Address, worker address.Address) { + rt.ExpectValidateCallerAddr(owner, worker) + + expectRet := &miner.GetControlAddressesReturn{Owner: owner, Worker: worker} + + rt.ExpectSend( + provider, + builtin.MethodsMiner.ControlAddresses, + nil, + big.Zero(), + expectRet, + exitcode.Ok, + ) +} + +func (h *marketActorTestHarness) withdrawProviderBalance(rt *mock.Runtime, withDrawAmt, expectedSend abi.TokenAmount, miner *minerAddrs) { + rt.SetCaller(miner.worker, builtin.AccountActorCodeID) + h.expectProviderControlAddressesAndValidateCaller(rt, miner.provider, miner.owner, miner.worker) + + params := market.WithdrawBalanceParams{ + ProviderOrClientAddress: miner.provider, + Amount: withDrawAmt, + } + + rt.ExpectSend(miner.owner, builtin.MethodSend, nil, expectedSend, nil, exitcode.Ok) + rt.Call(h.WithdrawBalance, ¶ms) + rt.Verify() +} + +func (h *marketActorTestHarness) withdrawClientBalance(rt *mock.Runtime, client address.Address, withDrawAmt, expectedSend abi.TokenAmount) { + rt.SetCaller(client, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.CallerTypesSignable...) + rt.ExpectSend(client, builtin.MethodSend, nil, expectedSend, nil, exitcode.Ok) + + params := market.WithdrawBalanceParams{ + ProviderOrClientAddress: client, + Amount: withDrawAmt, + } + + rt.Call(h.WithdrawBalance, ¶ms) + rt.Verify() +} + +func (h *marketActorTestHarness) cronTickNoChangeBalances(rt *mock.Runtime, client, provider address.Address) { + // fetch current client and provider escrow balances + cLocked := h.getLockedBalance(rt, client) + cEscrow := h.getEscrowBalance(rt, client) + pLocked := h.getLockedBalance(rt, provider) + pEscrow := h.getEscrowBalance(rt, provider) + + h.cronTick(rt) + + require.EqualValues(h.t, cEscrow, h.getEscrowBalance(rt, client)) + require.EqualValues(h.t, cLocked, h.getLockedBalance(rt, client)) + require.EqualValues(h.t, pEscrow, h.getEscrowBalance(rt, provider)) + require.EqualValues(h.t, pLocked, h.getLockedBalance(rt, provider)) +} + +func (h *marketActorTestHarness) cronTickAndAssertBalances(rt *mock.Runtime, client, provider address.Address, + currentEpoch abi.ChainEpoch, dealId abi.DealID) (payment abi.TokenAmount, amountSlashed abi.TokenAmount) { + // fetch current client and provider escrow balances + cLocked := h.getLockedBalance(rt, client) + cEscrow := h.getEscrowBalance(rt, client) + pLocked := h.getLockedBalance(rt, provider) + pEscrow := h.getEscrowBalance(rt, provider) + amountSlashed = big.Zero() + + s := h.getDealState(rt, dealId) + d := h.getDealProposal(rt, dealId) + + // end epoch for payment calc + paymentEnd := d.EndEpoch + if s.SlashEpoch != -1 { + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, d.ProviderCollateral, nil, exitcode.Ok) + amountSlashed = d.ProviderCollateral + + if s.SlashEpoch < d.StartEpoch { + paymentEnd = d.StartEpoch + } else { + paymentEnd = s.SlashEpoch + } + } else if currentEpoch < paymentEnd { + paymentEnd = currentEpoch + } + + // start epoch for payment calc + paymentStart := d.StartEpoch + if s.LastUpdatedEpoch != -1 { + paymentStart = s.LastUpdatedEpoch + } + duration := paymentEnd - paymentStart + payment = big.Mul(big.NewInt(int64(duration)), d.StoragePricePerEpoch) + + // expected updated amounts + updatedClientEscrow := big.Sub(cEscrow, payment) + updatedProviderEscrow := big.Add(pEscrow, payment) + updatedProviderEscrow = big.Sub(updatedProviderEscrow, amountSlashed) + updatedClientLocked := big.Sub(cLocked, payment) + updatedProviderLocked := pLocked + // if the deal has expired or been slashed, locked amount will be zero for provider and client. + isDealExpired := paymentEnd == d.EndEpoch + if isDealExpired || s.SlashEpoch != -1 { + updatedClientLocked = big.Zero() + updatedProviderLocked = big.Zero() + } + + h.cronTick(rt) + + require.EqualValues(h.t, updatedClientEscrow, h.getEscrowBalance(rt, client)) + require.EqualValues(h.t, updatedClientLocked, h.getLockedBalance(rt, client)) + require.Equal(h.t, updatedProviderLocked, h.getLockedBalance(rt, provider)) + require.Equal(h.t, updatedProviderEscrow.Int64(), h.getEscrowBalance(rt, provider).Int64()) + + return +} + +func (h *marketActorTestHarness) cronTick(rt *mock.Runtime) { + rt.ExpectValidateCallerAddr(builtin.CronActorAddr) + rt.SetCaller(builtin.CronActorAddr, builtin.CronActorCodeID) + param := adt.EmptyValue{} + rt.Call(h.CronTick, ¶m) + rt.Verify() +} + +func (h *marketActorTestHarness) publishDeals(rt *mock.Runtime, minerAddrs *minerAddrs, deals ...market.DealProposal) []abi.DealID { + rt.SetCaller(minerAddrs.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.CallerTypesSignable...) + rt.ExpectSend( + minerAddrs.provider, + builtin.MethodsMiner.ControlAddresses, + nil, + big.Zero(), + &miner.GetControlAddressesReturn{Owner: minerAddrs.owner, Worker: minerAddrs.worker}, + exitcode.Ok, + ) + + var params market.PublishStorageDealsParams + + for _, deal := range deals { + // create a client proposal with a valid signature + buf := bytes.Buffer{} + require.NoError(h.t, deal.MarshalCBOR(&buf), "failed to marshal deal proposal") + sig := crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("does not matter")} + clientProposal := market.ClientDealProposal{deal, sig} + params.Deals = append(params.Deals, clientProposal) + + // expect a call to verify the above signature + rt.ExpectVerifySignature(sig, deal.Client, buf.Bytes(), nil) + if deal.VerifiedDeal { + param := &verifreg.UseBytesParams{ + Address: deal.Client, + DealSize: big.NewIntUnsigned(uint64(deal.PieceSize)), + } + + rt.ExpectSend(builtin.VerifiedRegistryActorAddr, builtin.MethodsVerifiedRegistry.UseBytes, param, abi.NewTokenAmount(0), nil, exitcode.Ok) + } + } + + ret := rt.Call(h.PublishStorageDeals, ¶ms) + rt.Verify() + + resp, ok := ret.(*market.PublishStorageDealsReturn) + require.True(h.t, ok, "unexpected type returned from call to PublishStorageDeals") + require.Len(h.t, resp.IDs, len(deals)) + + // assert state after publishing the deals + dealIds := resp.IDs + for i, deaId := range dealIds { + expected := deals[i] + p := h.getDealProposal(rt, deaId) + + require.Equal(h.t, expected.StartEpoch, p.StartEpoch) + require.Equal(h.t, expected.EndEpoch, p.EndEpoch) + require.Equal(h.t, expected.PieceCID, p.PieceCID) + require.Equal(h.t, expected.PieceSize, p.PieceSize) + require.Equal(h.t, expected.Client, p.Client) + require.Equal(h.t, expected.Provider, p.Provider) + require.Equal(h.t, expected.Label, p.Label) + require.Equal(h.t, expected.VerifiedDeal, p.VerifiedDeal) + require.Equal(h.t, expected.StoragePricePerEpoch, p.StoragePricePerEpoch) + require.Equal(h.t, expected.ClientCollateral, p.ClientCollateral) + require.Equal(h.t, expected.ProviderCollateral, p.ProviderCollateral) + } + + return resp.IDs +} + +func (h *marketActorTestHarness) assertDealsNotActivated(rt *mock.Runtime, epoch abi.ChainEpoch, dealIDs ...abi.DealID) { + var st market.State + rt.GetState(&st) + + states, err := market.AsDealStateArray(adt.AsStore(rt), st.States) + require.NoError(h.t, err) + + for _, d := range dealIDs { + _, found, err := states.Get(d) + require.NoError(h.t, err) + require.False(h.t, found) + } +} + +func (h *marketActorTestHarness) activateDeals(rt *mock.Runtime, sectorExpiry abi.ChainEpoch, provider address.Address, currentEpoch abi.ChainEpoch, dealIDs ...abi.DealID) { + rt.SetCaller(provider, builtin.StorageMinerActorCodeID) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + + params := &market.ActivateDealsParams{DealIDs: dealIDs, SectorExpiry: sectorExpiry} + + ret := rt.Call(h.ActivateDeals, params) + rt.Verify() + + require.Nil(h.t, ret) + + for _, d := range dealIDs { + s := h.getDealState(rt, d) + require.EqualValues(h.t, currentEpoch, s.SectorStartEpoch) + } +} + +func (h *marketActorTestHarness) getDealProposal(rt *mock.Runtime, dealID abi.DealID) *market.DealProposal { + var st market.State + rt.GetState(&st) + + deals, err := market.AsDealProposalArray(adt.AsStore(rt), st.Proposals) + require.NoError(h.t, err) + + d, found, err := deals.Get(dealID) + require.NoError(h.t, err) + require.True(h.t, found) + require.NotNil(h.t, d) + + return d +} + +func (h *marketActorTestHarness) getEscrowBalance(rt *mock.Runtime, addr address.Address) abi.TokenAmount { + var st market.State + rt.GetState(&st) + + return st.GetEscrowBalance(rt, addr) +} + +func (h *marketActorTestHarness) getLockedBalance(rt *mock.Runtime, addr address.Address) abi.TokenAmount { + var st market.State + rt.GetState(&st) + + return st.GetLockedBalance(rt, addr) +} + +func (h *marketActorTestHarness) getDealState(rt *mock.Runtime, dealID abi.DealID) *market.DealState { + var st market.State + rt.GetState(&st) + + states, err := market.AsDealStateArray(adt.AsStore(rt), st.States) + require.NoError(h.t, err) + + s, found, err := states.Get(dealID) + require.NoError(h.t, err) + require.True(h.t, found) + require.NotNil(h.t, s) + + return s +} + +func (h *marketActorTestHarness) assertLockedFundStates(rt *mock.Runtime, storageFee, providerCollateral, clientCollateral abi.TokenAmount) { + var st market.State + rt.GetState(&st) + + require.Equal(h.t, clientCollateral, st.TotalClientLockedCollateral) + require.Equal(h.t, providerCollateral, st.TotalProviderLockedCollateral) + require.Equal(h.t, storageFee, st.TotalClientStorageFee) +} + +func (h *marketActorTestHarness) assertDealDeleted(rt *mock.Runtime, dealId abi.DealID) { + var st market.State + rt.GetState(&st) + + proposals, err := market.AsDealProposalArray(adt.AsStore(rt), st.Proposals) + require.NoError(h.t, err) + _, found, err := proposals.Get(dealId) + require.NoError(h.t, err) + require.False(h.t, found) + + states, err := market.AsDealStateArray(adt.AsStore(rt), st.States) + require.NoError(h.t, err) + _, found, err = states.Get(dealId) + require.NoError(h.t, err) + require.False(h.t, found) +} + +func (h *marketActorTestHarness) assertDealsTerminated(rt *mock.Runtime, epoch abi.ChainEpoch, dealIds ...abi.DealID) { + for _, d := range dealIds { + s := h.getDealState(rt, d) + require.EqualValues(h.t, epoch, s.SlashEpoch) + } +} + +func (h *marketActorTestHarness) assertDeaslNotTerminated(rt *mock.Runtime, dealIds ...abi.DealID) { + for _, d := range dealIds { + s := h.getDealState(rt, d) + require.EqualValues(h.t, abi.ChainEpoch(-1), s.SlashEpoch) + } +} + +func (h *marketActorTestHarness) terminateDeals(rt *mock.Runtime, minerAddr address.Address, dealIds ...abi.DealID) { + rt.SetCaller(minerAddr, builtin.StorageMinerActorCodeID) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + + params := &market.OnMinerSectorsTerminateParams{DealIDs: dealIds} + + ret := rt.Call(h.OnMinerSectorsTerminate, params) + rt.Verify() + require.Nil(h.t, ret) +} + +func (h *marketActorTestHarness) publishAndActivateDeal(rt *mock.Runtime, client address.Address, minerAddrs *minerAddrs, + startEpoch, endEpoch, currentEpoch, sectorExpiry abi.ChainEpoch) abi.DealID { + deal := h.generateDealAndAddFunds(rt, client, minerAddrs, startEpoch, endEpoch) + dealIds := h.publishDeals(rt, minerAddrs, deal) + h.activateDeals(rt, sectorExpiry, minerAddrs.provider, currentEpoch, dealIds[0]) + return dealIds[0] +} + +func (h *marketActorTestHarness) updateLastUpdated(rt *mock.Runtime, dealId abi.DealID, newLastUpdated abi.ChainEpoch) { + var st market.State + + rt.Transaction(&st, func() interface{} { + states, err := market.AsDealStateArray(adt.AsStore(rt), st.States) + require.NoError(h.t, err) + s, found, err := states.Get(dealId) + require.True(h.t, found) + require.NoError(h.t, err) + require.NotNil(h.t, s) + + require.NoError(h.t, states.Set(dealId, &market.DealState{s.SectorStartEpoch, newLastUpdated, s.SlashEpoch})) + st.States, err = states.Root() + require.NoError(h.t, err) + return nil + }) +} + +func (h *marketActorTestHarness) deleteDealProposal(rt *mock.Runtime, dealId abi.DealID) { + var st market.State + + rt.Transaction(&st, func() interface{} { + deals, err := market.AsDealProposalArray(adt.AsStore(rt), st.Proposals) + require.NoError(h.t, err) + require.NoError(h.t, deals.Delete(uint64(dealId))) + st.Proposals, err = deals.Root() + require.NoError(h.t, err) + return nil + }) +} + +func (h *marketActorTestHarness) generateAndPublishDeal(rt *mock.Runtime, client address.Address, minerAddrs *minerAddrs, + startEpoch, endEpoch abi.ChainEpoch) abi.DealID { + deal := h.generateDealAndAddFunds(rt, client, minerAddrs, startEpoch, endEpoch) + dealIds := h.publishDeals(rt, minerAddrs, deal) + return dealIds[0] +} + +func (h *marketActorTestHarness) generateDealAndAddFunds(rt *mock.Runtime, client address.Address, minerAddrs *minerAddrs, + startEpoch, endEpoch abi.ChainEpoch) market.DealProposal { + deal4 := generateDealProposal(client, minerAddrs.provider, startEpoch, endEpoch) + h.addProviderFunds(rt, deal4.ProviderCollateral, minerAddrs) + h.addParticipantFunds(rt, client, deal4.ClientBalanceRequirement()) + + return deal4 +} + +func generateDealProposal(client, provider address.Address, startEpoch, endEpoch abi.ChainEpoch) market.DealProposal { + pieceCid := tutil.MakeCID("1") + pieceSize := abi.PaddedPieceSize(2048) + storagePerEpoch := big.NewInt(10) + clientCollateral := big.NewInt(10) + providerCollateral := big.NewInt(10) + + return market.DealProposal{pieceCid, pieceSize, false, client, provider, "label", startEpoch, + endEpoch, storagePerEpoch, providerCollateral, clientCollateral} +} + +func basicMarketSetup(t *testing.T, owner, provider, worker, client address.Address) (*mock.Runtime, *marketActorTestHarness) { + builder := mock.NewBuilder(context.Background(), builtin.StorageMarketActorAddr). + WithCaller(builtin.SystemActorAddr, builtin.InitActorCodeID). + WithActorType(owner, builtin.AccountActorCodeID). + WithActorType(worker, builtin.AccountActorCodeID). + WithActorType(provider, builtin.StorageMinerActorCodeID). + WithActorType(client, builtin.AccountActorCodeID) + + rt := builder.Build(t) + + actor := marketActorTestHarness{t: t} + actor.constructAndVerify(rt) + + return rt, &actor +} + +func mkPublishStorageParams(proposals ...market.DealProposal) *market.PublishStorageDealsParams { + m := &market.PublishStorageDealsParams{} + for _, p := range proposals { + m.Deals = append(m.Deals, market.ClientDealProposal{Proposal: p}) + } + return m +} + +func mkActivateDealParams(sectorExpiry abi.ChainEpoch, dealIds ...abi.DealID) *market.ActivateDealsParams { + return &market.ActivateDealsParams{SectorExpiry: sectorExpiry, DealIDs: dealIds} +} + +func mkTerminateDealParams(dealIds ...abi.DealID) *market.OnMinerSectorsTerminateParams { + return &market.OnMinerSectorsTerminateParams{dealIds} +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/policy.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/policy.go new file mode 100644 index 000000000..bdbe4b85c --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/policy.go @@ -0,0 +1,42 @@ +package market + +import ( + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" +) + +// DealUpdatesInterval is the number of blocks between payouts for deals +const DealUpdatesInterval = 100 + +// Bounds (inclusive) on deal duration +func dealDurationBounds(size abi.PaddedPieceSize) (min abi.ChainEpoch, max abi.ChainEpoch) { + // Cryptoeconomic modelling to date has used an assumption of a maximum deal duration of up to one year. + // It very likely can be much longer, but we're not sure yet. + return abi.ChainEpoch(0), abi.ChainEpoch(1 * builtin.EpochsInYear) // PARAM_FINISH +} + +func dealPricePerEpochBounds(size abi.PaddedPieceSize, duration abi.ChainEpoch) (min abi.TokenAmount, max abi.TokenAmount) { + return abi.NewTokenAmount(0), abi.TotalFilecoin // PARAM_FINISH +} + +func dealProviderCollateralBounds(pieceSize abi.PaddedPieceSize, duration abi.ChainEpoch) (min abi.TokenAmount, max abi.TokenAmount) { + return abi.NewTokenAmount(0), abi.TotalFilecoin // PARAM_FINISH +} + +func dealClientCollateralBounds(pieceSize abi.PaddedPieceSize, duration abi.ChainEpoch) (min abi.TokenAmount, max abi.TokenAmount) { + return abi.NewTokenAmount(0), abi.TotalFilecoin // PARAM_FINISH +} + +// Penalty to provider deal collateral if the deadline expires before sector commitment. +func collateralPenaltyForDealActivationMissed(providerCollateral abi.TokenAmount) abi.TokenAmount { + return providerCollateral // PARAM_FINISH +} + +// Computes the weight for a deal proposal, which is a function of its size and duration. +func DealWeight(proposal *DealProposal) abi.DealWeight { + dealDuration := big.NewInt(int64(proposal.Duration())) + dealSize := big.NewIntUnsigned(uint64(proposal.PieceSize)) + dealSpaceTime := big.Mul(dealDuration, dealSize) + return dealSpaceTime +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/set_multimap.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/set_multimap.go new file mode 100644 index 000000000..049d98655 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/set_multimap.go @@ -0,0 +1,159 @@ +package market + +import ( + "reflect" + + cid "github.com/ipfs/go-cid" + "github.com/ipfs/go-hamt-ipld" + errors "github.com/pkg/errors" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type SetMultimap struct { + mp *adt.Map + store adt.Store +} + +// Interprets a store as a HAMT-based map of HAMT-based sets with root `r`. +func AsSetMultimap(s adt.Store, r cid.Cid) (*SetMultimap, error) { + m, err := adt.AsMap(s, r) + if err != nil { + return nil, err + } + return &SetMultimap{mp: m, store: s}, nil +} + +// Creates a new map backed by an empty HAMT and flushes it to the store. +func MakeEmptySetMultimap(s adt.Store) *SetMultimap { + m := adt.MakeEmptyMap(s) + return &SetMultimap{m, s} +} + +// Returns the root cid of the underlying HAMT. +func (mm *SetMultimap) Root() (cid.Cid, error) { + return mm.mp.Root() +} + +func (mm *SetMultimap) Put(epoch abi.ChainEpoch, v abi.DealID) error { + // Load the hamt under key, or initialize a new empty one if not found. + k := adt.UIntKey(uint64(epoch)) + set, found, err := mm.get(k) + if err != nil { + return err + } + if !found { + set = adt.MakeEmptySet(mm.store) + } + + // Add to the set. + if err = set.Put(dealKey(v)); err != nil { + return errors.Wrapf(err, "failed to add key to set %v", epoch) + } + + src, err := set.Root() + if err != nil { + return xerrors.Errorf("failed to flush set root: %w", err) + } + // Store the new set root under key. + newSetRoot := cbg.CborCid(src) + err = mm.mp.Put(k, &newSetRoot) + if err != nil { + return errors.Wrapf(err, "failed to store set") + } + return nil +} + +func (mm *SetMultimap) PutMany(epoch abi.ChainEpoch, vs []abi.DealID) error { + // Load the hamt under key, or initialize a new empty one if not found. + k := adt.UIntKey(uint64(epoch)) + set, found, err := mm.get(k) + if err != nil { + return err + } + if !found { + set = adt.MakeEmptySet(mm.store) + } + + // Add to the set. + for _, v := range vs { + if err = set.Put(dealKey(v)); err != nil { + return errors.Wrapf(err, "failed to add key to set %v", epoch) + } + } + + src, err := set.Root() + if err != nil { + return xerrors.Errorf("failed to flush set root: %w", err) + } + // Store the new set root under key. + newSetRoot := cbg.CborCid(src) + err = mm.mp.Put(k, &newSetRoot) + if err != nil { + return errors.Wrapf(err, "failed to store set") + } + return nil +} + +// Removes all values for a key. +func (mm *SetMultimap) RemoveAll(key abi.ChainEpoch) error { + err := mm.mp.Delete(adt.UIntKey(uint64(key))) + if err != nil && !xerrors.Is(err, hamt.ErrNotFound) { + return xerrors.Errorf("failed to delete set key %v: %w", key, err) + } + return nil +} + +// Iterates all entries for a key, iteration halts if the function returns an error. +func (mm *SetMultimap) ForEach(epoch abi.ChainEpoch, fn func(id abi.DealID) error) error { + set, found, err := mm.get(adt.UIntKey(uint64(epoch))) + if err != nil { + return err + } + if found { + return set.ForEach(func(k string) error { + v, err := parseDealKey(k) + if err != nil { + return err + } + return fn(v) + }) + } + return nil +} + +func (mm *SetMultimap) get(key adt.Keyer) (*adt.Set, bool, error) { + var setRoot cbg.CborCid + found, err := mm.mp.Get(key, &setRoot) + if err != nil { + return nil, false, errors.Wrapf(err, "failed to load set key %v", key) + } + var set *adt.Set + if found { + set, err = adt.AsSet(mm.store, cid.Cid(setRoot)) + if err != nil { + return nil, false, err + } + } + return set, found, nil +} + +func dealKey(e abi.DealID) adt.Keyer { + return adt.UIntKey(uint64(e)) +} + +func parseDealKey(s string) (abi.DealID, error) { + key, err := adt.ParseUIntKey(s) + return abi.DealID(key), err +} + +func init() { + // Check that DealID is indeed an unsigned integer to confirm that dealKey is making the right interpretation. + var e abi.DealID + if reflect.TypeOf(e).Kind() != reflect.Uint64 { + panic("incorrect sector number encoding") + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/types.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/types.go new file mode 100644 index 000000000..affe5b560 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/market/types.go @@ -0,0 +1,89 @@ +package market + +import ( + "github.com/filecoin-project/specs-actors/actors/abi" + . "github.com/filecoin-project/specs-actors/actors/util/adt" + + "github.com/ipfs/go-cid" +) + +// A specialization of a array to deals. +// It is an error to query for a key that doesn't exist. +type DealArray struct { + *Array +} + +// Interprets a store as balance table with root `r`. +func AsDealProposalArray(s Store, r cid.Cid) (*DealArray, error) { + a, err := AsArray(s, r) + if err != nil { + return nil, err + } + return &DealArray{a}, nil +} + +// Returns the root cid of underlying AMT. +func (t *DealArray) Root() (cid.Cid, error) { + return t.Array.Root() +} + +// Gets the deal for a key. The entry must have been previously initialized. +func (t *DealArray) Get(id abi.DealID) (*DealProposal, bool, error) { + var value DealProposal + found, err := t.Array.Get(uint64(id), &value) + return &value, found, err +} + +func (t *DealArray) Set(k abi.DealID, value *DealProposal) error { + return t.Array.Set(uint64(k), value) +} + +func (t *DealArray) Delete(key uint64) error { + return t.Array.Delete(key) +} + +// A specialization of a array to deals. +// It is an error to query for a key that doesn't exist. +type DealMetaArray struct { + *Array +} + +// Interprets a store as balance table with root `r`. +func AsDealStateArray(s Store, r cid.Cid) (*DealMetaArray, error) { + dsa, err := AsArray(s, r) + if err != nil { + return nil, err + } + + return &DealMetaArray{dsa}, nil +} + +// Returns the root cid of underlying AMT. +func (t *DealMetaArray) Root() (cid.Cid, error) { + return t.Array.Root() +} + +// Gets the deal for a key. The entry must have been previously initialized. +func (t *DealMetaArray) Get(id abi.DealID) (*DealState, bool, error) { + var value DealState + found, err := t.Array.Get(uint64(id), &value) + if err != nil { + return nil, false, err // The errors from Map carry good information, no need to wrap here. + } + if !found { + return &DealState{ + SectorStartEpoch: epochUndefined, + LastUpdatedEpoch: epochUndefined, + SlashEpoch: epochUndefined, + }, false, nil + } + return &value, true, nil +} + +func (t *DealMetaArray) Set(k abi.DealID, value *DealState) error { + return t.Array.Set(uint64(k), value) +} + +func (t *DealMetaArray) Delete(id abi.DealID) error { + return t.Array.Delete(uint64(id)) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/methods.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/methods.go new file mode 100644 index 000000000..181f27390 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/methods.go @@ -0,0 +1,108 @@ +package builtin + +import ( + abi "github.com/filecoin-project/specs-actors/actors/abi" +) + +const ( + MethodSend = abi.MethodNum(0) + MethodConstructor = abi.MethodNum(1) + + // TODO fin: remove this once canonical method numbers are finalized + // https://github.com/filecoin-project/specs-actors/issues/461 + MethodPlaceholder = abi.MethodNum(1 << 30) +) + +var MethodsAccount = struct { + Constructor abi.MethodNum + PubkeyAddress abi.MethodNum +}{MethodConstructor, 2} + +var MethodsInit = struct { + Constructor abi.MethodNum + Exec abi.MethodNum +}{MethodConstructor, 2} + +var MethodsCron = struct { + Constructor abi.MethodNum + EpochTick abi.MethodNum +}{MethodConstructor, 2} + +var MethodsReward = struct { + Constructor abi.MethodNum + AwardBlockReward abi.MethodNum + ThisEpochReward abi.MethodNum + UpdateNetworkKPI abi.MethodNum +}{MethodConstructor, 2, 3, 4} + +var MethodsMultisig = struct { + Constructor abi.MethodNum + Propose abi.MethodNum + Approve abi.MethodNum + Cancel abi.MethodNum + AddSigner abi.MethodNum + RemoveSigner abi.MethodNum + SwapSigner abi.MethodNum + ChangeNumApprovalsThreshold abi.MethodNum +}{MethodConstructor, 2, 3, 4, 5, 6, 7, 8} + +var MethodsPaych = struct { + Constructor abi.MethodNum + UpdateChannelState abi.MethodNum + Settle abi.MethodNum + Collect abi.MethodNum +}{MethodConstructor, 2, 3, 4} + +var MethodsMarket = struct { + Constructor abi.MethodNum + AddBalance abi.MethodNum + WithdrawBalance abi.MethodNum + PublishStorageDeals abi.MethodNum + VerifyDealsForActivation abi.MethodNum + ActivateDeals abi.MethodNum + OnMinerSectorsTerminate abi.MethodNum + ComputeDataCommitment abi.MethodNum + CronTick abi.MethodNum +}{MethodConstructor, 2, 3, 4, 5, 6, 7, 8, 9} + +var MethodsPower = struct { + Constructor abi.MethodNum + CreateMiner abi.MethodNum + UpdateClaimedPower abi.MethodNum + EnrollCronEvent abi.MethodNum + OnEpochTickEnd abi.MethodNum + UpdatePledgeTotal abi.MethodNum + OnConsensusFault abi.MethodNum + SubmitPoRepForBulkVerify abi.MethodNum + CurrentTotalPower abi.MethodNum +}{MethodConstructor, 2, 3, 4, 5, 6, 7, 8, 9} + +var MethodsMiner = struct { + Constructor abi.MethodNum + ControlAddresses abi.MethodNum + ChangeWorkerAddress abi.MethodNum + ChangePeerID abi.MethodNum + SubmitWindowedPoSt abi.MethodNum + PreCommitSector abi.MethodNum + ProveCommitSector abi.MethodNum + ExtendSectorExpiration abi.MethodNum + TerminateSectors abi.MethodNum + DeclareFaults abi.MethodNum + DeclareFaultsRecovered abi.MethodNum + OnDeferredCronEvent abi.MethodNum + CheckSectorProven abi.MethodNum + AddLockedFund abi.MethodNum + ReportConsensusFault abi.MethodNum + WithdrawBalance abi.MethodNum + ConfirmSectorProofsValid abi.MethodNum + ChangeMultiaddrs abi.MethodNum +}{MethodConstructor, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18} + +var MethodsVerifiedRegistry = struct { + Constructor abi.MethodNum + AddVerifier abi.MethodNum + RemoveVerifier abi.MethodNum + AddVerifiedClient abi.MethodNum + UseBytes abi.MethodNum + RestoreBytes abi.MethodNum +}{MethodConstructor, 2, 3, 4, 5, 6} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/cbor_gen.go new file mode 100644 index 000000000..67c4b0ecb --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/cbor_gen.go @@ -0,0 +1,2645 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package miner + +import ( + "fmt" + "io" + + "github.com/filecoin-project/go-bitfield" + "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{144}); err != nil { + return err + } + + // t.Info (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.Info); err != nil { + return xerrors.Errorf("failed to write cid field t.Info: %w", err) + } + + // t.PreCommitDeposits (big.Int) (struct) + if err := t.PreCommitDeposits.MarshalCBOR(w); err != nil { + return err + } + + // t.LockedFunds (big.Int) (struct) + if err := t.LockedFunds.MarshalCBOR(w); err != nil { + return err + } + + // t.VestingFunds (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.VestingFunds); err != nil { + return xerrors.Errorf("failed to write cid field t.VestingFunds: %w", err) + } + + // t.InitialPledgeRequirement (big.Int) (struct) + if err := t.InitialPledgeRequirement.MarshalCBOR(w); err != nil { + return err + } + + // t.PreCommittedSectors (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.PreCommittedSectors); err != nil { + return xerrors.Errorf("failed to write cid field t.PreCommittedSectors: %w", err) + } + + // t.Sectors (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.Sectors); err != nil { + return xerrors.Errorf("failed to write cid field t.Sectors: %w", err) + } + + // t.ProvingPeriodStart (abi.ChainEpoch) (int64) + if t.ProvingPeriodStart >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ProvingPeriodStart))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.ProvingPeriodStart)-1)); err != nil { + return err + } + } + + // t.NewSectors (bitfield.BitField) (struct) + if err := t.NewSectors.MarshalCBOR(w); err != nil { + return err + } + + // t.SectorExpirations (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.SectorExpirations); err != nil { + return xerrors.Errorf("failed to write cid field t.SectorExpirations: %w", err) + } + + // t.Deadlines (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.Deadlines); err != nil { + return xerrors.Errorf("failed to write cid field t.Deadlines: %w", err) + } + + // t.Faults (bitfield.BitField) (struct) + if err := t.Faults.MarshalCBOR(w); err != nil { + return err + } + + // t.FaultEpochs (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.FaultEpochs); err != nil { + return xerrors.Errorf("failed to write cid field t.FaultEpochs: %w", err) + } + + // t.Recoveries (bitfield.BitField) (struct) + if err := t.Recoveries.MarshalCBOR(w); err != nil { + return err + } + + // t.PostSubmissions (bitfield.BitField) (struct) + if err := t.PostSubmissions.MarshalCBOR(w); err != nil { + return err + } + + // t.NextDeadlineToProcessFaults (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextDeadlineToProcessFaults))); err != nil { + return err + } + + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 16 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Info (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.Info: %w", err) + } + + t.Info = c + + } + // t.PreCommitDeposits (big.Int) (struct) + + { + + if err := t.PreCommitDeposits.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.PreCommitDeposits: %w", err) + } + + } + // t.LockedFunds (big.Int) (struct) + + { + + if err := t.LockedFunds.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.LockedFunds: %w", err) + } + + } + // t.VestingFunds (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.VestingFunds: %w", err) + } + + t.VestingFunds = c + + } + // t.InitialPledgeRequirement (big.Int) (struct) + + { + + if err := t.InitialPledgeRequirement.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.InitialPledgeRequirement: %w", err) + } + + } + // t.PreCommittedSectors (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.PreCommittedSectors: %w", err) + } + + t.PreCommittedSectors = c + + } + // t.Sectors (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.Sectors: %w", err) + } + + t.Sectors = c + + } + // t.ProvingPeriodStart (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.ProvingPeriodStart = abi.ChainEpoch(extraI) + } + // t.NewSectors (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.NewSectors = new(bitfield.BitField) + if err := t.NewSectors.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.NewSectors pointer: %w", err) + } + } + + } + // t.SectorExpirations (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.SectorExpirations: %w", err) + } + + t.SectorExpirations = c + + } + // t.Deadlines (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.Deadlines: %w", err) + } + + t.Deadlines = c + + } + // t.Faults (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Faults = new(bitfield.BitField) + if err := t.Faults.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Faults pointer: %w", err) + } + } + + } + // t.FaultEpochs (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.FaultEpochs: %w", err) + } + + t.FaultEpochs = c + + } + // t.Recoveries (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Recoveries = new(bitfield.BitField) + if err := t.Recoveries.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Recoveries pointer: %w", err) + } + } + + } + // t.PostSubmissions (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.PostSubmissions = new(bitfield.BitField) + if err := t.PostSubmissions.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.PostSubmissions pointer: %w", err) + } + } + + } + // t.NextDeadlineToProcessFaults (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.NextDeadlineToProcessFaults = uint64(extra) + + } + return nil +} + +func (t *MinerInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{136}); err != nil { + return err + } + + // t.Owner (address.Address) (struct) + if err := t.Owner.MarshalCBOR(w); err != nil { + return err + } + + // t.Worker (address.Address) (struct) + if err := t.Worker.MarshalCBOR(w); err != nil { + return err + } + + // t.PendingWorkerKey (miner.WorkerKeyChange) (struct) + if err := t.PendingWorkerKey.MarshalCBOR(w); err != nil { + return err + } + + // t.PeerId ([]uint8) (slice) + if len(t.PeerId) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.PeerId was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.PeerId)))); err != nil { + return err + } + if _, err := w.Write(t.PeerId); err != nil { + return err + } + + // t.Multiaddrs ([][]uint8) (slice) + if len(t.Multiaddrs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Multiaddrs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Multiaddrs)))); err != nil { + return err + } + for _, v := range t.Multiaddrs { + if len(v) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field v was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(v)))); err != nil { + return err + } + if _, err := w.Write(v); err != nil { + return err + } + } + + // t.SealProofType (abi.RegisteredSealProof) (int64) + if t.SealProofType >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProofType))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProofType)-1)); err != nil { + return err + } + } + + // t.SectorSize (abi.SectorSize) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorSize))); err != nil { + return err + } + + // t.WindowPoStPartitionSectors (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.WindowPoStPartitionSectors))); err != nil { + return err + } + + return nil +} + +func (t *MinerInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 8 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Owner (address.Address) (struct) + + { + + if err := t.Owner.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Owner: %w", err) + } + + } + // t.Worker (address.Address) (struct) + + { + + if err := t.Worker.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Worker: %w", err) + } + + } + // t.PendingWorkerKey (miner.WorkerKeyChange) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.PendingWorkerKey = new(WorkerKeyChange) + if err := t.PendingWorkerKey.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.PendingWorkerKey pointer: %w", err) + } + } + + } + // t.PeerId ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.PeerId: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.PeerId = make([]byte, extra) + if _, err := io.ReadFull(br, t.PeerId); err != nil { + return err + } + // t.Multiaddrs ([][]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Multiaddrs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Multiaddrs = make([][]uint8, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Multiaddrs[i]: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Multiaddrs[i] = make([]byte, extra) + if _, err := io.ReadFull(br, t.Multiaddrs[i]); err != nil { + return err + } + } + } + + // t.SealProofType (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProofType = abi.RegisteredSealProof(extraI) + } + // t.SectorSize (abi.SectorSize) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorSize = abi.SectorSize(extra) + + } + // t.WindowPoStPartitionSectors (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.WindowPoStPartitionSectors = uint64(extra) + + } + return nil +} + +func (t *Deadlines) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Due ([36]*bitfield.BitField) (array) + if len(t.Due) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Due was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Due)))); err != nil { + return err + } + for _, v := range t.Due { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *Deadlines) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Due ([36]*bitfield.BitField) (array) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Due: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra != 36 { + return fmt.Errorf("expected array to have 36 elements") + } + + t.Due = [36]*bitfield.BitField{} + + for i := 0; i < int(extra); i++ { + + var v bitfield.BitField + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Due[i] = &v + } + + return nil +} + +func (t *SectorPreCommitOnChainInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{133}); err != nil { + return err + } + + // t.Info (miner.SectorPreCommitInfo) (struct) + if err := t.Info.MarshalCBOR(w); err != nil { + return err + } + + // t.PreCommitDeposit (big.Int) (struct) + if err := t.PreCommitDeposit.MarshalCBOR(w); err != nil { + return err + } + + // t.PreCommitEpoch (abi.ChainEpoch) (int64) + if t.PreCommitEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.PreCommitEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.PreCommitEpoch)-1)); err != nil { + return err + } + } + + // t.DealWeight (big.Int) (struct) + if err := t.DealWeight.MarshalCBOR(w); err != nil { + return err + } + + // t.VerifiedDealWeight (big.Int) (struct) + if err := t.VerifiedDealWeight.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *SectorPreCommitOnChainInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 5 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Info (miner.SectorPreCommitInfo) (struct) + + { + + if err := t.Info.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Info: %w", err) + } + + } + // t.PreCommitDeposit (big.Int) (struct) + + { + + if err := t.PreCommitDeposit.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.PreCommitDeposit: %w", err) + } + + } + // t.PreCommitEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.PreCommitEpoch = abi.ChainEpoch(extraI) + } + // t.DealWeight (big.Int) (struct) + + { + + if err := t.DealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.DealWeight: %w", err) + } + + } + // t.VerifiedDealWeight (big.Int) (struct) + + { + + if err := t.VerifiedDealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.VerifiedDealWeight: %w", err) + } + + } + return nil +} + +func (t *SectorPreCommitInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{136}); err != nil { + return err + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + if t.SealProof >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProof))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProof)-1)); err != nil { + return err + } + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { + return err + } + + // t.SealedCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.SealedCID); err != nil { + return xerrors.Errorf("failed to write cid field t.SealedCID: %w", err) + } + + // t.SealRandEpoch (abi.ChainEpoch) (int64) + if t.SealRandEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealRandEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealRandEpoch)-1)); err != nil { + return err + } + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.Expiration (abi.ChainEpoch) (int64) + if t.Expiration >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Expiration))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Expiration)-1)); err != nil { + return err + } + } + + // t.ReplaceCapacity (bool) (bool) + if err := cbg.WriteBool(w, t.ReplaceCapacity); err != nil { + return err + } + + // t.ReplaceSector (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ReplaceSector))); err != nil { + return err + } + + return nil +} + +func (t *SectorPreCommitInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 8 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProof = abi.RegisteredSealProof(extraI) + } + // t.SectorNumber (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorNumber = abi.SectorNumber(extra) + + } + // t.SealedCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.SealedCID: %w", err) + } + + t.SealedCID = c + + } + // t.SealRandEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealRandEpoch = abi.ChainEpoch(extraI) + } + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = abi.DealID(val) + } + + // t.Expiration (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Expiration = abi.ChainEpoch(extraI) + } + // t.ReplaceCapacity (bool) (bool) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.ReplaceCapacity = false + case 21: + t.ReplaceCapacity = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + // t.ReplaceSector (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.ReplaceSector = abi.SectorNumber(extra) + + } + return nil +} + +func (t *SectorOnChainInfo) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{137}); err != nil { + return err + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { + return err + } + + // t.SealProof (abi.RegisteredSealProof) (int64) + if t.SealProof >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProof))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProof)-1)); err != nil { + return err + } + } + + // t.SealedCID (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.SealedCID); err != nil { + return xerrors.Errorf("failed to write cid field t.SealedCID: %w", err) + } + + // t.DealIDs ([]abi.DealID) (slice) + if len(t.DealIDs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.DealIDs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil { + return err + } + for _, v := range t.DealIDs { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.Activation (abi.ChainEpoch) (int64) + if t.Activation >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Activation))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Activation)-1)); err != nil { + return err + } + } + + // t.Expiration (abi.ChainEpoch) (int64) + if t.Expiration >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Expiration))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Expiration)-1)); err != nil { + return err + } + } + + // t.DealWeight (big.Int) (struct) + if err := t.DealWeight.MarshalCBOR(w); err != nil { + return err + } + + // t.VerifiedDealWeight (big.Int) (struct) + if err := t.VerifiedDealWeight.MarshalCBOR(w); err != nil { + return err + } + + // t.InitialPledge (big.Int) (struct) + if err := t.InitialPledge.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *SectorOnChainInfo) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 9 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorNumber = abi.SectorNumber(extra) + + } + // t.SealProof (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProof = abi.RegisteredSealProof(extraI) + } + // t.SealedCID (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.SealedCID: %w", err) + } + + t.SealedCID = c + + } + // t.DealIDs ([]abi.DealID) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.DealIDs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.DealIDs = make([]abi.DealID, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj) + } + + t.DealIDs[i] = abi.DealID(val) + } + + // t.Activation (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Activation = abi.ChainEpoch(extraI) + } + // t.Expiration (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Expiration = abi.ChainEpoch(extraI) + } + // t.DealWeight (big.Int) (struct) + + { + + if err := t.DealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.DealWeight: %w", err) + } + + } + // t.VerifiedDealWeight (big.Int) (struct) + + { + + if err := t.VerifiedDealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.VerifiedDealWeight: %w", err) + } + + } + // t.InitialPledge (big.Int) (struct) + + { + + if err := t.InitialPledge.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.InitialPledge: %w", err) + } + + } + return nil +} + +func (t *WorkerKeyChange) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.NewWorker (address.Address) (struct) + if err := t.NewWorker.MarshalCBOR(w); err != nil { + return err + } + + // t.EffectiveAt (abi.ChainEpoch) (int64) + if t.EffectiveAt >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.EffectiveAt))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.EffectiveAt)-1)); err != nil { + return err + } + } + return nil +} + +func (t *WorkerKeyChange) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.NewWorker (address.Address) (struct) + + { + + if err := t.NewWorker.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.NewWorker: %w", err) + } + + } + // t.EffectiveAt (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.EffectiveAt = abi.ChainEpoch(extraI) + } + return nil +} + +func (t *SubmitWindowedPoStParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.Deadline (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Deadline))); err != nil { + return err + } + + // t.Partitions ([]uint64) (slice) + if len(t.Partitions) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Partitions was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Partitions)))); err != nil { + return err + } + for _, v := range t.Partitions { + if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil { + return err + } + } + + // t.Proofs ([]abi.PoStProof) (slice) + if len(t.Proofs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Proofs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Proofs)))); err != nil { + return err + } + for _, v := range t.Proofs { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.Skipped (bitfield.BitField) (struct) + if err := t.Skipped.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *SubmitWindowedPoStParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Deadline (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Deadline = uint64(extra) + + } + // t.Partitions ([]uint64) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Partitions: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Partitions = make([]uint64, extra) + } + + for i := 0; i < int(extra); i++ { + + maj, val, err := cbg.CborReadHeader(br) + if err != nil { + return xerrors.Errorf("failed to read uint64 for t.Partitions slice: %w", err) + } + + if maj != cbg.MajUnsignedInt { + return xerrors.Errorf("value read for array t.Partitions was not a uint, instead got %d", maj) + } + + t.Partitions[i] = uint64(val) + } + + // t.Proofs ([]abi.PoStProof) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Proofs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Proofs = make([]abi.PoStProof, extra) + } + + for i := 0; i < int(extra); i++ { + + var v abi.PoStProof + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Proofs[i] = v + } + + // t.Skipped (bitfield.BitField) (struct) + + { + + if err := t.Skipped.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Skipped: %w", err) + } + + } + return nil +} + +func (t *TerminateSectorsParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Sectors (bitfield.BitField) (struct) + if err := t.Sectors.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *TerminateSectorsParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Sectors (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Sectors = new(bitfield.BitField) + if err := t.Sectors.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Sectors pointer: %w", err) + } + } + + } + return nil +} + +func (t *ChangePeerIDParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.NewID ([]uint8) (slice) + if len(t.NewID) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.NewID was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.NewID)))); err != nil { + return err + } + if _, err := w.Write(t.NewID); err != nil { + return err + } + return nil +} + +func (t *ChangePeerIDParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.NewID ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.NewID: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.NewID = make([]byte, extra) + if _, err := io.ReadFull(br, t.NewID); err != nil { + return err + } + return nil +} + +func (t *ChangeMultiaddrsParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.NewMultiaddrs ([][]uint8) (slice) + if len(t.NewMultiaddrs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.NewMultiaddrs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.NewMultiaddrs)))); err != nil { + return err + } + for _, v := range t.NewMultiaddrs { + if len(v) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field v was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(v)))); err != nil { + return err + } + if _, err := w.Write(v); err != nil { + return err + } + } + return nil +} + +func (t *ChangeMultiaddrsParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.NewMultiaddrs ([][]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.NewMultiaddrs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.NewMultiaddrs = make([][]uint8, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.NewMultiaddrs[i]: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.NewMultiaddrs[i] = make([]byte, extra) + if _, err := io.ReadFull(br, t.NewMultiaddrs[i]); err != nil { + return err + } + } + } + + return nil +} + +func (t *ProveCommitSectorParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { + return err + } + + // t.Proof ([]uint8) (slice) + if len(t.Proof) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Proof was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil { + return err + } + if _, err := w.Write(t.Proof); err != nil { + return err + } + return nil +} + +func (t *ProveCommitSectorParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorNumber = abi.SectorNumber(extra) + + } + // t.Proof ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Proof: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Proof = make([]byte, extra) + if _, err := io.ReadFull(br, t.Proof); err != nil { + return err + } + return nil +} + +func (t *ChangeWorkerAddressParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.NewWorker (address.Address) (struct) + if err := t.NewWorker.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *ChangeWorkerAddressParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.NewWorker (address.Address) (struct) + + { + + if err := t.NewWorker.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.NewWorker: %w", err) + } + + } + return nil +} + +func (t *ExtendSectorExpirationParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { + return err + } + + // t.NewExpiration (abi.ChainEpoch) (int64) + if t.NewExpiration >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NewExpiration))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.NewExpiration)-1)); err != nil { + return err + } + } + return nil +} + +func (t *ExtendSectorExpirationParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorNumber = abi.SectorNumber(extra) + + } + // t.NewExpiration (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.NewExpiration = abi.ChainEpoch(extraI) + } + return nil +} + +func (t *DeclareFaultsParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Faults ([]miner.FaultDeclaration) (slice) + if len(t.Faults) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Faults was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Faults)))); err != nil { + return err + } + for _, v := range t.Faults { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *DeclareFaultsParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Faults ([]miner.FaultDeclaration) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Faults: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Faults = make([]FaultDeclaration, extra) + } + + for i := 0; i < int(extra); i++ { + + var v FaultDeclaration + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Faults[i] = v + } + + return nil +} + +func (t *DeclareFaultsRecoveredParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.Recoveries ([]miner.RecoveryDeclaration) (slice) + if len(t.Recoveries) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Recoveries was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Recoveries)))); err != nil { + return err + } + for _, v := range t.Recoveries { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *DeclareFaultsRecoveredParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Recoveries ([]miner.RecoveryDeclaration) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Recoveries: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Recoveries = make([]RecoveryDeclaration, extra) + } + + for i := 0; i < int(extra); i++ { + + var v RecoveryDeclaration + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Recoveries[i] = v + } + + return nil +} + +func (t *ReportConsensusFaultParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.BlockHeader1 ([]uint8) (slice) + if len(t.BlockHeader1) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.BlockHeader1 was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.BlockHeader1)))); err != nil { + return err + } + if _, err := w.Write(t.BlockHeader1); err != nil { + return err + } + + // t.BlockHeader2 ([]uint8) (slice) + if len(t.BlockHeader2) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.BlockHeader2 was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.BlockHeader2)))); err != nil { + return err + } + if _, err := w.Write(t.BlockHeader2); err != nil { + return err + } + + // t.BlockHeaderExtra ([]uint8) (slice) + if len(t.BlockHeaderExtra) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.BlockHeaderExtra was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.BlockHeaderExtra)))); err != nil { + return err + } + if _, err := w.Write(t.BlockHeaderExtra); err != nil { + return err + } + return nil +} + +func (t *ReportConsensusFaultParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.BlockHeader1 ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.BlockHeader1: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.BlockHeader1 = make([]byte, extra) + if _, err := io.ReadFull(br, t.BlockHeader1); err != nil { + return err + } + // t.BlockHeader2 ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.BlockHeader2: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.BlockHeader2 = make([]byte, extra) + if _, err := io.ReadFull(br, t.BlockHeader2); err != nil { + return err + } + // t.BlockHeaderExtra ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.BlockHeaderExtra: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.BlockHeaderExtra = make([]byte, extra) + if _, err := io.ReadFull(br, t.BlockHeaderExtra); err != nil { + return err + } + return nil +} + +func (t *GetControlAddressesReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Owner (address.Address) (struct) + if err := t.Owner.MarshalCBOR(w); err != nil { + return err + } + + // t.Worker (address.Address) (struct) + if err := t.Worker.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *GetControlAddressesReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Owner (address.Address) (struct) + + { + + if err := t.Owner.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Owner: %w", err) + } + + } + // t.Worker (address.Address) (struct) + + { + + if err := t.Worker.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Worker: %w", err) + } + + } + return nil +} + +func (t *CheckSectorProvenParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil { + return err + } + + return nil +} + +func (t *CheckSectorProvenParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SectorNumber (abi.SectorNumber) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorNumber = abi.SectorNumber(extra) + + } + return nil +} + +func (t *WithdrawBalanceParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.AmountRequested (big.Int) (struct) + if err := t.AmountRequested.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *WithdrawBalanceParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.AmountRequested (big.Int) (struct) + + { + + if err := t.AmountRequested.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.AmountRequested: %w", err) + } + + } + return nil +} + +func (t *CronEventPayload) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.EventType (miner.CronEventType) (int64) + if t.EventType >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.EventType))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.EventType)-1)); err != nil { + return err + } + } + + // t.Sectors (bitfield.BitField) (struct) + if err := t.Sectors.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *CronEventPayload) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.EventType (miner.CronEventType) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.EventType = CronEventType(extraI) + } + // t.Sectors (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Sectors = new(bitfield.BitField) + if err := t.Sectors.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Sectors pointer: %w", err) + } + } + + } + return nil +} + +func (t *FaultDeclaration) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Deadline (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Deadline))); err != nil { + return err + } + + // t.Sectors (bitfield.BitField) (struct) + if err := t.Sectors.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *FaultDeclaration) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Deadline (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Deadline = uint64(extra) + + } + // t.Sectors (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Sectors = new(bitfield.BitField) + if err := t.Sectors.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Sectors pointer: %w", err) + } + } + + } + return nil +} + +func (t *RecoveryDeclaration) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Deadline (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Deadline))); err != nil { + return err + } + + // t.Sectors (bitfield.BitField) (struct) + if err := t.Sectors.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *RecoveryDeclaration) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Deadline (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Deadline = uint64(extra) + + } + // t.Sectors (bitfield.BitField) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Sectors = new(bitfield.BitField) + if err := t.Sectors.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Sectors pointer: %w", err) + } + } + + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/deadlines.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/deadlines.go new file mode 100644 index 000000000..9b52d2592 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/deadlines.go @@ -0,0 +1,284 @@ +package miner + +import ( + "fmt" + "math" + "sort" + + "golang.org/x/xerrors" + + "github.com/filecoin-project/specs-actors/actors/abi" +) + +// Deadline calculations with respect to a current epoch. +// "Deadline" refers to the window during which proofs may be submitted. +// Windows are non-overlapping ranges [Open, Close), but the challenge epoch for a window occurs before +// the window opens. +// The current epoch may not necessarily lie within the deadline or proving period represented here. +type DeadlineInfo struct { + CurrentEpoch abi.ChainEpoch // Epoch at which this info was calculated. + PeriodStart abi.ChainEpoch // First epoch of the proving period (<= CurrentEpoch). + Index uint64 // A deadline index, in [0..WPoStProvingPeriodDeadlines) unless period elapsed. + Open abi.ChainEpoch // First epoch from which a proof may be submitted, inclusive (>= CurrentEpoch). + Close abi.ChainEpoch // First epoch from which a proof may no longer be submitted, exclusive (>= Open). + Challenge abi.ChainEpoch // Epoch at which to sample the chain for challenge (< Open). + FaultCutoff abi.ChainEpoch // First epoch at which a fault declaration is rejected (< Open). +} + +// Whether the proving period has begun. +func (d *DeadlineInfo) PeriodStarted() bool { + return d.CurrentEpoch >= d.PeriodStart +} + +// Whether the proving period has elapsed. +func (d *DeadlineInfo) PeriodElapsed() bool { + return d.CurrentEpoch >= d.NextPeriodStart() +} + +// Whether the current deadline is currently open. +func (d *DeadlineInfo) IsOpen() bool { + return d.CurrentEpoch >= d.Open && d.CurrentEpoch < d.Close +} + +// Whether the current deadline has already closed. +func (d *DeadlineInfo) HasElapsed() bool { + return d.CurrentEpoch >= d.Close +} + +// Whether the deadline's fault cutoff has passed. +func (d *DeadlineInfo) FaultCutoffPassed() bool { + return d.CurrentEpoch >= d.FaultCutoff +} + +// The last epoch in the proving period. +func (d *DeadlineInfo) PeriodEnd() abi.ChainEpoch { + return d.PeriodStart + WPoStProvingPeriod - 1 +} + +// The first epoch in the next proving period. +func (d *DeadlineInfo) NextPeriodStart() abi.ChainEpoch { + return d.PeriodStart + WPoStProvingPeriod +} + +// Calculates the deadline at some epoch for a proving period and returns the deadline-related calculations. +func ComputeProvingPeriodDeadline(periodStart, currEpoch abi.ChainEpoch) *DeadlineInfo { + periodProgress := currEpoch - periodStart + if periodProgress >= WPoStProvingPeriod { + // Proving period has completely elapsed. + return NewDeadlineInfo(periodStart, WPoStPeriodDeadlines, currEpoch) + } + deadlineIdx := uint64(periodProgress / WPoStChallengeWindow) + if periodProgress < 0 { // Period not yet started. + deadlineIdx = 0 + } + return NewDeadlineInfo(periodStart, deadlineIdx, currEpoch) +} + +// Returns deadline-related calculations for a deadline in some proving period and the current epoch. +func NewDeadlineInfo(periodStart abi.ChainEpoch, deadlineIdx uint64, currEpoch abi.ChainEpoch) *DeadlineInfo { + if deadlineIdx < WPoStPeriodDeadlines { + deadlineOpen := periodStart + (abi.ChainEpoch(deadlineIdx) * WPoStChallengeWindow) + return &DeadlineInfo{ + CurrentEpoch: currEpoch, + PeriodStart: periodStart, + Index: deadlineIdx, + Open: deadlineOpen, + Close: deadlineOpen + WPoStChallengeWindow, + Challenge: deadlineOpen - WPoStChallengeLookback, + FaultCutoff: deadlineOpen - FaultDeclarationCutoff, + } + } else { + // Return deadline info for a no-duration deadline immediately after the last real one. + afterLastDeadline := periodStart + WPoStProvingPeriod + return &DeadlineInfo{ + CurrentEpoch: currEpoch, + PeriodStart: periodStart, + Index: deadlineIdx, + Open: afterLastDeadline, + Close: afterLastDeadline, + Challenge: afterLastDeadline, + FaultCutoff: 0, + } + } +} + +// Computes the first partition index and number of sectors for a deadline. +// Partitions are numbered globally for the miner, not per-deadline. +// If the deadline has no sectors, the first partition index is the index that a partition at that deadline would +// have, if non-empty (and sectorCount is zero). +func PartitionsForDeadline(d *Deadlines, partitionSize, deadlineIdx uint64) (firstPartition, sectorCount uint64, _ error) { + if deadlineIdx >= WPoStPeriodDeadlines { + return 0, 0, fmt.Errorf("invalid deadline index %d for %d deadlines", deadlineIdx, WPoStPeriodDeadlines) + } + var partitionCountSoFar uint64 + for i := uint64(0); i < WPoStPeriodDeadlines; i++ { + partitionCount, thisSectorCount, err := DeadlineCount(d, partitionSize, i) + if err != nil { + return 0, 0, err + } + if i == deadlineIdx { + return partitionCountSoFar, thisSectorCount, nil + } + partitionCountSoFar += partitionCount + } + return 0, 0, nil +} + +// Counts the partitions (including up to one partial) and sectors at a deadline. +func DeadlineCount(d *Deadlines, partitionSize, deadlineIdx uint64) (partitionCount, sectorCount uint64, err error) { + if deadlineIdx >= WPoStPeriodDeadlines { + return 0, 0, fmt.Errorf("invalid deadline index %d for %d deadlines", deadlineIdx, WPoStPeriodDeadlines) + } + sectorCount, err = d.Due[deadlineIdx].Count() + if err != nil { + return 0, 0, err + } + + partitionCount = sectorCount / partitionSize + if sectorCount%partitionSize != 0 { + partitionCount++ + } + return +} + +// Computes a bitfield of the sector numbers included in a sequence of partitions due at some deadline. +// Fails if any partition is not due at the provided deadline. +func ComputePartitionsSectors(d *Deadlines, partitionSize uint64, deadlineIndex uint64, partitions []uint64) ([]*abi.BitField, error) { + deadlineFirstPartition, deadlineSectorCount, err := PartitionsForDeadline(d, partitionSize, deadlineIndex) + if err != nil { + return nil, fmt.Errorf("failed to count partitions for deadline %d: %w", deadlineIndex, err) + } + // ceil(deadlineSectorCount / partitionSize) + deadlinePartitionCount := (deadlineSectorCount + partitionSize - 1) / partitionSize + + // Work out which sector numbers the partitions correspond to. + deadlineSectors := d.Due[deadlineIndex] + partitionsSectors := make([]*abi.BitField, len(partitions)) + for i, pIdx := range partitions { + if pIdx < deadlineFirstPartition || pIdx >= deadlineFirstPartition+deadlinePartitionCount { + return nil, fmt.Errorf("invalid partition %d at deadline %d with first %d, count %d", + pIdx, deadlineIndex, deadlineFirstPartition, deadlinePartitionCount) + } + + // Slice out the sectors corresponding to this partition from the deadline's sector bitfield. + sectorOffset := (pIdx - deadlineFirstPartition) * partitionSize + sectorCount := min64(partitionSize, deadlineSectorCount-sectorOffset) + partitionSectors, err := deadlineSectors.Slice(sectorOffset, sectorCount) + if err != nil { + return nil, fmt.Errorf("failed to slice deadline %d, size %d, offset %d, count %d", + deadlineIndex, deadlineSectorCount, sectorOffset, sectorCount) + } + partitionsSectors[i] = partitionSectors + } + return partitionsSectors, nil +} + +// Assigns a sequence of sector numbers to deadlines by: +// - filling any non-full partitions, in round-robin order across the deadlines +// - repeatedly adding a new partition to the deadline with the fewest partitions +// When multiple partitions share the minimal sector count, one is chosen at random (from a seed). +func AssignNewSectors(deadlines *Deadlines, partitionSize uint64, newSectors []uint64, seed abi.Randomness) error { + nextNewSector := uint64(0) + // The first deadline is left empty since it's more difficult for a miner to orchestrate proofs. + // The set of sectors due at the deadline isn't known until the proving period actually starts and any + // new sectors are assigned to it (here). + // Practically, a miner must also wait for some probabilistic finality after that before beginning proof + // calculations. + // It's left empty so a miner has at least one challenge duration to prepare for proving after new sectors + // are assigned. + firstAssignableDeadline := uint64(1) + + // Assigns up to `count` sectors to `deadline` and advances `nextNewSector`. + assignToDeadline := func(count uint64, deadline uint64) error { + countToAdd := min64(count, uint64(len(newSectors))-nextNewSector) + sectorsToAdd := newSectors[nextNewSector : nextNewSector+countToAdd] + err := deadlines.AddToDeadline(deadline, sectorsToAdd...) + if err != nil { + return fmt.Errorf("failed to add %d sectors to deadline %d: %w", countToAdd, deadline, err) + } + nextNewSector += countToAdd + return nil + } + + // Iterate deadlines and fill any partial partitions. There's no great advantage to filling more- or less- + // full ones first, so they're filled in sequence order. + // Meanwhile, record the partition count at each deadline. + deadlinePartitionCounts := make([]uint64, WPoStPeriodDeadlines) + for i := uint64(0); i < WPoStPeriodDeadlines && nextNewSector < uint64(len(newSectors)); i++ { + if i < firstAssignableDeadline { + // Mark unassignable deadlines as "full" so nothing more will be assigned. + deadlinePartitionCounts[i] = math.MaxUint64 + continue + } + partitionCount, sectorCount, err := DeadlineCount(deadlines, partitionSize, i) + if err != nil { + return fmt.Errorf("failed to count sectors in partition %d: %w", i, err) + } + deadlinePartitionCounts[i] = partitionCount + + gap := partitionSize - (sectorCount % partitionSize) + if gap != partitionSize { + err = assignToDeadline(gap, i) + if err != nil { + return err + } + } + } + + // While there remain new sectors to assign, fill a new partition in one of the deadlines that is least full. + // Do this by maintaining a slice of deadline indexes sorted by partition count. + // Shuffling this slice to re-sort as weights change is O(n^2). + // For a large number of partitions, a heap would be the way to do this in O(n*log n), but for small numbers + // is probably overkill. + // A miner onboarding a monumental 1EiB of 32GiB sectors uniformly throughout a year will fill 40 partitions + // per proving period (40^2=1600). With 64GiB sectors, half that (20^2=400). + // TODO: randomize assignment among equally-full deadlines https://github.com/filecoin-project/specs-actors/issues/432 + + dlIdxs := make([]uint64, WPoStPeriodDeadlines) + for i := range dlIdxs { + dlIdxs[i] = uint64(i) + } + + sortDeadlines := func() { + // Order deadline indexes by corresponding partition count (then secondarily by index) to form a queue. + sort.SliceStable(dlIdxs, func(i, j int) bool { + idxI, idxJ := dlIdxs[i], dlIdxs[j] + countI, countJ := deadlinePartitionCounts[idxI], deadlinePartitionCounts[idxJ] + if countI == countJ { + return idxI < idxJ + } + return countI < countJ + }) + } + + sortDeadlines() + for nextNewSector < uint64(len(newSectors)) { + // Assign a full partition to the least-full deadline. + targetDeadline := dlIdxs[0] + err := assignToDeadline(partitionSize, targetDeadline) + if err != nil { + return err + } + deadlinePartitionCounts[targetDeadline]++ + // Re-sort the queue. + // Only the first element has changed, the remainder is still sorted, so with an insertion-sort under + // the hood this will be linear. + sortDeadlines() + } + return nil +} + +// FindDeadline returns the deadline index for a given sector number. +// It returns an error if the sector number is not tracked by deadlines. +func FindDeadline(deadlines *Deadlines, sectorNum abi.SectorNumber) (uint64, error) { + for deadlineIdx, sectorNums := range deadlines.Due { + found, err := sectorNums.IsSet(uint64(sectorNum)) + if err != nil { + return 0, err + } + if found { + return uint64(deadlineIdx), nil + } + } + return 0, xerrors.New("sectorNum not due at any deadline") +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/deadlines_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/deadlines_test.go new file mode 100644 index 000000000..e60d87873 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/deadlines_test.go @@ -0,0 +1,613 @@ +package miner_test + +import ( + "testing" + + "github.com/filecoin-project/go-bitfield" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/builtin/miner" +) + +func TestProvingPeriodDeadlines(t *testing.T) { + PP := miner.WPoStProvingPeriod + CW := miner.WPoStChallengeWindow + DLS := miner.WPoStPeriodDeadlines + + t.Run("pre-open", func(t *testing.T) { + curr := abi.ChainEpoch(0) // Current is before the period opens. + { + periodStart := miner.FaultDeclarationCutoff + 1 + di := miner.ComputeProvingPeriodDeadline(periodStart, curr) + assert.Equal(t, uint64(0), di.Index) + assert.Equal(t, periodStart, di.Open) + + assert.False(t, di.PeriodStarted()) + assert.False(t, di.IsOpen()) + assert.False(t, di.HasElapsed()) + assert.False(t, di.FaultCutoffPassed()) + assert.Equal(t, periodStart+miner.WPoStProvingPeriod-1, di.PeriodEnd()) + assert.Equal(t, periodStart+miner.WPoStProvingPeriod, di.NextPeriodStart()) + } + { + periodStart := miner.FaultDeclarationCutoff - 1 + di := miner.ComputeProvingPeriodDeadline(periodStart, curr) + assert.True(t, di.FaultCutoffPassed()) + } + }) + + t.Run("offset zero", func(t *testing.T) { + firstPeriodStart := abi.ChainEpoch(0) + + // First proving period. + di := assertDeadlineInfo(t, 0, firstPeriodStart, 0, 0) + assert.Equal(t, -miner.WPoStChallengeLookback, di.Challenge) + assert.Equal(t, -miner.FaultDeclarationCutoff, di.FaultCutoff) + assert.True(t, di.IsOpen()) + assert.True(t, di.FaultCutoffPassed()) + + assertDeadlineInfo(t, 1, firstPeriodStart, 0, 0) + // Final epoch of deadline 0. + assertDeadlineInfo(t, CW-1, firstPeriodStart, 0, 0) + // First epoch of deadline 1 + assertDeadlineInfo(t, CW, firstPeriodStart, 1, CW) + assertDeadlineInfo(t, CW+1, firstPeriodStart, 1, CW) + // Final epoch of deadline 1 + assertDeadlineInfo(t, CW*2-1, firstPeriodStart, 1, CW) + // First epoch of deadline 2 + assertDeadlineInfo(t, CW*2, firstPeriodStart, 2, CW*2) + + // Last epoch of last deadline + assertDeadlineInfo(t, PP-1, firstPeriodStart, DLS-1, PP-CW) + + // Second proving period + // First epoch of deadline 0 + secondPeriodStart := PP + di = assertDeadlineInfo(t, PP, secondPeriodStart, 0, PP) + assert.Equal(t, PP-miner.WPoStChallengeLookback, di.Challenge) + assert.Equal(t, PP-miner.FaultDeclarationCutoff, di.FaultCutoff) + + // Final epoch of deadline 0. + assertDeadlineInfo(t, PP+CW-1, secondPeriodStart, 0, PP+0) + // First epoch of deadline 1 + assertDeadlineInfo(t, PP+CW, secondPeriodStart, 1, PP+CW) + assertDeadlineInfo(t, PP+CW+1, secondPeriodStart, 1, PP+CW) + }) + + t.Run("offset non-zero", func(t *testing.T) { + offset := CW*2 + 2 // Arbitrary not aligned with challenge window. + initialPPStart := offset - PP + firstDlIndex := miner.WPoStPeriodDeadlines - uint64(offset/CW) - 1 + firstDlOpen := initialPPStart + CW*abi.ChainEpoch(firstDlIndex) + + require.True(t, offset < PP) + require.True(t, initialPPStart < 0) + require.True(t, firstDlOpen < 0) + + // Incomplete initial proving period. + // At epoch zero, the initial deadlines in the period have already passed and we're part way through + // another one. + di := assertDeadlineInfo(t, 0, initialPPStart, firstDlIndex, firstDlOpen) + assert.Equal(t, firstDlOpen-miner.WPoStChallengeLookback, di.Challenge) + assert.Equal(t, firstDlOpen-miner.FaultDeclarationCutoff, di.FaultCutoff) + assert.True(t, di.IsOpen()) + assert.True(t, di.FaultCutoffPassed()) + + // Epoch 1 + assertDeadlineInfo(t, 1, initialPPStart, firstDlIndex, firstDlOpen) + + // Epoch 2 rolls over to third-last challenge window + assertDeadlineInfo(t, 2, initialPPStart, firstDlIndex+1, firstDlOpen+CW) + assertDeadlineInfo(t, 3, initialPPStart, firstDlIndex+1, firstDlOpen+CW) + + // Last epoch of second-last window. + assertDeadlineInfo(t, 2+CW-1, initialPPStart, firstDlIndex+1, firstDlOpen+CW) + // First epoch of last challenge window. + assertDeadlineInfo(t, 2+CW, initialPPStart, firstDlIndex+2, firstDlOpen+CW*2) + // Last epoch of last challenge window. + assert.Equal(t, miner.WPoStPeriodDeadlines-1, firstDlIndex+2) + assertDeadlineInfo(t, 2+2*CW-1, initialPPStart, firstDlIndex+2, firstDlOpen+CW*2) + + // First epoch of next proving period. + assertDeadlineInfo(t, 2+2*CW, initialPPStart+PP, 0, initialPPStart+PP) + assertDeadlineInfo(t, 2+2*CW+1, initialPPStart+PP, 0, initialPPStart+PP) + }) + + t.Run("period expired", func(t *testing.T) { + offset := abi.ChainEpoch(1) + d := miner.ComputeProvingPeriodDeadline(offset, offset+miner.WPoStProvingPeriod) + assert.True(t, d.PeriodStarted()) + assert.True(t, d.PeriodElapsed()) + assert.Equal(t, miner.WPoStPeriodDeadlines, d.Index) + assert.False(t, d.IsOpen()) + assert.True(t, d.HasElapsed()) + assert.True(t, d.FaultCutoffPassed()) + assert.Equal(t, offset+miner.WPoStProvingPeriod-1, d.PeriodEnd()) + assert.Equal(t, offset+miner.WPoStProvingPeriod, d.NextPeriodStart()) + }) +} + +func assertDeadlineInfo(t *testing.T, current, periodStart abi.ChainEpoch, expectedIndex uint64, expectedDeadlineOpen abi.ChainEpoch) *miner.DeadlineInfo { + expected := makeDeadline(current, periodStart, expectedIndex, expectedDeadlineOpen) + actual := miner.ComputeProvingPeriodDeadline(periodStart, current) + assert.True(t, actual.PeriodStarted()) + assert.True(t, actual.IsOpen()) + assert.False(t, actual.HasElapsed()) + assert.Equal(t, expected, actual) + return actual +} + +func makeDeadline(currEpoch, periodStart abi.ChainEpoch, index uint64, deadlineOpen abi.ChainEpoch) *miner.DeadlineInfo { + return &miner.DeadlineInfo{ + CurrentEpoch: currEpoch, + PeriodStart: periodStart, + Index: index, + Open: deadlineOpen, + Close: deadlineOpen + miner.WPoStChallengeWindow, + Challenge: deadlineOpen - miner.WPoStChallengeLookback, + FaultCutoff: deadlineOpen - miner.FaultDeclarationCutoff, + } +} + +func TestPartitionsForDeadline(t *testing.T) { + const partSize = uint64(1000) + + t.Run("empty deadlines", func(t *testing.T) { + dl := buildDeadlines(t, []uint64{}) + firstIndex, sectorCount, err := miner.PartitionsForDeadline(dl, partSize, 0) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, uint64(0), sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, miner.WPoStPeriodDeadlines-1) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, uint64(0), sectorCount) + }) + + t.Run("single sector at first deadline", func(t *testing.T) { + dl := buildDeadlines(t, []uint64{1}) + firstIndex, sectorCount, err := miner.PartitionsForDeadline(dl, partSize, 0) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, uint64(1), sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 1) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Zero(t, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, miner.WPoStPeriodDeadlines-1) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Zero(t, sectorCount) + }) + + t.Run("single sector at non-first deadline", func(t *testing.T) { + dl := buildDeadlines(t, []uint64{0, 1}) + firstIndex, sectorCount, err := miner.PartitionsForDeadline(dl, partSize, 0) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, uint64(0), sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 1) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, uint64(1), sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 2) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Equal(t, uint64(0), sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, miner.WPoStPeriodDeadlines-1) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Equal(t, uint64(0), sectorCount) + }) + + t.Run("deadlines with one full partitions", func(t *testing.T) { + dl := NewDeadlinesBuilder(t).addToAll(partSize).Deadlines + firstIndex, sectorCount, err := miner.PartitionsForDeadline(dl, partSize, 0) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, partSize, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 1) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Equal(t, partSize, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, miner.WPoStPeriodDeadlines-1) + require.NoError(t, err) + assert.Equal(t, miner.WPoStPeriodDeadlines-1, firstIndex) + assert.Equal(t, partSize, sectorCount) + }) + + t.Run("partial partitions", func(t *testing.T) { + dl := buildDeadlines(t, []uint64{ + 0: partSize - 1, + 1: partSize, + 2: partSize - 2, + 3: partSize, + 4: partSize - 3, + 5: partSize, + }) + firstIndex, sectorCount, err := miner.PartitionsForDeadline(dl, partSize, 0) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, partSize-1, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 1) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Equal(t, partSize, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 2) + require.NoError(t, err) + assert.Equal(t, uint64(2), firstIndex) + assert.Equal(t, partSize-2, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 5) + require.NoError(t, err) + assert.Equal(t, uint64(5), firstIndex) + assert.Equal(t, partSize, sectorCount) + }) + + t.Run("multiple partitions", func(t *testing.T) { + dl := buildDeadlines(t, []uint64{ + 0: partSize, // 1 partition 1 total + 1: partSize * 2, // 2 partitions 3 total + 2: partSize*4 - 1, // 4 partitions 7 total + 3: partSize * 6, // 6 partitions 13 total + 4: partSize*8 - 1, // 8 partitions 21 total + 5: partSize * 9, // 9 partitions 30 total + }) + + firstIndex, sectorCount, err := miner.PartitionsForDeadline(dl, partSize, 0) + require.NoError(t, err) + assert.Equal(t, uint64(0), firstIndex) + assert.Equal(t, partSize, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 1) + require.NoError(t, err) + assert.Equal(t, uint64(1), firstIndex) + assert.Equal(t, partSize*2, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 2) + require.NoError(t, err) + assert.Equal(t, uint64(3), firstIndex) + assert.Equal(t, partSize*4-1, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 3) + require.NoError(t, err) + assert.Equal(t, uint64(7), firstIndex) + assert.Equal(t, partSize*6, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 4) + require.NoError(t, err) + assert.Equal(t, uint64(13), firstIndex) + assert.Equal(t, partSize*8-1, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, 5) + require.NoError(t, err) + assert.Equal(t, uint64(21), firstIndex) + assert.Equal(t, partSize*9, sectorCount) + + firstIndex, sectorCount, err = miner.PartitionsForDeadline(dl, partSize, miner.WPoStPeriodDeadlines-1) + require.NoError(t, err) + assert.Equal(t, uint64(30), firstIndex) + assert.Equal(t, uint64(0), sectorCount) + }) +} + +func TestComputePartitionsSectors(t *testing.T) { + const partSize = uint64(1000) + + t.Run("no partitions due at empty deadline", func(t *testing.T) { + dls := miner.ConstructDeadlines() + dls.Due[1] = bfSeq(0, 1) + + // No partitions at deadline 0 + _, err := miner.ComputePartitionsSectors(dls, partSize, 0, []uint64{0}) + require.Error(t, err) + + // No partitions at deadline 2 + _, err = miner.ComputePartitionsSectors(dls, partSize, 2, []uint64{0}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 2, []uint64{1}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 2, []uint64{2}) + require.Error(t, err) + }) + t.Run("single sector", func(t *testing.T) { + dls := miner.ConstructDeadlines() + dls.Due[1] = bfSeq(0, 1) + partitions, err := miner.ComputePartitionsSectors(dls, partSize, 1, []uint64{0}) + require.NoError(t, err) + assert.Equal(t, 1, len(partitions)) + assertBfEqual(t, bfSeq(0, 1), partitions[0]) + }) + t.Run("full partition", func(t *testing.T) { + dls := miner.ConstructDeadlines() + dls.Due[10] = bfSeq(1234, partSize) + partitions, err := miner.ComputePartitionsSectors(dls, partSize, 10, []uint64{0}) + require.NoError(t, err) + assert.Equal(t, 1, len(partitions)) + assertBfEqual(t, bfSeq(1234, partSize), partitions[0]) + }) + t.Run("full plus partial partition", func(t *testing.T) { + dls := miner.ConstructDeadlines() + dls.Due[10] = bfSeq(5555, partSize+1) + partitions, err := miner.ComputePartitionsSectors(dls, partSize, 10, []uint64{0}) // First partition + require.NoError(t, err) + assert.Equal(t, 1, len(partitions)) + assertBfEqual(t, bfSeq(5555, partSize), partitions[0]) + + partitions, err = miner.ComputePartitionsSectors(dls, partSize, 10, []uint64{1}) // Second partition + require.NoError(t, err) + assert.Equal(t, 1, len(partitions)) + assertBfEqual(t, bfSeq(5555+partSize, 1), partitions[0]) + + partitions, err = miner.ComputePartitionsSectors(dls, partSize, 10, []uint64{0, 1}) // Both partitions + require.NoError(t, err) + assert.Equal(t, 2, len(partitions)) + assertBfEqual(t, bfSeq(5555, partSize), partitions[0]) + assertBfEqual(t, bfSeq(5555+partSize, 1), partitions[1]) + }) + t.Run("multiple partitions", func(t *testing.T) { + dls := miner.ConstructDeadlines() + dls.Due[1] = bfSeq(0, 3*partSize+1) + partitions, err := miner.ComputePartitionsSectors(dls, partSize, 1, []uint64{0, 1, 2, 3}) + require.NoError(t, err) + assert.Equal(t, 4, len(partitions)) + assertBfEqual(t, bfSeq(0, partSize), partitions[0]) + assertBfEqual(t, bfSeq(1*partSize, partSize), partitions[1]) + assertBfEqual(t, bfSeq(2*partSize, partSize), partitions[2]) + assertBfEqual(t, bfSeq(3*partSize, 1), partitions[3]) + }) + t.Run("partitions numbered across deadlines", func(t *testing.T) { + dls := miner.ConstructDeadlines() + dls.Due[1] = bfSeq(0, 3*partSize+1) + dls.Due[3] = bfSeq(3*partSize+1, 1) + dls.Due[5] = bfSeq(3*partSize+1+1, 2*partSize) + + partitions, err := miner.ComputePartitionsSectors(dls, partSize, 1, []uint64{0, 1, 2, 3}) + require.NoError(t, err) + assert.Equal(t, 4, len(partitions)) + + partitions, err = miner.ComputePartitionsSectors(dls, partSize, 3, []uint64{4}) + require.NoError(t, err) + assert.Equal(t, 1, len(partitions)) + assertBfEqual(t, bfSeq(3*partSize+1, 1), partitions[0]) + + partitions, err = miner.ComputePartitionsSectors(dls, partSize, 5, []uint64{5, 6}) + require.NoError(t, err) + assert.Equal(t, 2, len(partitions)) + assertBfEqual(t, bfSeq(3*partSize+1+1, partSize), partitions[0]) + assertBfEqual(t, bfSeq(3*partSize+1+1+partSize, partSize), partitions[1]) + + // Mismatched deadline/partition pairs + _, err = miner.ComputePartitionsSectors(dls, partSize, 1, []uint64{4}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 2, []uint64{4}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 3, []uint64{0}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 3, []uint64{3}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 3, []uint64{5}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 4, []uint64{5}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 5, []uint64{0}) + require.Error(t, err) + _, err = miner.ComputePartitionsSectors(dls, partSize, 5, []uint64{7}) + require.Error(t, err) + }) +} + +func TestAssignNewSectors(t *testing.T) { + partSize := uint64(4) + seed := abi.Randomness([]byte{}) + + assign := func(deadlines *miner.Deadlines, sectors []uint64) *miner.Deadlines { + require.NoError(t, miner.AssignNewSectors(deadlines, partSize, sectors, seed)) + return deadlines + } + + t.Run("initial assignment", func(t *testing.T) { + { + deadlines := assign(miner.ConstructDeadlines(), seq(0, 0)) + NewDeadlinesBuilder(t).verify(deadlines) + } + { + deadlines := assign(miner.ConstructDeadlines(), seq(0, 1)) + NewDeadlinesBuilder(t, 0, 1).verify(deadlines) + } + { + deadlines := assign(miner.ConstructDeadlines(), seq(0, 15)) + NewDeadlinesBuilder(t, 0, 4, 4, 4, 3).verify(deadlines) + } + { + deadlines := assign(miner.ConstructDeadlines(), seq(0, (miner.WPoStPeriodDeadlines-1)*partSize+1)) + NewDeadlinesBuilder(t).addToAllFrom(1, partSize).addTo(1, 1).verify(deadlines) + } + }) + t.Run("incremental assignment", func(t *testing.T) { + { + // Add one sector at a time. + deadlines := NewDeadlinesBuilder(t, 0, 1).Deadlines + assign(deadlines, seq(1, 1)) + NewDeadlinesBuilder(t, 0, 2).verify(deadlines) + assign(deadlines, seq(2, 1)) + NewDeadlinesBuilder(t, 0, 3).verify(deadlines) + assign(deadlines, seq(3, 1)) + NewDeadlinesBuilder(t, 0, 4).verify(deadlines) + assign(deadlines, seq(4, 1)) + NewDeadlinesBuilder(t, 0, 4, 1).verify(deadlines) + } + { + // Add one partition at a time. + deadlines := miner.ConstructDeadlines() + assign(deadlines, seq(0, 4)) + NewDeadlinesBuilder(t, 0, 4).verify(deadlines) + assign(deadlines, seq(4, 4)) + NewDeadlinesBuilder(t, 0, 4, 4).verify(deadlines) + assign(deadlines, seq(2*4, 4)) + NewDeadlinesBuilder(t, 0, 4, 4, 4).verify(deadlines) + assign(deadlines, seq(3*4, 4)) + NewDeadlinesBuilder(t, 0, 4, 4, 4, 4).verify(deadlines) + } + { + // Add lots + deadlines := miner.ConstructDeadlines() + assign(deadlines, seq(0, 2*partSize+1)) + NewDeadlinesBuilder(t, 0, partSize, partSize, 1).verify(deadlines) + assign(deadlines, seq(2*partSize+1, partSize)) + NewDeadlinesBuilder(t, 0, partSize, partSize, partSize, 1).verify(deadlines) + } + }) + t.Run("fill partial partitions first", func(t *testing.T) { + { + b := NewDeadlinesBuilder(t, 0, 4, 3, 1) + deadlines := assign(b.Deadlines, seq(b.NextSectorIdx, 4)) + + NewDeadlinesBuilder(t, 0, 4, 3, 1). + addTo(2, 1). // Fill the first partial partition + addTo(3, 3). // Fill the next partial partition + verify(deadlines) + } + { + b := NewDeadlinesBuilder(t, 0, 9, 8, 7, 4, 1) + deadlines := assign(b.Deadlines, seq(b.NextSectorIdx, 7)) + + NewDeadlinesBuilder(t, 0, 9, 8, 7, 4, 1). + addTo(1, 3). // Fill the first partial partition, in deadline 1 + addTo(3, 1). // Fill the next partial partition + addTo(5, 3). // Fill the final partial partition + verify(deadlines) + } + }) + t.Run("fill less full deadlines first", func(t *testing.T) { + { + b := NewDeadlinesBuilder(t, 0, 12, 4, 4, 8). + addToAllFrom(5, 100) // Fill trailing deadlines so we can just use the first few. + deadlines := b.Deadlines + assign(deadlines, seq(b.NextSectorIdx, 20)) + + NewDeadlinesBuilder(t, 0, 12, 4, 4, 8). + addToAllFrom(5, 100). + addTo(2, 4). + addTo(3, 4). + addTo(2, 4). + addTo(3, 4). + addTo(4, 4). + verify(deadlines) + } + }) + // TODO: a final test including partial and full partitions that exercises both filling the partials first, + // then prioritising the less full deadlines. + // https://github.com/filecoin-project/specs-actors/issues/439 +} + +// +// Deadlines Utils +// + +func assertBfEqual(t *testing.T, expected, actual *bitfield.BitField) { + ex, err := expected.All(1 << 20) + require.NoError(t, err) + ac, err := actual.All(1 << 20) + require.NoError(t, err) + assert.Equal(t, ex, ac) +} + +func assertDeadlinesEqual(t *testing.T, expected, actual *miner.Deadlines) { + for i := range expected.Due { + ex, err := expected.Due[i].All(1 << 20) + require.NoError(t, err) + ac, err := actual.Due[i].All(1 << 20) + require.NoError(t, err) + assert.Equal(t, ex, ac, "mismatched deadlines at index %d", i) + } +} + +// Creates a bitfield with a sequence of `count` values from `first. +func bfSeq(first uint64, count uint64) *abi.BitField { + values := seq(first, count) + return bitfield.NewFromSet(values) +} + +// Creates a slice of integers with a sequence of `count` values from `first. +func seq(first uint64, count uint64) []uint64 { + values := make([]uint64, count) + for i := range values { + values[i] = first + uint64(i) + } + return values +} + +// accepts an array were the value at each index indicates how many sectors are in the partition of the returned Deadlines +// Example: +// gen := [miner.WPoStPeriodDeadlines]uint64{1, 42, 89, 0} returns a deadline with: +// 1 sectors at deadlineIdx 0 +// 42 sectors at deadlineIdx 1 +// 89 sectors at deadlineIdx 2 +// 0 sectors at deadlineIdx 3-47 +func buildDeadlines(t *testing.T, gen []uint64) *miner.Deadlines { + return NewDeadlinesBuilder(t).addToFrom(0, gen...).Deadlines +} + +// A builder for initialising a Deadlines with sectors assigned. +type DeadlinesBuilder struct { + Deadlines *miner.Deadlines + NextSectorIdx uint64 + t *testing.T +} + +// Creates a new builder, with optional initial sector counts. +func NewDeadlinesBuilder(t *testing.T, counts ...uint64) *DeadlinesBuilder { + b := &DeadlinesBuilder{miner.ConstructDeadlines(), 0, t} + b.addToFrom(0, counts...) + return b +} + +// Assigns count new sectors to deadline idx. +func (b *DeadlinesBuilder) addTo(idx uint64, count uint64) *DeadlinesBuilder { + nums := seq(b.NextSectorIdx, count) + b.NextSectorIdx += count + require.NoError(b.t, b.Deadlines.AddToDeadline(idx, nums...)) + return b +} + +// Assigns counts[i] new sectors to deadlines sequentially from first. +func (b *DeadlinesBuilder) addToFrom(first uint64, counts ...uint64) *DeadlinesBuilder { + for i, c := range counts { + b.addTo(first+uint64(i), c) + } + return b +} + +// Assigns count new sectors to every deadline. +func (b *DeadlinesBuilder) addToAll(count uint64) *DeadlinesBuilder { + for i := range b.Deadlines.Due { + b.addTo(uint64(i), count) + } + return b +} + +// Assigns count new sectors to every deadline from first until the last. +func (b *DeadlinesBuilder) addToAllFrom(first uint64, count uint64) *DeadlinesBuilder { + for i := first; i < miner.WPoStPeriodDeadlines; i++ { + b.addTo(i, count) + } + return b +} + +// Verifies that deadlines match this builder as expected values. +func (b *DeadlinesBuilder) verify(actual *miner.Deadlines) { + assertDeadlinesEqual(b.t, b.Deadlines, actual) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/expirations.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/expirations.go new file mode 100644 index 000000000..cd011d97b --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/expirations.go @@ -0,0 +1,37 @@ +package miner + +import ( + "sort" + + "github.com/filecoin-project/specs-actors/actors/abi" +) + +type sectorEpochSet struct { + epoch abi.ChainEpoch + sectors []uint64 +} + +// Takes a slice of sector infos and returns sector info sets grouped and +// sorted by expiration epoch. +// +// Note: While each sector set is sorted by epoch, the order of per-epoch sector +// sets is maintained. +func groupSectorsByExpiration(sectors []*SectorOnChainInfo) []sectorEpochSet { + sectorsByExpiration := make(map[abi.ChainEpoch][]uint64) + + for _, sector := range sectors { + sectorsByExpiration[sector.Expiration] = append(sectorsByExpiration[sector.Expiration], uint64(sector.SectorNumber)) + } + + sectorEpochSets := make([]sectorEpochSet, 0, len(sectorsByExpiration)) + + // This map iteration is non-deterministic but safe because we sort by epoch below. + for expiration, sectors := range sectorsByExpiration { + sectorEpochSets = append(sectorEpochSets, sectorEpochSet{expiration, sectors}) + } + + sort.Slice(sectorEpochSets, func(i, j int) bool { + return sectorEpochSets[i].epoch < sectorEpochSets[j].epoch + }) + return sectorEpochSets +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/expirations_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/expirations_test.go new file mode 100644 index 000000000..df82dffd8 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/expirations_test.go @@ -0,0 +1,39 @@ +package miner + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestExpirations(t *testing.T) { + sectors := []*SectorOnChainInfo{{ + Expiration: 0, + SectorNumber: 1, + }, { + Expiration: 0, + SectorNumber: 2, + }, { + Expiration: 2, + SectorNumber: 3, + }, { + Expiration: 0, + SectorNumber: 4, + }} + result := groupSectorsByExpiration(sectors) + expected := []sectorEpochSet{{ + epoch: 0, + sectors: []uint64{1, 2, 4}, + }, { + epoch: 2, + sectors: []uint64{3}, + }} + require.Equal(t, expected, result) +} + +func TestExpirationsEmpty(t *testing.T) { + sectors := []*SectorOnChainInfo{} + result := groupSectorsByExpiration(sectors) + expected := []sectorEpochSet{} + require.Equal(t, expected, result) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_actor.go new file mode 100644 index 000000000..f9c895c93 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_actor.go @@ -0,0 +1,2200 @@ +package miner + +import ( + "bytes" + "encoding/binary" + "fmt" + + addr "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-bitfield" + cid "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + market "github.com/filecoin-project/specs-actors/actors/builtin/market" + power "github.com/filecoin-project/specs-actors/actors/builtin/power" + crypto "github.com/filecoin-project/specs-actors/actors/crypto" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + . "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Runtime = vmr.Runtime + +type CronEventType int64 + +const ( + CronEventWorkerKeyChange CronEventType = iota + CronEventPreCommitExpiry + CronEventProvingPeriod +) + +type CronEventPayload struct { + EventType CronEventType + Sectors *abi.BitField +} + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.ControlAddresses, + 3: a.ChangeWorkerAddress, + 4: a.ChangePeerID, + 5: a.SubmitWindowedPoSt, + 6: a.PreCommitSector, + 7: a.ProveCommitSector, + 8: a.ExtendSectorExpiration, + 9: a.TerminateSectors, + 10: a.DeclareFaults, + 11: a.DeclareFaultsRecovered, + 12: a.OnDeferredCronEvent, + 13: a.CheckSectorProven, + 14: a.AddLockedFund, + 15: a.ReportConsensusFault, + 16: a.WithdrawBalance, + 17: a.ConfirmSectorProofsValid, + 18: a.ChangeMultiaddrs, + } +} + +var _ abi.Invokee = Actor{} + +///////////////// +// Constructor // +///////////////// + +// Storage miner actors are created exclusively by the storage power actor. In order to break a circular dependency +// between the two, the construction parameters are defined in the power actor. +type ConstructorParams = power.MinerConstructorParams + +func (a Actor) Constructor(rt Runtime, params *ConstructorParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.InitActorAddr) + + _, ok := SupportedProofTypes[params.SealProofType] + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "proof type %d not allowed for new miner actors", params.SealProofType) + } + + owner := resolveOwnerAddress(rt, params.OwnerAddr) + worker := resolveWorkerAddress(rt, params.WorkerAddr) + + emptyMap, err := adt.MakeEmptyMap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to construct initial state: %v", err) + } + + emptyArray, err := adt.MakeEmptyArray(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to construct initial state: %v", err) + } + + emptyDeadlines := ConstructDeadlines() + emptyDeadlinesCid := rt.Store().Put(emptyDeadlines) + + currEpoch := rt.CurrEpoch() + offset, err := assignProvingPeriodOffset(rt.Message().Receiver(), currEpoch, rt.Syscalls().HashBlake2b) + builtin.RequireNoErr(rt, err, exitcode.ErrSerialization, "failed to assign proving period offset") + periodStart := nextProvingPeriodStart(currEpoch, offset) + Assert(periodStart > currEpoch) + + info, err := ConstructMinerInfo(owner, worker, params.PeerId, params.Multiaddrs, params.SealProofType) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "failed to construct initial miner info") + infoCid := rt.Store().Put(info) + + state, err := ConstructState(infoCid, periodStart, emptyArray, emptyMap, emptyDeadlinesCid) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "failed to construct state") + rt.State().Create(state) + + // Register cron callback for epoch before the first proving period starts. + enrollCronEvent(rt, periodStart-1, &CronEventPayload{ + EventType: CronEventProvingPeriod, + }) + return nil +} + +///////////// +// Control // +///////////// + +type GetControlAddressesReturn struct { + Owner addr.Address + Worker addr.Address +} + +func (a Actor) ControlAddresses(rt Runtime, _ *adt.EmptyValue) *GetControlAddressesReturn { + rt.ValidateImmediateCallerAcceptAny() + var st State + rt.State().Readonly(&st) + info := getMinerInfo(rt, &st) + return &GetControlAddressesReturn{ + Owner: info.Owner, + Worker: info.Worker, + } +} + +type ChangeWorkerAddressParams struct { + NewWorker addr.Address +} + +func (a Actor) ChangeWorkerAddress(rt Runtime, params *ChangeWorkerAddressParams) *adt.EmptyValue { + var effectiveEpoch abi.ChainEpoch + var st State + rt.State().Transaction(&st, func() interface{} { + info := getMinerInfo(rt, &st) + + rt.ValidateImmediateCallerIs(info.Owner) + + worker := resolveWorkerAddress(rt, params.NewWorker) + + effectiveEpoch = rt.CurrEpoch() + WorkerKeyChangeDelay + + // This may replace another pending key change. + info.PendingWorkerKey = &WorkerKeyChange{ + NewWorker: worker, + EffectiveAt: effectiveEpoch, + } + err := st.SaveInfo(adt.AsStore(rt), info) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not save miner info") + return nil + }) + + cronPayload := CronEventPayload{ + EventType: CronEventWorkerKeyChange, + } + enrollCronEvent(rt, effectiveEpoch, &cronPayload) + return nil +} + +type ChangePeerIDParams struct { + NewID abi.PeerID +} + +func (a Actor) ChangePeerID(rt Runtime, params *ChangePeerIDParams) *adt.EmptyValue { + var st State + rt.State().Transaction(&st, func() interface{} { + info := getMinerInfo(rt, &st) + + rt.ValidateImmediateCallerIs(info.Worker) + info.PeerId = params.NewID + err := st.SaveInfo(adt.AsStore(rt), info) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not save miner info") + return nil + }) + return nil +} + +type ChangeMultiaddrsParams struct { + NewMultiaddrs []abi.Multiaddrs +} + +func (a Actor) ChangeMultiaddrs(rt Runtime, params *ChangeMultiaddrsParams) *adt.EmptyValue { + var st State + rt.State().Transaction(&st, func() interface{} { + info := getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + info.Multiaddrs = params.NewMultiaddrs + err := st.SaveInfo(adt.AsStore(rt), info) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not save miner info") + return nil + }) + return nil +} + +////////////////// +// WindowedPoSt // +////////////////// + +// Information submitted by a miner to provide a Window PoSt. +type SubmitWindowedPoStParams struct { + // The deadline index which the submission targets. + Deadline uint64 + // The partition indices being proven. + // Partitions are counted across all deadlines, such that all partition indices in the second deadline are greater + // than the partition numbers in the first deadlines. + Partitions []uint64 + // Array of proofs, one per distinct registered proof type present in the sectors being proven. + // In the usual case of a single proof type, this array will always have a single element (independent of number of partitions). + Proofs []abi.PoStProof + // Sectors skipped while proving that weren't already declared faulty + Skipped abi.BitField +} + +// Invoked by miner's worker address to submit their fallback post +func (a Actor) SubmitWindowedPoSt(rt Runtime, params *SubmitWindowedPoStParams) *adt.EmptyValue { + currEpoch := rt.CurrEpoch() + store := adt.AsStore(rt) + var st State + var newFaultSectors []*SectorOnChainInfo + var recoveredSectors []*SectorOnChainInfo + penalty := abi.NewTokenAmount(0) + + // Get the total power/reward. We need these to compute penalties. + epochReward := requestCurrentEpochBlockReward(rt) + pwrTotal := requestCurrentTotalPower(rt) + + var info *MinerInfo + rt.State().Transaction(&st, func() interface{} { + info = getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + + // Validate that the miner didn't try to prove too many partitions at once. + partitionSize := info.WindowPoStPartitionSectors + submissionPartitionLimit := windowPoStMessagePartitionsMax(partitionSize) + if uint64(len(params.Partitions)) > submissionPartitionLimit { + rt.Abortf(exitcode.ErrIllegalArgument, "too many partitions %d, limit %d", len(params.Partitions), submissionPartitionLimit) + } + + // Load and check deadline. + currDeadline := st.DeadlineInfo(currEpoch) + deadlines, err := st.LoadDeadlines(adt.AsStore(rt)) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deadlines") + + // Double check that the current proving period has started. This should only happen if the cron actor wasn't invoked. + if !currDeadline.PeriodStarted() { + rt.Abortf(exitcode.ErrIllegalState, "proving period %d not yet open at %d", currDeadline.PeriodStart, currEpoch) + } + + // The miner may only submit a proof for the current deadline. + if params.Deadline != currDeadline.Index { + rt.Abortf(exitcode.ErrIllegalArgument, "invalid deadline %d at epoch %d, expected %d", + params.Deadline, currEpoch, currDeadline.Index) + } + + // Detect and mark faults from any missed deadlines (doesn't including the current deadline). + // Traverse earlier submissions and enact detected faults. + // This isn't strictly necessary, but keeps the power table up to date eagerly and can force payment + // of penalties if locked pledge drops too low. + detectedFaultSectors, detectedFaultPenalty := detectFaultsThisPeriod(rt, &st, store, currDeadline, deadlines, epochReward, pwrTotal.QualityAdjPower) + penalty = big.Add(penalty, detectedFaultPenalty) + newFaultSectors = append(newFaultSectors, detectedFaultSectors...) + + // Add skipped as faults + skippedFaultSectors, skippedPenalty := processSkippedFaults(rt, &st, store, currDeadline, info, deadlines, epochReward, pwrTotal.QualityAdjPower, ¶ms.Skipped) + penalty = big.Add(penalty, skippedPenalty) + newFaultSectors = append(newFaultSectors, skippedFaultSectors...) + + // Work out which sectors are due in the declared partitions at this deadline. + partitionsSectors, err := ComputePartitionsSectors(deadlines, partitionSize, currDeadline.Index, params.Partitions) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to compute partitions sectors at deadline %d, partitions %s", + currDeadline.Index, params.Partitions) + + provenSectors, err := bitfield.MultiMerge(partitionsSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to union %d partitions of sectors", len(partitionsSectors)) + + // Load sector infos, substituting a known-good sector for known-faulty sectors. + // NOTE: ErrIllegalState isn't quite correct. This can fail if the user submits a proof for a partition + // with only faulty sectors. Ideally we'd distinguish between the two cases, but that's tricky to do at the moment. + sectorInfos, declaredRecoveries, err := st.LoadSectorInfosForProof(store, provenSectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load proven sector info") + + // Skip verification if all sectors are faults + if len(sectorInfos) > 0 { + // Verify the proof. + // A failed verification doesn't immediately cause a penalty; the miner can try again. + verifyWindowedPost(rt, currDeadline.Challenge, sectorInfos, params.Proofs) + } + + // Record the successful submission + postedPartitions := bitfield.NewFromSet(params.Partitions) + contains, err := abi.BitFieldContainsAny(st.PostSubmissions, postedPartitions) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to intersect post partitions") + if contains { + rt.Abortf(exitcode.ErrIllegalArgument, "duplicate PoSt partition") + } + err = st.AddPoStSubmissions(postedPartitions) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to record submissions for partitions %s", params.Partitions) + + // If the PoSt was successful, restore declared recoveries. + err = st.RemoveFaults(store, declaredRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to remove recoveries from faults") + + err = st.RemoveRecoveries(declaredRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to remove recoveries") + + // Load info for recovered sectors for recovery of power outside this state transaction. + empty, err := declaredRecoveries.IsEmpty() + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check if bitfield was empty: %s") + + if !empty { + sectorsByNumber := make(map[abi.SectorNumber]*SectorOnChainInfo, len(sectorInfos)) + for _, s := range sectorInfos { + sectorsByNumber[s.SectorNumber] = s + } + + _ = declaredRecoveries.ForEach(func(i uint64) error { + recoveredSectors = append(recoveredSectors, sectorsByNumber[abi.SectorNumber(i)]) + return nil + }) + } + return nil + }) + + // Restore power for recovered sectors. Remove power for new faults. + requestUpdateSectorPower(rt, info.SectorSize, recoveredSectors, newFaultSectors) + // Burn penalties. + burnFundsAndNotifyPledgeChange(rt, penalty) + return nil +} + +/////////////////////// +// Sector Commitment // +/////////////////////// + +// Proposals must be posted on chain via sma.PublishStorageDeals before PreCommitSector. +// Optimization: PreCommitSector could contain a list of deals that are not published yet. +func (a Actor) PreCommitSector(rt Runtime, params *SectorPreCommitInfo) *adt.EmptyValue { + if params.Expiration <= rt.CurrEpoch() { + rt.Abortf(exitcode.ErrIllegalArgument, "sector expiration %v must be after now (%v)", params.Expiration, rt.CurrEpoch()) + } + if params.SealRandEpoch >= rt.CurrEpoch() { + rt.Abortf(exitcode.ErrIllegalArgument, "seal challenge epoch %v must be before now %v", params.SealRandEpoch, rt.CurrEpoch()) + } + challengeEarliest := sealChallengeEarliest(rt.CurrEpoch(), params.SealProof) + if params.SealRandEpoch < challengeEarliest { + // The subsequent commitment proof can't possibly be accepted because the seal challenge will be deemed + // too old. Note that passing this check doesn't guarantee the proof will be soon enough, depending on + // when it arrives. + rt.Abortf(exitcode.ErrIllegalArgument, "seal challenge epoch %v too old, must be after %v", params.SealRandEpoch, challengeEarliest) + } + if params.ReplaceCapacity && len(params.DealIDs) == 0 { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot replace sector without committing deals") + } + + // gather information from other actors + epochReward := requestCurrentEpochBlockReward(rt) + pwrTotal := requestCurrentTotalPower(rt) + dealWeight := requestDealWeight(rt, params.DealIDs, rt.CurrEpoch(), params.Expiration) + circulatingSupply := rt.TotalFilCircSupply() + + store := adt.AsStore(rt) + var st State + newlyVestedAmount := rt.State().Transaction(&st, func() interface{} { + info := getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + if params.SealProof != info.SealProofType { + rt.Abortf(exitcode.ErrIllegalArgument, "sector seal proof %v must match miner seal proof type %d", params.SealProof, info.SealProofType) + } + + _, preCommitFound, err := st.GetPrecommittedSector(store, params.SectorNumber) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check pre-commit %v", params.SectorNumber) + if preCommitFound { + rt.Abortf(exitcode.ErrIllegalArgument, "sector %v already pre-committed", params.SectorNumber) + } + + sectorFound, err := st.HasSectorNo(store, params.SectorNumber) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check sector %v", params.SectorNumber) + if sectorFound { + rt.Abortf(exitcode.ErrIllegalArgument, "sector %v already committed", params.SectorNumber) + } + + validateExpiration(rt, &st, rt.CurrEpoch(), params.Expiration, params.SealProof) + + depositMinimum := big.Zero() + if params.ReplaceCapacity { + replaceSector := validateReplaceSector(rt, &st, store, params) + // Note the replaced sector's initial pledge as a lower bound for the new sector's deposit + depositMinimum = replaceSector.InitialPledge + } + + newlyVestedFund, err := st.UnlockVestedFunds(store, rt.CurrEpoch()) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to vest funds") + availableBalance := st.GetAvailableBalance(rt.CurrentBalance()) + duration := params.Expiration - rt.CurrEpoch() + + sectorWeight := QAPowerForWeight(info.SectorSize, duration, dealWeight.DealWeight, dealWeight.VerifiedDealWeight) + depositReq := big.Max( + precommitDeposit(sectorWeight, pwrTotal.QualityAdjPower, pwrTotal.PledgeCollateral, epochReward, circulatingSupply), + depositMinimum, + ) + if availableBalance.LessThan(depositReq) { + rt.Abortf(exitcode.ErrInsufficientFunds, "insufficient funds for pre-commit deposit: %v", depositReq) + } + + st.AddPreCommitDeposit(depositReq) + st.AssertBalanceInvariants(rt.CurrentBalance()) + + if err := st.PutPrecommittedSector(store, &SectorPreCommitOnChainInfo{ + Info: *params, + PreCommitDeposit: depositReq, + PreCommitEpoch: rt.CurrEpoch(), + DealWeight: dealWeight.DealWeight, + VerifiedDealWeight: dealWeight.VerifiedDealWeight, + }); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to write pre-committed sector %v: %v", params.SectorNumber, err) + } + + return newlyVestedFund + }).(abi.TokenAmount) + + notifyPledgeChanged(rt, newlyVestedAmount.Neg()) + + bf := abi.NewBitField() + bf.Set(uint64(params.SectorNumber)) + + // Request deferred Cron check for PreCommit expiry check. + cronPayload := CronEventPayload{ + EventType: CronEventPreCommitExpiry, + Sectors: bf, + } + + msd, ok := MaxSealDuration[params.SealProof] + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "no max seal duration set for proof type: %d", params.SealProof) + } + + // The +1 here is critical for the batch verification of proofs. Without it, if a proof arrived exactly on the + // due epoch, ProveCommitSector would accept it, then the expiry event would remove it, and then + // ConfirmSectorProofsValid would fail to find it. + expiryBound := rt.CurrEpoch() + msd + 1 + enrollCronEvent(rt, expiryBound, &cronPayload) + + return nil +} + +type ProveCommitSectorParams struct { + SectorNumber abi.SectorNumber + Proof []byte +} + +// Checks state of the corresponding sector pre-commitment, then schedules the proof to be verified in bulk +// by the power actor. +// If valid, the power actor will call ConfirmSectorProofsValid at the end of the same epoch as this message. +func (a Actor) ProveCommitSector(rt Runtime, params *ProveCommitSectorParams) *adt.EmptyValue { + rt.ValidateImmediateCallerAcceptAny() + + store := adt.AsStore(rt) + var st State + rt.State().Readonly(&st) + + // Verify locked funds are are at least the sum of sector initial pledges. + // Note that this call does not actually compute recent vesting, so the reported locked funds may be + // slightly higher than the true amount (i.e. slightly in the miner's favour). + // Computing vesting here would be almost always redundant since vesting is quantized to ~daily units. + // Vesting will be at most one proving period old if computed in the cron callback. + verifyPledgeMeetsInitialRequirements(rt, &st) + + sectorNo := params.SectorNumber + precommit, found, err := st.GetPrecommittedSector(store, sectorNo) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load pre-committed sector %v", sectorNo) + if !found { + rt.Abortf(exitcode.ErrNotFound, "no pre-committed sector %v", sectorNo) + } + + msd, ok := MaxSealDuration[precommit.Info.SealProof] + if !ok { + rt.Abortf(exitcode.ErrIllegalState, "no max seal duration for proof type: %d", precommit.Info.SealProof) + } + proveCommitDue := precommit.PreCommitEpoch + msd + if rt.CurrEpoch() > proveCommitDue { + rt.Abortf(exitcode.ErrIllegalArgument, "commitment proof for %d too late at %d, due %d", sectorNo, rt.CurrEpoch(), proveCommitDue) + } + + svi := getVerifyInfo(rt, &SealVerifyStuff{ + SealedCID: precommit.Info.SealedCID, + InteractiveEpoch: precommit.PreCommitEpoch + PreCommitChallengeDelay, + SealRandEpoch: precommit.Info.SealRandEpoch, + Proof: params.Proof, + DealIDs: precommit.Info.DealIDs, + SectorNumber: precommit.Info.SectorNumber, + RegisteredSealProof: precommit.Info.SealProof, + }) + + _, code := rt.Send( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.SubmitPoRepForBulkVerify, + svi, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to submit proof for bulk verification") + return nil +} + +func (a Actor) ConfirmSectorProofsValid(rt Runtime, params *builtin.ConfirmSectorProofsParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.StoragePowerActorAddr) + + var st State + rt.State().Readonly(&st) + store := adt.AsStore(rt) + info := getMinerInfo(rt, &st) + // Committed-capacity sectors licensed for early removal by new sectors being proven. + var replaceSectors []*SectorOnChainInfo + replaceSectorKeys := map[abi.SectorNumber]struct{}{} // For de-duplication + var preCommits []*SectorPreCommitOnChainInfo + for _, sectorNo := range params.Sectors { + precommit, found, err := st.GetPrecommittedSector(store, sectorNo) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load pre-committed sector %v", sectorNo) + if !found || err != nil { + // This relies on the precommit having been checked in ProveCommitSector and not removed (expired) before + // this call. This in turn relies on the call from the power actor reliably coming in the same + // epoch as ProveCommitSector. + + // TODO #564 log: "failed to get precommitted sector on sector %d, dropping from prove commit set" + continue + } + + if precommit.Info.ReplaceCapacity { + replaceSector := precommit.Info.ReplaceSector + info, exists, err := st.GetSector(store, replaceSector) + if err != nil { + // TODO #564 log "failed to check sector %d, dropping from prove commit set" + continue + } + faulty, err := st.Faults.IsSet(uint64(replaceSector)) + if err != nil { + // TODO #564 log "failed to check sector %d fault state, dropping from prove commit set" + continue + } + _, set := replaceSectorKeys[replaceSector] + // It doesn't matter if the committed-capacity sector no longer exists, or if multiple sectors attempt to + // replace the same committed-capacity sector, so long as we don't try to terminate it more than once. + // It just represents a lost opportunity to terminate a committed sector early. + // Similarly, if faulty, allow the new sector commitment to proceed but just decline to terminate the + // committed-capacity one. + if exists && !set && !faulty { + replaceSectorKeys[replaceSector] = struct{}{} + replaceSectors = append(replaceSectors, info) + } + } + + // Check (and activate) storage deals associated to sector. Abort if checks failed. + // TODO: we should batch these calls... + // https://github.com/filecoin-project/specs-actors/issues/474 + _, code := rt.Send( + builtin.StorageMarketActorAddr, + builtin.MethodsMarket.ActivateDeals, + &market.ActivateDealsParams{ + DealIDs: precommit.Info.DealIDs, + SectorExpiry: precommit.Info.Expiration, + }, + abi.NewTokenAmount(0), + ) + if code != exitcode.Ok { + // TODO #564 log: "failed to activate deals on sector %d, dropping from prove commit set" + continue + } + + preCommits = append(preCommits, precommit) + } + + // When all prove commits have failed abort early + if len(preCommits) == 0 { + rt.Abortf(exitcode.ErrIllegalArgument, "all prove commits failed to validate") + } + + // This transaction should replace the one inside the loop above. + // Migrate state mutations into here. + totalPledge := big.Zero() + newSectors := make([]*SectorOnChainInfo, 0) + newlyVestedAmount := rt.State().Transaction(&st, func() interface{} { + err := scheduleReplaceSectorsExpiration(rt, &st, store, replaceSectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to replace sector expirations") + + newSectorNos := make([]abi.SectorNumber, 0, len(preCommits)) + for _, precommit := range preCommits { + // initial pledge is precommit deposit + initialPledge := precommit.PreCommitDeposit + totalPledge = big.Add(totalPledge, initialPledge) + newSectorInfo := SectorOnChainInfo{ + SectorNumber: precommit.Info.SectorNumber, + SealProof: precommit.Info.SealProof, + SealedCID: precommit.Info.SealedCID, + DealIDs: precommit.Info.DealIDs, + Expiration: precommit.Info.Expiration, + Activation: precommit.PreCommitEpoch, + DealWeight: precommit.DealWeight, + VerifiedDealWeight: precommit.VerifiedDealWeight, + InitialPledge: initialPledge, + } + newSectors = append(newSectors, &newSectorInfo) + newSectorNos = append(newSectorNos, newSectorInfo.SectorNumber) + } + + err = st.PutSectors(store, newSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to put new sectors") + + err = st.DeletePrecommittedSectors(store, newSectorNos...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to delete precommited sectors") + + err = st.AddSectorExpirations(store, newSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to add new sector expirations") + + err = st.AddNewSectors(newSectorNos...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to add new sectors to new sectors bitfield") + + // Add sector and pledge lock-up to miner state + newlyVestedFund, err := st.UnlockVestedFunds(store, rt.CurrEpoch()) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to vest new funds: %s", err) + } + + // Unlock deposit for successful proofs, make it available for lock-up as initial pledge. + st.AddPreCommitDeposit(totalPledge.Neg()) + st.AddInitialPledgeRequirement(totalPledge) + + // Lock up initial pledge for new sectors. + availableBalance := st.GetAvailableBalance(rt.CurrentBalance()) + if availableBalance.LessThan(totalPledge) { + rt.Abortf(exitcode.ErrInsufficientFunds, "insufficient funds for aggregate initial pledge requirement %s, available: %s", totalPledge, availableBalance) + } + if err := st.AddLockedFunds(store, rt.CurrEpoch(), totalPledge, &PledgeVestingSpec); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to add aggregate pledge: %v", err) + } + st.AssertBalanceInvariants(rt.CurrentBalance()) + + return newlyVestedFund + }).(abi.TokenAmount) + + // Request power and pledge update for activated sector. + requestUpdateSectorPower(rt, info.SectorSize, newSectors, nil) + notifyPledgeChanged(rt, big.Sub(totalPledge, newlyVestedAmount)) + + return nil +} + +type CheckSectorProvenParams struct { + SectorNumber abi.SectorNumber +} + +func (a Actor) CheckSectorProven(rt Runtime, params *CheckSectorProvenParams) *adt.EmptyValue { + rt.ValidateImmediateCallerAcceptAny() + + var st State + rt.State().Readonly(&st) + store := adt.AsStore(rt) + sectorNo := params.SectorNumber + + if _, found, err := st.GetSector(store, sectorNo); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to load proven sector %v", sectorNo) + } else if !found { + rt.Abortf(exitcode.ErrNotFound, "sector %v not proven", sectorNo) + } + return nil +} + +///////////////////////// +// Sector Modification // +///////////////////////// + +type ExtendSectorExpirationParams struct { + SectorNumber abi.SectorNumber + NewExpiration abi.ChainEpoch +} + +func (a Actor) ExtendSectorExpiration(rt Runtime, params *ExtendSectorExpirationParams) *adt.EmptyValue { + var st State + rt.State().Readonly(&st) + info := getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + + store := adt.AsStore(rt) + sectorNo := params.SectorNumber + oldSector, found, err := st.GetSector(store, sectorNo) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load sector %v", sectorNo) + if !found { + rt.Abortf(exitcode.ErrNotFound, "no such sector %v", sectorNo) + } + if params.NewExpiration < oldSector.Expiration { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot reduce sector expiration to %d from %d", + params.NewExpiration, oldSector.Expiration) + } + + validateExpiration(rt, &st, oldSector.Activation, params.NewExpiration, oldSector.SealProof) + + newSector := *oldSector + newSector.Expiration = params.NewExpiration + qaPowerDelta := big.Sub(QAPowerForSector(info.SectorSize, &newSector), QAPowerForSector(info.SectorSize, oldSector)) + + _, code := rt.Send( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.UpdateClaimedPower, + &power.UpdateClaimedPowerParams{ + RawByteDelta: big.Zero(), // Sector size has not changed + QualityAdjustedDelta: qaPowerDelta, + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to modify sector weight") + + // Store new sector expiry. + rt.State().Transaction(&st, func() interface{} { + err = st.PutSectors(store, &newSector) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to update sector %v", sectorNo) + + // move expiration from old epoch to new + err = st.RemoveSectorExpirations(store, oldSector) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to remove sector expiration %v at %d", sectorNo, oldSector.Expiration) + err = st.AddSectorExpirations(store, &newSector) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to add sector expiration %v at %d", sectorNo, newSector.Expiration) + return nil + }) + return nil +} + +type TerminateSectorsParams struct { + Sectors *abi.BitField +} + +func (a Actor) TerminateSectors(rt Runtime, params *TerminateSectorsParams) *adt.EmptyValue { + var st State + rt.State().Readonly(&st) + info := getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + + epochReward := requestCurrentEpochBlockReward(rt) + pwrTotal := requestCurrentTotalPower(rt) + // Note: this cannot terminate pre-committed but un-proven sectors. + // They must be allowed to expire (and deposit burnt). + terminateSectors(rt, params.Sectors, power.SectorTerminationManual, epochReward, pwrTotal.QualityAdjPower) + return nil +} + +//////////// +// Faults // +//////////// + +type DeclareFaultsParams struct { + Faults []FaultDeclaration +} + +type FaultDeclaration struct { + Deadline uint64 // In range [0..WPoStPeriodDeadlines) + Sectors *abi.BitField +} + +func (a Actor) DeclareFaults(rt Runtime, params *DeclareFaultsParams) *adt.EmptyValue { + if uint64(len(params.Faults)) > WPoStPeriodDeadlines { + rt.Abortf(exitcode.ErrIllegalArgument, "too many declarations %d, max %d", len(params.Faults), WPoStPeriodDeadlines) + } + + currEpoch := rt.CurrEpoch() + store := adt.AsStore(rt) + var st State + var declaredFaultSectors []*SectorOnChainInfo + var detectedFaultSectors []*SectorOnChainInfo + penalty := abi.NewTokenAmount(0) + + epochReward := requestCurrentEpochBlockReward(rt) + pwrTotal := requestCurrentTotalPower(rt) + + var info *MinerInfo + rt.State().Transaction(&st, func() interface{} { + info = getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + + currDeadline := st.DeadlineInfo(currEpoch) + deadlines, err := st.LoadDeadlines(adt.AsStore(rt)) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deadlines") + + // Traverse earlier submissions and enact detected faults. + // This is necessary to move the NextDeadlineToProcessFaults index past the deadline that this recovery + // is targeting, so that the recovery won't be declared failed next time it's checked during this proving period. + detectedFaultSectors, penalty = detectFaultsThisPeriod(rt, &st, store, currDeadline, deadlines, epochReward, pwrTotal.QualityAdjPower) + + var decaredSectors []*abi.BitField + for _, decl := range params.Faults { + targetDeadline, err := declarationDeadlineInfo(st.ProvingPeriodStart, decl.Deadline, currEpoch) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "invalid fault declaration deadline") + + err = validateFRDeclaration(deadlines, targetDeadline, decl.Sectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "invalid fault declaration") + decaredSectors = append(decaredSectors, decl.Sectors) + } + + allDeclared, err := bitfield.MultiMerge(decaredSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to union faults") + + // Split declarations into declarations of new faults, and retraction of declared recoveries. + retractedRecoveries, err := bitfield.IntersectBitField(st.Recoveries, allDeclared) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to intersect sectors with recoveries") + + newFaults, err := bitfield.SubtractBitField(allDeclared, retractedRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to subtract recoveries from sectors") + + empty, err := newFaults.IsEmpty() + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check if bitfield was empty") + + if !empty { + // Check new fault are really new. + contains, err := abi.BitFieldContainsAny(st.Faults, newFaults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to intersect existing faults") + if contains { + // This could happen if attempting to declare a fault for a deadline that's already passed, + // detected and added to Faults above. + // The miner must for the fault detection at proving period end, or submit again omitting + // sectors in deadlines that have passed. + // Alternatively, we could subtract the just-detected faults from new faults. + rt.Abortf(exitcode.ErrIllegalArgument, "attempted to re-declare fault") + } + + // Add new faults to state and charge fee. + // Note: this sets the fault epoch for all declarations to be the beginning of this proving period, + // even if some sectors have already been proven in this period. + // It would better to use the target deadline's proving period start (which may be the one subsequent + // to the current). + err = st.AddFaults(store, newFaults, st.ProvingPeriodStart) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to add faults") + + // Note: this charges a fee for all declarations, even if the sectors have already been proven + // in this proving period. This discourages early declaration compared with waiting for + // the proving period to roll over. + // It would be better to charge a fee for this proving period only if the target deadline has + // not already passed. If it _has_ already passed then either: + // - the miner submitted PoSt successfully and should not be penalised more relative to + // submitting this declaration after the proving period rolls over, or + // - the miner failed to submit PoSt and will be penalised at the proving period end + // In either case, the miner will pay a fee for the subsequent proving period at the start + // of that period, unless faults are recovered sooner. + + // Load info for sectors. + declaredFaultSectors, err = st.LoadSectorInfos(store, newFaults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load fault sectors") + + // Unlock penalty for declared faults. + declaredPenalty, err := unlockDeclaredFaultPenalty(&st, store, info.SectorSize, currEpoch, epochReward, pwrTotal.QualityAdjPower, declaredFaultSectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to charge fault fee") + penalty = big.Add(penalty, declaredPenalty) + } + + // Remove faulty recoveries + empty, err = retractedRecoveries.IsEmpty() + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check if bitfield was empty") + + if !empty { + err = st.RemoveRecoveries(retractedRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to remove recoveries") + } + return nil + }) + + // Remove power for new faulty sectors. + requestUpdateSectorPower(rt, info.SectorSize, nil, append(detectedFaultSectors, declaredFaultSectors...)) + burnFundsAndNotifyPledgeChange(rt, penalty) + + return nil +} + +type DeclareFaultsRecoveredParams struct { + Recoveries []RecoveryDeclaration +} + +type RecoveryDeclaration struct { + Deadline uint64 // In range [0..WPoStPeriodDeadlines) + Sectors *abi.BitField +} + +func (a Actor) DeclareFaultsRecovered(rt Runtime, params *DeclareFaultsRecoveredParams) *adt.EmptyValue { + if uint64(len(params.Recoveries)) > WPoStPeriodDeadlines { + rt.Abortf(exitcode.ErrIllegalArgument, "too many declarations %d, max %d", len(params.Recoveries), WPoStPeriodDeadlines) + } + + var detectedFaultSectors []*SectorOnChainInfo + penalty := abi.NewTokenAmount(0) + + epochReward := requestCurrentEpochBlockReward(rt) + pwrTotal := requestCurrentTotalPower(rt) + + currEpoch := rt.CurrEpoch() + store := adt.AsStore(rt) + var st State + var info *MinerInfo + rt.State().Transaction(&st, func() interface{} { + info = getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker) + + currDeadline := st.DeadlineInfo(currEpoch) + deadlines, err := st.LoadDeadlines(adt.AsStore(rt)) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deadlines") + + // Traverse earlier submissions and enact detected faults. + // This is necessary to move the NextDeadlineToProcessFaults index past the deadline that this recovery + // is targeting, so that the recovery won't be declared failed next time it's checked during this proving period. + detectedFaultSectors, penalty = detectFaultsThisPeriod(rt, &st, store, currDeadline, deadlines, epochReward, pwrTotal.QualityAdjPower) + + var declaredSectors []*abi.BitField + for _, decl := range params.Recoveries { + targetDeadline, err := declarationDeadlineInfo(st.ProvingPeriodStart, decl.Deadline, currEpoch) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "invalid recovery declaration deadline") + + err = validateFRDeclaration(deadlines, targetDeadline, decl.Sectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "invalid recovery declaration") + declaredSectors = append(declaredSectors, decl.Sectors) + } + + allRecoveries, err := bitfield.MultiMerge(declaredSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to union recoveries") + + contains, err := abi.BitFieldContainsAll(st.Faults, allRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check recoveries are faulty") + if !contains { + rt.Abortf(exitcode.ErrIllegalArgument, "declared recoveries not currently faulty") + } + contains, err = abi.BitFieldContainsAny(st.Recoveries, allRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to intersect new recoveries") + if contains { + rt.Abortf(exitcode.ErrIllegalArgument, "sector already declared recovered") + } + + err = st.AddRecoveries(allRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "invalid recoveries") + return nil + }) + + // Remove power for new faulty sectors. + requestUpdateSectorPower(rt, info.SectorSize, nil, detectedFaultSectors) + burnFundsAndNotifyPledgeChange(rt, penalty) + + // Power is not restored yet, but when the recovered sectors are successfully PoSted. + return nil +} + +/////////////////////// +// Pledge Collateral // +/////////////////////// + +// Locks up some amount of a the miner's unlocked balance (including any received alongside the invoking message). +func (a Actor) AddLockedFund(rt Runtime, amountToLock *abi.TokenAmount) *adt.EmptyValue { + store := adt.AsStore(rt) + var st State + newlyVested := rt.State().Transaction(&st, func() interface{} { + info := getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Worker, info.Owner, builtin.RewardActorAddr) + + newlyVestedFund, err := st.UnlockVestedFunds(store, rt.CurrEpoch()) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to vest funds") + + availableBalance := st.GetAvailableBalance(rt.CurrentBalance()) + if availableBalance.LessThan(*amountToLock) { + rt.Abortf(exitcode.ErrInsufficientFunds, "insufficient funds to lock, available: %v, requested: %v", availableBalance, *amountToLock) + } + + if err := st.AddLockedFunds(store, rt.CurrEpoch(), *amountToLock, &PledgeVestingSpec); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to lock pledge: %v", err) + } + return newlyVestedFund + }).(abi.TokenAmount) + + notifyPledgeChanged(rt, big.Sub(*amountToLock, newlyVested)) + return nil +} + +type ReportConsensusFaultParams struct { + BlockHeader1 []byte + BlockHeader2 []byte + BlockHeaderExtra []byte +} + +func (a Actor) ReportConsensusFault(rt Runtime, params *ReportConsensusFaultParams) *adt.EmptyValue { + // Note: only the first reporter of any fault is rewarded. + // Subsequent invocations fail because the target miner has been removed. + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + reporter := rt.Message().Caller() + + fault, err := rt.Syscalls().VerifyConsensusFault(params.BlockHeader1, params.BlockHeader2, params.BlockHeaderExtra) + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "fault not verified: %s", err) + } + + // Elapsed since the fault (i.e. since the higher of the two blocks) + faultAge := rt.CurrEpoch() - fault.Epoch + if faultAge <= 0 { + rt.Abortf(exitcode.ErrIllegalArgument, "invalid fault epoch %v ahead of current %v", fault.Epoch, rt.CurrEpoch()) + } + + // Reward reporter with a share of the miner's current balance. + slasherReward := RewardForConsensusSlashReport(faultAge, rt.CurrentBalance()) + _, code := rt.Send(reporter, builtin.MethodSend, nil, slasherReward) + builtin.RequireSuccess(rt, code, "failed to reward reporter") + + var st State + rt.State().Readonly(&st) + + // Notify power actor with lock-up total being removed. + _, code = rt.Send( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.OnConsensusFault, + &st.LockedFunds, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to notify power actor on consensus fault") + + // close deals and burn funds + terminateMiner(rt) + + return nil +} + +type WithdrawBalanceParams struct { + AmountRequested abi.TokenAmount +} + +func (a Actor) WithdrawBalance(rt Runtime, params *WithdrawBalanceParams) *adt.EmptyValue { + var st State + if params.AmountRequested.LessThan(big.Zero()) { + rt.Abortf(exitcode.ErrIllegalArgument, "negative fund requested for withdrawal: %s", params.AmountRequested) + } + var info *MinerInfo + newlyVestedAmount := rt.State().Transaction(&st, func() interface{} { + info = getMinerInfo(rt, &st) + rt.ValidateImmediateCallerIs(info.Owner) + newlyVestedFund, err := st.UnlockVestedFunds(adt.AsStore(rt), rt.CurrEpoch()) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to vest fund: %v", err) + } + + // Verify locked funds are are at least the sum of sector initial pledges after vesting. + verifyPledgeMeetsInitialRequirements(rt, &st) + + return newlyVestedFund + }).(abi.TokenAmount) + + currBalance := rt.CurrentBalance() + amountWithdrawn := big.Min(st.GetAvailableBalance(currBalance), params.AmountRequested) + Assert(amountWithdrawn.LessThanEqual(currBalance)) + + _, code := rt.Send(info.Owner, builtin.MethodSend, nil, amountWithdrawn) + builtin.RequireSuccess(rt, code, "failed to withdraw balance") + + pledgeDelta := newlyVestedAmount.Neg() + notifyPledgeChanged(rt, pledgeDelta) + + st.AssertBalanceInvariants(rt.CurrentBalance()) + return nil +} + +////////// +// Cron // +////////// + +func (a Actor) OnDeferredCronEvent(rt Runtime, payload *CronEventPayload) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.StoragePowerActorAddr) + + switch payload.EventType { + case CronEventProvingPeriod: + handleProvingPeriod(rt) + case CronEventPreCommitExpiry: + if payload.Sectors != nil { + checkPrecommitExpiry(rt, payload.Sectors) + } + case CronEventWorkerKeyChange: + commitWorkerKeyChange(rt) + } + + return nil +} + +//////////////////////////////////////////////////////////////////////////////// +// Utility functions & helpers +//////////////////////////////////////////////////////////////////////////////// + +// Invoked at the end of each proving period, at the end of the epoch before the next one starts. +func handleProvingPeriod(rt Runtime) { + store := adt.AsStore(rt) + + epochReward := requestCurrentEpochBlockReward(rt) + pwrTotal := requestCurrentTotalPower(rt) + + var st State + { + // Vest locked funds. + // This happens first so that any subsequent penalties are taken from locked pledge, rather than free funds. + newlyVestedAmount := rt.State().Transaction(&st, func() interface{} { + newlyVestedFund, err := st.UnlockVestedFunds(store, rt.CurrEpoch()) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to vest funds") + return newlyVestedFund + }).(abi.TokenAmount) + + notifyPledgeChanged(rt, newlyVestedAmount.Neg()) + } + + // Note: because the cron actor is not invoked on epochs with empty tipsets, the current epoch is not necessarily + // exactly the final epoch of the period; it may be slightly later (i.e. in the subsequent period). + // Further, this method is invoked once *before* the first proving period starts, after the actor is first + // constructed; this is detected by !deadline.PeriodStarted(). + // Use deadline.PeriodEnd() rather than rt.CurrEpoch unless certain of the desired semantics. + deadline := NewDeadlineInfo(0, 0, 0) + var info *MinerInfo + { + // Detect and penalize missing proofs. + var detectedFaultSectors []*SectorOnChainInfo + currEpoch := rt.CurrEpoch() + penalty := abi.NewTokenAmount(0) + rt.State().Transaction(&st, func() interface{} { + info = getMinerInfo(rt, &st) + deadline = st.DeadlineInfo(currEpoch) + if deadline.PeriodStarted() { // Skip checking faults on the first, incomplete period. + deadlines, err := st.LoadDeadlines(store) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deadlines") + detectedFaultSectors, penalty = processMissingPoStFaults(rt, &st, store, deadlines, + deadline.PeriodStart, WPoStPeriodDeadlines, deadline.PeriodEnd(), epochReward, + pwrTotal.QualityAdjPower) + } + return nil + }) + + // Remove power for new faults, and burn penalties. + requestUpdateSectorPower(rt, info.SectorSize, nil, detectedFaultSectors) + burnFundsAndNotifyPledgeChange(rt, penalty) + } + + { + // Expire sectors that are due. + expiredSectors := abi.NewBitField() + rt.State().Transaction(&st, func() interface{} { + var err error + expiredSectors, err = popSectorExpirations(&st, store, deadline.PeriodEnd()) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load expired sectors") + return nil + }) + + // Terminate expired sectors (sends messages to power and market actors). + terminateSectors(rt, expiredSectors, power.SectorTerminationExpired, epochReward, pwrTotal.QualityAdjPower) + } + + { + // Terminate sectors with faults that are too old, and pay fees for ongoing faults. + expiredFaults := abi.NewBitField() + ongoingFaults := abi.NewBitField() + ongoingFaultPenalty := abi.NewTokenAmount(0) + rt.State().Transaction(&st, func() interface{} { + var err error + expiredFaults, ongoingFaults, err = popExpiredFaults(&st, store, deadline.PeriodEnd()-FaultMaxAge) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load fault epochs") + + // Load info for ongoing faults. + // TODO: this is potentially super expensive for a large miner with ongoing faults + // https://github.com/filecoin-project/specs-actors/issues/411 + ongoingFaultInfos, err := st.LoadSectorInfos(store, ongoingFaults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load fault sectors") + + // Unlock penalty for ongoing faults. + ongoingFaultPenalty, err = unlockDeclaredFaultPenalty(&st, store, info.SectorSize, deadline.PeriodEnd(), epochReward, pwrTotal.QualityAdjPower, ongoingFaultInfos) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to charge fault fee") + return nil + }) + + terminateSectors(rt, expiredFaults, power.SectorTerminationFaulty, epochReward, pwrTotal.QualityAdjPower) + burnFundsAndNotifyPledgeChange(rt, ongoingFaultPenalty) + } + + { + // Establish new proving sets and clear proofs. + rt.State().Transaction(&st, func() interface{} { + deadlines, err := st.LoadDeadlines(store) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deadlines") + + // Assign new sectors to deadlines. + newSectors, err := st.NewSectors.All(NewSectorsPerPeriodMax) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to expand new sectors") + + if len(newSectors) > 0 { + //if period end is not in the future, get randomness from previous epoch + randomnessEpoch := minEpoch(deadline.PeriodEnd(), rt.CurrEpoch()-ElectionLookback) + assignmentSeed := rt.GetRandomness(crypto.DomainSeparationTag_WindowedPoStDeadlineAssignment, randomnessEpoch, nil) + err = AssignNewSectors(deadlines, info.WindowPoStPartitionSectors, newSectors, assignmentSeed) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to assign new sectors to deadlines") + + // Store updated deadline state. + err = st.SaveDeadlines(store, deadlines) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to store new deadlines") + + st.NewSectors = abi.NewBitField() + } + + // Reset PoSt submissions for next period. + err = st.ClearPoStSubmissions() + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to clear PoSt submissions") + + // Set new proving period start. + if deadline.PeriodStarted() { + st.ProvingPeriodStart = st.ProvingPeriodStart + WPoStProvingPeriod + } + return nil + }) + } + + // Schedule cron callback for next period + nextPeriodEnd := st.ProvingPeriodStart + WPoStProvingPeriod - 1 + enrollCronEvent(rt, nextPeriodEnd, &CronEventPayload{ + EventType: CronEventProvingPeriod, + }) +} + +// Detects faults from PoSt submissions that have not arrived in schedule earlier in the current proving period. +func detectFaultsThisPeriod(rt Runtime, st *State, store adt.Store, currDeadline *DeadlineInfo, deadlines *Deadlines, epochReward abi.TokenAmount, currentTotalPower abi.StoragePower) ([]*SectorOnChainInfo, abi.TokenAmount) { + if currDeadline.PeriodElapsed() { + // A cron event has not yet processed the previous proving period and established the next one. + // This is possible in the first non-empty epoch of a proving period if there was an empty tipset on the + // last epoch of the previous period. + // The period must be reset before processing missing-post faults. + rt.Abortf(exitcode.ErrIllegalState, "proving period at %d elapsed, next one not yet opened", currDeadline.PeriodStart) + } + return processMissingPoStFaults(rt, st, store, deadlines, currDeadline.PeriodStart, currDeadline.Index, currDeadline.CurrentEpoch, epochReward, currentTotalPower) +} + +// Discovers how skipped faults declared during post intersect with existing faults and recoveries, then unlocks funds +// and returns the penalty to be paid and the sector infos needed to deduct power. +// - Skipped faults that are not in the current deadline will trigger an error. +// - Skipped faults that have previously been marked recovered, will be penalized as a retracted recovery but will not +// result in a change in power (the power has already been removed). +// - Skipped faults that are already declared, but not recovered will be ignored. +// - The rest will be penalized as undeclared faults and have their power removed. +func processSkippedFaults(rt Runtime, st *State, store adt.Store, currDeadline *DeadlineInfo, minerInfo *MinerInfo, deadlines *Deadlines, epochReward abi.TokenAmount, currentTotalPower abi.StoragePower, skipped *bitfield.BitField) ([]*SectorOnChainInfo, abi.TokenAmount) { + empty, err := skipped.IsEmpty() + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalArgument, "failed to check if skipped sectors is empty") + if empty { + return nil, abi.NewTokenAmount(0) + } + + currEpoch := rt.CurrEpoch() + var newFaultSectors []*SectorOnChainInfo + + // Check that the declared sectors are actually due at the deadline. + deadlineSectors := deadlines.Due[currDeadline.Index] + contains, err := abi.BitFieldContainsAll(deadlineSectors, skipped) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not check if skipped faults are in deadline") + if !contains { + rt.Abortf(exitcode.ErrIllegalArgument, "skipped faults contains sectors not due in deadline %d", currDeadline.Index) + } + + // Find all skipped faults that have been labeled recovered + retractedRecoveries, err := bitfield.IntersectBitField(st.Recoveries, skipped) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to intersect sectors with recoveries") + + // Ignore skipped faults that are already faults + newFaults, err := bitfield.SubtractBitField(skipped, st.Faults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to subtract existing faults from skipped") + + // Add Faults + err = st.AddFaults(store, newFaults, currDeadline.PeriodStart) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to add skipped faults") + + // Remove faulty recoveries + err = st.RemoveRecoveries(retractedRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to remove recoveries") + + // Load info for sectors. + newFaultSectors, err = st.LoadSectorInfos(store, newFaults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load fault sectors") + + // load info for retractions + retractedRecoveryInfos, err := st.LoadSectorInfos(store, retractedRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load retracted recovery secrtors") + + // Penalize new skipped faults and retracted recoveries + // This differs from declaring faults "on time", where retracting recoveries doesn't attract an extra penalty + penalizeFaultSectors := append(newFaultSectors, retractedRecoveryInfos...) + penalty, err := unlockUndeclaredFaultPenalty(st, store, minerInfo.SectorSize, currEpoch, epochReward, currentTotalPower, penalizeFaultSectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to charge fault fee") + + // Return only new faulty sectors (excluding retracted recoveries) for power updates + return newFaultSectors, penalty +} + +// Detects faults from missing PoSt submissions that did not arrive by some deadline, and moves +// the NextDeadlineToProcessFaults index up to that deadline. +func processMissingPoStFaults(rt Runtime, st *State, store adt.Store, deadlines *Deadlines, periodStart abi.ChainEpoch, beforeDeadline uint64, currEpoch abi.ChainEpoch, epochReward abi.TokenAmount, currentTotalPower abi.StoragePower) ([]*SectorOnChainInfo, abi.TokenAmount) { + // This method must be called to process the end of one proving period before moving on to the process something + // the next. Usually, sinceDeadline would be <= beforeDeadline since the former is updated to match the latter + // and the call during proving period cron will set NextDeadlineToProcessFaults back to zero. + // In the odd case where the proving period's penultimate tipset is empty, this method must be invoked by the cron + // callback before allowing any fault/recovery declaration or PoSt to do partial processing. + AssertMsg(st.NextDeadlineToProcessFaults <= beforeDeadline, "invalid next-deadline %d after before-deadline %d while detecting faults", + st.NextDeadlineToProcessFaults, beforeDeadline) + + info := getMinerInfo(rt, st) + detectedFaults, failedRecoveries, err := computeFaultsFromMissingPoSts(info.WindowPoStPartitionSectors, st.Faults, st.Recoveries, st.PostSubmissions, deadlines, st.NextDeadlineToProcessFaults, beforeDeadline) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to compute detected faults") + st.NextDeadlineToProcessFaults = beforeDeadline % WPoStPeriodDeadlines + + err = st.AddFaults(store, detectedFaults, periodStart) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to record new faults") + + err = st.RemoveRecoveries(failedRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to record failed recoveries") + + // Load info for sectors. + // TODO: this is potentially super expensive for a large miner failing to submit proofs. + // https://github.com/filecoin-project/specs-actors/issues/411 + detectedFaultSectors, err := st.LoadSectorInfos(store, detectedFaults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load fault sectors") + failedRecoverySectors, err := st.LoadSectorInfos(store, failedRecoveries) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load failed recovery sectors") + + // Unlock sector penalty for all undeclared faults. + latePenalizedSectors := append(detectedFaultSectors, failedRecoverySectors...) + penalty, err := unlockUndeclaredLateFaultPenalty(st, store, info.SectorSize, currEpoch, epochReward, currentTotalPower, latePenalizedSectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to charge sector penalty") + + return detectedFaultSectors, penalty +} + +// Computes the sectors that were expected to be present in partitions of a PoSt submission but were not, in the +// deadlines from sinceDeadline (inclusive) to beforeDeadline (exclusive). +func computeFaultsFromMissingPoSts(partitionSize uint64, faults, recoveries, postSubmissions *abi.BitField, deadlines *Deadlines, sinceDeadline, beforeDeadline uint64) (detectedFaults, failedRecoveries *abi.BitField, err error) { + // TODO: Iterating this bitfield and keeping track of what partitions we're expecting could remove the + // need to expand this into a potentially-giant map. But it's tricksy. + // https://github.com/filecoin-project/specs-actors/issues/477 + submissions, err := postSubmissions.AllMap(activePartitionsMax(partitionSize)) + if err != nil { + return nil, nil, fmt.Errorf("failed to expand submissions: %w", err) + } + + deadlineFirstPartition := uint64(0) + var fGroups, rGroups []*abi.BitField + for dlIdx := uint64(0); dlIdx < beforeDeadline; dlIdx++ { + dlPartCount, dlSectorCount, err := DeadlineCount(deadlines, partitionSize, dlIdx) + if err != nil { + return nil, nil, fmt.Errorf("failed to count deadline %d partitions: %w", dlIdx, err) + } + if dlIdx < sinceDeadline { + deadlineFirstPartition += dlPartCount + continue + } + deadlineSectors := deadlines.Due[dlIdx] + for dlPartIdx := uint64(0); dlPartIdx < dlPartCount; dlPartIdx++ { + if !submissions[deadlineFirstPartition+dlPartIdx] { + // No PoSt received in prior period. + partFirstSectorIdx := dlPartIdx * partitionSize + partSectorCount := min64(partitionSize, dlSectorCount-partFirstSectorIdx) + + partitionSectors, err := deadlineSectors.Slice(partFirstSectorIdx, partSectorCount) + if err != nil { + return nil, nil, fmt.Errorf("failed to slice deadline %d partition %d sectors %d..%d: %w", + dlIdx, dlPartIdx, partFirstSectorIdx, partFirstSectorIdx+dlPartCount, err) + } + + // Record newly-faulty sectors. + newFaults, err := bitfield.SubtractBitField(partitionSectors, faults) + if err != nil { + return nil, nil, fmt.Errorf("bitfield subtract failed: %s", err) + } + fGroups = append(fGroups, newFaults) + + // Record failed recoveries. + // By construction, these are already faulty and thus not in newFaults. + failedRecovery, err := bitfield.IntersectBitField(partitionSectors, recoveries) + if err != nil { + return nil, nil, fmt.Errorf("bitfield intersect failed: %s", err) + } + rGroups = append(rGroups, failedRecovery) + } + } + + deadlineFirstPartition += dlPartCount + } + detectedFaults, err = bitfield.MultiMerge(fGroups...) + if err != nil { + return nil, nil, fmt.Errorf("failed to union detected fault groups: %w", err) + } + failedRecoveries, err = bitfield.MultiMerge(rGroups...) + if err != nil { + return nil, nil, fmt.Errorf("failed to union failed recovery groups: %w", err) + } + return +} + +// Check expiry is exactly *the epoch before* the start of a proving period. +func validateExpiration(rt Runtime, st *State, activation, expiration abi.ChainEpoch, sealProof abi.RegisteredSealProof) { + // expiration cannot exceed MaxSectorExpirationExtension from now + if expiration > rt.CurrEpoch()+MaxSectorExpirationExtension { + rt.Abortf(exitcode.ErrIllegalArgument, "invalid expiration %d, cannot be more than %d past current epoch %d", + expiration, MaxSectorExpirationExtension, rt.CurrEpoch()) + } + + // total sector lifetime cannot exceed SectorMaximumLifetime for the sector's seal proof + if expiration-activation > sealProof.SectorMaximumLifetime() { + rt.Abortf(exitcode.ErrIllegalArgument, "invalid expiration %d, total sector lifetime (%d) cannot exceed %d after activation %d", + expiration, expiration-activation, sealProof.SectorMaximumLifetime(), activation) + } + + // ensure expiration is one epoch before a proving period boundary + periodOffset := st.ProvingPeriodStart % WPoStProvingPeriod + expiryOffset := (expiration + 1) % WPoStProvingPeriod + if expiryOffset != periodOffset { + rt.Abortf(exitcode.ErrIllegalArgument, "invalid expiration %d, must be immediately before proving period boundary %d mod %d", + expiration, periodOffset, WPoStProvingPeriod) + } +} + +func validateReplaceSector(rt Runtime, st *State, store adt.Store, params *SectorPreCommitInfo) *SectorOnChainInfo { + replaceSector, found, err := st.GetSector(store, params.ReplaceSector) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load sector %v", params.SectorNumber) + if !found { + rt.Abortf(exitcode.ErrNotFound, "no such sector %v to replace", params.ReplaceSector) + } + + if len(replaceSector.DealIDs) > 0 { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot replace sector %v which has deals", params.ReplaceSector) + } + if params.SealProof != replaceSector.SealProof { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot replace sector %v seal proof %v with seal proof %v", + params.ReplaceSector, replaceSector.SealProof, params.SealProof) + } + if params.Expiration < replaceSector.Expiration { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot replace sector %v expiration %v with sooner expiration %v", + params.ReplaceSector, replaceSector.Expiration, params.Expiration) + } + faulty, err := st.Faults.IsSet(uint64(params.ReplaceSector)) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check fault for sector %v", params.ReplaceSector) + if faulty { + // Note: the sector might still fault later, in which case we should not license its termination. + rt.Abortf(exitcode.ErrIllegalArgument, "cannot replace faulty sector %v", params.ReplaceSector) + } + return replaceSector +} + +// scheduleReplaceSectorsExpiration re-schedules sector expirations at the end +// of the current proving period. +// +// This function also updates the Expiration field of the passed-in sector +// slice, in-place. +func scheduleReplaceSectorsExpiration(rt Runtime, st *State, store adt.Store, replaceSectors []*SectorOnChainInfo) error { + if len(replaceSectors) == 0 { + return nil + } + + // Mark replaced sectors for on-time expiration at the end of the current proving period. + // They can't be removed right now because they may yet be challenged for Window PoSt in this period, + // and the deadline assignments can't be changed mid-period. + // If their initial pledge hasn't finished vesting yet, it just continues vesting (like other termination paths). + // Note that a sector's weight and power were calculated from its lifetime when the sector was first + // committed, but are not recalculated here. We only get away with this because we know the replaced sector + // has no deals and so its power does not vary with lifetime. + // That's a very brittle constraint, and would be much better with two-phase termination (where we could + // deduct power immediately). + // See https://github.com/filecoin-project/specs-actors/issues/535 + deadlineInfo := st.DeadlineInfo(rt.CurrEpoch()) + newExpiration := deadlineInfo.PeriodEnd() + + if err := st.RemoveSectorExpirations(store, replaceSectors...); err != nil { + return xerrors.Errorf("when removing expirations for replacement: %w", err) + } + + for _, sector := range replaceSectors { + sector.Expiration = newExpiration + } + + if err := st.PutSectors(store, replaceSectors...); err != nil { + return xerrors.Errorf("when updating sector expirations: %w", err) + } + + if err := st.AddSectorExpirations(store, replaceSectors...); err != nil { + return xerrors.Errorf("when replacing sector expirations: %w", err) + } + return nil +} + +// Removes and returns sector numbers that expire at or before an epoch. +func popSectorExpirations(st *State, store adt.Store, epoch abi.ChainEpoch) (*abi.BitField, error) { + var expiredEpochs []abi.ChainEpoch + var expiredSectors []*abi.BitField + errDone := fmt.Errorf("done") + err := st.ForEachSectorExpiration(store, func(expiry abi.ChainEpoch, sectors *abi.BitField) error { + if expiry > epoch { + return errDone + } + expiredSectors = append(expiredSectors, sectors) + expiredEpochs = append(expiredEpochs, expiry) + return nil + }) + if err != nil && err != errDone { + return nil, err + } + err = st.ClearSectorExpirations(store, expiredEpochs...) + if err != nil { + return nil, fmt.Errorf("failed to clear sector expirations %s: %w", expiredEpochs, err) + } + + allExpiries, err := bitfield.MultiMerge(expiredSectors...) + if err != nil { + return nil, fmt.Errorf("failed to union expired sectors: %w", err) + } + return allExpiries, err +} + +// Removes and returns sector numbers that were faulty at or before an epoch, and returns the sector +// numbers for other ongoing faults. +func popExpiredFaults(st *State, store adt.Store, latestTermination abi.ChainEpoch) (*abi.BitField, *abi.BitField, error) { + var expiredEpochs []abi.ChainEpoch + var expiredFaults []*abi.BitField + var ongoingFaults []*abi.BitField + errDone := fmt.Errorf("done") + err := st.ForEachFaultEpoch(store, func(faultStart abi.ChainEpoch, faults *abi.BitField) error { + if faultStart <= latestTermination { + expiredFaults = append(expiredFaults, faults) + expiredEpochs = append(expiredEpochs, faultStart) + } else { + ongoingFaults = append(ongoingFaults, faults) + } + return nil + }) + if err != nil && err != errDone { + return nil, nil, nil + } + err = st.ClearFaultEpochs(store, expiredEpochs...) + if err != nil { + return nil, nil, fmt.Errorf("failed to clear fault epochs %s: %w", expiredEpochs, err) + } + + allExpiries, err := bitfield.MultiMerge(expiredFaults...) + if err != nil { + return nil, nil, fmt.Errorf("failed to union expired faults: %w", err) + } + allOngoing, err := bitfield.MultiMerge(ongoingFaults...) + if err != nil { + return nil, nil, fmt.Errorf("failed to union ongoing faults: %w", err) + } + + return allExpiries, allOngoing, err +} + +func checkPrecommitExpiry(rt Runtime, sectors *abi.BitField) { + store := adt.AsStore(rt) + var st State + + // initialize here to add together for all sectors and minimize calls across actors + depositToBurn := abi.NewTokenAmount(0) + rt.State().Transaction(&st, func() interface{} { + var sectorNos []abi.SectorNumber + err := sectors.ForEach(func(i uint64) error { + sectorNo := abi.SectorNumber(i) + sector, found, err := st.GetPrecommittedSector(store, sectorNo) + if err != nil { + return err + } + if !found { + // already committed/deleted + return nil + } + + // mark it for deletion + sectorNos = append(sectorNos, sectorNo) + + // increment deposit to burn + depositToBurn = big.Add(depositToBurn, sector.PreCommitDeposit) + return nil + }) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to check pre-commit expiries") + + // Actually delete it. + if len(sectorNos) > 0 { + err = st.DeletePrecommittedSectors(store, sectorNos...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to delete pre-commits") + } + + st.PreCommitDeposits = big.Sub(st.PreCommitDeposits, depositToBurn) + Assert(st.PreCommitDeposits.GreaterThanEqual(big.Zero())) + return nil + }) + + // This deposit was locked separately to pledge collateral so there's no pledge change here. + burnFunds(rt, depositToBurn) +} + +// TODO: red flag that this method is potentially super expensive +// https://github.com/filecoin-project/specs-actors/issues/483 +func terminateSectors(rt Runtime, sectorNos *abi.BitField, terminationType power.SectorTermination, epochReward abi.TokenAmount, currentTotalPower abi.StoragePower) { + currentEpoch := rt.CurrEpoch() + empty, err := sectorNos.IsEmpty() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to count sectors") + } + if empty { + return + } + + store := adt.AsStore(rt) + var st State + + var dealIDs []abi.DealID + var terminatedSectors []*SectorOnChainInfo + var faultySectors []*SectorOnChainInfo + penalty := abi.NewTokenAmount(0) + var info *MinerInfo + rt.State().Transaction(&st, func() interface{} { + info = getMinerInfo(rt, &st) + maxAllowedFaults, err := st.GetMaxAllowedFaults(store) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load fault max") + + // Narrow faults to just the set that are expiring, before expanding to a map. + faults, err := bitfield.IntersectBitField(sectorNos, st.Faults) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load faults") + + faultsMap, err := faults.AllMap(maxAllowedFaults) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to expand faults") + } + + // sectors we're not terminating because they either don't exist or have expired. + var notTerminatedSectorNos []uint64 + pledgeRequirementToRemove := abi.NewTokenAmount(0) + err = sectorNos.ForEach(func(sectorNo uint64) error { + sector, found, err := st.GetSector(store, abi.SectorNumber(sectorNo)) + if err != nil { + return fmt.Errorf("failed to load sector %v: %w", sectorNo, err) + } + + // If the sector wasn't found, skip termination. It may + // have already expired, have been terminated due to a + // faults, etc. + if !found { + notTerminatedSectorNos = append(notTerminatedSectorNos, sectorNo) + return nil + } + + // If we're terminating the sector because it expired, + // make sure it has actually expired. + // + // We can hit this case if the sector was changed + // somehow but the termination wasn't removed from the + // SectorExpirations queue. + // + // TODO: This should not be possible. We should consider + // failing in this case. + if terminationType == power.SectorTerminationExpired && currentEpoch < sector.Expiration { + notTerminatedSectorNos = append(notTerminatedSectorNos, sectorNo) + return nil + } + + dealIDs = append(dealIDs, sector.DealIDs...) + terminatedSectors = append(terminatedSectors, sector) + + _, fault := faultsMap[sectorNo] + if fault { + faultySectors = append(faultySectors, sector) + } + + pledgeRequirementToRemove = big.Add(pledgeRequirementToRemove, sector.InitialPledge) + return nil + }) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load sector metadata") + + terminatedSectorNos, err := bitfield.SubtractBitField(sectorNos, bitfield.NewFromSet(notTerminatedSectorNos)) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to subtract skipped sector set") + + // lower initial pledge requirement + st.AddInitialPledgeRequirement(pledgeRequirementToRemove.Neg()) + + deadlines, err := st.LoadDeadlines(store) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to load deadlines") + + err = removeTerminatedSectors(&st, store, deadlines, terminatedSectorNos) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to delete sectors: %v", err) + } + + err = st.SaveDeadlines(store, deadlines) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to store new deadlines") + + if terminationType != power.SectorTerminationExpired { + + // Remove scheduled expirations. + err = st.RemoveSectorExpirations(store, terminatedSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to remove expirations for terminated sectors") + + // Unlock penalty. + penalty, err = unlockTerminationPenalty(&st, store, info.SectorSize, rt.CurrEpoch(), epochReward, currentTotalPower, terminatedSectors) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to unlock penalty %s", err) + } + } + return nil + }) + + // TODO: could we compress the multiple calls to power actor into one sector termination call? + // https://github.com/filecoin-project/specs-actors/issues/478 + // Compute the power delta as if recovering all the currently-faulty sectors before terminating all of them. + requestUpdateSectorPower(rt, info.SectorSize, faultySectors, terminatedSectors) + requestTerminateDeals(rt, dealIDs) + + burnFundsAndNotifyPledgeChange(rt, penalty) +} + +// Removes a group sectors from the sector set and its number from all sector collections in state. +func removeTerminatedSectors(st *State, store adt.Store, deadlines *Deadlines, sectors *abi.BitField) error { + err := st.DeleteSectors(store, sectors) + if err != nil { + return err + } + err = st.RemoveNewSectors(sectors) + if err != nil { + return err + } + err = deadlines.RemoveFromAllDeadlines(sectors) + if err != nil { + return err + } + err = st.RemoveFaults(store, sectors) + if err != nil { + return err + } + err = st.RemoveRecoveries(sectors) + return err +} + +func enrollCronEvent(rt Runtime, eventEpoch abi.ChainEpoch, callbackPayload *CronEventPayload) { + payload := new(bytes.Buffer) + err := callbackPayload.MarshalCBOR(payload) + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "failed to serialize payload: %v", err) + } + _, code := rt.Send( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.EnrollCronEvent, + &power.EnrollCronEventParams{ + EventEpoch: eventEpoch, + Payload: payload.Bytes(), + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to enroll cron event") +} + +func requestUpdateSectorPower(rt Runtime, sectorSize abi.SectorSize, sectorsAdded, sectorsRemoved []*SectorOnChainInfo) (rawDelta, qaDelta big.Int) { + if len(sectorsAdded)+len(sectorsRemoved) == 0 { + return + } + addRawPower, addQAPower := PowerForSectors(sectorSize, sectorsAdded) + remRawPower, remQAPower := PowerForSectors(sectorSize, sectorsRemoved) + rawDelta = big.Sub(addRawPower, remRawPower) + qaDelta = big.Sub(addQAPower, remQAPower) + + _, code := rt.Send( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.UpdateClaimedPower, + &power.UpdateClaimedPowerParams{ + RawByteDelta: rawDelta, + QualityAdjustedDelta: qaDelta, + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to update power for sectors added %v, removed %v", sectorsAdded, sectorsRemoved) + return +} + +func requestTerminateDeals(rt Runtime, dealIDs []abi.DealID) { + if len(dealIDs) == 0 { + return + } + _, code := rt.Send( + builtin.StorageMarketActorAddr, + builtin.MethodsMarket.OnMinerSectorsTerminate, + &market.OnMinerSectorsTerminateParams{ + DealIDs: dealIDs, + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to terminate deals %v, exit code %v", dealIDs, code) +} + +func requestTerminateAllDeals(rt Runtime, st *State) { //nolint:deadcode,unused + // TODO: red flag this is an ~unbounded computation. + // Transform into an idempotent partial computation that can be progressed on each invocation. + // https://github.com/filecoin-project/specs-actors/issues/483 + dealIds := []abi.DealID{} + if err := st.ForEachSector(adt.AsStore(rt), func(sector *SectorOnChainInfo) { + dealIds = append(dealIds, sector.DealIDs...) + }); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to traverse sectors for termination: %v", err) + } + + requestTerminateDeals(rt, dealIds) +} + +func verifyWindowedPost(rt Runtime, challengeEpoch abi.ChainEpoch, sectors []*SectorOnChainInfo, proofs []abi.PoStProof) { + minerActorID, err := addr.IDFromAddress(rt.Message().Receiver()) + AssertNoError(err) // Runtime always provides ID-addresses + + // Regenerate challenge randomness, which must match that generated for the proof. + var addrBuf bytes.Buffer + err = rt.Message().Receiver().MarshalCBOR(&addrBuf) + AssertNoError(err) + postRandomness := rt.GetRandomness(crypto.DomainSeparationTag_WindowedPoStChallengeSeed, challengeEpoch, addrBuf.Bytes()) + + sectorProofInfo := make([]abi.SectorInfo, len(sectors)) + for i, s := range sectors { + sectorProofInfo[i] = s.AsSectorInfo() + } + + // Get public inputs + pvInfo := abi.WindowPoStVerifyInfo{ + Randomness: abi.PoStRandomness(postRandomness), + Proofs: proofs, + ChallengedSectors: sectorProofInfo, + Prover: abi.ActorID(minerActorID), + } + + // Verify the PoSt Proof + if err := rt.Syscalls().VerifyPoSt(pvInfo); err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "invalid PoSt %+v: %s", pvInfo, err) + } +} + +// SealVerifyParams is the structure of information that must be sent with a +// message to commit a sector. Most of this information is not needed in the +// state tree but will be verified in sm.CommitSector. See SealCommitment for +// data stored on the state tree for each sector. +type SealVerifyStuff struct { + SealedCID cid.Cid // CommR + InteractiveEpoch abi.ChainEpoch // Used to derive the interactive PoRep challenge. + abi.RegisteredSealProof + Proof []byte + DealIDs []abi.DealID + abi.SectorNumber + SealRandEpoch abi.ChainEpoch // Used to tie the seal to a chain. +} + +func getVerifyInfo(rt Runtime, params *SealVerifyStuff) *abi.SealVerifyInfo { + if rt.CurrEpoch() <= params.InteractiveEpoch { + rt.Abortf(exitcode.ErrForbidden, "too early to prove sector") + } + + // Check randomness. + challengeEarliest := sealChallengeEarliest(rt.CurrEpoch(), params.RegisteredSealProof) + if params.SealRandEpoch < challengeEarliest { + rt.Abortf(exitcode.ErrIllegalArgument, "seal epoch %v too old, expected >= %v", params.SealRandEpoch, challengeEarliest) + } + + commD := requestUnsealedSectorCID(rt, params.RegisteredSealProof, params.DealIDs) + + minerActorID, err := addr.IDFromAddress(rt.Message().Receiver()) + AssertNoError(err) // Runtime always provides ID-addresses + + buf := new(bytes.Buffer) + err = rt.Message().Receiver().MarshalCBOR(buf) + AssertNoError(err) + + svInfoRandomness := rt.GetRandomness(crypto.DomainSeparationTag_SealRandomness, params.SealRandEpoch, buf.Bytes()) + svInfoInteractiveRandomness := rt.GetRandomness(crypto.DomainSeparationTag_InteractiveSealChallengeSeed, params.InteractiveEpoch, buf.Bytes()) + + return &abi.SealVerifyInfo{ + SealProof: params.RegisteredSealProof, + SectorID: abi.SectorID{ + Miner: abi.ActorID(minerActorID), + Number: params.SectorNumber, + }, + DealIDs: params.DealIDs, + InteractiveRandomness: abi.InteractiveSealRandomness(svInfoInteractiveRandomness), + Proof: params.Proof, + Randomness: abi.SealRandomness(svInfoRandomness), + SealedCID: params.SealedCID, + UnsealedCID: commD, + } +} + +// Closes down this miner by erasing its power, terminating all its deals and burning its funds +func terminateMiner(rt Runtime) { + var st State + rt.State().Readonly(&st) + + requestTerminateAllDeals(rt, &st) + + // Delete the actor and burn all remaining funds + rt.DeleteActor(builtin.BurntFundsActorAddr) +} + +// Requests the storage market actor compute the unsealed sector CID from a sector's deals. +func requestUnsealedSectorCID(rt Runtime, proofType abi.RegisteredSealProof, dealIDs []abi.DealID) cid.Cid { + ret, code := rt.Send( + builtin.StorageMarketActorAddr, + builtin.MethodsMarket.ComputeDataCommitment, + &market.ComputeDataCommitmentParams{ + SectorType: proofType, + DealIDs: dealIDs, + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed request for unsealed sector CID for deals %v", dealIDs) + var unsealedCID cbg.CborCid + AssertNoError(ret.Into(&unsealedCID)) + return cid.Cid(unsealedCID) +} + +func requestDealWeight(rt Runtime, dealIDs []abi.DealID, sectorStart, sectorExpiry abi.ChainEpoch) market.VerifyDealsForActivationReturn { + var dealWeights market.VerifyDealsForActivationReturn + ret, code := rt.Send( + builtin.StorageMarketActorAddr, + builtin.MethodsMarket.VerifyDealsForActivation, + &market.VerifyDealsForActivationParams{ + DealIDs: dealIDs, + SectorStart: sectorStart, + SectorExpiry: sectorExpiry, + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to verify deals and get deal weight") + AssertNoError(ret.Into(&dealWeights)) + return dealWeights + +} + +func commitWorkerKeyChange(rt Runtime) *adt.EmptyValue { + var st State + rt.State().Transaction(&st, func() interface{} { + info := getMinerInfo(rt, &st) + if info.PendingWorkerKey == nil { + rt.Abortf(exitcode.ErrIllegalState, "No pending key change.") + } + + if info.PendingWorkerKey.EffectiveAt > rt.CurrEpoch() { + rt.Abortf(exitcode.ErrIllegalState, "Too early for key change. Current: %v, Change: %v)", rt.CurrEpoch(), info.PendingWorkerKey.EffectiveAt) + } + + info.Worker = info.PendingWorkerKey.NewWorker + info.PendingWorkerKey = nil + err := st.SaveInfo(adt.AsStore(rt), info) + builtin.RequireNoErr(rt, err, exitcode.ErrSerialization, "failed to save miner info") + + return nil + }) + return nil +} + +// Requests the current epoch target block reward from the reward actor. +func requestCurrentEpochBlockReward(rt Runtime) abi.TokenAmount { + rwret, code := rt.Send(builtin.RewardActorAddr, builtin.MethodsReward.ThisEpochReward, nil, big.Zero()) + builtin.RequireSuccess(rt, code, "failed to check epoch reward") + epochReward := abi.NewTokenAmount(0) + err := rwret.Into(&epochReward) + builtin.RequireNoErr(rt, err, exitcode.ErrSerialization, "failed to unmarshal epoch reward value") + return epochReward +} + +// Requests the current network total power and pledge from the power actor. +func requestCurrentTotalPower(rt Runtime) *power.CurrentTotalPowerReturn { + pwret, code := rt.Send(builtin.StoragePowerActorAddr, builtin.MethodsPower.CurrentTotalPower, nil, big.Zero()) + builtin.RequireSuccess(rt, code, "failed to check current power") + var pwr power.CurrentTotalPowerReturn + err := pwret.Into(&pwr) + builtin.RequireNoErr(rt, err, exitcode.ErrSerialization, "failed to unmarshal power total value") + return &pwr +} + +// Verifies that the total locked balance exceeds the sum of sector initial pledges. +func verifyPledgeMeetsInitialRequirements(rt Runtime, st *State) { + if st.LockedFunds.LessThan(st.InitialPledgeRequirement) { + rt.Abortf(exitcode.ErrInsufficientFunds, "locked funds insufficient to cover initial pledges (%v < %v)", + st.LockedFunds, st.InitialPledgeRequirement) + } +} + +// Resolves an address to an ID address and verifies that it is address of an account or multisig actor. +func resolveOwnerAddress(rt Runtime, raw addr.Address) addr.Address { + resolved, ok := rt.ResolveAddress(raw) + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "unable to resolve address %v", raw) + } + Assert(resolved.Protocol() == addr.ID) + + ownerCode, ok := rt.GetActorCodeCID(resolved) + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "no code for address %v", resolved) + } + if !builtin.IsPrincipal(ownerCode) { + rt.Abortf(exitcode.ErrIllegalArgument, "owner actor type must be a principal, was %v", ownerCode) + } + return resolved +} + +// Resolves an address to an ID address and verifies that it is address of an account actor with an associated BLS key. +// The worker must be BLS since the worker key will be used alongside a BLS-VRF. +func resolveWorkerAddress(rt Runtime, raw addr.Address) addr.Address { + resolved, ok := rt.ResolveAddress(raw) + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "unable to resolve address %v", raw) + } + Assert(resolved.Protocol() == addr.ID) + + ownerCode, ok := rt.GetActorCodeCID(resolved) + if !ok { + rt.Abortf(exitcode.ErrIllegalArgument, "no code for address %v", resolved) + } + if ownerCode != builtin.AccountActorCodeID { + rt.Abortf(exitcode.ErrIllegalArgument, "worker actor type must be an account, was %v", ownerCode) + } + + if raw.Protocol() != addr.BLS { + ret, code := rt.Send(resolved, builtin.MethodsAccount.PubkeyAddress, nil, big.Zero()) + builtin.RequireSuccess(rt, code, "failed to fetch account pubkey from %v", resolved) + var pubkey addr.Address + err := ret.Into(&pubkey) + if err != nil { + rt.Abortf(exitcode.ErrSerialization, "failed to deserialize address result: %v", ret) + } + if pubkey.Protocol() != addr.BLS { + rt.Abortf(exitcode.ErrIllegalArgument, "worker account %v must have BLS pubkey, was %v", resolved, pubkey.Protocol()) + } + } + return resolved +} + +func burnFundsAndNotifyPledgeChange(rt Runtime, amt abi.TokenAmount) { + burnFunds(rt, amt) + notifyPledgeChanged(rt, amt.Neg()) +} + +func burnFunds(rt Runtime, amt abi.TokenAmount) { + if amt.GreaterThan(big.Zero()) { + _, code := rt.Send(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, amt) + builtin.RequireSuccess(rt, code, "failed to burn funds") + } +} + +func notifyPledgeChanged(rt Runtime, pledgeDelta abi.TokenAmount) { + if !pledgeDelta.IsZero() { + _, code := rt.Send(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdatePledgeTotal, &pledgeDelta, big.Zero()) + builtin.RequireSuccess(rt, code, "failed to update total pledge") + } +} + +// Assigns proving period offset randomly in the range [0, WPoStProvingPeriod) by hashing +// the actor's address and current epoch. +func assignProvingPeriodOffset(myAddr addr.Address, currEpoch abi.ChainEpoch, hash func(data []byte) [32]byte) (abi.ChainEpoch, error) { + offsetSeed := bytes.Buffer{} + err := myAddr.MarshalCBOR(&offsetSeed) + if err != nil { + return 0, fmt.Errorf("failed to serialize address: %w", err) + } + + err = binary.Write(&offsetSeed, binary.BigEndian, currEpoch) + if err != nil { + return 0, fmt.Errorf("failed to serialize epoch: %w", err) + } + + digest := hash(offsetSeed.Bytes()) + var offset uint64 + err = binary.Read(bytes.NewBuffer(digest[:]), binary.BigEndian, &offset) + if err != nil { + return 0, fmt.Errorf("failed to interpret digest: %w", err) + } + + offset = offset % uint64(WPoStProvingPeriod) + return abi.ChainEpoch(offset), nil +} + +// Computes the epoch at which a proving period should start such that it is greater than the current epoch, and +// has a defined offset from being an exact multiple of WPoStProvingPeriod. +// A miner is exempt from Winow PoSt until the first full proving period starts. +func nextProvingPeriodStart(currEpoch abi.ChainEpoch, offset abi.ChainEpoch) abi.ChainEpoch { + currModulus := currEpoch % WPoStProvingPeriod + var periodProgress abi.ChainEpoch // How far ahead is currEpoch from previous offset boundary. + if currModulus >= offset { + periodProgress = currModulus - offset + } else { + periodProgress = WPoStProvingPeriod - (offset - currModulus) + } + + periodStart := currEpoch - periodProgress + WPoStProvingPeriod + Assert(periodStart > currEpoch) + return periodStart +} + +// Computes deadline information for a fault or recovery declaration. +// If the deadline has not yet elapsed, the declaration is taken as being for the current proving period. +// If the deadline has elapsed, it's instead taken as being for the next proving period after the current epoch. +func declarationDeadlineInfo(periodStart abi.ChainEpoch, deadlineIdx uint64, currEpoch abi.ChainEpoch) (*DeadlineInfo, error) { + if deadlineIdx >= WPoStPeriodDeadlines { + return nil, fmt.Errorf("invalid deadline %d, must be < %d", deadlineIdx, WPoStPeriodDeadlines) + } + + deadline := NewDeadlineInfo(periodStart, deadlineIdx, currEpoch) + // While deadline is in the past, roll over to the next proving period.. + for deadline.HasElapsed() { + deadline = NewDeadlineInfo(deadline.NextPeriodStart(), deadlineIdx, currEpoch) + } + return deadline, nil +} + +// Checks that a fault or recovery declaration of sectors at a specific deadline is valid and not within +// the exclusion window for the deadline. +func validateFRDeclaration(deadlines *Deadlines, deadline *DeadlineInfo, declaredSectors *abi.BitField) error { + if deadline.FaultCutoffPassed() { + return fmt.Errorf("late fault or recovery declaration at %v", deadline) + } + + // Check that the declared sectors are actually due at the deadline. + deadlineSectors := deadlines.Due[deadline.Index] + contains, err := abi.BitFieldContainsAll(deadlineSectors, declaredSectors) + if err != nil { + return fmt.Errorf("failed to check sectors at deadline: %w", err) + } + if !contains { + return fmt.Errorf("sectors not all due at deadline %d", deadline.Index) + } + return nil +} + +// qaPowerForSectors sums the quality adjusted power of all sectors +func qaPowerForSectors(sectorSize abi.SectorSize, sectors []*SectorOnChainInfo) abi.StoragePower { + power := big.Zero() + for _, s := range sectors { + power = big.Add(power, QAPowerForSector(sectorSize, s)) + } + return power +} + +func unlockDeclaredFaultPenalty(st *State, store adt.Store, sectorSize abi.SectorSize, currEpoch abi.ChainEpoch, epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, sectors []*SectorOnChainInfo) (abi.TokenAmount, error) { + totalQAPower := qaPowerForSectors(sectorSize, sectors) + fee := PledgePenaltyForDeclaredFault(epochTargetReward, networkQAPower, totalQAPower) + return st.UnlockUnvestedFunds(store, currEpoch, fee) +} + +func unlockUndeclaredFaultPenalty(st *State, store adt.Store, sectorSize abi.SectorSize, currEpoch abi.ChainEpoch, epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, sectors []*SectorOnChainInfo) (abi.TokenAmount, error) { + totalQAPower := qaPowerForSectors(sectorSize, sectors) + fee := PledgePenaltyForUndeclaredFault(epochTargetReward, networkQAPower, totalQAPower) + return st.UnlockUnvestedFunds(store, currEpoch, fee) +} + +func unlockUndeclaredLateFaultPenalty(st *State, store adt.Store, sectorSize abi.SectorSize, currEpoch abi.ChainEpoch, epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, sectors []*SectorOnChainInfo) (abi.TokenAmount, error) { + totalQAPower := qaPowerForSectors(sectorSize, sectors) + fee := PledgePenaltyForLateUndeclaredFault(epochTargetReward, networkQAPower, totalQAPower) + return st.UnlockUnvestedFunds(store, currEpoch, fee) +} + +func unlockTerminationPenalty(st *State, store adt.Store, sectorSize abi.SectorSize, currEpoch abi.ChainEpoch, epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, sectors []*SectorOnChainInfo) (abi.TokenAmount, error) { + totalFee := big.Zero() + for _, s := range sectors { + sectorPower := QAPowerForSector(sectorSize, s) + fee := PledgePenaltyForTermination(s.InitialPledge, currEpoch-s.Activation, epochTargetReward, networkQAPower, sectorPower) + totalFee = big.Add(fee, totalFee) + } + return st.UnlockUnvestedFunds(store, currEpoch, totalFee) +} + +// Returns the sum of the raw byte and quality-adjusted power for sectors. +func PowerForSectors(sectorSize abi.SectorSize, sectors []*SectorOnChainInfo) (rawBytePower, qaPower big.Int) { + rawBytePower = big.Mul(big.NewIntUnsigned(uint64(sectorSize)), big.NewIntUnsigned(uint64(len(sectors)))) + qaPower = qaPowerForSectors(sectorSize, sectors) + return +} + +// The oldest seal challenge epoch that will be accepted in the current epoch. +func sealChallengeEarliest(currEpoch abi.ChainEpoch, proof abi.RegisteredSealProof) abi.ChainEpoch { + return currEpoch - ChainFinality - MaxSealDuration[proof] +} + +func getMinerInfo(rt Runtime, st *State) *MinerInfo { + info, err := st.GetInfo(adt.AsStore(rt)) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not read miner info") + return info +} + +func min64(a, b uint64) uint64 { + if a < b { + return a + } + return b +} + +func minEpoch(a, b abi.ChainEpoch) abi.ChainEpoch { + if a < b { + return a + } + return b +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_internal_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_internal_test.go new file mode 100644 index 000000000..2b47c2711 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_internal_test.go @@ -0,0 +1,164 @@ +package miner + +import ( + "testing" + + "github.com/minio/blake2b-simd" + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + tutils "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestAssignProvingPeriodBoundary(t *testing.T) { + addr1 := tutils.NewActorAddr(t, "a") + addr2 := tutils.NewActorAddr(t, "b") + startEpoch := abi.ChainEpoch(1) + + // ensure the values are different for different addresses + b1, err := assignProvingPeriodOffset(addr1, startEpoch, blake2b.Sum256) + assert.NoError(t, err) + assert.True(t, b1 >= 0) + assert.True(t, b1 < WPoStProvingPeriod) + + b2, err := assignProvingPeriodOffset(addr2, startEpoch, blake2b.Sum256) + assert.NoError(t, err) + assert.True(t, b2 >= 0) + assert.True(t, b2 < WPoStProvingPeriod) + + assert.NotEqual(t, b1, b2) + + // Ensure boundaries are always less than a proving period. + for i := 0; i < 10_000; i++ { + boundary, err := assignProvingPeriodOffset(addr1, abi.ChainEpoch(i), blake2b.Sum256) + assert.NoError(t, err) + assert.True(t, boundary >= 0) + assert.True(t, boundary < WPoStProvingPeriod) + } +} + +func TestNextProvingPeriodStart(t *testing.T) { + // At epoch zero... + curr := e(0) + // ... with offset zero, the first period start skips one period ahead, ... + assert.Equal(t, WPoStProvingPeriod, nextProvingPeriodStart(curr, 0)) + + // ... and all non-zero offsets are simple. + assert.Equal(t, e(1), nextProvingPeriodStart(curr, 1)) + assert.Equal(t, e(10), nextProvingPeriodStart(curr, 10)) + assert.Equal(t, WPoStProvingPeriod-1, nextProvingPeriodStart(curr, WPoStProvingPeriod-1)) + + // At epoch 1, offsets 0 and 1 start a long way forward, but offsets 2 and later start soon. + curr = 1 + assert.Equal(t, WPoStProvingPeriod, nextProvingPeriodStart(curr, 0)) + assert.Equal(t, WPoStProvingPeriod+1, nextProvingPeriodStart(curr, 1)) + assert.Equal(t, e(2), nextProvingPeriodStart(curr, 2)) + assert.Equal(t, e(3), nextProvingPeriodStart(curr, 3)) + assert.Equal(t, WPoStProvingPeriod-1, nextProvingPeriodStart(curr, WPoStProvingPeriod-1)) + + // An arbitrary mid-period epoch. + curr = 123 + assert.Equal(t, WPoStProvingPeriod, nextProvingPeriodStart(curr, 0)) + assert.Equal(t, WPoStProvingPeriod+1, nextProvingPeriodStart(curr, 1)) + assert.Equal(t, WPoStProvingPeriod+122, nextProvingPeriodStart(curr, 122)) + assert.Equal(t, WPoStProvingPeriod+123, nextProvingPeriodStart(curr, 123)) + assert.Equal(t, e(124), nextProvingPeriodStart(curr, 124)) + assert.Equal(t, WPoStProvingPeriod-1, nextProvingPeriodStart(curr, WPoStProvingPeriod-1)) + + // The final epoch in the chain's first full period + curr = WPoStProvingPeriod - 1 + assert.Equal(t, WPoStProvingPeriod, nextProvingPeriodStart(curr, 0)) + assert.Equal(t, WPoStProvingPeriod+1, nextProvingPeriodStart(curr, 1)) + assert.Equal(t, WPoStProvingPeriod+2, nextProvingPeriodStart(curr, 2)) + assert.Equal(t, WPoStProvingPeriod+WPoStProvingPeriod-2, nextProvingPeriodStart(curr, WPoStProvingPeriod-2)) + assert.Equal(t, WPoStProvingPeriod+WPoStProvingPeriod-1, nextProvingPeriodStart(curr, WPoStProvingPeriod-1)) + + // Into the chain's second period + curr = WPoStProvingPeriod + assert.Equal(t, 2*WPoStProvingPeriod, nextProvingPeriodStart(curr, 0)) + assert.Equal(t, WPoStProvingPeriod+1, nextProvingPeriodStart(curr, 1)) + assert.Equal(t, WPoStProvingPeriod+2, nextProvingPeriodStart(curr, 2)) + assert.Equal(t, WPoStProvingPeriod+WPoStProvingPeriod-1, nextProvingPeriodStart(curr, WPoStProvingPeriod-1)) + + curr = WPoStProvingPeriod + 234 + assert.Equal(t, 2*WPoStProvingPeriod, nextProvingPeriodStart(curr, 0)) + assert.Equal(t, 2*WPoStProvingPeriod+1, nextProvingPeriodStart(curr, 1)) + assert.Equal(t, 2*WPoStProvingPeriod+233, nextProvingPeriodStart(curr, 233)) + assert.Equal(t, 2*WPoStProvingPeriod+234, nextProvingPeriodStart(curr, 234)) + assert.Equal(t, WPoStProvingPeriod+235, nextProvingPeriodStart(curr, 235)) + assert.Equal(t, WPoStProvingPeriod+WPoStProvingPeriod-1, nextProvingPeriodStart(curr, WPoStProvingPeriod-1)) +} + +type e = abi.ChainEpoch + +func TestFaultFeeInvariants(t *testing.T) { + t.Run("Undeclared faults are more expensive than declared faults", func(t *testing.T) { + epochReward := abi.NewTokenAmount(1_000) + networkPower := abi.NewStoragePower(100 << 50) + faultySectorPower := abi.NewStoragePower(1 << 50) + + ff := PledgePenaltyForDeclaredFault(epochReward, networkPower, faultySectorPower) + sp := PledgePenaltyForUndeclaredFault(epochReward, networkPower, faultySectorPower) + assert.True(t, sp.GreaterThan(ff)) + }) + + t.Run("Declared and Undeclared fault penalties are linear over sectorQAPower term", func(t *testing.T) { + epochReward := abi.NewTokenAmount(1_000) + networkPower := abi.NewStoragePower(100 << 50) + faultySectorAPower := abi.NewStoragePower(1 << 50) + faultySectorBPower := abi.NewStoragePower(19 << 50) + faultySectorCPower := abi.NewStoragePower(63 << 50) + totalFaultPower := big.Add(big.Add(faultySectorAPower, faultySectorBPower), faultySectorCPower) + + // Declared faults + ffA := PledgePenaltyForDeclaredFault(epochReward, networkPower, faultySectorAPower) + ffB := PledgePenaltyForDeclaredFault(epochReward, networkPower, faultySectorBPower) + ffC := PledgePenaltyForDeclaredFault(epochReward, networkPower, faultySectorCPower) + + ffAll := PledgePenaltyForDeclaredFault(epochReward, networkPower, totalFaultPower) + + // Because we can introduce rounding error between 1 and zero for every penalty calculation + // we can at best expect n calculations of 1 power to be within n of 1 calculation of n powers. + diff := big.Sub(ffAll, big.Add(ffC, big.Add(ffA, ffB))) + assert.True(t, diff.GreaterThanEqual(big.Zero())) + assert.True(t, diff.LessThan(big.NewInt(3))) + + // Undeclared faults + spA := PledgePenaltyForUndeclaredFault(epochReward, networkPower, faultySectorAPower) + spB := PledgePenaltyForUndeclaredFault(epochReward, networkPower, faultySectorBPower) + spC := PledgePenaltyForUndeclaredFault(epochReward, networkPower, faultySectorCPower) + + spAll := PledgePenaltyForUndeclaredFault(epochReward, networkPower, totalFaultPower) + + // Because we can introduce rounding error between 1 and zero for every penalty calculation + // we can at best expect n calculations of 1 power to be within n of 1 calculation of n powers. + diff = big.Sub(spAll, big.Add(spC, big.Add(spA, spB))) + assert.True(t, diff.GreaterThanEqual(big.Zero())) + assert.True(t, diff.LessThan(big.NewInt(3))) + + }) +} + +func TestQuantizeUp(t *testing.T) { + t.Run("zero offset", func(t *testing.T) { + assert.Equal(t, abi.ChainEpoch(50), quantizeUp(42, 10, 0)) + assert.Equal(t, abi.ChainEpoch(16000), quantizeUp(16000, 100, 0)) + assert.Equal(t, abi.ChainEpoch(0), quantizeUp(-5, 10, 0)) + assert.Equal(t, abi.ChainEpoch(-50), quantizeUp(-50, 10, 0)) + assert.Equal(t, abi.ChainEpoch(-50), quantizeUp(-53, 10, 0)) + }) + + t.Run("non zero offset", func(t *testing.T) { + assert.Equal(t, abi.ChainEpoch(6), quantizeUp(4, 5, 1)) + assert.Equal(t, abi.ChainEpoch(1), quantizeUp(0, 5, 1)) + assert.Equal(t, abi.ChainEpoch(-4), quantizeUp(-6, 5, 1)) + assert.Equal(t, abi.ChainEpoch(4), quantizeUp(2, 10, 4)) + }) + + t.Run("offset seed bigger than unit is normalized", func(t *testing.T) { + assert.Equal(t, abi.ChainEpoch(13), quantizeUp(9, 5, 28)) // offset should be 3 + assert.Equal(t, abi.ChainEpoch(10000), quantizeUp(10000, 100, 2000000)) + }) + +} \ No newline at end of file diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_state.go new file mode 100644 index 000000000..cc9ea2ede --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_state.go @@ -0,0 +1,1165 @@ +package miner + +import ( + "fmt" + "reflect" + + addr "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-bitfield" + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + xerrors "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + . "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// Balance of Miner Actor should be greater than or equal to +// the sum of PreCommitDeposits and LockedFunds. +// Excess balance as computed by st.GetAvailableBalance will be +// withdrawable or usable for pre-commit deposit or pledge lock-up. +type State struct { + // Information not related to sectors. + Info cid.Cid + + PreCommitDeposits abi.TokenAmount // Total funds locked as PreCommitDeposits + LockedFunds abi.TokenAmount // Total unvested funds locked as pledge collateral + VestingFunds cid.Cid // Array, AMT[ChainEpoch]TokenAmount + InitialPledgeRequirement abi.TokenAmount // Sum of initial pledge requirements of all active sectors + + // Sectors that have been pre-committed but not yet proven. + PreCommittedSectors cid.Cid // Map, HAMT[SectorNumber]SectorPreCommitOnChainInfo + + // Information for all proven and not-yet-expired sectors. + Sectors cid.Cid // Array, AMT[SectorNumber]SectorOnChainInfo (sparse) + + // The first epoch in this miner's current proving period. This is the first epoch in which a PoSt for a + // partition at the miner's first deadline may arrive. Alternatively, it is after the last epoch at which + // a PoSt for the previous window is valid. + // Always greater than zero, his may be greater than the current epoch for genesis miners in the first + // WPoStProvingPeriod epochs of the chain; the epochs before the first proving period starts are exempt from Window + // PoSt requirements. + // Updated at the end of every period by a power actor cron event. + ProvingPeriodStart abi.ChainEpoch + + // Sector numbers prove-committed since period start, to be added to Deadlines at next proving period boundary. + NewSectors *abi.BitField + + // Sector numbers indexed by expiry epoch (which are on proving period boundaries). + // Invariant: Keys(Sectors) == union(SectorExpirations.Values()) + SectorExpirations cid.Cid // Array, AMT[ChainEpoch]Bitfield + + // The sector numbers due for PoSt at each deadline in the current proving period, frozen at period start. + // New sectors are added and expired ones removed at proving period boundary. + // Faults are not subtracted from this in state, but on the fly. + Deadlines cid.Cid + + // All currently known faulty sectors, mutated eagerly. + // These sectors are exempt from inclusion in PoSt. + Faults *abi.BitField + + // Faulty sector numbers indexed by the start epoch of the proving period in which detected. + // Used to track fault durations for eventual sector termination. + // At most 14 entries, b/c sectors faulty longer expire. + // Invariant: Faults == union(FaultEpochs.Values()) + FaultEpochs cid.Cid // AMT[ChainEpoch]Bitfield + + // Faulty sectors that will recover when next included in a valid PoSt. + // Invariant: Recoveries ⊆ Faults. + Recoveries *abi.BitField + + // Records successful PoSt submission in the current proving period by partition number. + // The presence of a partition number indicates on-time PoSt received. + PostSubmissions *abi.BitField + + // The index of the next deadline for which faults should been detected and processed (after it's closed). + // The proving period cron handler will always reset this to 0, for the subsequent period. + // Eager fault detection processing on fault/recovery declarations or PoSt may set a smaller number, + // indicating partial progress, from which subsequent processing should continue. + // In the range [0, WPoStProvingPeriodDeadlines). + NextDeadlineToProcessFaults uint64 +} + +type MinerInfo struct { + // Account that owns this miner. + // - Income and returned collateral are paid to this address. + // - This address is also allowed to change the worker address for the miner. + Owner addr.Address // Must be an ID-address. + + // Worker account for this miner. + // The associated pubkey-type address is used to sign blocks and messages on behalf of this miner. + Worker addr.Address // Must be an ID-address. + + PendingWorkerKey *WorkerKeyChange + + // Byte array representing a Libp2p identity that should be used when connecting to this miner. + PeerId abi.PeerID + + // Slice of byte arrays representing Libp2p multi-addresses used for establishing a connection with this miner. + Multiaddrs []abi.Multiaddrs + + // The proof type used by this miner for sealing sectors. + SealProofType abi.RegisteredSealProof + + // Amount of space in each sector committed by this miner. + // This is computed from the proof type and represented here redundantly. + SectorSize abi.SectorSize + + // The number of sectors in each Window PoSt partition (proof). + // This is computed from the proof type and represented here redundantly. + WindowPoStPartitionSectors uint64 +} + +type WorkerKeyChange struct { + NewWorker addr.Address // Must be an ID address + EffectiveAt abi.ChainEpoch +} + +// Information provided by a miner when pre-committing a sector. +type SectorPreCommitInfo struct { + SealProof abi.RegisteredSealProof + SectorNumber abi.SectorNumber + SealedCID cid.Cid // CommR + SealRandEpoch abi.ChainEpoch + DealIDs []abi.DealID + Expiration abi.ChainEpoch + ReplaceCapacity bool // Whether to replace a "committed capacity" no-deal sector (requires non-empty DealIDs) + ReplaceSector abi.SectorNumber // The committed capacity sector to replace +} + +// Information stored on-chain for a pre-committed sector. +type SectorPreCommitOnChainInfo struct { + Info SectorPreCommitInfo + PreCommitDeposit abi.TokenAmount + PreCommitEpoch abi.ChainEpoch + DealWeight abi.DealWeight // Integral of active deals over sector lifetime + VerifiedDealWeight abi.DealWeight // Integral of active verified deals over sector lifetime +} + +// Information stored on-chain for a proven sector. +type SectorOnChainInfo struct { + SectorNumber abi.SectorNumber + SealProof abi.RegisteredSealProof // The seal proof type implies the PoSt proof/s + SealedCID cid.Cid // CommR + DealIDs []abi.DealID + Activation abi.ChainEpoch // Epoch during which the sector proof was accepted + Expiration abi.ChainEpoch // Epoch during which the sector expires + DealWeight abi.DealWeight // Integral of active deals over sector lifetime + VerifiedDealWeight abi.DealWeight // Integral of active verified deals over sector lifetime + InitialPledge abi.TokenAmount // Pledge collected to commit this sector +} + +func ConstructState(infoCid cid.Cid, periodStart abi.ChainEpoch, emptyArrayCid, emptyMapCid, emptyDeadlinesCid cid.Cid) (*State, error) { + + return &State{ + Info: infoCid, + + PreCommitDeposits: abi.NewTokenAmount(0), + LockedFunds: abi.NewTokenAmount(0), + VestingFunds: emptyArrayCid, + InitialPledgeRequirement: abi.NewTokenAmount(0), + + PreCommittedSectors: emptyMapCid, + Sectors: emptyArrayCid, + ProvingPeriodStart: periodStart, + NewSectors: abi.NewBitField(), + SectorExpirations: emptyArrayCid, + Deadlines: emptyDeadlinesCid, + Faults: abi.NewBitField(), + FaultEpochs: emptyArrayCid, + Recoveries: abi.NewBitField(), + PostSubmissions: abi.NewBitField(), + }, nil +} + +func ConstructMinerInfo(owner addr.Address, worker addr.Address, pid []byte, multiAddrs [][]byte, sealProofType abi.RegisteredSealProof) (*MinerInfo, error) { + + sectorSize, err := sealProofType.SectorSize() + if err != nil { + return nil, err + } + + partitionSectors, err := sealProofType.WindowPoStPartitionSectors() + if err != nil { + return nil, err + } + return &MinerInfo{ + Owner: owner, + Worker: worker, + PendingWorkerKey: nil, + PeerId: pid, + Multiaddrs: multiAddrs, + SealProofType: sealProofType, + SectorSize: sectorSize, + WindowPoStPartitionSectors: partitionSectors, + }, nil +} + +func (st *State) GetInfo(store adt.Store) (*MinerInfo, error) { + var info MinerInfo + if err := store.Get(store.Context(), st.Info, &info); err != nil { + return nil, xerrors.Errorf("failed to get miner info %w", err) + } + return &info, nil +} + +func (st *State) SaveInfo(store adt.Store, info *MinerInfo) error { + c, err := store.Put(store.Context(), info) + if err != nil { + return err + } + st.Info = c + return nil +} + +// Returns deadline calculations for the current proving period. +func (st *State) DeadlineInfo(currEpoch abi.ChainEpoch) *DeadlineInfo { + return ComputeProvingPeriodDeadline(st.ProvingPeriodStart, currEpoch) +} + +func (st *State) GetSectorCount(store adt.Store) (uint64, error) { + arr, err := adt.AsArray(store, st.Sectors) + if err != nil { + return 0, err + } + + return arr.Length(), nil +} + +func (st *State) GetMaxAllowedFaults(store adt.Store) (uint64, error) { + sectorCount, err := st.GetSectorCount(store) + if err != nil { + return 0, err + } + return 2 * sectorCount, nil +} + +func (st *State) PutPrecommittedSector(store adt.Store, info *SectorPreCommitOnChainInfo) error { + precommitted, err := adt.AsMap(store, st.PreCommittedSectors) + if err != nil { + return err + } + + err = precommitted.Put(SectorKey(info.Info.SectorNumber), info) + if err != nil { + return errors.Wrapf(err, "failed to store precommitment for %v", info) + } + st.PreCommittedSectors, err = precommitted.Root() + return err +} + +func (st *State) GetPrecommittedSector(store adt.Store, sectorNo abi.SectorNumber) (*SectorPreCommitOnChainInfo, bool, error) { + precommitted, err := adt.AsMap(store, st.PreCommittedSectors) + if err != nil { + return nil, false, err + } + + var info SectorPreCommitOnChainInfo + found, err := precommitted.Get(SectorKey(sectorNo), &info) + if err != nil { + return nil, false, errors.Wrapf(err, "failed to load precommitment for %v", sectorNo) + } + return &info, found, nil +} + +func (st *State) DeletePrecommittedSectors(store adt.Store, sectorNos ...abi.SectorNumber) error { + precommitted, err := adt.AsMap(store, st.PreCommittedSectors) + if err != nil { + return err + } + + for _, sectorNo := range sectorNos { + err = precommitted.Delete(SectorKey(sectorNo)) + if err != nil { + return xerrors.Errorf("failed to delete precommitment for %v: %w", sectorNo, err) + } + } + st.PreCommittedSectors, err = precommitted.Root() + return err +} + +func (st *State) HasSectorNo(store adt.Store, sectorNo abi.SectorNumber) (bool, error) { + sectors, err := adt.AsArray(store, st.Sectors) + if err != nil { + return false, err + } + + var info SectorOnChainInfo + found, err := sectors.Get(uint64(sectorNo), &info) + if err != nil { + return false, xerrors.Errorf("failed to get sector %v: %w", sectorNo, err) + } + return found, nil +} + +func (st *State) PutSectors(store adt.Store, newSectors ...*SectorOnChainInfo) error { + sectors, err := adt.AsArray(store, st.Sectors) + if err != nil { + return xerrors.Errorf("failed to load sectors: %w", err) + } + + for _, sector := range newSectors { + if err := sectors.Set(uint64(sector.SectorNumber), sector); err != nil { + return xerrors.Errorf("failed to put sector %v: %w", sector, err) + } + } + + st.Sectors, err = sectors.Root() + if err != nil { + return xerrors.Errorf("failed to persist sectors: %w", err) + } + return nil +} + +func (st *State) GetSector(store adt.Store, sectorNo abi.SectorNumber) (*SectorOnChainInfo, bool, error) { + sectors, err := adt.AsArray(store, st.Sectors) + if err != nil { + return nil, false, err + } + + var info SectorOnChainInfo + found, err := sectors.Get(uint64(sectorNo), &info) + if err != nil { + return nil, false, errors.Wrapf(err, "failed to get sector %v", sectorNo) + } + return &info, found, nil +} + +func (st *State) DeleteSectors(store adt.Store, sectorNos *abi.BitField) error { + sectors, err := adt.AsArray(store, st.Sectors) + if err != nil { + return err + } + err = sectorNos.ForEach(func(sectorNo uint64) error { + if err = sectors.Delete(sectorNo); err != nil { + return errors.Wrapf(err, "failed to delete sector %v", sectorNos) + } + return nil + }) + if err != nil { + return err + } + + st.Sectors, err = sectors.Root() + return err +} + +// Iterates sectors. +// The pointer provided to the callback is not safe for re-use. Copy the pointed-to value in full to hold a reference. +func (st *State) ForEachSector(store adt.Store, f func(*SectorOnChainInfo)) error { + sectors, err := adt.AsArray(store, st.Sectors) + if err != nil { + return err + } + var sector SectorOnChainInfo + return sectors.ForEach(§or, func(idx int64) error { + f(§or) + return nil + }) +} + +// Adds some sector numbers to the new sectors bitfield. +func (st *State) AddNewSectors(sectorNos ...abi.SectorNumber) (err error) { + ns := abi.NewBitField() + for _, sector := range sectorNos { + ns.Set(uint64(sector)) + } + st.NewSectors, err = bitfield.MergeBitFields(st.NewSectors, ns) + if err != nil { + return err + } + + count, err := st.NewSectors.Count() + if err != nil { + return err + } + if count > NewSectorsPerPeriodMax { + return fmt.Errorf("too many new sectors %d, max %d", count, NewSectorsPerPeriodMax) + } + return nil +} + +// Removes some sector numbers from the new sectors bitfield, if present. +func (st *State) RemoveNewSectors(sectorNos *abi.BitField) (err error) { + st.NewSectors, err = bitfield.SubtractBitField(st.NewSectors, sectorNos) + return err +} + +// Gets the sector numbers expiring at some epoch. +func (st *State) GetSectorExpirations(store adt.Store, expiry abi.ChainEpoch) (*abi.BitField, error) { + arr, err := adt.AsArray(store, st.SectorExpirations) + if err != nil { + return nil, err + } + + bf := abi.NewBitField() + _, err = arr.Get(uint64(expiry), bf) + if err != nil { + return nil, err + } + + return bf, nil +} + +// Iterates sector expiration groups in order. +// Note that the sectors bitfield provided to the callback is not safe to store. +func (st *State) ForEachSectorExpiration(store adt.Store, f func(expiry abi.ChainEpoch, sectors *abi.BitField) error) error { + arr, err := adt.AsArray(store, st.SectorExpirations) + if err != nil { + return err + } + + var bf bitfield.BitField + return arr.ForEach(&bf, func(i int64) error { + bfCopy, err := bf.Copy() + if err != nil { + return err + } + return f(abi.ChainEpoch(i), bfCopy) + }) +} + +// Adds some sector numbers to the set expiring at an epoch. +// The sector numbers are given as uint64s to avoid pointless conversions. +func (st *State) AddSectorExpirations(store adt.Store, sectors ...*SectorOnChainInfo) error { + if len(sectors) == 0 { + return nil + } + + arr, err := adt.AsArray(store, st.SectorExpirations) + if err != nil { + return xerrors.Errorf("failed to load sector expirations: %w", err) + } + + for _, epochSet := range groupSectorsByExpiration(sectors) { + bf := new(abi.BitField) + _, err = arr.Get(uint64(epochSet.epoch), bf) + if err != nil { + return xerrors.Errorf("failed to lookup sector expirations at epoch %v: %w", epochSet.epoch, err) + } + + bf, err = bitfield.MergeBitFields(bf, bitfield.NewFromSet(epochSet.sectors)) + if err != nil { + return xerrors.Errorf("failed to update sector expirations at epoch %v: %w", epochSet.epoch, err) + } + count, err := bf.Count() + if err != nil { + return xerrors.Errorf("failed to count sector expirations at epoch %v: %w", epochSet.epoch, err) + } + if count > SectorsMax { + return fmt.Errorf("too many sectors at expiration %d, %d, max %d", epochSet.epoch, count, SectorsMax) + } + + if err = arr.Set(uint64(epochSet.epoch), bf); err != nil { + return xerrors.Errorf("failed to set sector expirations at epoch %v: %w", epochSet.epoch, err) + } + } + + st.SectorExpirations, err = arr.Root() + if err != nil { + return xerrors.Errorf("failed to persist sector expirations: %w", err) + } + return nil +} + +// Removes some sector numbers from the set expiring at an epoch. +func (st *State) RemoveSectorExpirations(store adt.Store, sectors ...*SectorOnChainInfo) error { + if len(sectors) == 0 { + return nil + } + + arr, err := adt.AsArray(store, st.SectorExpirations) + if err != nil { + return xerrors.Errorf("failed to load sector expirations: %w", err) + } + + for _, epochSet := range groupSectorsByExpiration(sectors) { + bf := new(abi.BitField) + _, err = arr.Get(uint64(epochSet.epoch), bf) + if err != nil { + return xerrors.Errorf("failed to lookup sector expirations at epoch %v: %w", epochSet.epoch, err) + } + + bf, err = bitfield.SubtractBitField(bf, bitfield.NewFromSet(epochSet.sectors)) + if err != nil { + return xerrors.Errorf("failed to update sector expirations at epoch %v: %w", epochSet.epoch, err) + } + + if empty, err := bf.IsEmpty(); err != nil { + return xerrors.Errorf("corrupted sector expirations bitfield at epoch %v: %w", epochSet.epoch, err) + } else if empty { + if err := arr.Delete(uint64(epochSet.epoch)); err != nil { + return xerrors.Errorf("failed to delete sector expirations at epoch %v: %w", epochSet.epoch, err) + } + } else if err = arr.Set(uint64(epochSet.epoch), bf); err != nil { + return xerrors.Errorf("failed to set sector expirations at epoch %v: %w", epochSet.epoch, err) + } + } + + st.SectorExpirations, err = arr.Root() + if err != nil { + return xerrors.Errorf("failed to persist sector expirations: %w", err) + } + return nil +} + +// Removes all sector numbers from the set expiring some epochs. +func (st *State) ClearSectorExpirations(store adt.Store, expirations ...abi.ChainEpoch) error { + arr, err := adt.AsArray(store, st.SectorExpirations) + if err != nil { + return err + } + + for _, exp := range expirations { + err = arr.Delete(uint64(exp)) + if err != nil { + return err + } + } + + st.SectorExpirations, err = arr.Root() + return err +} + +// Adds sectors numbers to faults and fault epochs. +func (st *State) AddFaults(store adt.Store, sectorNos *abi.BitField, faultEpoch abi.ChainEpoch) (err error) { + empty, err := sectorNos.IsEmpty() + if err != nil { + return err + } + if empty { + return nil + } + + { + st.Faults, err = bitfield.MergeBitFields(st.Faults, sectorNos) + if err != nil { + return err + } + + count, err := st.Faults.Count() + if err != nil { + return err + } + if count > SectorsMax { + return fmt.Errorf("too many faults %d, max %d", count, SectorsMax) + } + } + + { + epochFaultArr, err := adt.AsArray(store, st.FaultEpochs) + if err != nil { + return err + } + + bf := abi.NewBitField() + _, err = epochFaultArr.Get(uint64(faultEpoch), bf) + if err != nil { + return err + } + + bf, err = bitfield.MergeBitFields(bf, sectorNos) + if err != nil { + return err + } + + if err = epochFaultArr.Set(uint64(faultEpoch), bf); err != nil { + return err + } + + st.FaultEpochs, err = epochFaultArr.Root() + if err != nil { + return err + } + } + + return nil +} + +// Removes sector numbers from faults and fault epochs, if present. +func (st *State) RemoveFaults(store adt.Store, sectorNos *abi.BitField) error { + if empty, err := sectorNos.IsEmpty(); err != nil { + return err + } else if empty { + return nil + } + + if newFaults, err := bitfield.SubtractBitField(st.Faults, sectorNos); err != nil { + return err + } else { + st.Faults = newFaults + } + + arr, err := adt.AsArray(store, st.FaultEpochs) + if err != nil { + return err + } + + type change struct { + index uint64 + value *abi.BitField + } + + var ( + epochsChanged []change + epochsDeleted []uint64 + ) + + epochFaultsOld := &abi.BitField{} + err = arr.ForEach(epochFaultsOld, func(i int64) error { + countOld, err := epochFaultsOld.Count() + if err != nil { + return err + } + + epochFaultsNew, err := bitfield.SubtractBitField(epochFaultsOld, sectorNos) + if err != nil { + return err + } + + countNew, err := epochFaultsNew.Count() + if err != nil { + return err + } + + if countNew == 0 { + epochsDeleted = append(epochsDeleted, uint64(i)) + } else if countOld != countNew { + epochsChanged = append(epochsChanged, change{index: uint64(i), value: epochFaultsNew}) + } + + return nil + }) + if err != nil { + return err + } + + err = arr.BatchDelete(epochsDeleted) + if err != nil { + return err + } + + for _, change := range epochsChanged { + err = arr.Set(change.index, change.value) + if err != nil { + return err + } + } + + st.FaultEpochs, err = arr.Root() + return err +} + +// Iterates faults by declaration epoch, in order. +func (st *State) ForEachFaultEpoch(store adt.Store, cb func(epoch abi.ChainEpoch, faults *abi.BitField) error) error { + arr, err := adt.AsArray(store, st.FaultEpochs) + if err != nil { + return err + } + + var bf bitfield.BitField + return arr.ForEach(&bf, func(i int64) error { + bfCopy, err := bf.Copy() + if err != nil { + return err + } + return cb(abi.ChainEpoch(i), bfCopy) + }) +} + +func (st *State) ClearFaultEpochs(store adt.Store, epochs ...abi.ChainEpoch) error { + arr, err := adt.AsArray(store, st.FaultEpochs) + if err != nil { + return err + } + + for _, exp := range epochs { + err = arr.Delete(uint64(exp)) + if err != nil { + return nil + } + } + + st.FaultEpochs, err = arr.Root() + return err +} + +// Adds sectors to recoveries. +func (st *State) AddRecoveries(sectorNos *abi.BitField) (err error) { + empty, err := sectorNos.IsEmpty() + if err != nil { + return err + } + if empty { + return nil + } + st.Recoveries, err = bitfield.MergeBitFields(st.Recoveries, sectorNos) + if err != nil { + return err + } + + count, err := st.Recoveries.Count() + if err != nil { + return err + } + if count > SectorsMax { + return fmt.Errorf("too many recoveries %d, max %d", count, SectorsMax) + } + return nil +} + +// Removes sectors from recoveries, if present. +func (st *State) RemoveRecoveries(sectorNos *abi.BitField) (err error) { + empty, err := sectorNos.IsEmpty() + if err != nil { + return err + } + if empty { + return nil + } + st.Recoveries, err = bitfield.SubtractBitField(st.Recoveries, sectorNos) + return err +} + +// Loads sector info for a sequence of sectors. +func (st *State) LoadSectorInfos(store adt.Store, sectors *abi.BitField) ([]*SectorOnChainInfo, error) { + var sectorInfos []*SectorOnChainInfo + err := sectors.ForEach(func(i uint64) error { + sectorOnChain, found, err := st.GetSector(store, abi.SectorNumber(i)) + if err != nil { + return xerrors.Errorf("failed to load sector %d: %w", i, err) + } else if !found { + return fmt.Errorf("can't find sector %d", i) + } + sectorInfos = append(sectorInfos, sectorOnChain) + return nil + }) + return sectorInfos, err +} + +// Loads info for a set of sectors to be proven. +// If any of the sectors are declared faulty and not to be recovered, info for the first non-faulty sector is substituted instead. +// If any of the sectors are declared recovered, they are returned from this method. +func (st *State) LoadSectorInfosForProof(store adt.Store, provenSectors *abi.BitField) (sectorInfos []*SectorOnChainInfo, recoveries *bitfield.BitField, err error) { + // Extract a fault set relevant to the sectors being submitted, for expansion into a map. + declaredFaults, err := bitfield.IntersectBitField(provenSectors, st.Faults) + if err != nil { + return nil, nil, xerrors.Errorf("failed to intersect proof sectors with faults: %w", err) + } + + recoveries, err = bitfield.IntersectBitField(declaredFaults, st.Recoveries) + if err != nil { + return nil, nil, xerrors.Errorf("failed to intersect recoveries with faults: %w", err) + } + + expectedFaults, err := bitfield.SubtractBitField(declaredFaults, recoveries) + if err != nil { + return nil, nil, xerrors.Errorf("failed to subtract recoveries from faults: %w", err) + } + + nonFaults, err := bitfield.SubtractBitField(provenSectors, expectedFaults) + if err != nil { + return nil, nil, xerrors.Errorf("failed to diff bitfields: %w", err) + } + + // return empty if no non-faults + empty, err := nonFaults.IsEmpty() + if err != nil { + return nil, nil, xerrors.Errorf("failed to check if bitfield was empty: %w", err) + } + if empty { + return nil, recoveries, nil + } + + // Select a non-faulty sector as a substitute for faulty ones. + goodSectorNo, err := nonFaults.First() + if err != nil { + return nil, nil, xerrors.Errorf("failed to get first good sector: %w", err) + } + + // Load sector infos + sectorInfos, err = st.LoadSectorInfosWithFaultMask(store, provenSectors, expectedFaults, abi.SectorNumber(goodSectorNo)) + if err != nil { + return nil, nil, xerrors.Errorf("failed to load sector infos: %w", err) + } + return +} + +// Loads sector info for a sequence of sectors, substituting info for a stand-in sector for any that are faulty. +func (st *State) LoadSectorInfosWithFaultMask(store adt.Store, sectors *abi.BitField, faults *abi.BitField, faultStandIn abi.SectorNumber) ([]*SectorOnChainInfo, error) { + standInInfo, found, err := st.GetSector(store, faultStandIn) + if err != nil { + return nil, fmt.Errorf("failed to load stand-in sector %d: %v", faultStandIn, err) + } else if !found { + return nil, fmt.Errorf("can't find stand-in sector %d", faultStandIn) + } + + // Expand faults into a map for quick lookups. + // The faults bitfield should already be a subset of the sectors bitfield. + sectorCount, err := sectors.Count() + if err != nil { + return nil, err + } + faultSet, err := faults.AllMap(sectorCount) + if err != nil { + return nil, fmt.Errorf("failed to expand faults: %w", err) + } + + // Load the sector infos, masking out fault sectors with a good one. + sectorInfos := make([]*SectorOnChainInfo, 0, sectorCount) + err = sectors.ForEach(func(i uint64) error { + sector := standInInfo + faulty := faultSet[i] + if !faulty { + sectorOnChain, found, err := st.GetSector(store, abi.SectorNumber(i)) + if err != nil { + return xerrors.Errorf("failed to load sector %d: %w", i, err) + } else if !found { + return fmt.Errorf("can't find sector %d", i) + } + sector = sectorOnChain + } + sectorInfos = append(sectorInfos, sector) + return nil + }) + return sectorInfos, err +} + +// Adds partition numbers to the set of PoSt submissions +func (st *State) AddPoStSubmissions(partitionNos *abi.BitField) (err error) { + st.PostSubmissions, err = bitfield.MergeBitFields(st.PostSubmissions, partitionNos) + return err +} + +// Removes all PoSt submissions +func (st *State) ClearPoStSubmissions() error { + st.PostSubmissions = abi.NewBitField() + return nil +} + +func (st *State) LoadDeadlines(store adt.Store) (*Deadlines, error) { + var deadlines Deadlines + if err := store.Get(store.Context(), st.Deadlines, &deadlines); err != nil { + return nil, fmt.Errorf("failed to load deadlines (%s): %w", st.Deadlines, err) + } + + return &deadlines, nil +} + +func (st *State) SaveDeadlines(store adt.Store, deadlines *Deadlines) error { + c, err := store.Put(store.Context(), deadlines) + if err != nil { + return err + } + st.Deadlines = c + return nil +} + +// +// PoSt Deadlines and partitions +// + +type Deadlines struct { + // A bitfield of sector numbers due at each deadline. + // The sectors for each deadline are logically grouped into sequential partitions for proving. + Due [WPoStPeriodDeadlines]*abi.BitField +} + +func ConstructDeadlines() *Deadlines { + d := &Deadlines{Due: [WPoStPeriodDeadlines]*abi.BitField{}} + for i := range d.Due { + d.Due[i] = abi.NewBitField() + } + return d +} + +// Adds sector numbers to a deadline. +// The sector numbers are given as uint64 to avoid pointless conversions for bitfield use. +func (d *Deadlines) AddToDeadline(deadline uint64, newSectors ...uint64) (err error) { + ns := bitfield.NewFromSet(newSectors) + d.Due[deadline], err = bitfield.MergeBitFields(d.Due[deadline], ns) + return err +} + +// Removes sector numbers from all deadlines. +func (d *Deadlines) RemoveFromAllDeadlines(sectorNos *abi.BitField) (err error) { + for i := range d.Due { + d.Due[i], err = bitfield.SubtractBitField(d.Due[i], sectorNos) + if err != nil { + return err + } + } + return nil +} + +// +// Funds and vesting +// + +func (st *State) AddPreCommitDeposit(amount abi.TokenAmount) { + newTotal := big.Add(st.PreCommitDeposits, amount) + AssertMsg(newTotal.GreaterThanEqual(big.Zero()), "negative pre-commit deposit %s after adding %s to prior %s", + newTotal, amount, st.PreCommitDeposits) + st.PreCommitDeposits = newTotal +} + +func (st *State) AddInitialPledgeRequirement(amount abi.TokenAmount) { + newTotal := big.Add(st.InitialPledgeRequirement, amount) + AssertMsg(newTotal.GreaterThanEqual(big.Zero()), "negative initial pledge %s after adding %s to prior %s", + newTotal, amount, st.InitialPledgeRequirement) + st.InitialPledgeRequirement = newTotal +} + +func (st *State) AddLockedFunds(store adt.Store, currEpoch abi.ChainEpoch, vestingSum abi.TokenAmount, spec *VestSpec) error { + AssertMsg(vestingSum.GreaterThanEqual(big.Zero()), "negative vesting sum %s", vestingSum) + vestingFunds, err := adt.AsArray(store, st.VestingFunds) + if err != nil { + return err + } + + // Nothing unlocks here, this is just the start of the clock. + vestBegin := currEpoch + spec.InitialDelay + vestPeriod := big.NewInt(int64(spec.VestPeriod)) + vestedSoFar := big.Zero() + for e := vestBegin + spec.StepDuration; vestedSoFar.LessThan(vestingSum); e += spec.StepDuration { + vestEpoch := quantizeUp(e, spec.Quantization, st.ProvingPeriodStart) + elapsed := vestEpoch - vestBegin + + targetVest := big.Zero() //nolint:ineffassign + if elapsed < spec.VestPeriod { + // Linear vesting, PARAM_FINISH + targetVest = big.Div(big.Mul(vestingSum, big.NewInt(int64(elapsed))), vestPeriod) + } else { + targetVest = vestingSum + } + + vestThisTime := big.Sub(targetVest, vestedSoFar) + vestedSoFar = targetVest + + // Load existing entry, else set a new one + key := EpochKey(vestEpoch) + lockedFundEntry := big.Zero() + _, err = vestingFunds.Get(key, &lockedFundEntry) + if err != nil { + return err + } + + lockedFundEntry = big.Add(lockedFundEntry, vestThisTime) + err = vestingFunds.Set(key, &lockedFundEntry) + if err != nil { + return err + } + } + + st.VestingFunds, err = vestingFunds.Root() + if err != nil { + return err + } + st.LockedFunds = big.Add(st.LockedFunds, vestingSum) + + return nil +} + +// Unlocks an amount of funds that have *not yet vested*, if possible. +// The soonest-vesting entries are unlocked first. +// Returns the amount actually unlocked. +func (st *State) UnlockUnvestedFunds(store adt.Store, currEpoch abi.ChainEpoch, target abi.TokenAmount) (abi.TokenAmount, error) { + vestingFunds, err := adt.AsArray(store, st.VestingFunds) + if err != nil { + return big.Zero(), err + } + + amountUnlocked := abi.NewTokenAmount(0) + lockedEntry := abi.NewTokenAmount(0) + var toDelete []uint64 + var finished = fmt.Errorf("finished") + + // Iterate vestingFunds are in order of release. + err = vestingFunds.ForEach(&lockedEntry, func(k int64) error { + if amountUnlocked.LessThan(target) { + if k >= int64(currEpoch) { + unlockAmount := big.Min(big.Sub(target, amountUnlocked), lockedEntry) + amountUnlocked = big.Add(amountUnlocked, unlockAmount) + lockedEntry = big.Sub(lockedEntry, unlockAmount) + + if lockedEntry.IsZero() { + toDelete = append(toDelete, uint64(k)) + } else { + if err = vestingFunds.Set(uint64(k), &lockedEntry); err != nil { + return err + } + } + } + return nil + } else { + return finished + } + }) + + if err != nil && err != finished { + return big.Zero(), err + } + + err = deleteMany(vestingFunds, toDelete) + if err != nil { + return big.Zero(), errors.Wrapf(err, "failed to delete locked fund during slash: %v", err) + } + + st.LockedFunds = big.Sub(st.LockedFunds, amountUnlocked) + Assert(st.LockedFunds.GreaterThanEqual(big.Zero())) + st.VestingFunds, err = vestingFunds.Root() + if err != nil { + return big.Zero(), err + } + + return amountUnlocked, nil +} + +// Unlocks all vesting funds that have vested before the provided epoch. +// Returns the amount unlocked. +func (st *State) UnlockVestedFunds(store adt.Store, currEpoch abi.ChainEpoch) (abi.TokenAmount, error) { + vestingFunds, err := adt.AsArray(store, st.VestingFunds) + if err != nil { + return big.Zero(), err + } + + amountUnlocked := abi.NewTokenAmount(0) + lockedEntry := abi.NewTokenAmount(0) + var toDelete []uint64 + var finished = fmt.Errorf("finished") + + // Iterate vestingFunds in order of release. + err = vestingFunds.ForEach(&lockedEntry, func(k int64) error { + if k < int64(currEpoch) { + amountUnlocked = big.Add(amountUnlocked, lockedEntry) + toDelete = append(toDelete, uint64(k)) + } else { + return finished // stop iterating + } + return nil + }) + + if err != nil && err != finished { + return big.Zero(), err + } + + err = deleteMany(vestingFunds, toDelete) + if err != nil { + return big.Zero(), errors.Wrapf(err, "failed to delete locked fund during vest: %v", err) + } + + st.LockedFunds = big.Sub(st.LockedFunds, amountUnlocked) + Assert(st.LockedFunds.GreaterThanEqual(big.Zero())) + st.VestingFunds, err = vestingFunds.Root() + if err != nil { + return big.Zero(), err + } + + return amountUnlocked, nil +} + +// CheckVestedFunds returns the amount of vested funds that have vested before the provided epoch. +func (st *State) CheckVestedFunds(store adt.Store, currEpoch abi.ChainEpoch) (abi.TokenAmount, error) { + vestingFunds, err := adt.AsArray(store, st.VestingFunds) + if err != nil { + return big.Zero(), err + } + + amountUnlocked := abi.NewTokenAmount(0) + lockedEntry := abi.NewTokenAmount(0) + var finished = fmt.Errorf("finished") + + // Iterate vestingFunds in order of release. + err = vestingFunds.ForEach(&lockedEntry, func(k int64) error { + if k < int64(currEpoch) { + amountUnlocked = big.Add(amountUnlocked, lockedEntry) + } else { + return finished // stop iterating + } + return nil + }) + if err != nil && err != finished { + return big.Zero(), err + } + + return amountUnlocked, nil +} + +func (st *State) GetAvailableBalance(actorBalance abi.TokenAmount) abi.TokenAmount { + availableBal := big.Sub(big.Sub(actorBalance, st.LockedFunds), st.PreCommitDeposits) + Assert(availableBal.GreaterThanEqual(big.Zero())) + return availableBal +} + +func (st *State) AssertBalanceInvariants(balance abi.TokenAmount) { + Assert(st.PreCommitDeposits.GreaterThanEqual(big.Zero())) + Assert(st.LockedFunds.GreaterThanEqual(big.Zero())) + Assert(balance.GreaterThanEqual(big.Add(st.PreCommitDeposits, st.LockedFunds))) +} + +// +// Sectors +// + +func (s *SectorOnChainInfo) AsSectorInfo() abi.SectorInfo { + return abi.SectorInfo{ + SealProof: s.SealProof, + SectorNumber: s.SectorNumber, + SealedCID: s.SealedCID, + } +} + +// +// Misc helpers +// + +func deleteMany(arr *adt.Array, keys []uint64) error { + // If AMT exposed a batch delete we could save some writes here. + for _, i := range keys { + err := arr.Delete(i) + if err != nil { + return err + } + } + return nil +} + +// Rounds e to the nearest exact multiple of the quantization unit offset by +// offsetSeed % unit, rounding up. +// This function is equivalent to `unit * ceil(e - (offsetSeed % unit) / unit) + (offsetSeed % unit)` +// with the variables/operations are over real numbers instead of ints. +// Precondition: unit >= 0 else behaviour is undefined +func quantizeUp(e abi.ChainEpoch, unit abi.ChainEpoch, offsetSeed abi.ChainEpoch) abi.ChainEpoch { + offset := offsetSeed % unit + + remainder := (e - offset) % unit + quotient := (e - offset) / unit + // Don't round if epoch falls on a quantization epoch + if remainder == 0 { + return unit*quotient + offset + } + // Negative truncating division rounds up + if e-offset < 0 { + return unit*quotient + offset + } + return unit*(quotient+1) + offset + +} + +func SectorKey(e abi.SectorNumber) adt.Keyer { + return adt.UIntKey(uint64(e)) +} + +func EpochKey(e abi.ChainEpoch) uint64 { + return uint64(e) +} + +func init() { + // Check that ChainEpoch is indeed an unsigned integer to confirm that SectorKey is making the right interpretation. + var e abi.SectorNumber + if reflect.TypeOf(e).Kind() != reflect.Uint64 { + panic("incorrect sector number encoding") + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_state_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_state_test.go new file mode 100644 index 000000000..c6c7c35fb --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_state_test.go @@ -0,0 +1,1089 @@ +package miner_test + +import ( + "context" + "fmt" + "testing" + + "github.com/filecoin-project/go-bitfield" + cid "github.com/ipfs/go-cid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin/miner" + "github.com/filecoin-project/specs-actors/actors/util/adt" + "github.com/filecoin-project/specs-actors/support/ipld" + tutils "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestPrecommittedSectorsStore(t *testing.T) { + t.Run("Put, get and delete", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + sectorNo := abi.SectorNumber(1) + + pc1 := newSectorPreCommitOnChainInfo(sectorNo, tutils.MakeCID("1"), abi.NewTokenAmount(1), abi.ChainEpoch(1)) + harness.putPreCommit(pc1) + assert.Equal(t, pc1, harness.getPreCommit(sectorNo)) + + pc2 := newSectorPreCommitOnChainInfo(sectorNo, tutils.MakeCID("2"), abi.NewTokenAmount(1), abi.ChainEpoch(1)) + harness.putPreCommit(pc2) + assert.Equal(t, pc2, harness.getPreCommit(sectorNo)) + + harness.deletePreCommit(sectorNo) + assert.False(t, harness.hasPreCommit(sectorNo)) + }) + + t.Run("Delete nonexistent value returns an error", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + sectorNo := abi.SectorNumber(1) + err := harness.s.DeletePrecommittedSectors(harness.store, sectorNo) + assert.Error(t, err) + }) + + t.Run("Get nonexistent value returns false", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + sectorNo := abi.SectorNumber(1) + assert.False(t, harness.hasPreCommit(sectorNo)) + }) +} + +func TestSectorsStore(t *testing.T) { + t.Run("Put get and delete", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNo := abi.SectorNumber(1) + sectorInfo1 := newSectorOnChainInfo(sectorNo, tutils.MakeCID("1"), big.NewInt(1), abi.ChainEpoch(1)) + sectorInfo2 := newSectorOnChainInfo(sectorNo, tutils.MakeCID("2"), big.NewInt(2), abi.ChainEpoch(2)) + + harness.putSector(sectorInfo1) + assert.True(t, harness.hasSectorNo(sectorNo)) + out := harness.getSector(sectorNo) + assert.Equal(t, sectorInfo1, out) + + harness.putSector(sectorInfo2) + out = harness.getSector(sectorNo) + assert.Equal(t, sectorInfo2, out) + + harness.deleteSectors(uint64(sectorNo)) + assert.False(t, harness.hasSectorNo(sectorNo)) + }) + + t.Run("Delete nonexistent value returns an error", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNo := abi.SectorNumber(1) + bf := abi.NewBitField() + bf.Set(uint64(sectorNo)) + + assert.Error(t, harness.s.DeleteSectors(harness.store, bf)) + }) + + t.Run("Get nonexistent value returns false", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNo := abi.SectorNumber(1) + assert.False(t, harness.hasSectorNo(sectorNo)) + }) + + t.Run("Iterate and Delete multiple sector", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + // set of sectors, the larger numbers here are not significant + sectorNos := []uint64{100, 200, 300, 400, 500, 600, 700, 800, 900, 1000} + + // put all the sectors in the store + for _, s := range sectorNos { + i := int64(0) + harness.putSector(newSectorOnChainInfo(abi.SectorNumber(s), tutils.MakeCID(fmt.Sprintf("%d", i)), big.NewInt(i), abi.ChainEpoch(i))) + i++ + } + + sectorNoIdx := 0 + err := harness.s.ForEachSector(harness.store, func(si *miner.SectorOnChainInfo) { + require.Equal(t, abi.SectorNumber(sectorNos[sectorNoIdx]), si.SectorNumber) + sectorNoIdx++ + }) + assert.NoError(t, err) + + // ensure we iterated over the expected number of sectors + assert.Equal(t, len(sectorNos), sectorNoIdx) + + harness.deleteSectors(sectorNos...) + for _, s := range sectorNos { + assert.False(t, harness.hasSectorNo(abi.SectorNumber(s))) + } + }) +} + +func TestNewSectorsBitField(t *testing.T) { + t.Run("Add new sectors happy path", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + // set of sectors, the larger numbers here are not significant + sectorNos := []abi.SectorNumber{100, 200, 300, 400, 500, 600, 700, 800, 900, 1000} + harness.addNewSectors(sectorNos...) + assert.Equal(t, uint64(len(sectorNos)), harness.getNewSectorCount()) + }) + + t.Run("Add new sectors excludes duplicates", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNos := []abi.SectorNumber{1, 1, 2, 2, 3, 4, 5} + harness.addNewSectors(sectorNos...) + assert.Equal(t, uint64(5), harness.getNewSectorCount()) + }) + + t.Run("Remove sectors happy path", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNos := []abi.SectorNumber{1, 2, 3, 4, 5} + harness.addNewSectors(sectorNos...) + assert.Equal(t, uint64(len(sectorNos)), harness.getNewSectorCount()) + + harness.removeNewSectors(1, 3, 5) + assert.Equal(t, uint64(2), harness.getNewSectorCount()) + + sm, err := harness.s.NewSectors.All(uint64(len(sectorNos))) + assert.NoError(t, err) + assert.Equal(t, []uint64{2, 4}, sm) + }) + + t.Run("Add New sectors errors when adding too many new sectors", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + tooManySectors := make([]abi.SectorNumber, miner.NewSectorsPerPeriodMax+1) + for i := abi.SectorNumber(0); i < miner.NewSectorsPerPeriodMax+1; i++ { + tooManySectors[i] = i + } + + err := harness.s.AddNewSectors(tooManySectors...) + assert.Error(t, err) + + // sanity check nothing was added + // For omission reason see: https://github.com/filecoin-project/specs-actors/issues/300 + //assert.Equal(t, uint64(0), actorHarness.getNewSectorCount()) + }) +} + +func TestSectorExpirationStore(t *testing.T) { + exp1 := abi.ChainEpoch(10) + exp2 := abi.ChainEpoch(20) + sectorExpirations := map[abi.ChainEpoch][]uint64{ + exp1: {1, 2, 3, 4, 5}, + exp2: {6, 7, 8, 9, 10}, + } + + t.Run("Round trip add get sector expirations", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + harness.addSectorExpiration(exp1, sectorExpirations[exp1]...) + harness.addSectorExpiration(exp2, sectorExpirations[exp2]...) + + assert.Equal(t, sectorExpirations[exp1], harness.getSectorExpirations(exp1)) + assert.Equal(t, sectorExpirations[exp2], harness.getSectorExpirations(exp2)) + + // return nothing if there are no sectors at the epoch + assert.Empty(t, harness.getSectorExpirations(abi.ChainEpoch(0))) + + // remove the first sector from expiration set 1 + harness.removeSectorExpiration(exp1, sectorExpirations[exp1][0]) + assert.Equal(t, sectorExpirations[exp1][1:], harness.getSectorExpirations(exp1)) + assert.Equal(t, sectorExpirations[exp2], harness.getSectorExpirations(exp2)) // No change + + // remove all sectors from expiration set 2 + harness.removeSectorExpiration(exp2, sectorExpirations[exp2]...) + assert.Empty(t, harness.getSectorExpirations(exp2)) + + // Remove remainder + harness.removeSectorExpiration(exp1, sectorExpirations[exp1][1:]...) + err := harness.s.ForEachSectorExpiration(harness.store, func(epoch abi.ChainEpoch, expirations *abi.BitField) error { + assert.Fail(t, "unexpected expiration epoch: %v", epoch) + return nil + }) + require.NoError(t, err) + }) + + t.Run("Iteration by expiration", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + harness.addSectorExpiration(exp1, sectorExpirations[exp1]...) + harness.addSectorExpiration(exp2, sectorExpirations[exp2]...) + + var prevCallbackArg *abi.BitField + found := map[abi.ChainEpoch][]uint64{} + err := harness.s.ForEachSectorExpiration(harness.store, func(epoch abi.ChainEpoch, expirations *abi.BitField) error { + sectors, err := expirations.All(100) + require.NoError(t, err) + found[epoch] = sectors + + // Check that bitfield pointer argument is newly allocated, not re-used + assert.True(t, prevCallbackArg != expirations) + prevCallbackArg = expirations + return nil + }) + assert.NoError(t, err) + assert.Equal(t, sectorExpirations, found) + }) + + t.Run("Adding sectors at expiry merges with existing", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + mergedSectors := []uint64{21, 22, 23, 24, 25} + harness.addSectorExpiration(exp1, sectorExpirations[exp1]...) + harness.addSectorExpiration(exp1, mergedSectors...) + + merged := harness.getSectorExpirations(exp1) + assert.Equal(t, append(sectorExpirations[exp1], mergedSectors...), merged) + }) + + t.Run("clear sectors by expirations", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + harness.addSectorExpiration(exp1, sectorExpirations[exp1]...) + harness.addSectorExpiration(exp2, sectorExpirations[exp2]...) + + // ensure clearing works + harness.clearSectorExpiration(exp1, exp2) + empty1 := harness.getSectorExpirations(exp1) + assert.Empty(t, empty1) + + empty2 := harness.getSectorExpirations(exp2) + assert.Empty(t, empty2) + }) +} + +func TestFaultStore(t *testing.T) { + fault1 := abi.ChainEpoch(10) + fault2 := abi.ChainEpoch(20) + sectorFaults := map[abi.ChainEpoch][]uint64{ + fault1: {1, 2, 3, 4, 5}, + fault2: {6, 7, 8, 9, 10, 11}, + } + + t.Run("Add/remove all", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + harness.addFaults(fault1, sectorFaults[fault1]...) + harness.addFaults(fault2, sectorFaults[fault2]...) + + found := map[abi.ChainEpoch][]uint64{} + var prevCallbackArg *abi.BitField + err := harness.s.ForEachFaultEpoch(harness.store, func(epoch abi.ChainEpoch, faults *abi.BitField) error { + sectors, err := faults.All(100) + require.NoError(t, err) + found[epoch] = sectors + + // Assert the bitfield pointer is pointing to a distinct object on different calls, so that holding on + // to the reference is safe. + assert.True(t, faults != prevCallbackArg) + prevCallbackArg = faults + return nil + }) + require.NoError(t, err) + assert.Equal(t, sectorFaults, found) + + // remove all the faults + harness.removeFaults(sectorFaults[fault1]...) + harness.removeFaults(sectorFaults[fault2]...) + err = harness.s.ForEachFaultEpoch(harness.store, func(epoch abi.ChainEpoch, faults *abi.BitField) error { + assert.Fail(t, "unexpected fault epoch: %v", epoch) + return nil + }) + require.NoError(t, err) + }) + + t.Run("Add/remove some", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + harness.addFaults(fault1, sectorFaults[fault1]...) + harness.addFaults(fault2, sectorFaults[fault2]...) + + found := map[abi.ChainEpoch][]uint64{} + err := harness.s.ForEachFaultEpoch(harness.store, func(epoch abi.ChainEpoch, faults *abi.BitField) error { + sectors, err := faults.All(100) + require.NoError(t, err) + found[epoch] = sectors + return nil + }) + require.NoError(t, err) + assert.Equal(t, sectorFaults, found) + + // remove the faults + harness.removeFaults(sectorFaults[fault1][1:]...) + harness.removeFaults(sectorFaults[fault2][2:]...) + + found = map[abi.ChainEpoch][]uint64{} + err = harness.s.ForEachFaultEpoch(harness.store, func(epoch abi.ChainEpoch, faults *abi.BitField) error { + sectors, err := faults.All(100) + require.NoError(t, err) + found[epoch] = sectors + return nil + }) + require.NoError(t, err) + expected := map[abi.ChainEpoch][]uint64{ + fault1: {1}, + fault2: {6, 7}, + } + assert.Equal(t, expected, found) // FOIXME + }) + + t.Run("Clear all", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + harness.addFaults(fault1, []uint64{1, 2, 3, 4, 5}...) + harness.addFaults(fault2, []uint64{6, 7, 8, 9, 10, 11}...) + + // now clear all the faults + err := harness.s.ClearFaultEpochs(harness.store, fault1, fault2) + require.NoError(t, err) + + err = harness.s.ForEachFaultEpoch(harness.store, func(epoch abi.ChainEpoch, faults *abi.BitField) error { + assert.Fail(t, "unexpected fault epoch: %v", epoch) + return nil + }) + require.NoError(t, err) + }) +} + +func TestRecoveriesBitfield(t *testing.T) { + t.Run("Add new recoveries happy path", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + // set of sectors, the larger numbers here are not significant + sectorNos := []uint64{100, 200, 300, 400, 500, 600, 700, 800, 900, 1000} + harness.addRecoveries(sectorNos...) + assert.Equal(t, uint64(len(sectorNos)), harness.getRecoveriesCount()) + }) + + t.Run("Add new recoveries excludes duplicates", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNos := []uint64{1, 1, 2, 2, 3, 4, 5} + harness.addRecoveries(sectorNos...) + assert.Equal(t, uint64(5), harness.getRecoveriesCount()) + }) + + t.Run("Remove recoveries happy path", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNos := []uint64{1, 2, 3, 4, 5} + harness.addRecoveries(sectorNos...) + assert.Equal(t, uint64(len(sectorNos)), harness.getRecoveriesCount()) + + harness.removeRecoveries(1, 3, 5) + assert.Equal(t, uint64(2), harness.getRecoveriesCount()) + + recoveries, err := harness.s.Recoveries.All(uint64(len(sectorNos))) + assert.NoError(t, err) + assert.Equal(t, []uint64{2, 4}, recoveries) + }) +} + +func TestPostSubmissionsBitfield(t *testing.T) { + t.Run("Add new submission happy path", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + // set of sectors, the larger numbers here are not significant + partitionNos := []uint64{10, 20, 30, 40} + harness.addPoStSubmissions(partitionNos...) + assert.Equal(t, uint64(len(partitionNos)), harness.getPoStSubmissionsCount()) + }) + + t.Run("Add new submission excludes duplicates", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNos := []uint64{1, 1, 2, 2, 3, 4, 5} + harness.addPoStSubmissions(sectorNos...) + assert.Equal(t, uint64(5), harness.getPoStSubmissionsCount()) + }) + + t.Run("Clear submission happy path", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + + sectorNos := []uint64{1, 2, 3, 4, 5} + harness.addPoStSubmissions(sectorNos...) + assert.Equal(t, uint64(len(sectorNos)), harness.getPoStSubmissionsCount()) + + harness.clearPoStSubmissions() + assert.Equal(t, uint64(0), harness.getPoStSubmissionsCount()) + }) +} + +func TestVesting_AddLockedFunds_Table(t *testing.T) { + vestStartDelay := abi.ChainEpoch(10) + vestSum := int64(100) + + testcase := []struct { + desc string + vspec *miner.VestSpec + periodStart abi.ChainEpoch + vepocs []int64 + }{ + { + desc: "vest funds in a single epoch", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 1, + StepDuration: 1, + Quantization: 1, + }, + vepocs: []int64{0, 0, 100, 0}, + }, + { + desc: "vest funds with period=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 2, + StepDuration: 1, + Quantization: 1, + }, + vepocs: []int64{0, 0, 50, 50, 0}, + }, + { + desc: "vest funds with period=2 quantization=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 2, + StepDuration: 1, + Quantization: 2, + }, + vepocs: []int64{0, 0, 0, 100, 0}, + }, + {desc: "vest funds with period=3", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 3, + StepDuration: 1, + Quantization: 1, + }, + vepocs: []int64{0, 0, 33, 33, 34, 0}, + }, + { + desc: "vest funds with period=3 quantization=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 3, + StepDuration: 1, + Quantization: 2, + }, + vepocs: []int64{0, 0, 0, 66, 0, 34, 0}, + }, + {desc: "vest funds with period=2 step=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 2, + StepDuration: 2, + Quantization: 1, + }, + vepocs: []int64{0, 0, 0, 100, 0}, + }, + { + desc: "vest funds with period=5 step=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 2, + Quantization: 1, + }, + vepocs: []int64{0, 0, 0, 40, 0, 40, 0, 20, 0}, + }, + { + desc: "vest funds with delay=1 period=5 step=2", + vspec: &miner.VestSpec{ + InitialDelay: 1, + VestPeriod: 5, + StepDuration: 2, + Quantization: 1, + }, + vepocs: []int64{0, 0, 0, 0, 40, 0, 40, 0, 20, 0}, + }, + { + desc: "vest funds with period=5 step=2 quantization=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 2, + Quantization: 2, + }, + vepocs: []int64{0, 0, 0, 40, 0, 40, 0, 20, 0}, + }, + { + desc: "vest funds with period=5 step=3 quantization=1", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 3, + Quantization: 1, + }, + vepocs: []int64{0, 0, 0, 0, 60, 0, 0, 40, 0}, + }, + { + desc: "vest funds with period=5 step=3 quantization=2", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 3, + Quantization: 2, + }, + vepocs: []int64{0, 0, 0, 0, 0, 80, 0, 20, 0}, + }, + { + desc: "(step greater than period) vest funds with period=5 step=6 quantization=1", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 6, + Quantization: 1, + }, + vepocs: []int64{0, 0, 0, 0, 0, 0, 0, 100, 0}, + }, + { + desc: "vest funds with delay=5 period=5 step=1 quantization=1", + vspec: &miner.VestSpec{ + InitialDelay: 5, + VestPeriod: 5, + StepDuration: 1, + Quantization: 1, + }, + vepocs: []int64{0, 0, 0, 0, 0, 0, 0, 20, 20, 20, 20, 20, 0}, + }, + { + desc: "vest funds with offset 0", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 10, + StepDuration: 2, + Quantization: 2, + }, + vepocs: []int64{0, 0, 0, 20, 0, 20, 0, 20, 0, 20, 0, 20}, + }, + { + desc: "vest funds with offset 1", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 10, + StepDuration: 2, + Quantization: 2, + }, + periodStart: abi.ChainEpoch(1), + // start epoch is at 11 instead of 10 so vepocs are shifted by one from above case + vepocs: []int64{0, 0, 0, 20, 0, 20, 0, 20, 0, 20, 0, 20}, + }, + { + desc: "vest funds with proving period start > quantization unit", + vspec: &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 10, + StepDuration: 2, + Quantization: 2, + }, + // 55 % 2 = 1 so expect same vepocs with offset 1 as in previous case + periodStart: abi.ChainEpoch(55), + vepocs: []int64{0, 0, 0, 20, 0, 20, 0, 20, 0, 20, 0, 20}, + }, + } + for _, tc := range testcase { + t.Run(tc.desc, func(t *testing.T) { + harness := constructStateHarness(t, tc.periodStart) + vestStart := tc.periodStart + vestStartDelay + + harness.addLockedFunds(vestStart, abi.NewTokenAmount(vestSum), tc.vspec) + assert.Equal(t, abi.NewTokenAmount(vestSum), harness.s.LockedFunds) + + var totalVested int64 + for e, v := range tc.vepocs { + assert.Equal(t, abi.NewTokenAmount(v), harness.unlockVestedFunds(vestStart+abi.ChainEpoch(e))) + totalVested += v + assert.Equal(t, vestSum-totalVested, harness.s.LockedFunds.Int64()) + } + + assert.Equal(t, abi.NewTokenAmount(vestSum), abi.NewTokenAmount(totalVested)) + assert.True(t, harness.vestingFundsStoreEmpty()) + assert.Zero(t, harness.s.LockedFunds.Int64()) + }) + } +} + +func TestVestingFunds_AddLockedFunds(t *testing.T) { + t.Run("LockedFunds increases with sequential calls", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + vspec := &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 1, + StepDuration: 1, + Quantization: 1, + } + + vestStart := abi.ChainEpoch(10) + vestSum := abi.NewTokenAmount(100) + + harness.addLockedFunds(vestStart, vestSum, vspec) + assert.Equal(t, vestSum, harness.s.LockedFunds) + + harness.addLockedFunds(vestStart, vestSum, vspec) + assert.Equal(t, big.Mul(vestSum, big.NewInt(2)), harness.s.LockedFunds) + }) + + t.Run("Vests when quantize, step duration, and vesting period are coprime", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + vspec := &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 27, + StepDuration: 5, + Quantization: 7, + } + vestStart := abi.ChainEpoch(10) + vestSum := abi.NewTokenAmount(100) + harness.addLockedFunds(vestStart, vestSum, vspec) + assert.Equal(t, vestSum, harness.s.LockedFunds) + + totalVested := abi.NewTokenAmount(0) + for e := vestStart; e <= 43; e++ { + amountVested := harness.unlockVestedFunds(e) + switch e { + case 22: + assert.Equal(t, abi.NewTokenAmount(40), amountVested) + totalVested = big.Add(totalVested, amountVested) + case 29: + assert.Equal(t, abi.NewTokenAmount(26), amountVested) + totalVested = big.Add(totalVested, amountVested) + case 36: + assert.Equal(t, abi.NewTokenAmount(26), amountVested) + totalVested = big.Add(totalVested, amountVested) + case 43: + assert.Equal(t, abi.NewTokenAmount(8), amountVested) + totalVested = big.Add(totalVested, amountVested) + default: + assert.Equal(t, abi.NewTokenAmount(0), amountVested) + } + } + assert.Equal(t, vestSum, totalVested) + assert.Zero(t, harness.s.LockedFunds.Int64()) + assert.True(t, harness.vestingFundsStoreEmpty()) + }) +} + +func TestVestingFunds_UnvestedFunds(t *testing.T) { + t.Run("Unlock unvested funds leaving bucket with non-zero tokens", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + vspec := &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 1, + Quantization: 1, + } + vestStart := abi.ChainEpoch(100) + vestSum := abi.NewTokenAmount(100) + + harness.addLockedFunds(vestStart, vestSum, vspec) + + amountUnlocked := harness.unlockUnvestedFunds(vestStart, big.NewInt(39)) + assert.Equal(t, big.NewInt(39), amountUnlocked) + + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart)) + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+1)) + + // expected to be zero due to unlocking of UNvested funds + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+2)) + // expected to be non-zero due to unlocking of UNvested funds + assert.Equal(t, abi.NewTokenAmount(1), harness.unlockVestedFunds(vestStart+3)) + + assert.Equal(t, abi.NewTokenAmount(20), harness.unlockVestedFunds(vestStart+4)) + assert.Equal(t, abi.NewTokenAmount(20), harness.unlockVestedFunds(vestStart+5)) + assert.Equal(t, abi.NewTokenAmount(20), harness.unlockVestedFunds(vestStart+6)) + + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+7)) + + assert.Zero(t, harness.s.LockedFunds.Int64()) + assert.True(t, harness.vestingFundsStoreEmpty()) + }) + + t.Run("Unlock unvested funds leaving bucket with zero tokens", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + vspec := &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 1, + Quantization: 1, + } + vestStart := abi.ChainEpoch(100) + vestSum := abi.NewTokenAmount(100) + + harness.addLockedFunds(vestStart, vestSum, vspec) + + amountUnlocked := harness.unlockUnvestedFunds(vestStart, big.NewInt(40)) + assert.Equal(t, big.NewInt(40), amountUnlocked) + + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart)) + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+1)) + + // expected to be zero due to unlocking of UNvested funds + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+2)) + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+3)) + + assert.Equal(t, abi.NewTokenAmount(20), harness.unlockVestedFunds(vestStart+4)) + assert.Equal(t, abi.NewTokenAmount(20), harness.unlockVestedFunds(vestStart+5)) + assert.Equal(t, abi.NewTokenAmount(20), harness.unlockVestedFunds(vestStart+6)) + + assert.Equal(t, abi.NewTokenAmount(0), harness.unlockVestedFunds(vestStart+7)) + + assert.Zero(t, harness.s.LockedFunds.Int64()) + assert.True(t, harness.vestingFundsStoreEmpty()) + }) + + t.Run("Unlock all unvested funds", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + vspec := &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 5, + StepDuration: 1, + Quantization: 1, + } + vestStart := abi.ChainEpoch(10) + vestSum := abi.NewTokenAmount(100) + harness.addLockedFunds(vestStart, vestSum, vspec) + unvestedFunds := harness.unlockUnvestedFunds(vestStart, vestSum) + assert.Equal(t, vestSum, unvestedFunds) + + assert.Zero(t, harness.s.LockedFunds.Int64()) + assert.True(t, harness.vestingFundsStoreEmpty()) + }) + + t.Run("Unlock unvested funds value greater than LockedFunds", func(t *testing.T) { + harness := constructStateHarness(t, abi.ChainEpoch(0)) + vspec := &miner.VestSpec{ + InitialDelay: 0, + VestPeriod: 1, + StepDuration: 1, + Quantization: 1, + } + vestStart := abi.ChainEpoch(10) + vestSum := abi.NewTokenAmount(100) + harness.addLockedFunds(vestStart, vestSum, vspec) + unvestedFunds := harness.unlockUnvestedFunds(vestStart, abi.NewTokenAmount(200)) + assert.Equal(t, vestSum, unvestedFunds) + + assert.Zero(t, harness.s.LockedFunds.Int64()) + assert.True(t, harness.vestingFundsStoreEmpty()) + + }) + +} + +type stateHarness struct { + t testing.TB + + s *miner.State + store adt.Store +} + +// +// Vesting Store +// + +func (h *stateHarness) addLockedFunds(epoch abi.ChainEpoch, sum abi.TokenAmount, spec *miner.VestSpec) { + err := h.s.AddLockedFunds(h.store, epoch, sum, spec) + require.NoError(h.t, err) +} + +func (h *stateHarness) unlockUnvestedFunds(epoch abi.ChainEpoch, target abi.TokenAmount) abi.TokenAmount { + amount, err := h.s.UnlockUnvestedFunds(h.store, epoch, target) + require.NoError(h.t, err) + return amount +} + +func (h *stateHarness) unlockVestedFunds(epoch abi.ChainEpoch) abi.TokenAmount { + amount, err := h.s.UnlockVestedFunds(h.store, epoch) + require.NoError(h.t, err) + return amount +} + +func (h *stateHarness) vestingFundsStoreEmpty() bool { + vestingFunds, err := adt.AsArray(h.store, h.s.VestingFunds) + require.NoError(h.t, err) + empty := true + lockedEntry := abi.NewTokenAmount(0) + err = vestingFunds.ForEach(&lockedEntry, func(k int64) error { + empty = false + return nil + }) + require.NoError(h.t, err) + return empty +} + +// +// PostSubmissions Bitfield +// + +func (h *stateHarness) addPoStSubmissions(partitionNos ...uint64) { + err := h.s.AddPoStSubmissions(bitfield.NewFromSet(partitionNos)) + require.NoError(h.t, err) +} + +func (h *stateHarness) clearPoStSubmissions() { + err := h.s.ClearPoStSubmissions() + require.NoError(h.t, err) +} + +func (h *stateHarness) getPoStSubmissionsCount() uint64 { + count, err := h.s.PostSubmissions.Count() + require.NoError(h.t, err) + return count +} + +// +// Recoveries Bitfield +// + +func (h *stateHarness) addRecoveries(sectorNos ...uint64) { + bf := bitfield.NewFromSet(sectorNos) + err := h.s.AddRecoveries(bf) + require.NoError(h.t, err) +} + +func (h *stateHarness) removeRecoveries(sectorNos ...uint64) { + bf := bitfield.NewFromSet(sectorNos) + err := h.s.RemoveRecoveries(bf) + require.NoError(h.t, err) +} + +func (h *stateHarness) getRecoveriesCount() uint64 { + count, err := h.s.Recoveries.Count() + require.NoError(h.t, err) + return count +} + +// +// Faults Store +// + +func (h *stateHarness) addFaults(epoch abi.ChainEpoch, sectorNos ...uint64) { + bf := bitfield.NewFromSet(sectorNos) + err := h.s.AddFaults(h.store, bf, epoch) + require.NoError(h.t, err) +} + +func (h *stateHarness) removeFaults(sectorNos ...uint64) { + bf := bitfield.NewFromSet(sectorNos) + err := h.s.RemoveFaults(h.store, bf) + require.NoError(h.t, err) +} + +// +// Sector Expiration Store +// + +func (h *stateHarness) getSectorExpirations(expiry abi.ChainEpoch) []uint64 { + bf, err := h.s.GetSectorExpirations(h.store, expiry) + require.NoError(h.t, err) + sectors, err := bf.All(miner.SectorsMax) + require.NoError(h.t, err) + return sectors +} + +func (h *stateHarness) addSectorExpiration(expiry abi.ChainEpoch, sectorNos ...uint64) { + infos := make([]*miner.SectorOnChainInfo, len(sectorNos)) + for i, sectorNo := range sectorNos { + infos[i] = &miner.SectorOnChainInfo{ + SectorNumber: abi.SectorNumber(sectorNo), + Expiration: expiry, + } + } + err := h.s.AddSectorExpirations(h.store, infos...) + require.NoError(h.t, err) +} + +func (h *stateHarness) removeSectorExpiration(expiry abi.ChainEpoch, sectorNos ...uint64) { + infos := make([]*miner.SectorOnChainInfo, len(sectorNos)) + for i, sectorNo := range sectorNos { + infos[i] = &miner.SectorOnChainInfo{ + SectorNumber: abi.SectorNumber(sectorNo), + Expiration: expiry, + } + } + err := h.s.RemoveSectorExpirations(h.store, infos...) + require.NoError(h.t, err) +} + +func (h *stateHarness) clearSectorExpiration(excitations ...abi.ChainEpoch) { + err := h.s.ClearSectorExpirations(h.store, excitations...) + require.NoError(h.t, err) +} + +// +// NewSectors BitField Assertions +// + +func (h *stateHarness) addNewSectors(sectorNos ...abi.SectorNumber) { + err := h.s.AddNewSectors(sectorNos...) + require.NoError(h.t, err) +} + +// makes a bit field from the passed sector numbers +func (h *stateHarness) removeNewSectors(sectorNos ...uint64) { + bf := bitfield.NewFromSet(sectorNos) + err := h.s.RemoveNewSectors(bf) + require.NoError(h.t, err) +} + +func (h *stateHarness) getNewSectorCount() uint64 { + out, err := h.s.NewSectors.Count() + require.NoError(h.t, err) + return out +} + +// +// Sector Store Assertion Operations +// + +func (h *stateHarness) hasSectorNo(sectorNo abi.SectorNumber) bool { + found, err := h.s.HasSectorNo(h.store, sectorNo) + require.NoError(h.t, err) + return found +} + +func (h *stateHarness) putSector(sector *miner.SectorOnChainInfo) { + err := h.s.PutSectors(h.store, sector) + require.NoError(h.t, err) +} + +func (h *stateHarness) getSector(sectorNo abi.SectorNumber) *miner.SectorOnChainInfo { + sectors, found, err := h.s.GetSector(h.store, sectorNo) + require.NoError(h.t, err) + assert.True(h.t, found) + assert.NotNil(h.t, sectors) + return sectors +} + +// makes a bit field from the passed sector numbers +func (h *stateHarness) deleteSectors(sectorNos ...uint64) { + bf := bitfield.NewFromSet(sectorNos) + err := h.s.DeleteSectors(h.store, bf) + require.NoError(h.t, err) +} + +// +// Precommit Store Operations +// + +func (h *stateHarness) putPreCommit(info *miner.SectorPreCommitOnChainInfo) { + err := h.s.PutPrecommittedSector(h.store, info) + require.NoError(h.t, err) +} + +func (h *stateHarness) getPreCommit(sectorNo abi.SectorNumber) *miner.SectorPreCommitOnChainInfo { + out, found, err := h.s.GetPrecommittedSector(h.store, sectorNo) + require.NoError(h.t, err) + assert.True(h.t, found) + return out +} + +func (h *stateHarness) hasPreCommit(sectorNo abi.SectorNumber) bool { + _, found, err := h.s.GetPrecommittedSector(h.store, sectorNo) + require.NoError(h.t, err) + return found +} + +func (h *stateHarness) deletePreCommit(sectorNo abi.SectorNumber) { + err := h.s.DeletePrecommittedSectors(h.store, sectorNo) + require.NoError(h.t, err) +} + +func constructStateHarness(t *testing.T, periodBoundary abi.ChainEpoch) *stateHarness { + // store init + store := ipld.NewADTStore(context.Background()) + emptyMap, err := adt.MakeEmptyMap(store).Root() + require.NoError(t, err) + + emptyArray, err := adt.MakeEmptyArray(store).Root() + require.NoError(t, err) + + emptyDeadlines := miner.ConstructDeadlines() + emptyDeadlinesCid, err := store.Put(context.Background(), emptyDeadlines) + require.NoError(t, err) + + // state field init + owner := tutils.NewBLSAddr(t, 1) + worker := tutils.NewBLSAddr(t, 2) + + testSealProofType := abi.RegisteredSealProof_StackedDrg2KiBV1 + + sectorSize, err := testSealProofType.SectorSize() + require.NoError(t, err) + + partitionSectors, err := testSealProofType.WindowPoStPartitionSectors() + require.NoError(t, err) + + info := miner.MinerInfo{ + Owner: owner, + Worker: worker, + PendingWorkerKey: nil, + PeerId: abi.PeerID("peer"), + Multiaddrs: testMultiaddrs, + SealProofType: testSealProofType, + SectorSize: sectorSize, + WindowPoStPartitionSectors: partitionSectors, + } + infoCid, err := store.Put(context.Background(), &info) + require.NoError(t, err) + + state, err := miner.ConstructState(infoCid, periodBoundary, emptyArray, emptyMap, emptyDeadlinesCid) + require.NoError(t, err) + + // assert NewSectors bitfield was constructed correctly (empty) + newSectorsCount, err := state.NewSectors.Count() + assert.NoError(t, err) + assert.Equal(t, uint64(0), newSectorsCount) + + return &stateHarness{ + t: t, + + s: state, + store: store, + } +} + +// +// Type Construction Methods +// + +// returns a unique SectorPreCommitOnChainInfo with each invocation with SectorNumber set to `sectorNo`. +func newSectorPreCommitOnChainInfo(sectorNo abi.SectorNumber, sealed cid.Cid, deposit abi.TokenAmount, epoch abi.ChainEpoch) *miner.SectorPreCommitOnChainInfo { + info := newSectorPreCommitInfo(sectorNo, sealed) + return &miner.SectorPreCommitOnChainInfo{ + Info: *info, + PreCommitDeposit: deposit, + PreCommitEpoch: epoch, + DealWeight: big.Zero(), + VerifiedDealWeight: big.Zero(), + } +} + +const ( + sectorSealRandEpochValue = abi.ChainEpoch(1) + sectorExpiration = abi.ChainEpoch(1) +) + +// returns a unique SectorOnChainInfo with each invocation with SectorNumber set to `sectorNo`. +func newSectorOnChainInfo(sectorNo abi.SectorNumber, sealed cid.Cid, weight big.Int, activation abi.ChainEpoch) *miner.SectorOnChainInfo { + return &miner.SectorOnChainInfo{ + SectorNumber: sectorNo, + SealProof: abi.RegisteredSealProof_StackedDrg32GiBV1, + SealedCID: sealed, + DealIDs: nil, + Activation: activation, + Expiration: sectorExpiration, + DealWeight: weight, + VerifiedDealWeight: weight, + InitialPledge: abi.NewTokenAmount(0), + } +} + +// returns a unique SectorPreCommitInfo with each invocation with SectorNumber set to `sectorNo`. +func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid) *miner.SectorPreCommitInfo { + return &miner.SectorPreCommitInfo{ + SealProof: abi.RegisteredSealProof_StackedDrg32GiBV1, + SectorNumber: sectorNo, + SealedCID: sealed, + SealRandEpoch: sectorSealRandEpochValue, + DealIDs: nil, + Expiration: sectorExpiration, + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_test.go new file mode 100644 index 000000000..792999f03 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/miner_test.go @@ -0,0 +1,2316 @@ +package miner_test + +import ( + "bytes" + "context" + "encoding/binary" + "fmt" + "testing" + + addr "github.com/filecoin-project/go-address" + bitfield "github.com/filecoin-project/go-bitfield" + cid "github.com/ipfs/go-cid" + "github.com/minio/blake2b-simd" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + cbg "github.com/whyrusleeping/cbor-gen" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" + "github.com/filecoin-project/specs-actors/actors/builtin/market" + "github.com/filecoin-project/specs-actors/actors/builtin/miner" + "github.com/filecoin-project/specs-actors/actors/builtin/power" + "github.com/filecoin-project/specs-actors/actors/crypto" + "github.com/filecoin-project/specs-actors/actors/runtime" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + "github.com/filecoin-project/specs-actors/actors/util/adt" + "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +var testPid abi.PeerID +var testMultiaddrs []abi.Multiaddrs + +// A balance for use in tests where the miner's low balance is not interesting. +var bigBalance = big.Mul(big.NewInt(1000), big.NewInt(1e18)) + +func init() { + testPid = abi.PeerID("peerID") + + testMultiaddrs = []abi.Multiaddrs{ + {1}, + {2}, + } + + miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ + abi.RegisteredSealProof_StackedDrg2KiBV1: {}, + } +} + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, miner.Actor{}) +} + +func TestConstruction(t *testing.T) { + actor := miner.Actor{} + owner := tutil.NewIDAddr(t, 100) + worker := tutil.NewIDAddr(t, 101) + workerKey := tutil.NewBLSAddr(t, 0) + receiver := tutil.NewIDAddr(t, 1000) + builder := mock.NewBuilder(context.Background(), receiver). + WithActorType(owner, builtin.AccountActorCodeID). + WithActorType(worker, builtin.AccountActorCodeID). + WithHasher(blake2b.Sum256). + WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + + t.Run("simple construction", func(t *testing.T) { + rt := builder.Build(t) + params := miner.ConstructorParams{ + OwnerAddr: owner, + WorkerAddr: worker, + SealProofType: abi.RegisteredSealProof_StackedDrg2KiBV1, + PeerId: testPid, + Multiaddrs: testMultiaddrs, + } + + provingPeriodStart := abi.ChainEpoch(2386) // This is just set from running the code. + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + // Fetch worker pubkey. + rt.ExpectSend(worker, builtin.MethodsAccount.PubkeyAddress, nil, big.Zero(), &workerKey, exitcode.Ok) + // Register proving period cron. + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.EnrollCronEvent, + makeProvingPeriodCronEventParams(t, provingPeriodStart-1), big.Zero(), nil, exitcode.Ok) + ret := rt.Call(actor.Constructor, ¶ms) + + assert.Nil(t, ret) + rt.Verify() + + var st miner.State + rt.GetState(&st) + info, err := st.GetInfo(adt.AsStore(rt)) + require.NoError(t, err) + assert.Equal(t, params.OwnerAddr, info.Owner) + assert.Equal(t, params.WorkerAddr, info.Worker) + assert.Equal(t, params.PeerId, info.PeerId) + assert.Equal(t, params.Multiaddrs, info.Multiaddrs) + assert.Equal(t, abi.RegisteredSealProof_StackedDrg2KiBV1, info.SealProofType) + assert.Equal(t, abi.SectorSize(2048), info.SectorSize) + assert.Equal(t, uint64(2), info.WindowPoStPartitionSectors) + assert.Equal(t, provingPeriodStart, st.ProvingPeriodStart) + + assert.Equal(t, big.Zero(), st.PreCommitDeposits) + assert.Equal(t, big.Zero(), st.LockedFunds) + assert.True(t, st.VestingFunds.Defined()) + assert.True(t, st.PreCommittedSectors.Defined()) + assertEmptyBitfield(t, st.NewSectors) + assert.True(t, st.SectorExpirations.Defined()) + assert.True(t, st.Deadlines.Defined()) + assertEmptyBitfield(t, st.Faults) + assert.True(t, st.FaultEpochs.Defined()) + assertEmptyBitfield(t, st.Recoveries) + assertEmptyBitfield(t, st.PostSubmissions) + + var deadlines miner.Deadlines + assert.True(t, rt.Store().Get(st.Deadlines, &deadlines)) + for i := uint64(0); i < miner.WPoStPeriodDeadlines; i++ { + assertEmptyBitfield(t, deadlines.Due[i]) + } + }) +} + +// Tests for fetching and manipulating miner addresses. +func TestControlAddresses(t *testing.T) { + actor := newHarness(t, 0) + builder := builderForHarness(actor) + + t.Run("get addresses", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + o, w := actor.controlAddresses(rt) + assert.Equal(t, actor.owner, o) + assert.Equal(t, actor.worker, w) + }) + + // TODO: test changing worker (with delay), changing peer id + // https://github.com/filecoin-project/specs-actors/issues/479 +} + +// Test for sector precommitment and proving. +func TestCommitments(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + + // TODO more tests + // - Concurrent attempts to upgrade the same CC sector (one should succeed) + // - Insufficient funds for pre-commit, for prove-commit + // - CC sector targeted for upgrade expires naturally before the upgrade is proven + + t.Run("valid precommit then provecommit", func(t *testing.T) { + actor := newHarness(t, periodOffset) + rt := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()). + Build(t) + precommitEpoch := periodOffset + 1 + rt.SetEpoch(precommitEpoch) + actor.constructAndVerify(rt) + deadline := actor.deadline(rt) + + // Make a good commitment for the proof to target. + sectorNo := abi.SectorNumber(100) + precommit := makePreCommit(sectorNo, precommitEpoch-1, deadline.PeriodEnd(), nil) + actor.preCommitSector(rt, precommit) + + // assert precommit exists and meets expectations + onChainPrecommit := actor.getPreCommit(rt, sectorNo) + + // expect precommit deposit to be initial pledge calculated at precommit time + sectorSize, err := precommit.SealProof.SectorSize() + require.NoError(t, err) + + // deal weights mocked by actor harness for market actor must be set in precommit onchain info + assert.Equal(t, big.NewInt(int64(sectorSize/2)), onChainPrecommit.DealWeight) + assert.Equal(t, big.NewInt(int64(sectorSize/2)), onChainPrecommit.VerifiedDealWeight) + + qaPower := miner.QAPowerForWeight(sectorSize, precommit.Expiration-precommitEpoch, onChainPrecommit.DealWeight, onChainPrecommit.VerifiedDealWeight) + expectedDeposit := miner.InitialPledgeForPower(qaPower, actor.networkQAPower, actor.networkPledge, actor.epochReward, rt.TotalFilCircSupply()) + assert.Equal(t, expectedDeposit, onChainPrecommit.PreCommitDeposit) + + // expect total precommit deposit to equal our new deposit + st := getState(rt) + assert.Equal(t, expectedDeposit, st.PreCommitDeposits) + + // run prove commit logic + rt.SetEpoch(precommitEpoch + miner.PreCommitChallengeDelay + 1) + rt.SetBalance(big.Mul(big.NewInt(1000), big.NewInt(1e18))) + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo), proveCommitConf{}) + st = getState(rt) + + // expect precommit to have been removed + _, found, err := st.GetPrecommittedSector(rt.AdtStore(), sectorNo) + require.NoError(t, err) + require.False(t, found) + + // expect deposit to have been transferred to initial pledges + expectedInitialPledge := expectedDeposit + assert.Equal(t, big.Zero(), st.PreCommitDeposits) + assert.Equal(t, expectedInitialPledge, st.InitialPledgeRequirement) + + // expect new onchain sector + onChainSector := actor.getSector(rt, sectorNo) + + // expect deal weights to be transfered to on chain info + assert.Equal(t, onChainPrecommit.DealWeight, onChainSector.DealWeight) + assert.Equal(t, onChainPrecommit.VerifiedDealWeight, onChainSector.VerifiedDealWeight) + + // expect activation epoch to be precommit + assert.Equal(t, precommitEpoch, onChainSector.Activation) + + // expect initial plege of sector to be set + assert.Equal(t, expectedInitialPledge, onChainSector.InitialPledge) + + // expect locked initial pledge of sector to be the same as precommit deposit + assert.Equal(t, expectedInitialPledge, st.LockedFunds) + }) + + t.Run("invalid pre-commit rejected", func(t *testing.T) { + actor := newHarness(t, periodOffset) + rt := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()). + Build(t) + precommitEpoch := periodOffset + 1 + rt.SetEpoch(precommitEpoch) + actor.constructAndVerify(rt) + deadline := actor.deadline(rt) + challengeEpoch := precommitEpoch - 1 + + oldSector := actor.commitAndProveSectors(rt, 1, 100, nil)[0] + + // Good commitment. + actor.preCommitSector(rt, makePreCommit(101, challengeEpoch, deadline.PeriodEnd(), nil)) + + // Duplicate pre-commit sector ID + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, makePreCommit(101, challengeEpoch, deadline.PeriodEnd(), nil)) + }) + rt.Reset() + + // Sector ID already committed + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, makePreCommit(oldSector.SectorNumber, challengeEpoch, deadline.PeriodEnd(), nil)) + }) + rt.Reset() + + // Bad seal proof type + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + pc := makePreCommit(101, challengeEpoch, deadline.PeriodEnd(), nil) + pc.SealProof = abi.RegisteredSealProof_StackedDrg8MiBV1 + actor.preCommitSector(rt, pc) + }) + rt.Reset() + + // Expires at current epoch + rt.SetEpoch(deadline.PeriodEnd()) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, makePreCommit(101, challengeEpoch, deadline.PeriodEnd(), nil)) + }) + rt.Reset() + + // Expires before current epoch + expiration := deadline.PeriodEnd() + rt.SetEpoch(expiration + 1) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, makePreCommit(101, challengeEpoch, deadline.PeriodEnd(), nil)) + }) + rt.Reset() + + // Expires not on period end + expiration = deadline.PeriodEnd() - 1 + rt.SetEpoch(precommitEpoch) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, makePreCommit(101, challengeEpoch, expiration, nil)) + }) + rt.Reset() + + // Errors when expiry too far in the future + rt.SetEpoch(precommitEpoch) + expiration = deadline.PeriodEnd() + miner.WPoStProvingPeriod*(miner.MaxSectorExpirationExtension/miner.WPoStProvingPeriod+1) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, makePreCommit(101, challengeEpoch, deadline.PeriodEnd()-1, nil)) + }) + }) + + t.Run("valid committed capacity upgrade", func(t *testing.T) { + actor := newHarness(t, periodOffset) + rt := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()). + Build(t) + actor.constructAndVerify(rt) + + // Commit a sector to upgrade + oldSector := actor.commitAndProveSectors(rt, 1, 100, nil)[0] + + // Reduce the epoch reward so that a new sector's initial pledge would otherwise be lesser. + actor.epochReward = big.Div(actor.epochReward, big.NewInt(2)) + + challengeEpoch := rt.Epoch() - 1 + upgradeParams := makePreCommit(200, challengeEpoch, oldSector.Expiration, []abi.DealID{1}) + upgradeParams.ReplaceCapacity = true + upgradeParams.ReplaceSector = oldSector.SectorNumber + upgrade := actor.preCommitSector(rt, upgradeParams) + + // Check new pre-commit in state + assert.True(t, upgrade.Info.ReplaceCapacity) + assert.Equal(t, upgradeParams.ReplaceSector, upgrade.Info.ReplaceSector) + // Require new sector's pledge to be at least that of the old sector. + assert.Equal(t, oldSector.InitialPledge, upgrade.PreCommitDeposit) + + // Old sector is unchanged + oldSectorAgain := actor.getSector(rt, oldSector.SectorNumber) + assert.Equal(t, oldSector, oldSectorAgain) + + // Deposit and pledge as expected + st := getState(rt) + assert.Equal(t, st.PreCommitDeposits, upgrade.PreCommitDeposit) + assert.Equal(t, st.InitialPledgeRequirement, oldSector.InitialPledge) + assert.Equal(t, st.LockedFunds, oldSector.InitialPledge) + + // Prove new sector + rt.SetEpoch(upgrade.PreCommitEpoch + miner.PreCommitChallengeDelay + 1) + newSector := actor.proveCommitSectorAndConfirm(rt, &upgrade.Info, upgrade.PreCommitEpoch, + makeProveCommit(upgrade.Info.SectorNumber), proveCommitConf{}) + + // Both sectors have pledge + st = getState(rt) + assert.Equal(t, big.Zero(), st.PreCommitDeposits) + assert.Equal(t, st.InitialPledgeRequirement, big.Add(oldSector.InitialPledge, newSector.InitialPledge)) + assert.Equal(t, st.LockedFunds, big.Add(oldSector.InitialPledge, newSector.InitialPledge)) + + // The old sector's expiration has changed to the end of this proving period + deadline := actor.deadline(rt) + oldSectorAgain = actor.getSector(rt, oldSector.SectorNumber) + assert.Equal(t, deadline.PeriodEnd(), oldSectorAgain.Expiration) + + // Both sectors are currently listed as new, because deadlines not yet assigned + assertBfEqual(t, bitfield.NewFromSet([]uint64{100, 200}), st.NewSectors) + + // Roll forward to PP cron and expect old sector removed without penalty + completeProvingPeriod(rt, actor, &cronConfig{ + newSectors: true, + expiredSectorsPowerDelta: actor.claimParamsForSectors([]*miner.SectorOnChainInfo{oldSectorAgain}, false), + }) + + // The old sector is gone, only the new sector is assigned to a deadline. + st = getState(rt) + sectors := actor.collectSectors(rt) + assert.Equal(t, 1, len(sectors)) + assert.Nil(t, sectors[oldSector.SectorNumber]) + assert.Equal(t, newSector, sectors[newSector.SectorNumber]) + + expirations := actor.collectExpirations(rt) + assert.Equal(t, 1, len(expirations)) + assert.Equal(t, []uint64{200}, expirations[newSector.Expiration]) + + provingSet := actor.collectProvingSet(rt) + assert.Equal(t, map[uint64]struct{}{200: {}}, provingSet) + assertBfEqual(t, bitfield.NewFromSet([]uint64{}), st.NewSectors) // No new sectors + + // Old sector's pledge still locked (not penalized), but no longer contributes to minimum requirement. + assert.Equal(t, st.InitialPledgeRequirement, newSector.InitialPledge) + assert.Equal(t, st.LockedFunds, big.Add(oldSector.InitialPledge, newSector.InitialPledge)) + }) + + t.Run("invalid committed capacity upgrade rejected", func(t *testing.T) { + actor := newHarness(t, periodOffset) + rt := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()). + Build(t) + actor.constructAndVerify(rt) + + // Commit sectors to target upgrade. The first has no deals, the second has a deal. + oldSectors := actor.commitAndProveSectors(rt, 2, 100, [][]abi.DealID{nil, {10}}) + + challengeEpoch := rt.Epoch() - 1 + upgradeParams := makePreCommit(200, challengeEpoch, oldSectors[0].Expiration, []abi.DealID{20}) + upgradeParams.ReplaceCapacity = true + upgradeParams.ReplaceSector = oldSectors[0].SectorNumber + + { // Must have deals + params := *upgradeParams + params.DealIDs = nil + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, ¶ms) + }) + rt.Reset() + } + { // Old sector cannot have deals + params := *upgradeParams + params.ReplaceSector = oldSectors[1].SectorNumber + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, ¶ms) + }) + rt.Reset() + } + { // Target sector must exist + params := *upgradeParams + params.ReplaceSector = 999 + rt.ExpectAbort(exitcode.ErrNotFound, func() { + actor.preCommitSector(rt, ¶ms) + }) + rt.Reset() + } + { // Expiration must not be sooner than target + params := *upgradeParams + params.Expiration = params.Expiration - miner.WPoStProvingPeriod + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, ¶ms) + }) + rt.Reset() + } + { // Target must not be faulty + params := *upgradeParams + st := getState(rt) + st.Faults.Set(uint64(params.ReplaceSector)) + rt.ReplaceState(st) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.preCommitSector(rt, ¶ms) + }) + st.Faults = abi.NewBitField() + rt.ReplaceState(st) + rt.Reset() + } + + // Demonstrate that the params are otherwise ok + actor.preCommitSector(rt, upgradeParams) + rt.Verify() + }) + + t.Run("faulty committed capacity sector not replaced", func(t *testing.T) { + actor := newHarness(t, periodOffset) + rt := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()). + Build(t) + actor.constructAndVerify(rt) + + // Commit a sector to target upgrade + oldSector := actor.commitAndProveSectors(rt, 1, 100, nil)[0] + + // Complete proving period + // June 2020: it is impossible to declare fault for a sector not yet assigned to a deadline + completeProvingPeriod(rt, actor, &cronConfig{newSectors: true}) + + // Pre-commit a sector to replace the existing one + challengeEpoch := rt.Epoch() - 1 + upgradeParams := makePreCommit(200, challengeEpoch, oldSector.Expiration, []abi.DealID{20}) + upgradeParams.ReplaceCapacity = true + upgradeParams.ReplaceSector = oldSector.SectorNumber + + upgrade := actor.preCommitSector(rt, upgradeParams) + + // Declare the old sector faulty + _, qaPower := powerForSectors(actor.sectorSize, []*miner.SectorOnChainInfo{oldSector}) + fee := miner.PledgePenaltyForDeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + actor.declareFaults(rt, actor.networkQAPower, fee, oldSector) + + rt.SetEpoch(upgrade.PreCommitEpoch + miner.PreCommitChallengeDelay + 1) + // Proof is initially denied because the fault fee has reduced locked funds. + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + actor.proveCommitSectorAndConfirm(rt, &upgrade.Info, upgrade.PreCommitEpoch, + makeProveCommit(upgrade.Info.SectorNumber), proveCommitConf{}) + }) + rt.Reset() + + // Prove the new sector + actor.addLockedFund(rt, fee) + newSector := actor.proveCommitSectorAndConfirm(rt, &upgrade.Info, upgrade.PreCommitEpoch, + makeProveCommit(upgrade.Info.SectorNumber), proveCommitConf{}) + + // The old sector's expiration has *not* changed + oldSectorAgain := actor.getSector(rt, oldSector.SectorNumber) + assert.Equal(t, oldSector.Expiration, oldSectorAgain.Expiration) + + // Roll forward to PP cron. The faulty old sector pays a fee, but is not terminated. + penalty := miner.PledgePenaltyForDeclaredFault(actor.epochReward, actor.networkQAPower, + miner.QAPowerForSector(actor.sectorSize, oldSector)) + completeProvingPeriod(rt, actor, &cronConfig{ + newSectors: true, + ongoingFaultsPenalty: &penalty, + }) + + // Both sectors remain + sectors := actor.collectSectors(rt) + assert.Equal(t, 2, len(sectors)) + assert.Equal(t, oldSector, sectors[oldSector.SectorNumber]) + assert.Equal(t, newSector, sectors[newSector.SectorNumber]) + expirations := actor.collectExpirations(rt) + assert.Equal(t, 1, len(expirations)) + assert.Equal(t, []uint64{100, 200}, expirations[newSector.Expiration]) + }) + + t.Run("invalid proof rejected", func(t *testing.T) { + actor := newHarness(t, periodOffset) + rt := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()). + Build(t) + precommitEpoch := periodOffset + 1 + rt.SetEpoch(precommitEpoch) + actor.constructAndVerify(rt) + deadline := actor.deadline(rt) + + // Make a good commitment for the proof to target. + sectorNo := abi.SectorNumber(100) + precommit := makePreCommit(sectorNo, precommitEpoch-1, deadline.PeriodEnd(), nil) + actor.preCommitSector(rt, precommit) + + // Sector pre-commitment missing. + rt.SetEpoch(precommitEpoch + miner.PreCommitChallengeDelay + 1) + rt.ExpectAbort(exitcode.ErrNotFound, func() { + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo+1), proveCommitConf{}) + }) + rt.Reset() + + // Too late. + rt.SetEpoch(precommitEpoch + miner.MaxSealDuration[precommit.SealProof] + 1) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo), proveCommitConf{}) + }) + rt.Reset() + + // TODO: too early to prove sector + // TODO: seal rand epoch too old + // TODO: commitment expires before proof + // https://github.com/filecoin-project/specs-actors/issues/479 + + // Set the right epoch for all following tests + rt.SetEpoch(precommitEpoch + miner.PreCommitChallengeDelay + 1) + + // Invalid deals (market ActivateDeals aborts) + verifyDealsExit := make(map[abi.SectorNumber]exitcode.ExitCode) + verifyDealsExit[precommit.SectorNumber] = exitcode.ErrIllegalArgument + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo), proveCommitConf{ + verifyDealsExit: verifyDealsExit, + }) + }) + rt.Reset() + + // Invalid seal proof + /* TODO: how should this test work? + // https://github.com/filecoin-project/specs-actors/issues/479 + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo), proveCommitConf{ + verifySealErr: fmt.Errorf("for testing"), + }) + }) + rt.Reset() + */ + + // Good proof + rt.SetBalance(big.Mul(big.NewInt(1000), big.NewInt(1e18))) + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo), proveCommitConf{}) + st := getState(rt) + // Verify new sectors + newSectors, err := st.NewSectors.All(miner.SectorsMax) + require.NoError(t, err) + assert.Equal(t, []uint64{uint64(sectorNo)}, newSectors) + // Verify pledge lock-up + assert.True(t, st.LockedFunds.GreaterThan(big.Zero())) + rt.Reset() + + // Duplicate proof (sector no-longer pre-committed) + rt.ExpectAbort(exitcode.ErrNotFound, func() { + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(sectorNo), proveCommitConf{}) + }) + rt.Reset() + }) +} + +func TestWindowPost(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + precommitEpoch := abi.ChainEpoch(1) + builder := builderForHarness(actor). + WithEpoch(precommitEpoch). + WithBalance(bigBalance, big.Zero()) + + t.Run("test proof", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + store := rt.AdtStore() + _ = actor.commitAndProveSectors(rt, 1, 100, nil) + + // Skip to end of proving period, cron adds sectors to proving set. + actor.advancePastProvingPeriodWithCron(rt) + st := getState(rt) + + // Iterate deadlines in the proving period, setting epoch to the first in each deadline. + // Submit a window post for all partitions due at each deadline when necessary. + deadline := actor.deadline(rt) + for !deadline.PeriodElapsed() { + st = getState(rt) + deadlines, err := st.LoadDeadlines(store) + require.NoError(t, err) + + infos, partitions := actor.computePartitions(rt, deadlines, deadline.Index) + if len(infos) > 0 { + actor.submitWindowPoSt(rt, deadline, partitions, infos, nil) + } + + rt.SetEpoch(deadline.Close + 1) + deadline = actor.deadline(rt) + } + + // Oops, went one epoch too far, rewind to last epoch of last deadline window for the cron. + rt.SetEpoch(rt.Epoch() - 1) + + empty, err := st.PostSubmissions.IsEmpty() + require.NoError(t, err) + assert.False(t, empty, "no post submission") + }) + + runTillNextDeadline := func(rt *mock.Runtime) (*miner.DeadlineInfo, []*miner.SectorOnChainInfo, []uint64) { + st := getState(rt) + deadlines, err := st.LoadDeadlines(rt.AdtStore()) + require.NoError(t, err) + deadline := actor.deadline(rt) + + // advance to next deadline where we expect the first sectors to appear + rt.SetEpoch(deadline.Close + 1) + deadline = st.DeadlineInfo(rt.Epoch()) + + infos, partitions := actor.computePartitions(rt, deadlines, deadline.Index) + return deadline, infos, partitions + } + + runTillFirstDeadline := func(rt *mock.Runtime) (*miner.DeadlineInfo, []*miner.SectorOnChainInfo, []uint64) { + actor.constructAndVerify(rt) + + _ = actor.commitAndProveSectors(rt, 6, 100, nil) + + // Skip to end of proving period, cron adds sectors to proving set. + actor.advancePastProvingPeriodWithCron(rt) + + return runTillNextDeadline(rt) + } + + t.Run("successful recoveries recover power", func(t *testing.T) { + rt := builder.Build(t) + deadline, infos, partitions := runTillFirstDeadline(rt) + st := getState(rt) + + // mark all sectors as recovered faults + sectors := bitfield.New() + for _, info := range infos { + sectors.Set(uint64(info.SectorNumber)) + } + err := st.AddFaults(rt.AdtStore(), §ors, rt.Epoch()) + require.NoError(t, err) + err = st.AddRecoveries(§ors) + require.NoError(t, err) + rt.ReplaceState(st) + + rawPower, qaPower := miner.PowerForSectors(actor.sectorSize, infos) + + cfg := &poStConfig{ + expectedRawPowerDelta: rawPower, + expectedQAPowerDelta: qaPower, + expectedPenalty: big.Zero(), + skipped: abi.NewBitField(), + } + + actor.submitWindowPoSt(rt, deadline, partitions, infos, cfg) + }) + + t.Run("skipped faults are penalized and adjust power adjusted", func(t *testing.T) { + rt := builder.Build(t) + deadline, infos, partitions := runTillFirstDeadline(rt) + + // skip the first sector in the partition + skipped := bitfield.NewFromSet([]uint64{uint64(infos[0].SectorNumber)}) + + rawPower, qaPower := miner.PowerForSectors(actor.sectorSize, infos[:1]) + + // expected penalty is the fee for an undeclared fault + expectedPenalty := miner.PledgePenaltyForUndeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + cfg := &poStConfig{ + skipped: skipped, + expectedRawPowerDelta: rawPower.Neg(), + expectedQAPowerDelta: qaPower.Neg(), + expectedPenalty: expectedPenalty, + } + + actor.submitWindowPoSt(rt, deadline, partitions, infos, cfg) + }) + + t.Run("skipped all sectors in a deadline may be skipped", func(t *testing.T) { + rt := builder.Build(t) + deadline, infos, partitions := runTillFirstDeadline(rt) + + // skip all sectors in deadline + st := getState(rt) + deadlines, err := st.LoadDeadlines(rt.AdtStore()) + require.NoError(t, err) + skipped := deadlines.Due[deadline.Index] + count, err := skipped.Count() + require.NoError(t, err) + assert.Greater(t, count, uint64(0)) + + rawPower, qaPower := miner.PowerForSectors(actor.sectorSize, infos) + + // expected penalty is the fee for an undeclared fault + expectedPenalty := miner.PledgePenaltyForUndeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + cfg := &poStConfig{ + skipped: skipped, + expectedRawPowerDelta: rawPower.Neg(), + expectedQAPowerDelta: qaPower.Neg(), + expectedPenalty: expectedPenalty, + } + + actor.submitWindowPoSt(rt, deadline, partitions, infos, cfg) + }) + + t.Run("skipped recoveries are penalized and do not recover power", func(t *testing.T) { + rt := builder.Build(t) + deadline, infos, partitions := runTillFirstDeadline(rt) + st := getState(rt) + + // mark all sectors as recovered faults + sectors := bitfield.NewFromSet([]uint64{uint64(infos[0].SectorNumber)}) + err := st.AddFaults(rt.AdtStore(), sectors, rt.Epoch()) + require.NoError(t, err) + err = st.AddRecoveries(sectors) + require.NoError(t, err) + rt.ReplaceState(st) + + _, qaPower := miner.PowerForSectors(actor.sectorSize, infos[:1]) + + // skip the first sector in the partition + skipped := bitfield.NewFromSet([]uint64{uint64(infos[0].SectorNumber)}) + // expected penalty is the fee for an undeclared fault + expectedPenalty := miner.PledgePenaltyForUndeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + cfg := &poStConfig{ + expectedRawPowerDelta: big.Zero(), + expectedQAPowerDelta: big.Zero(), + expectedPenalty: expectedPenalty, + skipped: skipped, + } + + actor.submitWindowPoSt(rt, deadline, partitions, infos, cfg) + }) + + t.Run("skipping a fault from the wrong deadline is an error", func(t *testing.T) { + rt := builder.Build(t) + deadline, infos, partitions := runTillFirstDeadline(rt) + st := getState(rt) + + // look ahead to next deadline to find a sector not in this deadline + deadlines, err := st.LoadDeadlines(rt.AdtStore()) + require.NoError(t, err) + nextDeadline := st.DeadlineInfo(deadline.Close + 1) + nextInfos, _ := actor.computePartitions(rt, deadlines, nextDeadline.Index) + + _, qaPower := miner.PowerForSectors(actor.sectorSize, nextInfos[:1]) + + // skip the first sector in the partition + skipped := bitfield.NewFromSet([]uint64{uint64(nextInfos[0].SectorNumber)}) + // expected penalty is the fee for an undeclared fault + expectedPenalty := miner.PledgePenaltyForUndeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + cfg := &poStConfig{ + expectedRawPowerDelta: big.Zero(), + expectedQAPowerDelta: big.Zero(), + expectedPenalty: expectedPenalty, + skipped: skipped, + } + + rt.ExpectAbortConstainsMessage(exitcode.ErrIllegalArgument, "skipped faults contains sectors not due in deadline", func() { + actor.submitWindowPoSt(rt, deadline, partitions, infos, cfg) + }) + }) + + t.Run("detects faults from previous missed posts", func(t *testing.T) { + rt := builder.Build(t) + + // skip two PoSts + _, infos1, _ := runTillFirstDeadline(rt) + _, infos2, _ := runTillNextDeadline(rt) + deadline, infos3, partitions := runTillNextDeadline(rt) + + // assert we have sectors in each deadline + assert.Greater(t, len(infos1), 0) + assert.Greater(t, len(infos2), 0) + assert.Greater(t, len(infos3), 0) + + // expect power to be deducted for all sectors in first two deadlines + rawPower, qaPower := miner.PowerForSectors(actor.sectorSize, append(infos1, infos2...)) + + // expected penalty is the late undeclared fault penalty for all faulted sectors including retracted recoveries.. + expectedPenalty := miner.PledgePenaltyForLateUndeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + cfg := &poStConfig{ + skipped: abi.NewBitField(), + expectedRawPowerDelta: rawPower.Neg(), + expectedQAPowerDelta: qaPower.Neg(), + expectedPenalty: expectedPenalty, + } + + actor.submitWindowPoSt(rt, deadline, partitions, infos3, cfg) + + // same size and every info is set in bitset implies info1+info2 and st.Faults represent the same sectors + st := getState(rt) + faultCount, err := st.Faults.Count() + require.NoError(t, err) + assert.Equal(t, uint64(len(infos1)+len(infos2)), faultCount) + for _, info := range append(infos1, infos2...) { + set, err := st.Faults.IsSet(uint64(info.SectorNumber)) + require.NoError(t, err) + assert.True(t, set) + } + }) +} + +func TestProveCommit(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + t.Run("aborts if sum of initial pledges exceeds locked funds", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + // prove one sector to establish collateral and locked funds + actor.commitAndProveSectors(rt, 1, 100, nil) + + // preecommit another sector so we may prove it + expiration := 100*miner.WPoStProvingPeriod + periodOffset - 1 + precommitEpoch := rt.Epoch() + 1 + rt.SetEpoch(precommitEpoch) + precommit := makePreCommit(actor.nextSectorNo, rt.Epoch()-1, expiration, nil) + actor.preCommitSector(rt, precommit) + + // alter lock funds to simulate vesting since last prove + st := getState(rt) + st.LockedFunds = big.Div(st.LockedFunds, big.NewInt(2)) + rt.ReplaceState(st) + info := actor.getInfo(rt) + + rt.SetEpoch(precommitEpoch + miner.MaxSealDuration[info.SealProofType] - 1) + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(actor.nextSectorNo), proveCommitConf{}) + }) + rt.Reset() + + // succeeds when locked fund satisfy initial pledge requirement + st.LockedFunds = st.InitialPledgeRequirement + rt.ReplaceState(st) + actor.proveCommitSectorAndConfirm(rt, precommit, precommitEpoch, makeProveCommit(actor.nextSectorNo), proveCommitConf{}) + }) + + t.Run("drop invalid prove commit while processing valid one", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + // make two precommits + expiration := 100*miner.WPoStProvingPeriod + periodOffset - 1 + precommitEpoch := rt.Epoch() + 1 + rt.SetEpoch(precommitEpoch) + precommitA := makePreCommit(actor.nextSectorNo, rt.Epoch()-1, expiration, nil) + actor.preCommitSector(rt, precommitA) + sectorNoA := actor.nextSectorNo + actor.nextSectorNo++ + precommitB := makePreCommit(actor.nextSectorNo, rt.Epoch()-1, expiration, nil) + actor.preCommitSector(rt, precommitB) + sectorNoB := actor.nextSectorNo + + // handle both prove commits in the same epoch + info := actor.getInfo(rt) + rt.SetEpoch(precommitEpoch + miner.MaxSealDuration[info.SealProofType] - 1) + + actor.proveCommitSector(rt, precommitA, precommitEpoch, makeProveCommit(sectorNoA)) + actor.proveCommitSector(rt, precommitB, precommitEpoch, makeProveCommit(sectorNoB)) + + conf := proveCommitConf{ + verifyDealsExit: map[abi.SectorNumber]exitcode.ExitCode{ + sectorNoA: exitcode.ErrIllegalArgument, + }, + } + actor.confirmSectorProofsValid(rt, conf, precommitEpoch, precommitA, precommitB) + }) +} + +func TestProvingPeriodCron(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + t.Run("empty periods", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + st := getState(rt) + assert.Equal(t, periodOffset, st.ProvingPeriodStart) + + // First cron invocation just before the first proving period starts. + rt.SetEpoch(periodOffset - 1) + secondCronEpoch := periodOffset + miner.WPoStProvingPeriod - 1 + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: secondCronEpoch, + }) + // The proving period start isn't changed, because the period hadn't started yet. + st = getState(rt) + assert.Equal(t, periodOffset, st.ProvingPeriodStart) + + rt.SetEpoch(secondCronEpoch) + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: periodOffset + 2*miner.WPoStProvingPeriod - 1, + }) + // Proving period moves forward + st = getState(rt) + assert.Equal(t, periodOffset+miner.WPoStProvingPeriod, st.ProvingPeriodStart) + }) + + t.Run("first period gets randomness from previous epoch", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + st := getState(rt) + + sectorInfo := actor.commitAndProveSectors(rt, 1, 100, nil) + + // Flag new sectors to trigger request for randomness + rt.Transaction(st, func() interface{} { + st.NewSectors.Set(uint64(sectorInfo[0].SectorNumber)) + return nil + }) + + // First cron invocation just before the first proving period starts + // requires randomness come from current epoch minus lookback + rt.SetEpoch(periodOffset - 1) + secondCronEpoch := periodOffset + miner.WPoStProvingPeriod - 1 + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: secondCronEpoch, + newSectors: true, + }) + + // cron invocation after the proving period starts, requires randomness come from end of proving period + rt.SetEpoch(periodOffset) + actor.advanceProvingPeriodWithoutFaults(rt) + + // triggers a new request for randomness + rt.Transaction(st, func() interface{} { + st.NewSectors.Set(uint64(sectorInfo[0].SectorNumber)) + return nil + }) + + thirdCronEpoch := secondCronEpoch + miner.WPoStProvingPeriod + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: thirdCronEpoch, + newSectors: true, + }) + }) + + t.Run("detects and penalizes faults", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + allSectors := actor.commitAndProveSectors(rt, 2, 100, nil) + + // advance to end of proving period to add sectors to proving set + st := getState(rt) + deadline := st.DeadlineInfo(rt.Epoch()) + nextCron := deadline.NextPeriodStart() - 1 + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: nextCron, + newSectors: true, + }) + + // advance to next deadline where we expect the first sectors to appear + rt.SetEpoch(deadline.Close + 1) + deadline = st.DeadlineInfo(rt.Epoch()) + + // Skip to end of proving period, cron detects all sectors as faulty + rt.SetEpoch(deadline.PeriodEnd()) + nextCron = deadline.NextPeriodStart() + miner.WPoStProvingPeriod - 1 + + // Undetected faults penalized once as a late undetected fault + rawPower, qaPower := powerForSectors(actor.sectorSize, allSectors) + undetectedPenalty := miner.PledgePenaltyForLateUndeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + // power for sectors is removed + powerDeltaClaim := &power.UpdateClaimedPowerParams{ + RawByteDelta: rawPower.Neg(), + QualityAdjustedDelta: qaPower.Neg(), + } + + // Faults are charged again as ongoing faults + ongoingPenalty := miner.PledgePenaltyForDeclaredFault(actor.epochReward, actor.networkQAPower, qaPower) + + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: nextCron, + undetectedFaultsPenalty: &undetectedPenalty, + undetectedFaultsPowerDelta: powerDeltaClaim, + ongoingFaultsPenalty: &ongoingPenalty, + }) + + // expect both faults are added to state + st = getState(rt) + set, err := st.Faults.IsSet(uint64(allSectors[0].SectorNumber)) + require.NoError(t, err) + assert.True(t, set) + set, err = st.Faults.IsSet(uint64(allSectors[1].SectorNumber)) + require.NoError(t, err) + assert.True(t, set) + + // advance 3 deadlines + rt.SetEpoch(deadline.Close + 3*miner.WPoStChallengeWindow) + deadline = st.DeadlineInfo(rt.Epoch()) + + actor.declareRecoveries(rt, 1, sectorInfoAsBitfield(allSectors[1:])) + + // Skip to end of proving period, cron detects all sectors as faulty + rt.SetEpoch(deadline.PeriodEnd()) + nextCron = deadline.NextPeriodStart() + miner.WPoStProvingPeriod - 1 + + // Retracted recovery is penalized as an undetected fault, but power is unchanged + _, retractedQAPower := powerForSectors(actor.sectorSize, allSectors[1:]) + retractedPenalty := miner.PledgePenaltyForLateUndeclaredFault(actor.epochReward, actor.networkQAPower, retractedQAPower) + + // Faults are charged again as ongoing faults + _, faultQAPower := powerForSectors(actor.sectorSize, allSectors) + ongoingPenalty = miner.PledgePenaltyForDeclaredFault(actor.epochReward, actor.networkQAPower, faultQAPower) + + actor.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: nextCron, + undetectedFaultsPenalty: &retractedPenalty, + ongoingFaultsPenalty: &ongoingPenalty, + }) + }) + + // TODO: test cron being called one epoch late because the scheduled epoch had no blocks. +} + +func TestDeclareFaults(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + t.Run("declare fault pays fee", func(t *testing.T) { + // Get sector into proving state + rt := builder.Build(t) + actor.constructAndVerify(rt) + precommits := actor.commitAndProveSectors(rt, 1, 100, nil) + + // Skip to end of proving period, cron adds sectors to proving set. + completeProvingPeriod(rt, actor, &cronConfig{newSectors: true}) + info := actor.getSector(rt, precommits[0].SectorNumber) + + // Declare the sector as faulted + ss, err := info.SealProof.SectorSize() + require.NoError(t, err) + sectorQAPower := miner.QAPowerForSector(ss, info) + totalQAPower := big.NewInt(1 << 52) + fee := miner.PledgePenaltyForDeclaredFault(actor.epochReward, totalQAPower, sectorQAPower) + + actor.declareFaults(rt, totalQAPower, fee, info) + }) +} + +func TestExtendSectorExpiration(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + precommitEpoch := abi.ChainEpoch(1) + builder := builderForHarness(actor). + WithEpoch(precommitEpoch). + WithBalance(bigBalance, big.Zero()) + + commitSector := func(t *testing.T, rt *mock.Runtime) *miner.SectorOnChainInfo { + actor.constructAndVerify(rt) + sectorInfo := actor.commitAndProveSectors(rt, 1, 100, nil) + return sectorInfo[0] + } + + t.Run("rejects negative extension", func(t *testing.T) { + rt := builder.Build(t) + sector := commitSector(t, rt) + // attempt to shorten epoch + newExpiration := sector.Expiration - abi.ChainEpoch(miner.WPoStProvingPeriod) + params := &miner.ExtendSectorExpirationParams{ + SectorNumber: sector.SectorNumber, + NewExpiration: newExpiration, + } + + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.extendSector(rt, sector, 0, params) + }) + }) + + t.Run("rejects extension to invalid epoch", func(t *testing.T) { + rt := builder.Build(t) + sector := commitSector(t, rt) + + // attempt to extend to an epoch that is not a multiple of the proving period + the commit epoch + extension := 42*miner.WPoStProvingPeriod + 1 + newExpiration := sector.Expiration - abi.ChainEpoch(extension) + params := &miner.ExtendSectorExpirationParams{ + SectorNumber: sector.SectorNumber, + NewExpiration: newExpiration, + } + + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.extendSector(rt, sector, extension, params) + }) + }) + + t.Run("rejects extension too far in future", func(t *testing.T) { + rt := builder.Build(t) + sector := commitSector(t, rt) + + // extend by even proving period after max + rt.SetEpoch(sector.Expiration) + extension := miner.WPoStProvingPeriod * (miner.MaxSectorExpirationExtension/miner.WPoStProvingPeriod + 1) + newExpiration := rt.Epoch() + extension + params := &miner.ExtendSectorExpirationParams{ + SectorNumber: sector.SectorNumber, + NewExpiration: newExpiration, + } + + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.extendSector(rt, sector, extension, params) + }) + }) + + t.Run("rejects extension past max for seal proof", func(t *testing.T) { + rt := builder.Build(t) + sector := commitSector(t, rt) + rt.SetEpoch(sector.Expiration) + + maxLifetime := sector.SealProof.SectorMaximumLifetime() + + // extend sector until just below threshold + extension := miner.WPoStProvingPeriod * (miner.MaxSectorExpirationExtension/miner.WPoStProvingPeriod - 1) + expiration := rt.Epoch() + extension + for ; expiration-sector.Activation < maxLifetime; expiration += extension { + params := &miner.ExtendSectorExpirationParams{ + SectorNumber: sector.SectorNumber, + NewExpiration: expiration, + } + + actor.extendSector(rt, sector, extension, params) + rt.SetEpoch(expiration) + } + + // next extension fails because it extends sector past max lifetime + params := &miner.ExtendSectorExpirationParams{ + SectorNumber: sector.SectorNumber, + NewExpiration: expiration, + } + + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + actor.extendSector(rt, sector, extension, params) + }) + }) + + t.Run("updates expiration with valid params", func(t *testing.T) { + rt := builder.Build(t) + oldSector := commitSector(t, rt) + + extension := 42 * miner.WPoStProvingPeriod + newExpiration := oldSector.Expiration + extension + params := &miner.ExtendSectorExpirationParams{ + SectorNumber: oldSector.SectorNumber, + NewExpiration: newExpiration, + } + + actor.extendSector(rt, oldSector, extension, params) + + // assert sector expiration is set to the new value + st := getState(rt) + newSector := actor.getSector(rt, oldSector.SectorNumber) + assert.Equal(t, newExpiration, newSector.Expiration) + + // assert that an expiration exists at the target epoch + expirations, err := st.GetSectorExpirations(rt.AdtStore(), newExpiration) + require.NoError(t, err) + exists, err := expirations.IsSet(uint64(newSector.SectorNumber)) + require.NoError(t, err) + assert.True(t, exists) + + // assert that the expiration has been removed from the old epoch + expirations, err = st.GetSectorExpirations(rt.AdtStore(), oldSector.Expiration) + require.NoError(t, err) + exists, err = expirations.IsSet(uint64(newSector.SectorNumber)) + require.NoError(t, err) + assert.False(t, exists) + }) +} + +func TestTerminateSectors(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + commitSector := func(t *testing.T, rt *mock.Runtime) *miner.SectorOnChainInfo { + actor.constructAndVerify(rt) + precommitEpoch := abi.ChainEpoch(1) + rt.SetEpoch(precommitEpoch) + sectorInfo := actor.commitAndProveSectors(rt, 1, 100, nil) + return sectorInfo[0] + } + + t.Run("removes sector with correct accounting", func(t *testing.T) { + rt := builder.Build(t) + sector := commitSector(t, rt) + var initialLockedFunds abi.TokenAmount + + // A miner will pay the minimum of termination fee and locked funds. Add some locked funds to ensure + // correct fee calculation is used. + actor.addLockedFund(rt, big.NewInt(1<<61)) + + { + // Verify that a sector expiration was registered. + st := getState(rt) + expiration, err := st.GetSectorExpirations(rt.AdtStore(), sector.Expiration) + require.NoError(t, err) + expiringSectorNos, err := expiration.All(1) + require.NoError(t, err) + assert.Len(t, expiringSectorNos, 1) + assert.Equal(t, sector.SectorNumber, abi.SectorNumber(expiringSectorNos[0])) + initialLockedFunds = st.LockedFunds + } + + sectorSize, err := sector.SealProof.SectorSize() + require.NoError(t, err) + sectorPower := miner.QAPowerForSector(sectorSize, sector) + sectorAge := rt.Epoch() - sector.Activation + expectedFee := miner.PledgePenaltyForTermination(sector.InitialPledge, sectorAge, actor.epochReward, actor.networkQAPower, sectorPower) + + sectors := bitfield.New() + sectors.Set(uint64(sector.SectorNumber)) + actor.terminateSectors(rt, §ors, expectedFee) + + { + st := getState(rt) + + // expect sector expiration to have been removed + err = st.ForEachSectorExpiration(rt.AdtStore(), func(expiry abi.ChainEpoch, sectors *abi.BitField) error { + assert.Fail(t, "did not expect to find a sector expiration, found expiration at %s", expiry) + return nil + }) + assert.NoError(t, err) + + // expect sector to have been removed + _, found, err := st.GetSector(rt.AdtStore(), sector.SectorNumber) + require.NoError(t, err) + assert.False(t, found) + + // expect fee to have been unlocked and burnt + assert.Equal(t, big.Sub(initialLockedFunds, expectedFee), st.LockedFunds) + + // expect pledge requirement to have been decremented + assert.Equal(t, big.Zero(), st.InitialPledgeRequirement) + } + }) +} + +func TestWithdrawBalance(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + t.Run("happy path withdraws funds", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + // withdraw 1% of balance + actor.withdrawFunds(rt, big.Mul(big.NewInt(10), big.NewInt(1e18))) + }) + + t.Run("fails if miner is currently undercollateralized", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + // prove one sector to establish collateral and locked funds + actor.commitAndProveSectors(rt, 1, 100, nil) + + // alter lock funds to simulate vesting since last prove + st := getState(rt) + st.LockedFunds = big.Div(st.LockedFunds, big.NewInt(2)) + rt.ReplaceState(st) + + // withdraw 1% of balance + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + actor.withdrawFunds(rt, big.Mul(big.NewInt(10), big.NewInt(1e18))) + }) + }) +} + +func TestReportConsensusFault(t *testing.T) { + periodOffset := abi.ChainEpoch(100) + actor := newHarness(t, periodOffset) + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + rt := builder.Build(t) + actor.constructAndVerify(rt) + precommitEpoch := abi.ChainEpoch(1) + rt.SetEpoch(precommitEpoch) + dealIDs := [][]abi.DealID{{1, 2}, {3, 4}} + sectorInfo := actor.commitAndProveSectors(rt, 2, 10, dealIDs) + _ = sectorInfo + + params := &miner.ReportConsensusFaultParams{ + BlockHeader1: nil, + BlockHeader2: nil, + BlockHeaderExtra: nil, + } + + // miner should send a single call to terminate the deals for all its sectors + allDeals := []abi.DealID{} + for _, ids := range dealIDs { + allDeals = append(allDeals, ids...) + } + actor.reportConsensusFault(rt, addr.TestAddress, params, allDeals) +} + +func TestAddLockedFund(t *testing.T) { + periodOffset := abi.ChainEpoch(1808) + actor := newHarness(t, periodOffset) + + builder := builderForHarness(actor). + WithBalance(bigBalance, big.Zero()) + + t.Run("funds vest", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + st := getState(rt) + store := rt.AdtStore() + + // Nothing vesting to start + vestingFunds, err := adt.AsArray(store, st.VestingFunds) + require.NoError(t, err) + assert.Equal(t, uint64(0), vestingFunds.Length()) + assert.Equal(t, big.Zero(), st.LockedFunds) + + // Lock some funds with AddLockedFund + amt := abi.NewTokenAmount(600_000) + actor.addLockedFund(rt, amt) + st = getState(rt) + newVestingFunds, err := adt.AsArray(store, st.VestingFunds) + require.NoError(t, err) + require.Equal(t, uint64(7), newVestingFunds.Length()) // 1 day steps over 1 week + + // Vested FIL pays out on epochs with expected offset + lockedEntry := abi.NewTokenAmount(0) + expectedOffset := periodOffset % miner.PledgeVestingSpec.Quantization + err = newVestingFunds.ForEach(&lockedEntry, func(k int64) error { + assert.Equal(t, int64(expectedOffset), k%int64(miner.PledgeVestingSpec.Quantization)) + return nil + }) + require.NoError(t, err) + assert.Equal(t, amt, st.LockedFunds) + + }) + +} + +type actorHarness struct { + a miner.Actor + t testing.TB + + receiver addr.Address // The miner actor's own address + owner addr.Address + worker addr.Address + key addr.Address + + sealProofType abi.RegisteredSealProof + sectorSize abi.SectorSize + partitionSize uint64 + periodOffset abi.ChainEpoch + nextSectorNo abi.SectorNumber + + epochReward abi.TokenAmount + networkPledge abi.TokenAmount + networkRawPower abi.StoragePower + networkQAPower abi.StoragePower +} + +func newHarness(t testing.TB, provingPeriodOffset abi.ChainEpoch) *actorHarness { + sealProofType := abi.RegisteredSealProof_StackedDrg2KiBV1 + sectorSize, err := sealProofType.SectorSize() + require.NoError(t, err) + partitionSectors, err := sealProofType.WindowPoStPartitionSectors() + require.NoError(t, err) + owner := tutil.NewIDAddr(t, 100) + worker := tutil.NewIDAddr(t, 101) + workerKey := tutil.NewBLSAddr(t, 0) + receiver := tutil.NewIDAddr(t, 1000) + reward := big.Mul(big.NewIntUnsigned(100), big.NewIntUnsigned(1e18)) + return &actorHarness{ + t: t, + receiver: receiver, + owner: owner, + worker: worker, + key: workerKey, + + sealProofType: sealProofType, + sectorSize: sectorSize, + partitionSize: partitionSectors, + periodOffset: provingPeriodOffset, + nextSectorNo: 100, + + epochReward: reward, + networkPledge: big.Mul(reward, big.NewIntUnsigned(1000)), + networkRawPower: abi.NewStoragePower(1 << 50), + networkQAPower: abi.NewStoragePower(1 << 50), + } +} + +func (h *actorHarness) constructAndVerify(rt *mock.Runtime) { + params := miner.ConstructorParams{ + OwnerAddr: h.owner, + WorkerAddr: h.worker, + SealProofType: h.sealProofType, + PeerId: testPid, + } + + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + // Fetch worker pubkey. + rt.ExpectSend(h.worker, builtin.MethodsAccount.PubkeyAddress, nil, big.Zero(), &h.key, exitcode.Ok) + // Register proving period cron. + nextProvingPeriodEnd := h.periodOffset - 1 + for nextProvingPeriodEnd < rt.Epoch() { + nextProvingPeriodEnd += miner.WPoStProvingPeriod + } + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.EnrollCronEvent, + makeProvingPeriodCronEventParams(h.t, nextProvingPeriodEnd), big.Zero(), nil, exitcode.Ok) + rt.SetCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + ret := rt.Call(h.a.Constructor, ¶ms) + assert.Nil(h.t, ret) + rt.Verify() +} + +// +// State access helpers +// + +func (h *actorHarness) deadline(rt *mock.Runtime) *miner.DeadlineInfo { + st := getState(rt) + return st.DeadlineInfo(rt.Epoch()) +} + +func (h *actorHarness) getPreCommit(rt *mock.Runtime, sno abi.SectorNumber) *miner.SectorPreCommitOnChainInfo { + st := getState(rt) + pc, found, err := st.GetPrecommittedSector(rt.AdtStore(), sno) + require.NoError(h.t, err) + require.True(h.t, found) + return pc +} + +func (h *actorHarness) getSector(rt *mock.Runtime, sno abi.SectorNumber) *miner.SectorOnChainInfo { + st := getState(rt) + sector, found, err := st.GetSector(rt.AdtStore(), sno) + require.NoError(h.t, err) + require.True(h.t, found) + return sector +} + +func (h *actorHarness) getInfo(rt *mock.Runtime) *miner.MinerInfo { + var st miner.State + rt.GetState(&st) + info, err := st.GetInfo(adt.AsStore(rt)) + require.NoError(h.t, err) + return info +} + +// Collects all sector infos into a map. +func (h *actorHarness) collectSectors(rt *mock.Runtime) map[abi.SectorNumber]*miner.SectorOnChainInfo { + sectors := map[abi.SectorNumber]*miner.SectorOnChainInfo{} + st := getState(rt) + _ = st.ForEachSector(rt.AdtStore(), func(info *miner.SectorOnChainInfo) { + sector := *info + sectors[info.SectorNumber] = §or + }) + return sectors +} + +// Collects the sector numbers of all sectors assigned to a deadline. +func (h *actorHarness) collectProvingSet(rt *mock.Runtime) map[uint64]struct{} { + pset := map[uint64]struct{}{} + st := getState(rt) + deadlines, err := st.LoadDeadlines(rt.AdtStore()) + require.NoError(h.t, err) + for _, d := range deadlines.Due { + _ = d.ForEach(func(n uint64) error { + pset[n] = struct{}{} + return nil + }) + } + return pset +} + +// Collects all expirations into a map. +func (h *actorHarness) collectExpirations(rt *mock.Runtime) map[abi.ChainEpoch][]uint64 { + expirations := map[abi.ChainEpoch][]uint64{} + st := getState(rt) + _ = st.ForEachSectorExpiration(rt.AdtStore(), func(expiry abi.ChainEpoch, sectors *abi.BitField) error { + expanded, err := sectors.All(miner.SectorsMax) + require.NoError(h.t, err) + expirations[expiry] = expanded + return nil + }) + return expirations +} + +// +// Actor method calls +// + +func (h *actorHarness) controlAddresses(rt *mock.Runtime) (owner, worker addr.Address) { + rt.ExpectValidateCallerAny() + ret := rt.Call(h.a.ControlAddresses, nil).(*miner.GetControlAddressesReturn) + require.NotNil(h.t, ret) + rt.Verify() + return ret.Owner, ret.Worker +} + +func (h *actorHarness) preCommitSector(rt *mock.Runtime, params *miner.SectorPreCommitInfo) *miner.SectorPreCommitOnChainInfo { + + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker) + + { + pwrTotal := &power.CurrentTotalPowerReturn{ + RawBytePower: h.networkRawPower, + QualityAdjPower: h.networkQAPower, + PledgeCollateral: h.networkPledge, + } + expectQueryNetworkInfo(rt, pwrTotal, h.epochReward) + } + { + sectorSize, err := params.SealProof.SectorSize() + require.NoError(h.t, err) + + vdParams := market.VerifyDealsForActivationParams{ + DealIDs: params.DealIDs, + SectorStart: rt.Epoch(), + SectorExpiry: params.Expiration, + } + + vdReturn := market.VerifyDealsForActivationReturn{ + DealWeight: big.NewInt(int64(sectorSize / 2)), + VerifiedDealWeight: big.NewInt(int64(sectorSize / 2)), + } + rt.ExpectSend(builtin.StorageMarketActorAddr, builtin.MethodsMarket.VerifyDealsForActivation, &vdParams, big.Zero(), &vdReturn, exitcode.Ok) + } + { + eventPayload := miner.CronEventPayload{ + EventType: miner.CronEventPreCommitExpiry, + Sectors: bitfield.NewFromSet([]uint64{uint64(params.SectorNumber)}), + } + buf := bytes.Buffer{} + err := eventPayload.MarshalCBOR(&buf) + require.NoError(h.t, err) + cronParams := power.EnrollCronEventParams{ + EventEpoch: rt.Epoch() + miner.MaxSealDuration[params.SealProof] + 1, + Payload: buf.Bytes(), + } + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.EnrollCronEvent, &cronParams, big.Zero(), nil, exitcode.Ok) + } + + rt.Call(h.a.PreCommitSector, params) + rt.Verify() + return h.getPreCommit(rt, params.SectorNumber) +} + +// Options for proveCommitSector behaviour. +// Default zero values should let everything be ok. +type proveCommitConf struct { + verifyDealsExit map[abi.SectorNumber]exitcode.ExitCode +} + +func (h *actorHarness) proveCommitSector(rt *mock.Runtime, precommit *miner.SectorPreCommitInfo, precommitEpoch abi.ChainEpoch, + params *miner.ProveCommitSectorParams) { + commd := cbg.CborCid(tutil.MakeCID("commd")) + sealRand := abi.SealRandomness([]byte{1, 2, 3, 4}) + sealIntRand := abi.InteractiveSealRandomness([]byte{5, 6, 7, 8}) + interactiveEpoch := precommitEpoch + miner.PreCommitChallengeDelay + + // Prepare for and receive call to ProveCommitSector + { + cdcParams := market.ComputeDataCommitmentParams{ + DealIDs: precommit.DealIDs, + SectorType: precommit.SealProof, + } + rt.ExpectSend(builtin.StorageMarketActorAddr, builtin.MethodsMarket.ComputeDataCommitment, &cdcParams, big.Zero(), &commd, exitcode.Ok) + } + { + var buf bytes.Buffer + err := rt.Receiver().MarshalCBOR(&buf) + require.NoError(h.t, err) + rt.ExpectGetRandomness(crypto.DomainSeparationTag_SealRandomness, precommit.SealRandEpoch, buf.Bytes(), abi.Randomness(sealRand)) + rt.ExpectGetRandomness(crypto.DomainSeparationTag_InteractiveSealChallengeSeed, interactiveEpoch, buf.Bytes(), abi.Randomness(sealIntRand)) + } + { + actorId, err := addr.IDFromAddress(h.receiver) + require.NoError(h.t, err) + seal := abi.SealVerifyInfo{ + SectorID: abi.SectorID{ + Miner: abi.ActorID(actorId), + Number: precommit.SectorNumber, + }, + SealedCID: precommit.SealedCID, + SealProof: precommit.SealProof, + Proof: params.Proof, + DealIDs: precommit.DealIDs, + Randomness: sealRand, + InteractiveRandomness: sealIntRand, + UnsealedCID: cid.Cid(commd), + } + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.SubmitPoRepForBulkVerify, &seal, abi.NewTokenAmount(0), nil, exitcode.Ok) + } + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAny() + rt.Call(h.a.ProveCommitSector, params) + rt.Verify() +} + +func (h *actorHarness) confirmSectorProofsValid(rt *mock.Runtime, conf proveCommitConf, precommitEpoch abi.ChainEpoch, precommits ...*miner.SectorPreCommitInfo) { + // Prepare for and receive call to ConfirmSectorProofsValid. + var validPrecommits []*miner.SectorPreCommitInfo + var allSectorNumbers []abi.SectorNumber + for _, precommit := range precommits { + allSectorNumbers = append(allSectorNumbers, precommit.SectorNumber) + + vdParams := market.ActivateDealsParams{ + DealIDs: precommit.DealIDs, + SectorExpiry: precommit.Expiration, + } + exit, found := conf.verifyDealsExit[precommit.SectorNumber] + if !found { + exit = exitcode.Ok + validPrecommits = append(validPrecommits, precommit) + } + rt.ExpectSend(builtin.StorageMarketActorAddr, builtin.MethodsMarket.ActivateDeals, &vdParams, big.Zero(), nil, exit) + } + + // expected pledge is the sum of precommit deposits + if len(validPrecommits) > 0 { + expectPledge := big.Zero() + + expectQAPower := big.Zero() + expectRawPower := big.Zero() + for _, precommit := range validPrecommits { + precommitOnChain := h.getPreCommit(rt, precommit.SectorNumber) + + qaPowerDelta := miner.QAPowerForWeight(h.sectorSize, precommit.Expiration-precommitEpoch, precommitOnChain.DealWeight, precommitOnChain.VerifiedDealWeight) + expectQAPower = big.Add(expectQAPower, qaPowerDelta) + expectRawPower = big.Add(expectRawPower, big.NewIntUnsigned(uint64(h.sectorSize))) + + expectPledge = big.Add(expectPledge, precommitOnChain.PreCommitDeposit) + } + + pcParams := power.UpdateClaimedPowerParams{ + RawByteDelta: expectRawPower, + QualityAdjustedDelta: expectQAPower, + } + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdateClaimedPower, &pcParams, big.Zero(), nil, exitcode.Ok) + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdatePledgeTotal, &expectPledge, big.Zero(), nil, exitcode.Ok) + } + + rt.SetCaller(builtin.StoragePowerActorAddr, builtin.StoragePowerActorCodeID) + rt.ExpectValidateCallerAddr(builtin.StoragePowerActorAddr) + rt.Call(h.a.ConfirmSectorProofsValid, &builtin.ConfirmSectorProofsParams{Sectors: allSectorNumbers}) + rt.Verify() +} + +func (h *actorHarness) proveCommitSectorAndConfirm(rt *mock.Runtime, precommit *miner.SectorPreCommitInfo, precommitEpoch abi.ChainEpoch, + params *miner.ProveCommitSectorParams, conf proveCommitConf) *miner.SectorOnChainInfo { + h.proveCommitSector(rt, precommit, precommitEpoch, params) + h.confirmSectorProofsValid(rt, conf, precommitEpoch, precommit) + + newSector := h.getSector(rt, params.SectorNumber) + return newSector +} + +// Pre-commits and then proves a number of sectors. +// The sectors will expire at the end of lifetimePeriods proving periods after now. +// The runtime epoch will be moved forward to the epoch of commitment proofs. +func (h *actorHarness) commitAndProveSectors(rt *mock.Runtime, n int, lifetimePeriods uint64, dealIDs [][]abi.DealID) []*miner.SectorOnChainInfo { + precommitEpoch := rt.Epoch() + deadline := h.deadline(rt) + expiration := deadline.PeriodEnd() + abi.ChainEpoch(lifetimePeriods)*miner.WPoStProvingPeriod + + // Precommit + precommits := make([]*miner.SectorPreCommitInfo, n) + for i := 0; i < n; i++ { + sectorNo := h.nextSectorNo + var sectorDealIDs []abi.DealID + if dealIDs != nil { + sectorDealIDs = dealIDs[i] + } + precommit := makePreCommit(sectorNo, precommitEpoch-1, expiration, sectorDealIDs) + h.preCommitSector(rt, precommit) + precommits[i] = precommit + h.nextSectorNo++ + } + + rt.SetEpoch(precommitEpoch + miner.PreCommitChallengeDelay + 1) + + // Ensure this this doesn't cross a proving period boundary, else the expected cron call won't be + // invoked, which might mess things up later. + deadline = h.deadline(rt) + require.True(h.t, !deadline.PeriodElapsed()) + + info := []*miner.SectorOnChainInfo{} + for _, pc := range precommits { + sector := h.proveCommitSectorAndConfirm(rt, pc, precommitEpoch, makeProveCommit(pc.SectorNumber), proveCommitConf{}) + info = append(info, sector) + } + rt.Reset() + return info +} + +func (h *actorHarness) advancePastProvingPeriodWithCron(rt *mock.Runtime) { + st := getState(rt) + deadline := st.DeadlineInfo(rt.Epoch()) + rt.SetEpoch(deadline.PeriodEnd()) + nextCron := deadline.NextPeriodStart() + miner.WPoStProvingPeriod - 1 + h.onProvingPeriodCron(rt, &cronConfig{ + expectedEntrollment: nextCron, + newSectors: true, + }) + rt.SetEpoch(deadline.NextPeriodStart()) +} + +type poStConfig struct { + skipped *bitfield.BitField + expectedRawPowerDelta abi.StoragePower + expectedQAPowerDelta abi.StoragePower + expectedPenalty abi.TokenAmount +} + +func (h *actorHarness) submitWindowPoSt(rt *mock.Runtime, deadline *miner.DeadlineInfo, partitions []uint64, infos []*miner.SectorOnChainInfo, poStCfg *poStConfig) { + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker) + + rt.ExpectSend(builtin.RewardActorAddr, builtin.MethodsReward.ThisEpochReward, nil, big.Zero(), &h.epochReward, exitcode.Ok) + + pwrTotal := power.CurrentTotalPowerReturn{ + QualityAdjPower: h.networkQAPower, + } + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.CurrentTotalPower, nil, big.Zero(), &pwrTotal, exitcode.Ok) + + var registeredPoStProof, err = abi.RegisteredSealProof_StackedDrg2KiBV1.RegisteredWindowPoStProof() + require.NoError(h.t, err) + + proofs := make([]abi.PoStProof, 1) // Number of proofs doesn't depend on partition count + for i := range proofs { + proofs[i].PoStProof = registeredPoStProof + proofs[i].ProofBytes = []byte(fmt.Sprintf("proof%d", i)) + } + challengeRand := abi.SealRandomness([]byte{10, 11, 12, 13}) + + var goodInfo *miner.SectorOnChainInfo + if poStCfg != nil { + // find the first non-faulty sector in poSt to replace all faulty sectors. + for _, ci := range infos { + contains, err := poStCfg.skipped.IsSet(uint64(ci.SectorNumber)) + require.NoError(h.t, err) + if !contains { + goodInfo = ci + break + } + } + } + // goodInfo == nil indicates all the sectors have been skipped and should PoSt verification should not occur + if poStCfg == nil || goodInfo != nil { + var buf bytes.Buffer + err := rt.Receiver().MarshalCBOR(&buf) + require.NoError(h.t, err) + + rt.ExpectGetRandomness(crypto.DomainSeparationTag_WindowedPoStChallengeSeed, deadline.Challenge, buf.Bytes(), abi.Randomness(challengeRand)) + + actorId, err := addr.IDFromAddress(h.receiver) + require.NoError(h.t, err) + + // if not all sectors are skipped + proofInfos := make([]abi.SectorInfo, len(infos)) + for i, ci := range infos { + si := ci + if poStCfg != nil { + contains, err := poStCfg.skipped.IsSet(uint64(ci.SectorNumber)) + require.NoError(h.t, err) + if contains { + si = goodInfo + } + } + proofInfos[i] = abi.SectorInfo{ + SealProof: si.SealProof, + SectorNumber: si.SectorNumber, + SealedCID: si.SealedCID, + } + } + + vi := abi.WindowPoStVerifyInfo{ + Randomness: abi.PoStRandomness(challengeRand), + Proofs: proofs, + ChallengedSectors: proofInfos, + Prover: abi.ActorID(actorId), + } + rt.ExpectVerifyPoSt(vi, nil) + } + skipped := bitfield.New() + if poStCfg != nil { + // expect power update + if !poStCfg.expectedRawPowerDelta.IsZero() || !poStCfg.expectedQAPowerDelta.IsZero() { + claim := &power.UpdateClaimedPowerParams{ + RawByteDelta: poStCfg.expectedRawPowerDelta, + QualityAdjustedDelta: poStCfg.expectedQAPowerDelta, + } + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdateClaimedPower, claim, abi.NewTokenAmount(0), + nil, exitcode.Ok) + } + if !poStCfg.expectedPenalty.IsZero() { + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, poStCfg.expectedPenalty, nil, exitcode.Ok) + } + pledgeDelta := poStCfg.expectedPenalty.Neg() + if !pledgeDelta.IsZero() { + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdatePledgeTotal, &pledgeDelta, + abi.NewTokenAmount(0), nil, exitcode.Ok) + } + skipped = *poStCfg.skipped + } + + params := miner.SubmitWindowedPoStParams{ + Deadline: deadline.Index, + Partitions: partitions, + Proofs: proofs, + Skipped: skipped, + } + + rt.Call(h.a.SubmitWindowedPoSt, ¶ms) + rt.Verify() +} + +func (h *actorHarness) computePartitions(rt *mock.Runtime, deadlines *miner.Deadlines, deadlineIdx uint64) ([]*miner.SectorOnChainInfo, []uint64) { + st := getState(rt) + firstPartIdx, sectorCount, err := miner.PartitionsForDeadline(deadlines, h.partitionSize, deadlineIdx) + require.NoError(h.t, err) + if sectorCount == 0 { + return nil, nil + } + partitionCount, _, err := miner.DeadlineCount(deadlines, h.partitionSize, deadlineIdx) + require.NoError(h.t, err) + + partitions := make([]uint64, partitionCount) + for i := uint64(0); i < partitionCount; i++ { + partitions[i] = firstPartIdx + i + } + + partitionsSectors, err := miner.ComputePartitionsSectors(deadlines, h.partitionSize, deadlineIdx, partitions) + require.NoError(h.t, err) + provenSectors, err := bitfield.MultiMerge(partitionsSectors...) + require.NoError(h.t, err) + infos, _, err := st.LoadSectorInfosForProof(rt.AdtStore(), provenSectors) + require.NoError(h.t, err) + + return infos, partitions +} + +func (h *actorHarness) declareFaults(rt *mock.Runtime, totalQAPower abi.StoragePower, fee abi.TokenAmount, faultSectorInfos ...*miner.SectorOnChainInfo) { + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker) + + ss, err := faultSectorInfos[0].SealProof.SectorSize() + require.NoError(h.t, err) + expectedRawDelta, expectedQADelta := powerForSectors(ss, faultSectorInfos) + expectedRawDelta = expectedRawDelta.Neg() + expectedQADelta = expectedQADelta.Neg() + + expectedTotalPower := &power.CurrentTotalPowerReturn{ + QualityAdjPower: totalQAPower, + } + + expectQueryNetworkInfo(rt, expectedTotalPower, h.epochReward) + + // expect power update + claim := &power.UpdateClaimedPowerParams{ + RawByteDelta: expectedRawDelta, + QualityAdjustedDelta: expectedQADelta, + } + rt.ExpectSend( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.UpdateClaimedPower, + claim, + abi.NewTokenAmount(0), + nil, + exitcode.Ok, + ) + + // expect fee + rt.ExpectSend( + builtin.BurntFundsActorAddr, + builtin.MethodSend, + nil, + fee, + nil, + exitcode.Ok, + ) + + // expect pledge update + pledgeDelta := fee.Neg() + rt.ExpectSend( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.UpdatePledgeTotal, + &pledgeDelta, + abi.NewTokenAmount(0), + nil, + exitcode.Ok, + ) + + // Calculate params from faulted sector infos + st := getState(rt) + params := makeFaultParamsFromFaultingSectors(h.t, st, rt.AdtStore(), faultSectorInfos) + rt.Call(h.a.DeclareFaults, params) + rt.Verify() +} + +func (h *actorHarness) declareRecoveries(rt *mock.Runtime, deadlineIdx uint64, recoverySectors *bitfield.BitField) { + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker) + + expectedTotalPower := &power.CurrentTotalPowerReturn{ + QualityAdjPower: h.networkQAPower, + } + + expectQueryNetworkInfo(rt, expectedTotalPower, h.epochReward) + + // Calculate params from faulted sector infos + params := &miner.DeclareFaultsRecoveredParams{Recoveries: []miner.RecoveryDeclaration{{ + Deadline: deadlineIdx, + Sectors: recoverySectors, + }}} + + rt.Call(h.a.DeclareFaultsRecovered, params) + rt.Verify() +} + +func (h *actorHarness) advanceProvingPeriodWithoutFaults(rt *mock.Runtime) { + + // Iterate deadlines in the proving period, setting epoch to the first in each deadline. + // Submit a window post for all partitions due at each deadline when necessary. + deadline := h.deadline(rt) + for !deadline.PeriodElapsed() { + st := getState(rt) + store := rt.AdtStore() + deadlines, err := st.LoadDeadlines(store) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not load deadlines") + + firstPartIdx, sectorCount, err := miner.PartitionsForDeadline(deadlines, h.partitionSize, deadline.Index) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not get partitions for deadline") + if sectorCount != 0 { + partitionCount, _, err := miner.DeadlineCount(deadlines, h.partitionSize, deadline.Index) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not get partition count") + + partitions := make([]uint64, partitionCount) + for i := uint64(0); i < partitionCount; i++ { + partitions[i] = firstPartIdx + i + } + + partitionsSectors, err := miner.ComputePartitionsSectors(deadlines, h.partitionSize, deadline.Index, partitions) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not compute partitions") + provenSectors, err := bitfield.MultiMerge(partitionsSectors...) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not get proven sectors") + infos, _, err := st.LoadSectorInfosForProof(store, provenSectors) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not load sector info for proof") + + h.submitWindowPoSt(rt, deadline, partitions, infos, nil) + } + + rt.SetEpoch(deadline.Close + 1) + deadline = h.deadline(rt) + } + // Rewind one epoch to leave the current epoch as the penultimate one in the proving period, + // ready for proving-period cron. + rt.SetEpoch(rt.Epoch() - 1) +} + +func (h *actorHarness) extendSector(rt *mock.Runtime, sector *miner.SectorOnChainInfo, extension abi.ChainEpoch, params *miner.ExtendSectorExpirationParams) { + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker) + + newSector := *sector + newSector.Expiration += extension + qaDelta := big.Sub(miner.QAPowerForSector(h.sectorSize, &newSector), miner.QAPowerForSector(h.sectorSize, sector)) + + rt.ExpectSend(builtin.StoragePowerActorAddr, + builtin.MethodsPower.UpdateClaimedPower, + &power.UpdateClaimedPowerParams{ + RawByteDelta: big.Zero(), + QualityAdjustedDelta: qaDelta, + }, + abi.NewTokenAmount(0), + nil, + exitcode.Ok, + ) + rt.Call(h.a.ExtendSectorExpiration, params) + rt.Verify() +} + +func (h *actorHarness) terminateSectors(rt *mock.Runtime, sectors *abi.BitField, expectedFee abi.TokenAmount) { + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker) + + dealIDs := []abi.DealID{} + sectorInfos := []*miner.SectorOnChainInfo{} + err := sectors.ForEach(func(secNum uint64) error { + sector := h.getSector(rt, abi.SectorNumber(secNum)) + dealIDs = append(dealIDs, sector.DealIDs...) + + sectorInfos = append(sectorInfos, sector) + return nil + }) + require.NoError(h.t, err) + + { + expectQueryNetworkInfo(rt, &power.CurrentTotalPowerReturn{ + RawBytePower: h.networkRawPower, + QualityAdjPower: h.networkQAPower, + PledgeCollateral: h.networkPledge, + }, h.epochReward) + } + + { + rawPower, qaPower := miner.PowerForSectors(h.sectorSize, sectorInfos) + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdateClaimedPower, &power.UpdateClaimedPowerParams{ + RawByteDelta: rawPower.Neg(), + QualityAdjustedDelta: qaPower.Neg(), + }, abi.NewTokenAmount(0), nil, exitcode.Ok) + } + if big.Zero().LessThan(expectedFee) { + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, expectedFee, nil, exitcode.Ok) + pledgeDelta := expectedFee.Neg() + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdatePledgeTotal, &pledgeDelta, big.Zero(), nil, exitcode.Ok) + } + + params := &miner.TerminateSectorsParams{Sectors: sectors} + rt.Call(h.a.TerminateSectors, params) + rt.Verify() +} + +func (h *actorHarness) reportConsensusFault(rt *mock.Runtime, from addr.Address, params *miner.ReportConsensusFaultParams, dealIDs []abi.DealID) { + rt.SetCaller(from, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.CallerTypesSignable...) + + rt.ExpectVerifyConsensusFault(params.BlockHeader1, params.BlockHeader2, params.BlockHeaderExtra, &runtime.ConsensusFault{ + Target: h.receiver, + Epoch: rt.Epoch() - 1, + Type: runtime.ConsensusFaultDoubleForkMining, + }, nil) + + // slash reward + reward := miner.RewardForConsensusSlashReport(1, rt.Balance()) + rt.ExpectSend(from, builtin.MethodSend, nil, reward, nil, exitcode.Ok) + + // power termination + lockedFunds := getState(rt).LockedFunds + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.OnConsensusFault, &lockedFunds, abi.NewTokenAmount(0), nil, exitcode.Ok) + + // expect every deal to be closed out + rt.ExpectSend(builtin.StorageMarketActorAddr, builtin.MethodsMarket.OnMinerSectorsTerminate, &market.OnMinerSectorsTerminateParams{ + DealIDs: dealIDs, + }, abi.NewTokenAmount(0), nil, exitcode.Ok) + + // expect actor to be deleted + rt.ExpectDeleteActor(builtin.BurntFundsActorAddr) + + rt.Call(h.a.ReportConsensusFault, params) + rt.Verify() +} + +func (h *actorHarness) addLockedFund(rt *mock.Runtime, amt abi.TokenAmount) { + rt.SetCaller(h.worker, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.worker, h.owner, builtin.RewardActorAddr) + // expect pledge update + rt.ExpectSend( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.UpdatePledgeTotal, + &amt, + abi.NewTokenAmount(0), + nil, + exitcode.Ok, + ) + + rt.Call(h.a.AddLockedFund, &amt) + rt.Verify() +} + +type cronConfig struct { + expectedEntrollment abi.ChainEpoch + newSectors bool + vestingPledgeDelta *abi.TokenAmount // nolint:structcheck,unused + undetectedFaultsPowerDelta *power.UpdateClaimedPowerParams + undetectedFaultsPenalty *abi.TokenAmount + expiredSectorsPowerDelta *power.UpdateClaimedPowerParams + ongoingFaultsPenalty *abi.TokenAmount +} + +func (h *actorHarness) onProvingPeriodCron(rt *mock.Runtime, config *cronConfig) { + rt.ExpectValidateCallerAddr(builtin.StoragePowerActorAddr) + + // Preamble + rt.ExpectSend(builtin.RewardActorAddr, builtin.MethodsReward.ThisEpochReward, nil, big.Zero(), &h.epochReward, exitcode.Ok) + networkPower := big.NewIntUnsigned(1 << 50) + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.CurrentTotalPower, nil, big.Zero(), + &power.CurrentTotalPowerReturn{ + RawBytePower: networkPower, + QualityAdjPower: networkPower, + PledgeCollateral: h.networkPledge, + }, + exitcode.Ok) + + if config.undetectedFaultsPowerDelta != nil { + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdateClaimedPower, config.undetectedFaultsPowerDelta, + abi.NewTokenAmount(0), nil, exitcode.Ok) + } + if config.undetectedFaultsPenalty != nil { + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, *config.undetectedFaultsPenalty, nil, exitcode.Ok) + pledgeDelta := config.undetectedFaultsPenalty.Neg() + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdatePledgeTotal, &pledgeDelta, big.Zero(), nil, exitcode.Ok) + } + if config.expiredSectorsPowerDelta != nil { + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdateClaimedPower, config.expiredSectorsPowerDelta, + abi.NewTokenAmount(0), nil, exitcode.Ok) + } + if config.ongoingFaultsPenalty != nil { + rt.ExpectSend(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, *config.ongoingFaultsPenalty, nil, exitcode.Ok) + pledgeDelta := config.ongoingFaultsPenalty.Neg() + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.UpdatePledgeTotal, &pledgeDelta, big.Zero(), nil, exitcode.Ok) + } + + if config.newSectors { + // Establish new proving sets + randEpoch := rt.Epoch() - miner.ElectionLookback + rt.ExpectGetRandomness(crypto.DomainSeparationTag_WindowedPoStDeadlineAssignment, randEpoch, nil, bytes.Repeat([]byte{0}, 32)) + } + + // Re-enrollment for next period. + rt.ExpectSend(builtin.StoragePowerActorAddr, builtin.MethodsPower.EnrollCronEvent, + makeProvingPeriodCronEventParams(h.t, config.expectedEntrollment), big.Zero(), nil, exitcode.Ok) + + rt.SetCaller(builtin.StoragePowerActorAddr, builtin.StoragePowerActorCodeID) + rt.Call(h.a.OnDeferredCronEvent, &miner.CronEventPayload{ + EventType: miner.CronEventProvingPeriod, + }) + rt.Verify() +} + +func (h *actorHarness) withdrawFunds(rt *mock.Runtime, amount abi.TokenAmount) { + rt.SetCaller(h.owner, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(h.owner) + + rt.ExpectSend(h.owner, builtin.MethodSend, nil, amount, nil, exitcode.Ok) + + rt.Call(h.a.WithdrawBalance, &miner.WithdrawBalanceParams{ + AmountRequested: amount, + }) + rt.Verify() +} + +func (h *actorHarness) claimParamsForSectors(sectors []*miner.SectorOnChainInfo, addition bool) *power.UpdateClaimedPowerParams { + multiplier := big.NewInt(1) + if !addition { + multiplier = big.NewInt(-1) + } + rawPower, qaPower := powerForSectors(h.sectorSize, sectors) + return &power.UpdateClaimedPowerParams{ + RawByteDelta: big.Mul(rawPower, multiplier), + QualityAdjustedDelta: big.Mul(qaPower, multiplier), + } +} + +// +// Higher-level orchestration +// + +// Completes a proving period by moving the epoch forward to the penultimate one, calling the proving period cron handler, +// and then advancing to the first epoch in the new period. +func completeProvingPeriod(rt *mock.Runtime, h *actorHarness, config *cronConfig) { + deadline := h.deadline(rt) + rt.SetEpoch(deadline.PeriodEnd()) + config.expectedEntrollment = deadline.NextPeriodStart() + miner.WPoStProvingPeriod - 1 + h.onProvingPeriodCron(rt, config) + rt.SetEpoch(deadline.NextPeriodStart()) +} + +// +// Construction helpers, etc +// + +func builderForHarness(actor *actorHarness) *mock.RuntimeBuilder { + return mock.NewBuilder(context.Background(), actor.receiver). + WithActorType(actor.owner, builtin.AccountActorCodeID). + WithActorType(actor.worker, builtin.AccountActorCodeID). + WithHasher(fixedHasher(uint64(actor.periodOffset))) +} + +func getState(rt *mock.Runtime) *miner.State { + var st miner.State + rt.GetState(&st) + return &st +} + +func makeProvingPeriodCronEventParams(t testing.TB, epoch abi.ChainEpoch) *power.EnrollCronEventParams { + eventPayload := miner.CronEventPayload{EventType: miner.CronEventProvingPeriod} + buf := bytes.Buffer{} + err := eventPayload.MarshalCBOR(&buf) + require.NoError(t, err) + return &power.EnrollCronEventParams{ + EventEpoch: epoch, + Payload: buf.Bytes(), + } +} + +func makePreCommit(sectorNo abi.SectorNumber, challenge, expiration abi.ChainEpoch, dealIDs []abi.DealID) *miner.SectorPreCommitInfo { + return &miner.SectorPreCommitInfo{ + SealProof: abi.RegisteredSealProof_StackedDrg2KiBV1, + SectorNumber: sectorNo, + SealedCID: tutil.MakeCID("commr"), + SealRandEpoch: challenge, + DealIDs: dealIDs, + Expiration: expiration, + } +} + +func makeProveCommit(sectorNo abi.SectorNumber) *miner.ProveCommitSectorParams { + return &miner.ProveCommitSectorParams{ + SectorNumber: sectorNo, + Proof: []byte("proof"), + } +} + +func makeFaultParamsFromFaultingSectors(t testing.TB, st *miner.State, store adt.Store, faultSectorInfos []*miner.SectorOnChainInfo) *miner.DeclareFaultsParams { + deadlines, err := st.LoadDeadlines(store) + require.NoError(t, err) + faultAtDeadline := make(map[uint64][]uint64) + // Find the deadline for each faulty sector which must be provided with the fault declaration + for _, sectorInfo := range faultSectorInfos { + dl, err := miner.FindDeadline(deadlines, sectorInfo.SectorNumber) + require.NoError(t, err) + faultAtDeadline[dl] = append(faultAtDeadline[dl], uint64(sectorInfo.SectorNumber)) + } + params := &miner.DeclareFaultsParams{Faults: []miner.FaultDeclaration{}} + // Group together faults at the same deadline into a bitfield + for dl, sectorNumbers := range faultAtDeadline { + fault := miner.FaultDeclaration{ + Deadline: dl, + Sectors: bitfield.NewFromSet(sectorNumbers), + } + params.Faults = append(params.Faults, fault) + } + return params +} + +func sectorInfoAsBitfield(infos []*miner.SectorOnChainInfo) *bitfield.BitField { + bf := bitfield.New() + for _, info := range infos { + bf.Set(uint64(info.SectorNumber)) + } + return &bf +} + +func powerForSectors(sectorSize abi.SectorSize, sectors []*miner.SectorOnChainInfo) (rawBytePower, qaPower big.Int) { + rawBytePower = big.Mul(big.NewIntUnsigned(uint64(sectorSize)), big.NewIntUnsigned(uint64(len(sectors)))) + qaPower = big.Zero() + for _, s := range sectors { + qaPower = big.Add(qaPower, miner.QAPowerForSector(sectorSize, s)) + } + return rawBytePower, qaPower +} + +func assertEmptyBitfield(t *testing.T, b *abi.BitField) { + empty, err := b.IsEmpty() + require.NoError(t, err) + assert.True(t, empty) +} + +// Returns a fake hashing function that always arranges the first 8 bytes of the digest to be the binary +// encoding of a target uint64. +func fixedHasher(target uint64) func([]byte) [32]byte { + return func(_ []byte) [32]byte { + var buf bytes.Buffer + err := binary.Write(&buf, binary.BigEndian, target) + if err != nil { + panic(err) + } + var digest [32]byte + copy(digest[:], buf.Bytes()) + return digest + } +} + +func expectQueryNetworkInfo(rt *mock.Runtime, expectedTotalPower *power.CurrentTotalPowerReturn, expectedReward big.Int) { + rt.ExpectSend( + builtin.RewardActorAddr, + builtin.MethodsReward.ThisEpochReward, + nil, + big.Zero(), + &expectedReward, + exitcode.Ok, + ) + + rt.ExpectSend( + builtin.StoragePowerActorAddr, + builtin.MethodsPower.CurrentTotalPower, + nil, + big.Zero(), + expectedTotalPower, + exitcode.Ok, + ) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/monies.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/monies.go new file mode 100644 index 000000000..22a26e25e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/monies.go @@ -0,0 +1,85 @@ +package miner + +import ( + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" +) + +// IP = InitialPledgeFactor * BR(precommit time) +var InitialPledgeFactor = big.NewInt(20) + +// FF = (DeclaredFaultFactorNum / DeclaredFaultFactorDenom) * BR(t) +var DeclaredFaultFactorNum = big.NewInt(214) +var DeclaredFaultFactorDenom = big.NewInt(100) + +// SP = (UndeclaredFaultFactor / DeclaredFaultFactorDenom) * BR(t) +var UndeclaredFaultFactorNum = big.NewInt(5) +var UndeclaredFaultFactorDenom = big.NewInt(1) + +// This is the BR(t) value of the given sector for the current epoch. +// It is the expected reward this sector would pay out over a one day period. +// BR(t) = CurrEpochReward(t) * SectorQualityAdjustedPower * EpochsInDay / TotalNetworkQualityAdjustedPower(t) +func ExpectedDayRewardForPower(epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, qaSectorPower abi.StoragePower) abi.TokenAmount { + expectedRewardForProvingPeriod := big.Mul(big.NewInt(builtin.EpochsInDay), epochTargetReward) + return big.Div(big.Mul(qaSectorPower, expectedRewardForProvingPeriod), networkQAPower) +} + +// This is the FF(t) penalty for a sector expected to be in the fault state either because the fault was declared or because +// it has been previously detected by the network. +// FF(t) = DeclaredFaultFactor * BR(t) +func PledgePenaltyForDeclaredFault(epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, qaSectorPower abi.StoragePower) abi.TokenAmount { + return big.Div( + big.Mul(DeclaredFaultFactorNum, ExpectedDayRewardForPower(epochTargetReward, networkQAPower, qaSectorPower)), + DeclaredFaultFactorDenom) +} + +// This is the SP(t) penalty for a newly faulty sector that has not been declared. +// SP(t) = UndeclaredFaultFactor * BR(t) +func PledgePenaltyForUndeclaredFault(epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, qaSectorPower abi.StoragePower) abi.TokenAmount { + return big.Div( + big.Mul(UndeclaredFaultFactorNum, ExpectedDayRewardForPower(epochTargetReward, networkQAPower, qaSectorPower)), + UndeclaredFaultFactorDenom) +} + +// This is the SP(t) penalty for a newly faulty sector that has not been declared later than one deadline. +// SP_late(t) = 2*SP(t) +func PledgePenaltyForLateUndeclaredFault(epochTargetReward abi.TokenAmount, networkQAPower abi.StoragePower, qaSectorPower abi.StoragePower) abi.TokenAmount { + return big.Mul(big.NewInt(2), + PledgePenaltyForUndeclaredFault(epochTargetReward, networkQAPower, qaSectorPower)) +} + +// Penalty to locked pledge collateral for the termination of a sector before scheduled expiry. +// SectorAge is the time between now and the sector's activation. +func PledgePenaltyForTermination(initialPledge abi.TokenAmount, sectorAge abi.ChainEpoch, epochTargetReward abi.TokenAmount, networkQAPower, qaSectorPower abi.StoragePower) abi.TokenAmount { + // max(SP(t), IP + BR(StartEpoch)*min(SectorAgeInDays, 180)) + // where BR(StartEpoch)=IP/InitialPledgeFactor + // and sectorAgeInDays = sectorAge / EpochsInDay + cappedSectorAge := big.NewInt(int64(minEpoch(sectorAge, 180*builtin.EpochsInDay))) + return big.Max( + PledgePenaltyForLateUndeclaredFault(epochTargetReward, networkQAPower, qaSectorPower), + big.Add( + initialPledge, + big.Div( + big.Mul(initialPledge, cappedSectorAge), + big.Mul(InitialPledgeFactor, big.NewInt(builtin.EpochsInDay))))) +} + +// Computes the pledge requirement for committing new quality-adjusted power to the network, given the current +// total power, total pledge commitment, epoch block reward, and circulating token supply. +// In plain language, the pledge requirement is a multiple of the block reward expected to be earned by the +// newly-committed power, holding the per-epoch block reward constant (though in reality it will change over time). +// The network total pledge and circulating supply parameters are currently unused, but may be included in a +// future calculation. +func InitialPledgeForPower(qaPower abi.StoragePower, networkQAPower abi.StoragePower, networkTotalPledge abi.TokenAmount, epochTargetReward abi.TokenAmount, networkCirculatingSupply abi.TokenAmount) abi.TokenAmount { + // Details here are still subject to change. + // PARAM_FINISH + // https://github.com/filecoin-project/specs-actors/issues/468 + _ = networkCirculatingSupply // TODO: ce use this + _ = networkTotalPledge // TODO: ce use this + + if networkQAPower.IsZero() { + return epochTargetReward + } + return big.Mul(InitialPledgeFactor, ExpectedDayRewardForPower(epochTargetReward, networkQAPower, qaPower)) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/monies_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/monies_test.go new file mode 100644 index 000000000..329ae09ef --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/monies_test.go @@ -0,0 +1,63 @@ +package miner_test + +import ( + "github.com/filecoin-project/specs-actors/actors/builtin" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin/miner" +) + +// Test termination fee +func TestPledgePenaltyForTermination(t *testing.T) { + epochTargetReward := abi.NewTokenAmount(1 << 50) + qaSectorPower := abi.NewStoragePower(1 << 36) + networkQAPower := abi.NewStoragePower(1 << 50) + undeclaredPenalty := miner.PledgePenaltyForLateUndeclaredFault(epochTargetReward, networkQAPower, qaSectorPower) + + t.Run("when undeclared fault fee exceeds expected reward, returns undeclaraed fault fee", func(t *testing.T) { + // small pledge and means undeclared penalty will be bigger + initialPledge := abi.NewTokenAmount(1 << 10) + sectorAge := 20 * abi.ChainEpoch(builtin.EpochsInDay) + + fee := miner.PledgePenaltyForTermination(initialPledge, sectorAge, epochTargetReward, networkQAPower, qaSectorPower) + + assert.Equal(t, undeclaredPenalty, fee) + }) + + t.Run("when expected reward exceeds undeclared fault fee, returns expected reward", func(t *testing.T) { + // initialPledge equal to undeclaredPenalty guarantees expected reward is greater + initialPledge := undeclaredPenalty + sectorAgeInDays := int64(20) + sectorAge := abi.ChainEpoch(sectorAgeInDays * builtin.EpochsInDay) + + fee := miner.PledgePenaltyForTermination(initialPledge, sectorAge, epochTargetReward, networkQAPower, qaSectorPower) + + // expect fee to be pledge * br * age where br = pledge/initialPledgeFactor + expectedFee := big.Add( + initialPledge, + big.Div( + big.Mul(initialPledge, big.NewInt(sectorAgeInDays)), + miner.InitialPledgeFactor)) + assert.Equal(t, expectedFee, fee) + }) + + t.Run("sector age is capped", func(t *testing.T) { + initialPledge := undeclaredPenalty + sectorAgeInDays := 500 + sectorAge := abi.ChainEpoch(sectorAgeInDays * builtin.EpochsInDay) + + fee := miner.PledgePenaltyForTermination(initialPledge, sectorAge, epochTargetReward, networkQAPower, qaSectorPower) + + // expect fee to be pledge * br * age where br = pledge/initialPledgeFactor + expectedFee := big.Add( + initialPledge, + big.Div( + big.Mul(initialPledge, big.NewInt(180)), + miner.InitialPledgeFactor)) + assert.Equal(t, expectedFee, fee) + }) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/policy.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/policy.go new file mode 100644 index 000000000..5c76d6f64 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/miner/policy.go @@ -0,0 +1,196 @@ +package miner + +import ( + "fmt" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + . "github.com/filecoin-project/specs-actors/actors/util" +) + +// The period over which all a miner's active sectors will be challenged. +const WPoStProvingPeriod = abi.ChainEpoch(builtin.EpochsInDay) // 24 hours + +// The duration of a deadline's challenge window, the period before a deadline when the challenge is available. +const WPoStChallengeWindow = abi.ChainEpoch(40 * 60 / builtin.EpochDurationSeconds) // 40 minutes (36 per day) + +// The number of non-overlapping PoSt deadlines in each proving period. +const WPoStPeriodDeadlines = uint64(WPoStProvingPeriod / WPoStChallengeWindow) + +func init() { + // Check that the challenge windows divide the proving period evenly. + if WPoStProvingPeriod%WPoStChallengeWindow != 0 { + panic(fmt.Sprintf("incompatible proving period %d and challenge window %d", WPoStProvingPeriod, WPoStChallengeWindow)) + } + if abi.ChainEpoch(WPoStPeriodDeadlines)*WPoStChallengeWindow != WPoStProvingPeriod { + panic(fmt.Sprintf("incompatible proving period %d and challenge window %d", WPoStProvingPeriod, WPoStChallengeWindow)) + } +} + +// The maximum number of sectors that a miner can have simultaneously active. +// This also bounds the number of faults that can be declared, etc. +// TODO raise this number, carefully +// https://github.com/filecoin-project/specs-actors/issues/470 +const SectorsMax = 32 << 20 // PARAM_FINISH + +// The maximum number of proving partitions a miner can have simultaneously active. +func activePartitionsMax(partitionSectorCount uint64) uint64 { + return (SectorsMax / partitionSectorCount) + WPoStPeriodDeadlines +} + +// The maximum number of partitions that may be submitted in a single message. +// This bounds the size of a list/set of sector numbers that might be instantiated to process a submission. +func windowPoStMessagePartitionsMax(partitionSectorCount uint64) uint64 { + return 100_000 / partitionSectorCount +} + +// The maximum number of new sectors that may be staged by a miner during a single proving period. +const NewSectorsPerPeriodMax = 128 << 10 + +// Epochs after which chain state is final. +const ChainFinality = abi.ChainEpoch(900) + +// List of proof types which can be used when creating new miner actors +var SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{ + abi.RegisteredSealProof_StackedDrg32GiBV1: {}, + abi.RegisteredSealProof_StackedDrg64GiBV1: {}, +} + +// Maximum duration to allow for the sealing process for seal algorithms. +// Dependent on algorithm and sector size +var MaxSealDuration = map[abi.RegisteredSealProof]abi.ChainEpoch{ + abi.RegisteredSealProof_StackedDrg32GiBV1: abi.ChainEpoch(10000), // PARAM_FINISH + abi.RegisteredSealProof_StackedDrg2KiBV1: abi.ChainEpoch(10000), + abi.RegisteredSealProof_StackedDrg8MiBV1: abi.ChainEpoch(10000), + abi.RegisteredSealProof_StackedDrg512MiBV1: abi.ChainEpoch(10000), + abi.RegisteredSealProof_StackedDrg64GiBV1: abi.ChainEpoch(10000), +} + +// Number of epochs between publishing the precommit and when the challenge for interactive PoRep is drawn +// used to ensure it is not predictable by miner. +const PreCommitChallengeDelay = abi.ChainEpoch(10) + +// Lookback from the current epoch for state view for leader elections. +const ElectionLookback = abi.ChainEpoch(1) // PARAM_FINISH + +// Lookback from the deadline's challenge window opening from which to sample chain randomness for the challenge seed. +// This lookback exists so that deadline windows can be non-overlapping (which make the programming simpler) +// but without making the miner wait for chain stability before being able to start on PoSt computation. +// The challenge is available this many epochs before the window is actually open to receiving a PoSt. +const WPoStChallengeLookback = abi.ChainEpoch(20) + +// Minimum period before a deadline's challenge window opens that a fault must be declared for that deadline. +// This lookback must not be less than WPoStChallengeLookback lest a malicious miner be able to selectively declare +// faults after learning the challenge value. +const FaultDeclarationCutoff = WPoStChallengeLookback + 10 + +// The maximum age of a fault before the sector is terminated. +const FaultMaxAge = WPoStProvingPeriod*14 - 1 + +// Staging period for a miner worker key change. +// Finality is a harsh delay for a miner who has lost their worker key, as the miner will miss Window PoSts until +// it can be changed. It's the only safe value, though. We may implement a mitigation mechanism such as a second +// key or allowing the owner account to submit PoSts while a key change is pending. +const WorkerKeyChangeDelay = ChainFinality + +// Maximum number of epochs past the current epoch a sector may be set to expire. +// The actual maximum extension will be the minimum of CurrEpoch + MaximumSectorExpirationExtension +// and sector.ActivationEpoch+sealProof.SectorMaximumLifetime() +const MaxSectorExpirationExtension = builtin.EpochsInYear + +var QualityBaseMultiplier = big.NewInt(10) // PARAM_FINISH +var DealWeightMultiplier = big.NewInt(11) // PARAM_FINISH +var VerifiedDealWeightMultiplier = big.NewInt(100) // PARAM_FINISH +const SectorQualityPrecision = 20 + +// DealWeight and VerifiedDealWeight are spacetime occupied by regular deals and verified deals in a sector. +// Sum of DealWeight and VerifiedDealWeight should be less than or equal to total SpaceTime of a sector. +// Sectors full of VerifiedDeals will have a SectorQuality of VerifiedDealWeightMultiplier/QualityBaseMultiplier. +// Sectors full of Deals will have a SectorQuality of DealWeightMultiplier/QualityBaseMultiplier. +// Sectors with neither will have a SectorQuality of QualityBaseMultiplier/QualityBaseMultiplier. +// SectorQuality of a sector is a weighted average of multipliers based on their propotions. +func QualityForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.SectorQuality { + sectorSpaceTime := big.Mul(big.NewIntUnsigned(uint64(size)), big.NewInt(int64(duration))) + totalDealSpaceTime := big.Add(dealWeight, verifiedWeight) + Assert(sectorSpaceTime.GreaterThanEqual(totalDealSpaceTime)) + + weightedBaseSpaceTime := big.Mul(big.Sub(sectorSpaceTime, totalDealSpaceTime), QualityBaseMultiplier) + weightedDealSpaceTime := big.Mul(dealWeight, DealWeightMultiplier) + weightedVerifiedSpaceTime := big.Mul(verifiedWeight, VerifiedDealWeightMultiplier) + weightedSumSpaceTime := big.Add(weightedBaseSpaceTime, big.Add(weightedDealSpaceTime, weightedVerifiedSpaceTime)) + scaledUpWeightedSumSpaceTime := big.Lsh(weightedSumSpaceTime, SectorQualityPrecision) + + return big.Div(big.Div(scaledUpWeightedSumSpaceTime, sectorSpaceTime), QualityBaseMultiplier) +} + +// Returns the power for a sector size and weight. +func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower { + quality := QualityForWeight(size, duration, dealWeight, verifiedWeight) + return big.Rsh(big.Mul(big.NewIntUnsigned(uint64(size)), quality), SectorQualityPrecision) +} + +// Returns the quality-adjusted power for a sector. +func QAPowerForSector(size abi.SectorSize, sector *SectorOnChainInfo) abi.StoragePower { + duration := sector.Expiration - sector.Activation + return QAPowerForWeight(size, duration, sector.DealWeight, sector.VerifiedDealWeight) +} + +// Deposit per sector required at pre-commitment, refunded after the commitment is proven (else burned). +func precommitDeposit(qaSectorPower abi.StoragePower, networkQAPower abi.StoragePower, networkTotalPledge, epochTargetReward, circulatingSupply abi.TokenAmount) abi.TokenAmount { + return InitialPledgeForPower(qaSectorPower, networkQAPower, networkTotalPledge, epochTargetReward, circulatingSupply) +} + +type BigFrac struct { + numerator big.Int + denominator big.Int +} + +var consensusFaultReporterInitialShare = BigFrac{ + // PARAM_FINISH + numerator: big.NewInt(1), + denominator: big.NewInt(1000), +} +var consensusFaultReporterShareGrowthRate = BigFrac{ + // PARAM_FINISH + numerator: big.NewInt(101251), + denominator: big.NewInt(100000), +} + +// Specification for a linear vesting schedule. +type VestSpec struct { + InitialDelay abi.ChainEpoch // Delay before any amount starts vesting. + VestPeriod abi.ChainEpoch // Period over which the total should vest, after the initial delay. + StepDuration abi.ChainEpoch // Duration between successive incremental vests (independent of vesting period). + Quantization abi.ChainEpoch // Maximum precision of vesting table (limits cardinality of table). +} + +var PledgeVestingSpec = VestSpec{ + InitialDelay: abi.ChainEpoch(7 * builtin.EpochsInDay), // 1 week for testnet, PARAM_FINISH + VestPeriod: abi.ChainEpoch(7 * builtin.EpochsInDay), // 1 week for testnet, PARAM_FINISH + StepDuration: abi.ChainEpoch(1 * builtin.EpochsInDay), // 1 day for testnet, PARAM_FINISH + Quantization: 12 * builtin.EpochsInHour, // 12 hours for testnet, PARAM_FINISH +} + +func RewardForConsensusSlashReport(elapsedEpoch abi.ChainEpoch, collateral abi.TokenAmount) abi.TokenAmount { + // PARAM_FINISH + // var growthRate = SLASHER_SHARE_GROWTH_RATE_NUM / SLASHER_SHARE_GROWTH_RATE_DENOM + // var multiplier = growthRate^elapsedEpoch + // var slasherProportion = min(INITIAL_SLASHER_SHARE * multiplier, 1.0) + // return collateral * slasherProportion + + // BigInt Operation + // NUM = SLASHER_SHARE_GROWTH_RATE_NUM^elapsedEpoch * INITIAL_SLASHER_SHARE_NUM * collateral + // DENOM = SLASHER_SHARE_GROWTH_RATE_DENOM^elapsedEpoch * INITIAL_SLASHER_SHARE_DENOM + // slasher_amount = min(NUM/DENOM, collateral) + maxReporterShareNum := big.NewInt(1) + maxReporterShareDen := big.NewInt(2) + + elapsed := big.NewInt(int64(elapsedEpoch)) + slasherShareNumerator := big.Exp(consensusFaultReporterShareGrowthRate.numerator, elapsed) + slasherShareDenominator := big.Exp(consensusFaultReporterShareGrowthRate.denominator, elapsed) + + num := big.Mul(big.Mul(slasherShareNumerator, consensusFaultReporterInitialShare.numerator), collateral) + denom := big.Mul(slasherShareDenominator, consensusFaultReporterInitialShare.denominator) + return big.Min(big.Div(num, denom), big.Div(big.Mul(collateral, maxReporterShareNum), maxReporterShareDen)) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/cbor_gen.go new file mode 100644 index 000000000..d21de7229 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/cbor_gen.go @@ -0,0 +1,1351 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package multisig + +import ( + "fmt" + "io" + + address "github.com/filecoin-project/go-address" + abi "github.com/filecoin-project/specs-actors/actors/abi" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{135}); err != nil { + return err + } + + // t.Signers ([]address.Address) (slice) + if len(t.Signers) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Signers was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Signers)))); err != nil { + return err + } + for _, v := range t.Signers { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.NumApprovalsThreshold (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NumApprovalsThreshold))); err != nil { + return err + } + + // t.NextTxnID (multisig.TxnID) (int64) + if t.NextTxnID >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextTxnID))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.NextTxnID)-1)); err != nil { + return err + } + } + + // t.InitialBalance (big.Int) (struct) + if err := t.InitialBalance.MarshalCBOR(w); err != nil { + return err + } + + // t.StartEpoch (abi.ChainEpoch) (int64) + if t.StartEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.StartEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.StartEpoch)-1)); err != nil { + return err + } + } + + // t.UnlockDuration (abi.ChainEpoch) (int64) + if t.UnlockDuration >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.UnlockDuration))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.UnlockDuration)-1)); err != nil { + return err + } + } + + // t.PendingTxns (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.PendingTxns); err != nil { + return xerrors.Errorf("failed to write cid field t.PendingTxns: %w", err) + } + + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 7 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Signers ([]address.Address) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Signers: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Signers = make([]address.Address, extra) + } + + for i := 0; i < int(extra); i++ { + + var v address.Address + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Signers[i] = v + } + + // t.NumApprovalsThreshold (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.NumApprovalsThreshold = uint64(extra) + + } + // t.NextTxnID (multisig.TxnID) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.NextTxnID = TxnID(extraI) + } + // t.InitialBalance (big.Int) (struct) + + { + + if err := t.InitialBalance.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.InitialBalance: %w", err) + } + + } + // t.StartEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.StartEpoch = abi.ChainEpoch(extraI) + } + // t.UnlockDuration (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.UnlockDuration = abi.ChainEpoch(extraI) + } + // t.PendingTxns (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.PendingTxns: %w", err) + } + + t.PendingTxns = c + + } + return nil +} + +func (t *Transaction) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{133}); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + + // t.Value (big.Int) (struct) + if err := t.Value.MarshalCBOR(w); err != nil { + return err + } + + // t.Method (abi.MethodNum) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil { + return err + } + + // t.Params ([]uint8) (slice) + if len(t.Params) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Params was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil { + return err + } + if _, err := w.Write(t.Params); err != nil { + return err + } + + // t.Approved ([]address.Address) (slice) + if len(t.Approved) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Approved was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Approved)))); err != nil { + return err + } + for _, v := range t.Approved { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *Transaction) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 5 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + // t.Value (big.Int) (struct) + + { + + if err := t.Value.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Value: %w", err) + } + + } + // t.Method (abi.MethodNum) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Method = abi.MethodNum(extra) + + } + // t.Params ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Params: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Params = make([]byte, extra) + if _, err := io.ReadFull(br, t.Params); err != nil { + return err + } + // t.Approved ([]address.Address) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Approved: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Approved = make([]address.Address, extra) + } + + for i := 0; i < int(extra); i++ { + + var v address.Address + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Approved[i] = v + } + + return nil +} + +func (t *ProposalHashData) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{133}); err != nil { + return err + } + + // t.Requester (address.Address) (struct) + if err := t.Requester.MarshalCBOR(w); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + + // t.Value (big.Int) (struct) + if err := t.Value.MarshalCBOR(w); err != nil { + return err + } + + // t.Method (abi.MethodNum) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil { + return err + } + + // t.Params ([]uint8) (slice) + if len(t.Params) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Params was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil { + return err + } + if _, err := w.Write(t.Params); err != nil { + return err + } + return nil +} + +func (t *ProposalHashData) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 5 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Requester (address.Address) (struct) + + { + + if err := t.Requester.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Requester: %w", err) + } + + } + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + // t.Value (big.Int) (struct) + + { + + if err := t.Value.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Value: %w", err) + } + + } + // t.Method (abi.MethodNum) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Method = abi.MethodNum(extra) + + } + // t.Params ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Params: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Params = make([]byte, extra) + if _, err := io.ReadFull(br, t.Params); err != nil { + return err + } + return nil +} + +func (t *ConstructorParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.Signers ([]address.Address) (slice) + if len(t.Signers) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Signers was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Signers)))); err != nil { + return err + } + for _, v := range t.Signers { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.NumApprovalsThreshold (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NumApprovalsThreshold))); err != nil { + return err + } + + // t.UnlockDuration (abi.ChainEpoch) (int64) + if t.UnlockDuration >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.UnlockDuration))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.UnlockDuration)-1)); err != nil { + return err + } + } + return nil +} + +func (t *ConstructorParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Signers ([]address.Address) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Signers: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Signers = make([]address.Address, extra) + } + + for i := 0; i < int(extra); i++ { + + var v address.Address + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Signers[i] = v + } + + // t.NumApprovalsThreshold (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.NumApprovalsThreshold = uint64(extra) + + } + // t.UnlockDuration (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.UnlockDuration = abi.ChainEpoch(extraI) + } + return nil +} + +func (t *ProposeParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + + // t.Value (big.Int) (struct) + if err := t.Value.MarshalCBOR(w); err != nil { + return err + } + + // t.Method (abi.MethodNum) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil { + return err + } + + // t.Params ([]uint8) (slice) + if len(t.Params) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Params was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil { + return err + } + if _, err := w.Write(t.Params); err != nil { + return err + } + return nil +} + +func (t *ProposeParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + // t.Value (big.Int) (struct) + + { + + if err := t.Value.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Value: %w", err) + } + + } + // t.Method (abi.MethodNum) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Method = abi.MethodNum(extra) + + } + // t.Params ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Params: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Params = make([]byte, extra) + if _, err := io.ReadFull(br, t.Params); err != nil { + return err + } + return nil +} + +func (t *AddSignerParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Signer (address.Address) (struct) + if err := t.Signer.MarshalCBOR(w); err != nil { + return err + } + + // t.Increase (bool) (bool) + if err := cbg.WriteBool(w, t.Increase); err != nil { + return err + } + return nil +} + +func (t *AddSignerParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Signer (address.Address) (struct) + + { + + if err := t.Signer.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Signer: %w", err) + } + + } + // t.Increase (bool) (bool) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.Increase = false + case 21: + t.Increase = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + return nil +} + +func (t *RemoveSignerParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Signer (address.Address) (struct) + if err := t.Signer.MarshalCBOR(w); err != nil { + return err + } + + // t.Decrease (bool) (bool) + if err := cbg.WriteBool(w, t.Decrease); err != nil { + return err + } + return nil +} + +func (t *RemoveSignerParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Signer (address.Address) (struct) + + { + + if err := t.Signer.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Signer: %w", err) + } + + } + // t.Decrease (bool) (bool) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.Decrease = false + case 21: + t.Decrease = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + return nil +} + +func (t *TxnIDParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.ID (multisig.TxnID) (int64) + if t.ID >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ID))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.ID)-1)); err != nil { + return err + } + } + + // t.ProposalHash ([]uint8) (slice) + if len(t.ProposalHash) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.ProposalHash was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.ProposalHash)))); err != nil { + return err + } + if _, err := w.Write(t.ProposalHash); err != nil { + return err + } + return nil +} + +func (t *TxnIDParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.ID (multisig.TxnID) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.ID = TxnID(extraI) + } + // t.ProposalHash ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.ProposalHash: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.ProposalHash = make([]byte, extra) + if _, err := io.ReadFull(br, t.ProposalHash); err != nil { + return err + } + return nil +} + +func (t *ChangeNumApprovalsThresholdParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.NewThreshold (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NewThreshold))); err != nil { + return err + } + + return nil +} + +func (t *ChangeNumApprovalsThresholdParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.NewThreshold (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.NewThreshold = uint64(extra) + + } + return nil +} + +func (t *SwapSignerParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.From (address.Address) (struct) + if err := t.From.MarshalCBOR(w); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *SwapSignerParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.From (address.Address) (struct) + + { + + if err := t.From.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.From: %w", err) + } + + } + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + return nil +} + +func (t *ApproveReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.Applied (bool) (bool) + if err := cbg.WriteBool(w, t.Applied); err != nil { + return err + } + + // t.Code (exitcode.ExitCode) (int64) + if t.Code >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Code))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Code)-1)); err != nil { + return err + } + } + + // t.Ret ([]uint8) (slice) + if len(t.Ret) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Ret was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Ret)))); err != nil { + return err + } + if _, err := w.Write(t.Ret); err != nil { + return err + } + return nil +} + +func (t *ApproveReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Applied (bool) (bool) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.Applied = false + case 21: + t.Applied = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + // t.Code (exitcode.ExitCode) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Code = exitcode.ExitCode(extraI) + } + // t.Ret ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Ret: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Ret = make([]byte, extra) + if _, err := io.ReadFull(br, t.Ret); err != nil { + return err + } + return nil +} + +func (t *ProposeReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.TxnID (multisig.TxnID) (int64) + if t.TxnID >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TxnID))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.TxnID)-1)); err != nil { + return err + } + } + + // t.Applied (bool) (bool) + if err := cbg.WriteBool(w, t.Applied); err != nil { + return err + } + + // t.Code (exitcode.ExitCode) (int64) + if t.Code >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Code))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Code)-1)); err != nil { + return err + } + } + + // t.Ret ([]uint8) (slice) + if len(t.Ret) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Ret was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Ret)))); err != nil { + return err + } + if _, err := w.Write(t.Ret); err != nil { + return err + } + return nil +} + +func (t *ProposeReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.TxnID (multisig.TxnID) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.TxnID = TxnID(extraI) + } + // t.Applied (bool) (bool) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajOther { + return fmt.Errorf("booleans must be major type 7") + } + switch extra { + case 20: + t.Applied = false + case 21: + t.Applied = true + default: + return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra) + } + // t.Code (exitcode.ExitCode) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Code = exitcode.ExitCode(extraI) + } + // t.Ret ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Ret: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Ret = make([]byte, extra) + if _, err := io.ReadFull(br, t.Ret); err != nil { + return err + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_actor.go new file mode 100644 index 000000000..e12cda23e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_actor.go @@ -0,0 +1,518 @@ +package multisig + +import ( + "bytes" + "encoding/binary" + "fmt" + + addr "github.com/filecoin-project/go-address" + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type TxnID int64 + +func (t TxnID) Key() string { + // convert a TxnID to a HAMT key. + txnKey := make([]byte, binary.MaxVarintLen64) + n := binary.PutVarint(txnKey, int64(t)) + return string(txnKey[:n]) +} + +type Transaction struct { + To addr.Address + Value abi.TokenAmount + Method abi.MethodNum + Params []byte + + // This address at index 0 is the transaction proposer, order of this slice must be preserved. + Approved []addr.Address +} + +// Data for a BLAKE2B-256 to be attached to methods referencing proposals via TXIDs. +// Ensures the existence of a cryptographic reference to the original proposal. Useful +// for offline signers and for protection when reorgs change a multisig TXID. +// +// Requester - The requesting multisig wallet member. +// All other fields - From the "Transaction" struct. +type ProposalHashData struct { + Requester addr.Address + To addr.Address + Value abi.TokenAmount + Method abi.MethodNum + Params []byte +} + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.Propose, + 3: a.Approve, + 4: a.Cancel, + 5: a.AddSigner, + 6: a.RemoveSigner, + 7: a.SwapSigner, + 8: a.ChangeNumApprovalsThreshold, + } +} + +var _ abi.Invokee = Actor{} + +type ConstructorParams struct { + Signers []addr.Address + NumApprovalsThreshold uint64 + UnlockDuration abi.ChainEpoch +} + +func (a Actor) Constructor(rt vmr.Runtime, params *ConstructorParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.InitActorAddr) + + if len(params.Signers) < 1 { + rt.Abortf(exitcode.ErrIllegalArgument, "must have at least one signer") + } + + // do not allow duplicate signers + resolvedSigners := make(map[addr.Address]struct{}, len(params.Signers)) + for _, signer := range params.Signers { + resolved := resolve(rt.ResolveAddress, signer) + if _, ok := resolvedSigners[resolved]; ok { + rt.Abortf(exitcode.ErrIllegalArgument, "duplicate signer not allowed: %s", signer) + } + resolvedSigners[resolved] = struct{}{} + + } + + if params.NumApprovalsThreshold > uint64(len(params.Signers)) { + rt.Abortf(exitcode.ErrIllegalArgument, "must not require more approvals than signers") + } + + if params.NumApprovalsThreshold < 1 { + rt.Abortf(exitcode.ErrIllegalArgument, "must require at least one approval") + } + + if params.UnlockDuration < 0 { + rt.Abortf(exitcode.ErrIllegalArgument, "negative unlock duration disallowed") + } + + pending, err := adt.MakeEmptyMap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to create empty map: %v", err) + } + + var st State + st.Signers = params.Signers + st.NumApprovalsThreshold = params.NumApprovalsThreshold + st.PendingTxns = pending + st.InitialBalance = abi.NewTokenAmount(0) + if params.UnlockDuration != 0 { + st.InitialBalance = rt.Message().ValueReceived() + st.UnlockDuration = params.UnlockDuration + st.StartEpoch = rt.CurrEpoch() + } + + rt.State().Create(&st) + return nil +} + +type ProposeParams struct { + To addr.Address + Value abi.TokenAmount + Method abi.MethodNum + Params []byte +} + +type ProposeReturn struct { + // TxnID is the ID of the proposed transaction + TxnID TxnID + // Applied indicates if the transaction was applied as opposed to proposed but not applied due to lack of approvals + Applied bool + // Code is the exitcode of the transaction, if Applied is false this field should be ignored. + Code exitcode.ExitCode + // Ret is the return vale of the transaction, if Applied is false this field should be ignored. + Ret []byte +} + +func (a Actor) Propose(rt vmr.Runtime, params *ProposeParams) *ProposeReturn { + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + callerAddr := rt.Message().Caller() + + var txnID TxnID + var st State + var txn *Transaction + rt.State().Transaction(&st, func() interface{} { + if !isSigner(rt.ResolveAddress, &st, callerAddr) { + rt.Abortf(exitcode.ErrForbidden, "%s is not a signer", callerAddr) + } + + txnID = st.NextTxnID + st.NextTxnID += 1 + txn = &Transaction{ + To: params.To, + Value: params.Value, + Method: params.Method, + Params: params.Params, + Approved: []addr.Address{}, + } + + if err := st.putPendingTransaction(adt.AsStore(rt), txnID, txn); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to put transaction for propose: %v", err) + } + return nil + }) + + applied, ret, code := a.approveTransaction(rt, txnID, txn) + + // Note: this transaction ID may not be stable across chain re-orgs. + // The proposal hash may be provided as a stability check when approving. + return &ProposeReturn{ + TxnID: txnID, + Applied: applied, + Code: code, + Ret: ret, + } +} + +type TxnIDParams struct { + ID TxnID + ProposalHash []byte +} + +type ApproveReturn struct { + // Applied indicates if the transaction was applied as opposed to proposed but not applied due to lack of approvals + Applied bool + // Code is the exitcode of the transaction, if Applied is false this field should be ignored. + Code exitcode.ExitCode + // Ret is the return vale of the transaction, if Applied is false this field should be ignored. + Ret []byte +} + +func (a Actor) Approve(rt vmr.Runtime, params *TxnIDParams) *ApproveReturn { + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + callerAddr := rt.Message().Caller() + var st State + var txn *Transaction + rt.State().Transaction(&st, func() interface{} { + if !isSigner(rt.ResolveAddress, &st, callerAddr) { + rt.Abortf(exitcode.ErrForbidden, "%s is not a signer", callerAddr) + } + txn = a.getTransaction(rt, st, params.ID, params.ProposalHash, true) + return nil + }) + + // if the transaction already has enough approvers, execute it without "processing" this approval. + approved, ret, code := executeTransactionIfApproved(rt, st, params.ID, txn) + if !approved { + // if the transaction hasn't already been approved, let's "process" this approval + // and see if we can execute the transaction + approved, ret, code = a.approveTransaction(rt, params.ID, txn) + } + + return &ApproveReturn{ + Applied: approved, + Code: code, + Ret: ret, + } +} + +func (a Actor) Cancel(rt vmr.Runtime, params *TxnIDParams) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + callerAddr := rt.Message().Caller() + + var st State + rt.State().Transaction(&st, func() interface{} { + if !isSigner(rt.ResolveAddress, &st, callerAddr) { + rt.Abortf(exitcode.ErrForbidden, "%s is not a signer", callerAddr) + } + + txn, err := st.getPendingTransaction(adt.AsStore(rt), params.ID) + if err != nil { + rt.Abortf(exitcode.ErrNotFound, "failed to get transaction for cancel: %v", err) + } + proposer := txn.Approved[0] + if proposer != callerAddr { + rt.Abortf(exitcode.ErrForbidden, "Cannot cancel another signers transaction") + } + + // confirm the hashes match + calculatedHash, err := ComputeProposalHash(&txn, rt.Syscalls().HashBlake2b) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to compute proposal hash: %v", err) + } + if params.ProposalHash != nil && !bytes.Equal(params.ProposalHash, calculatedHash[:]) { + rt.Abortf(exitcode.ErrIllegalState, "hash does not match proposal params") + } + + if err = st.deletePendingTransaction(adt.AsStore(rt), params.ID); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to delete transaction for cancel: %v", err) + } + return nil + }) + return nil +} + +type AddSignerParams struct { + Signer addr.Address + Increase bool +} + +func (a Actor) AddSigner(rt vmr.Runtime, params *AddSignerParams) *adt.EmptyValue { + // Can only be called by the multisig wallet itself. + rt.ValidateImmediateCallerIs(rt.Message().Receiver()) + + var st State + rt.State().Transaction(&st, func() interface{} { + if isSigner(rt.ResolveAddress, &st, params.Signer) { + rt.Abortf(exitcode.ErrIllegalArgument, "%s is already a signer", params.Signer) + } + st.Signers = append(st.Signers, params.Signer) + if params.Increase { + st.NumApprovalsThreshold = st.NumApprovalsThreshold + 1 + } + return nil + }) + return nil +} + +type RemoveSignerParams struct { + Signer addr.Address + Decrease bool +} + +func (a Actor) RemoveSigner(rt vmr.Runtime, params *RemoveSignerParams) *adt.EmptyValue { + // Can only be called by the multisig wallet itself. + rt.ValidateImmediateCallerIs(rt.Message().Receiver()) + + var st State + rt.State().Transaction(&st, func() interface{} { + if !isSigner(rt.ResolveAddress, &st, params.Signer) { + rt.Abortf(exitcode.ErrNotFound, "%s is not a signer", params.Signer) + } + + if len(st.Signers) == 1 { + rt.Abortf(exitcode.ErrForbidden, "cannot remove only signer") + } + + newSigners := make([]addr.Address, 0, len(st.Signers)) + for _, s := range st.Signers { + if !isAddressEqual(rt.ResolveAddress, s, params.Signer) { + newSigners = append(newSigners, s) + } + } + + // if the number of signers is below the threshold after removing the given signer, + // we should decrease the threshold by 1. This means that decrease should NOT be set to false + // in such a scenario. + if !params.Decrease && uint64(len(st.Signers)-1) < st.NumApprovalsThreshold { + rt.Abortf(exitcode.ErrIllegalArgument, "can't reduce signers to %d below threshold %d with decrease=false", len(st.Signers)-1, st.NumApprovalsThreshold) + } + + if params.Decrease { + st.NumApprovalsThreshold = st.NumApprovalsThreshold - 1 + } + st.Signers = newSigners + return nil + }) + + return nil +} + +type SwapSignerParams struct { + From addr.Address + To addr.Address +} + +func (a Actor) SwapSigner(rt vmr.Runtime, params *SwapSignerParams) *adt.EmptyValue { + // Can only be called by the multisig wallet itself. + rt.ValidateImmediateCallerIs(rt.Message().Receiver()) + + var st State + rt.State().Transaction(&st, func() interface{} { + if !isSigner(rt.ResolveAddress, &st, params.From) { + rt.Abortf(exitcode.ErrNotFound, "%s is not a signer", params.From) + } + + if isSigner(rt.ResolveAddress, &st, params.To) { + rt.Abortf(exitcode.ErrIllegalArgument, "%s already a signer", params.To) + } + + newSigners := make([]addr.Address, 0, len(st.Signers)) + for _, s := range st.Signers { + if !isAddressEqual(rt.ResolveAddress, s, params.From) { + newSigners = append(newSigners, s) + } + } + newSigners = append(newSigners, params.To) + st.Signers = newSigners + return nil + }) + + return nil +} + +type ChangeNumApprovalsThresholdParams struct { + NewThreshold uint64 +} + +func (a Actor) ChangeNumApprovalsThreshold(rt vmr.Runtime, params *ChangeNumApprovalsThresholdParams) *adt.EmptyValue { + // Can only be called by the multisig wallet itself. + rt.ValidateImmediateCallerIs(rt.Message().Receiver()) + + var st State + rt.State().Transaction(&st, func() interface{} { + if params.NewThreshold == 0 || params.NewThreshold > uint64(len(st.Signers)) { + rt.Abortf(exitcode.ErrIllegalArgument, "New threshold value not supported") + } + + st.NumApprovalsThreshold = params.NewThreshold + return nil + }) + return nil +} + +func (a Actor) approveTransaction(rt vmr.Runtime, txnID TxnID, txn *Transaction) (bool, []byte, exitcode.ExitCode) { + var st State + // abort duplicate approval + for _, previousApprover := range txn.Approved { + if previousApprover == rt.Message().Caller() { + rt.Abortf(exitcode.ErrForbidden, "%s already approved this message", previousApprover) + } + } + + // add the caller to the list of approvers + rt.State().Transaction(&st, func() interface{} { + // update approved on the transaction + txn.Approved = append(txn.Approved, rt.Message().Caller()) + if err := st.putPendingTransaction(adt.AsStore(rt), txnID, txn); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to put transaction for approval: %v", err) + } + return nil + }) + + return executeTransactionIfApproved(rt, st, txnID, txn) +} + +func (a Actor) getTransaction(rt vmr.Runtime, st State, txnID TxnID, proposalHash []byte, checkHash bool) *Transaction { + var txn Transaction + + // get transaction from the state trie + var err error + txn, err = st.getPendingTransaction(adt.AsStore(rt), txnID) + if err != nil { + rt.Abortf(exitcode.ErrNotFound, "failed to get transaction for approval: %v", err) + } + + // confirm the hashes match + if checkHash { + calculatedHash, err := ComputeProposalHash(&txn, rt.Syscalls().HashBlake2b) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to compute proposal hash: %v", err) + } + if proposalHash != nil && !bytes.Equal(proposalHash, calculatedHash[:]) { + rt.Abortf(exitcode.ErrIllegalArgument, "hash does not match proposal params") + } + } + + return &txn +} + +func executeTransactionIfApproved(rt vmr.Runtime, st State, txnID TxnID, txn *Transaction) (bool, []byte, exitcode.ExitCode) { + var out vmr.CBORBytes + var code exitcode.ExitCode + applied := false + + thresholdMet := uint64(len(txn.Approved)) >= st.NumApprovalsThreshold + if thresholdMet { + if err := st.assertAvailable(rt.CurrentBalance(), txn.Value, rt.CurrEpoch()); err != nil { + rt.Abortf(exitcode.ErrInsufficientFunds, "insufficient funds unlocked: %v", err) + } + + var ret vmr.SendReturn + // A sufficient number of approvals have arrived and sufficient funds have been unlocked: relay the message and delete from pending queue. + ret, code = rt.Send( + txn.To, + txn.Method, + vmr.CBORBytes(txn.Params), + txn.Value, + ) + applied = true + + // Pass the return value through uninterpreted with the expectation that serializing into a CBORBytes never fails + // since it just copies the bytes. + if err := ret.Into(&out); err != nil { + rt.Abortf(exitcode.ErrSerialization, "failed to deserialize result: %v", err) + } + + // This could be rearranged to happen inside the first state transaction, before the send(). + rt.State().Transaction(&st, func() interface{} { + if err := st.deletePendingTransaction(adt.AsStore(rt), txnID); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to delete transaction for cleanup: %v", err) + } + return nil + }) + } + + return applied, out, code +} + +type AddressResolveFunc func(address addr.Address) (resolved addr.Address, found bool) + +func isAddressEqual(resolveFunc AddressResolveFunc, addr1, addr2 addr.Address) bool { + return resolve(resolveFunc, addr1) == resolve(resolveFunc, addr2) +} + +func isSigner(resolveFunc AddressResolveFunc, st *State, address addr.Address) bool { + candidateResolved := resolve(resolveFunc, address) + + for _, ap := range st.Signers { + signerResolved := resolve(resolveFunc, ap) + if signerResolved == candidateResolved { + return true + } + } + + return false +} + +func resolve(resolveFunc AddressResolveFunc, address addr.Address) addr.Address { + resolved := address + if resolved.Protocol() != addr.ID { + idAddr, found := resolveFunc(resolved) + if found { + resolved = idAddr + } + } + return resolved +} + +// Computes a digest of a proposed transaction. This digest is used to confirm identity of the transaction +// associated with an ID, which might change under chain re-orgs. +func ComputeProposalHash(txn *Transaction, hash func([]byte) [32]byte) ([]byte, error) { + hashData := ProposalHashData{ + Requester: txn.Approved[0], + To: txn.To, + Value: txn.Value, + Method: txn.Method, + Params: txn.Params, + } + + data, err := hashData.Serialize() + if err != nil { + return nil, fmt.Errorf("failed to construct multisig approval hash: %w", err) + } + + hashResult := hash(data) + return hashResult[:], nil +} + +func (phd *ProposalHashData) Serialize() ([]byte, error) { + buf := new(bytes.Buffer) + if err := phd.MarshalCBOR(buf); err != nil { + return nil, err + } + return buf.Bytes(), nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_state.go new file mode 100644 index 000000000..6689d4958 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_state.go @@ -0,0 +1,111 @@ +package multisig + +import ( + address "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + xerrors "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type State struct { + // Signers may be either public-key or actor ID-addresses. The ID address is canonical, but doesn't exist + // for a public key that has not yet received a message on chain. + // If any signer address is a public-key address, it will be resolved to an ID address and persisted + // in this state when the address is used. + Signers []address.Address + NumApprovalsThreshold uint64 + NextTxnID TxnID + + // Linear unlock + InitialBalance abi.TokenAmount + StartEpoch abi.ChainEpoch + UnlockDuration abi.ChainEpoch + + PendingTxns cid.Cid +} + +func (st *State) AmountLocked(elapsedEpoch abi.ChainEpoch) abi.TokenAmount { + if elapsedEpoch >= st.UnlockDuration { + return abi.NewTokenAmount(0) + } + + unitLocked := big.Div(st.InitialBalance, big.NewInt(int64(st.UnlockDuration))) + return big.Mul(unitLocked, big.Sub(big.NewInt(int64(st.UnlockDuration)), big.NewInt(int64(elapsedEpoch)))) +} + +// return nil if MultiSig maintains required locked balance after spending the amount, else return an error. +func (st *State) assertAvailable(currBalance abi.TokenAmount, amountToSpend abi.TokenAmount, currEpoch abi.ChainEpoch) error { + if amountToSpend.LessThan(big.Zero()) { + return errors.Errorf("amount to spend %s less than zero", amountToSpend.String()) + } + if currBalance.LessThan(amountToSpend) { + return errors.Errorf("current balance %s less than amount to spend %s", currBalance.String(), amountToSpend.String()) + } + + remainingBalance := big.Sub(currBalance, amountToSpend) + amountLocked := st.AmountLocked(currEpoch - st.StartEpoch) + if remainingBalance.LessThan(amountLocked) { + return errors.Errorf("actor balance if spent %s would be less than required locked amount %s", remainingBalance.String(), amountLocked.String()) + } + + return nil +} + +func (as *State) getPendingTransaction(s adt.Store, txnID TxnID) (Transaction, error) { + hm, err := adt.AsMap(s, as.PendingTxns) + if err != nil { + return Transaction{}, err + } + + var out Transaction + found, err := hm.Get(txnID, &out) + if err != nil { + return Transaction{}, errors.Wrapf(err, "failed to read transaction") + } + if !found { + return Transaction{}, errors.Errorf("failed to find transaction %v in HAMT %s", txnID, as.PendingTxns) + } + + return out, nil +} + +func (st *State) mutatePendingTransactions(s adt.Store, f func(pt *adt.Map) error) error { + hm, err := adt.AsMap(s, st.PendingTxns) + if err != nil { + return xerrors.Errorf("Failed to load pending txns map: %w", err) + } + + if err := f(hm); err != nil { + return err + } + + c, err := hm.Root() + if err != nil { + return xerrors.Errorf("failed to flush pending txns map: %w", err) + } + + st.PendingTxns = c + return nil +} + +func (as *State) putPendingTransaction(s adt.Store, txnID TxnID, txn *Transaction) error { + return as.mutatePendingTransactions(s, func(hm *adt.Map) error { + if err := hm.Put(txnID, txn); err != nil { + return errors.Wrapf(err, "failed to write transaction") + } + return nil + }) +} + +func (as *State) deletePendingTransaction(s adt.Store, txnID TxnID) error { + return as.mutatePendingTransactions(s, func(hm *adt.Map) error { + if err := hm.Delete(txnID); err != nil { + return errors.Wrapf(err, "failed to delete transaction") + } + return nil + }) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_test.go new file mode 100644 index 000000000..71c69453d --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/multisig/multisig_test.go @@ -0,0 +1,1629 @@ +package multisig_test + +import ( + "bytes" + "context" + "testing" + + addr "github.com/filecoin-project/go-address" + "github.com/minio/blake2b-simd" + assert "github.com/stretchr/testify/assert" + require "github.com/stretchr/testify/require" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + miner "github.com/filecoin-project/specs-actors/actors/builtin/miner" + multisig "github.com/filecoin-project/specs-actors/actors/builtin/multisig" + runtime "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" + mock "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, multisig.Actor{}) +} + +func TestConstruction(t *testing.T) { + actor := multisig.Actor{} + + receiver := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + + bob := tutil.NewIDAddr(t, 102) + bobNonId := tutil.NewBLSAddr(t, 2) + + charlie := tutil.NewIDAddr(t, 103) + + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + + t.Run("simple construction", func(t *testing.T) { + rt := builder.Build(t) + params := multisig.ConstructorParams{ + Signers: []addr.Address{anne, bob, charlie}, + NumApprovalsThreshold: 2, + UnlockDuration: 0, + } + + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + ret := rt.Call(actor.Constructor, ¶ms) + assert.Nil(t, ret) + rt.Verify() + + var st multisig.State + rt.GetState(&st) + assert.Equal(t, params.Signers, st.Signers) + assert.Equal(t, params.NumApprovalsThreshold, st.NumApprovalsThreshold) + assert.Equal(t, abi.NewTokenAmount(0), st.InitialBalance) + assert.Equal(t, abi.ChainEpoch(0), st.UnlockDuration) + assert.Equal(t, abi.ChainEpoch(0), st.StartEpoch) + txns, err := adt.AsMap(adt.AsStore(rt), st.PendingTxns) + assert.NoError(t, err) + keys, err := txns.CollectKeys() + require.NoError(t, err) + assert.Empty(t, keys) + }) + + t.Run("construction with vesting", func(t *testing.T) { + rt := builder.WithEpoch(1234).Build(t) + params := multisig.ConstructorParams{ + Signers: []addr.Address{anne, bob, charlie}, + NumApprovalsThreshold: 3, + UnlockDuration: 100, + } + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + ret := rt.Call(actor.Constructor, ¶ms) + assert.Nil(t, ret) + rt.Verify() + + var st multisig.State + rt.GetState(&st) + assert.Equal(t, params.Signers, st.Signers) + assert.Equal(t, params.NumApprovalsThreshold, st.NumApprovalsThreshold) + assert.Equal(t, abi.NewTokenAmount(0), st.InitialBalance) + assert.Equal(t, abi.ChainEpoch(100), st.UnlockDuration) + assert.Equal(t, abi.ChainEpoch(1234), st.StartEpoch) + // assert no transactions + }) + + t.Run("fail to construct multisig actor with 0 signers", func(t *testing.T) { + rt := builder.Build(t) + params := multisig.ConstructorParams{ + Signers: []addr.Address{}, + NumApprovalsThreshold: 1, + UnlockDuration: 1, + } + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.Constructor, ¶ms) + }) + rt.Verify() + + }) + + t.Run("fail to construct multisig with more approvals than signers", func(t *testing.T) { + rt := builder.Build(t) + params := multisig.ConstructorParams{ + Signers: []addr.Address{anne, bob, charlie}, + NumApprovalsThreshold: 4, + UnlockDuration: 1, + } + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.Constructor, ¶ms) + }) + rt.Verify() + }) + + t.Run("fail to construct multisig with duplicate signers(all ID addresses)", func(t *testing.T) { + rt := builder.Build(t) + params := multisig.ConstructorParams{ + Signers: []addr.Address{anne, bob, bob}, + NumApprovalsThreshold: 2, + UnlockDuration: 0, + } + + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.Constructor, ¶ms) + }) + rt.Verify() + }) + + t.Run("fail to construct multisig with duplicate signers(ID & non-ID addresses)", func(t *testing.T) { + rt := builder.Build(t) + params := multisig.ConstructorParams{ + Signers: []addr.Address{anne, bobNonId, bob}, + NumApprovalsThreshold: 2, + UnlockDuration: 0, + } + + rt.AddIDAddress(bobNonId, bob) + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.Constructor, ¶ms) + }) + rt.Verify() + }) +} + +func TestVesting(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + bob := tutil.NewIDAddr(t, 102) + charlie := tutil.NewIDAddr(t, 103) + darlene := tutil.NewIDAddr(t, 103) + + const unlockDuration = 10 + var multisigInitialBalance = abi.NewTokenAmount(100) + var fakeParams = runtime.CBORBytes([]byte{1, 2, 3, 4}) + + builder := mock.NewBuilder(context.Background(), receiver). + WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID). + WithEpoch(0). + // balance 0: current balance of the actor. receive: 100 the amount the multisig actor will be initalized with -- InitialBalance + WithBalance(multisigInitialBalance, multisigInitialBalance). + WithHasher(blake2b.Sum256) + + t.Run("happy path full vesting", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, 2, unlockDuration, []addr.Address{anne, bob, charlie}...) + + // anne proposes that darlene receives `multisgiInitialBalance` FIL. + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.SetReceived(big.Zero()) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, darlene, multisigInitialBalance, builtin.MethodSend, fakeParams, nil) + rt.Verify() + + // Advance the epoch s.t. all funds are unlocked. + rt.SetEpoch(0 + unlockDuration) + // bob approves annes transaction + rt.SetCaller(bob, builtin.AccountActorCodeID) + // expect darlene to receive the transaction proposed by anne. + rt.ExpectSend(darlene, builtin.MethodSend, fakeParams, multisigInitialBalance, nil, exitcode.Ok) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: darlene, + Value: multisigInitialBalance, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + actor.approveOK(rt, 0, proposalHashData, nil) + }) + + t.Run("partial vesting propose to send half the actor balance when the epoch is hald the unlock duration", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, 2, 10, []addr.Address{anne, bob, charlie}...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.SetReceived(big.Zero()) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, darlene, big.Div(multisigInitialBalance, big.NewInt(2)), builtin.MethodSend, fakeParams, nil) + rt.Verify() + + // set the current balance of the multisig actor to its InitialBalance amount + rt.SetEpoch(0 + unlockDuration/2) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectSend(darlene, builtin.MethodSend, fakeParams, big.Div(multisigInitialBalance, big.NewInt(2)), nil, exitcode.Ok) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: darlene, + Value: big.Div(multisigInitialBalance, big.NewInt(2)), + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + + actor.approveOK(rt, 0, proposalHashData, nil) + }) + + t.Run("propose and autoapprove transaction above locked amount fails", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, 1, unlockDuration, []addr.Address{anne, bob, charlie}...) + + rt.SetReceived(big.Zero()) + // this propose will fail since it would send more than the required locked balance and num approvals == 1 + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + _ = actor.propose(rt, darlene, abi.NewTokenAmount(100), builtin.MethodSend, fakeParams, nil) + }) + rt.Verify() + + // this will pass since sending below the locked amount is permitted + rt.SetEpoch(1) + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(darlene, builtin.MethodSend, fakeParams, abi.NewTokenAmount(10), nil, 0) + actor.proposeOK(rt, darlene, abi.NewTokenAmount(10), builtin.MethodSend, fakeParams, nil) + rt.Verify() + }) + + t.Run("fail to vest more than locked amount", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, 2, unlockDuration, []addr.Address{anne, bob, charlie}...) + + rt.SetReceived(big.Zero()) + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, darlene, big.Div(multisigInitialBalance, big.NewInt(2)), builtin.MethodSend, fakeParams, nil) + rt.Verify() + + // this propose will fail since it would send more than the required locked balance. + rt.SetEpoch(1) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: darlene, + Value: big.Div(multisigInitialBalance, big.NewInt(2)), + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + _ = actor.approve(rt, 0, proposalHashData, nil) + }) + rt.Verify() + }) + +} + +func TestPropose(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + bob := tutil.NewIDAddr(t, 102) + chuck := tutil.NewIDAddr(t, 103) + + const noUnlockDuration = int64(0) + var sendValue = abi.NewTokenAmount(10) + var fakeParams = runtime.CBORBytes([]byte{1, 2, 3, 4}) + var signers = []addr.Address{anne, bob} + + builder := mock.NewBuilder(context.Background(), receiver).WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + + t.Run("simple propose", func(t *testing.T) { + const numApprovals = uint64(2) + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + + // the transaction remains awaiting second approval + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("propose with threshold met", func(t *testing.T) { + const numApprovals = uint64(1) + + rt := builder.WithBalance(abi.NewTokenAmount(20), abi.NewTokenAmount(0)).Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.ExpectSend(chuck, builtin.MethodSend, fakeParams, sendValue, nil, 0) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + + // the transaction has been sent and cleaned up + actor.assertTransactions(rt) + rt.Verify() + }) + + t.Run("propose with threshold and non-empty return value", func(t *testing.T) { + const numApprovals = uint64(1) + + rt := builder.WithBalance(abi.NewTokenAmount(20), abi.NewTokenAmount(0)).Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + proposeRet := miner.GetControlAddressesReturn{ + Owner: tutil.NewIDAddr(t, 1), + Worker: tutil.NewIDAddr(t, 2), + } + rt.ExpectSend(chuck, builtin.MethodsMiner.ControlAddresses, fakeParams, sendValue, &proposeRet, 0) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + var out miner.GetControlAddressesReturn + actor.proposeOK(rt, chuck, sendValue, builtin.MethodsMiner.ControlAddresses, fakeParams, &out) + // assert ProposeReturn.Ret can be marshaled into the expected structure. + assert.Equal(t, proposeRet, out) + + // the transaction has been sent and cleaned up + actor.assertTransactions(rt) + rt.Verify() + + }) + + t.Run("fail propose with threshold met and insufficient balance", func(t *testing.T) { + const numApprovals = uint64(1) + rt := builder.WithBalance(abi.NewTokenAmount(0), abi.NewTokenAmount(0)).Build(t) + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrInsufficientFunds, func() { + _ = actor.propose(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + }) + rt.Verify() + + // proposal failed since it should have but failed to immediately execute. + actor.assertTransactions(rt) + }) + + t.Run("fail propose from non-signer", func(t *testing.T) { + // non-signer address + richard := tutil.NewIDAddr(t, 105) + const numApprovals = uint64(2) + + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(richard, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + _ = actor.propose(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + }) + rt.Verify() + + // the transaction is not persisted + actor.assertTransactions(rt) + }) +} + +func TestApprove(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + receiver := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + bob := tutil.NewIDAddr(t, 102) + chuck := tutil.NewIDAddr(t, 103) + + const noUnlockDuration = int64(0) + const numApprovals = uint64(2) + const txnID = int64(0) + const fakeMethod = abi.MethodNum(42) + var sendValue = abi.NewTokenAmount(10) + var fakeParams = runtime.CBORBytes([]byte{1, 2, 3, 4}) + var signers = []addr.Address{anne, bob} + + builder := mock.NewBuilder(context.Background(), receiver). + WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID). + WithHasher(blake2b.Sum256) + + t.Run("simple propose and approval", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + + rt.SetBalance(sendValue) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(chuck, fakeMethod, fakeParams, sendValue, nil, 0) + + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + + actor.approveOK(rt, txnID, proposalHashData, nil) + + // Transaction should be removed from actor state after send + actor.assertTransactions(rt) + }) + + t.Run("approve with non-empty return value", func(t *testing.T) { + const numApprovals = uint64(2) + + rt := builder.WithBalance(abi.NewTokenAmount(20), abi.NewTokenAmount(0)).Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, builtin.MethodsMiner.ControlAddresses, fakeParams, nil) + + approveRet := miner.GetControlAddressesReturn{ + Owner: tutil.NewIDAddr(t, 1), + Worker: tutil.NewIDAddr(t, 2), + } + + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodsMiner.ControlAddresses, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(chuck, builtin.MethodsMiner.ControlAddresses, fakeParams, sendValue, &approveRet, 0) + + var out miner.GetControlAddressesReturn + actor.approveOK(rt, txnID, proposalHashData, &out) + // assert approveRet.Ret can be marshaled into the expected structure. + assert.Equal(t, approveRet, out) + + // the transaction has been sent and cleaned up + actor.assertTransactions(rt) + }) + + t.Run("fail approval with bad proposal hash", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + + rt.SetBalance(sendValue) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectSend(chuck, fakeMethod, fakeParams, sendValue, nil, 0) + + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{bob}, + }) + _ = actor.approve(rt, txnID, proposalHashData, nil) + }) + }) + + t.Run("fail approve transaction more than once", func(t *testing.T) { + const numApprovals = uint64(2) + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + rt.Verify() + + // anne is going to approve it twice and fail, poor anne. + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + _ = actor.approve(rt, txnID, proposalHashData, nil) + }) + rt.Verify() + + // Transaction still exists + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("fail approve transaction that does not exist", func(t *testing.T) { + const dneTxnID = int64(1) + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + rt.Verify() + + // bob is going to approve a transaction that doesn't exist. + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrNotFound, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{bob}, + }) + _ = actor.approve(rt, dneTxnID, proposalHashData, nil) + }) + rt.Verify() + + // Transaction was not removed from store. + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("fail to approve transaction by non-signer", func(t *testing.T) { + // non-signer address + richard := tutil.NewIDAddr(t, 105) + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, builtin.MethodSend, fakeParams, nil) + + // richard is going to approve a transaction they are not a signer for. + rt.SetCaller(richard, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{richard}, + }) + _ = actor.approve(rt, txnID, proposalHashData, nil) + }) + rt.Verify() + + // Transaction was not removed from store. + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: builtin.MethodSend, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("proposed transaction is approved by proposer if number of approvers has already crossed threshold", func(t *testing.T) { + rt := builder.Build(t) + const newThreshold = 1 + signers := []addr.Address{anne, bob} + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + proposalHash := actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // reduce the threshold so the transaction is already approved + rt.SetCaller(receiver, builtin.MultisigActorCodeID) + rt.ExpectValidateCallerAddr(receiver) + actor.changeNumApprovalsThreshold(rt, newThreshold) + rt.Verify() + + // even if anne calls for an approval again(duplicate approval), transaction is executed because the threshold has been met. + rt.ExpectSend(chuck, fakeMethod, fakeParams, sendValue, nil, 0) + rt.SetBalance(sendValue) + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.approveOK(rt, txnID, proposalHash, nil) + + // Transaction should be removed from actor state after send + actor.assertTransactions(rt) + }) + + t.Run("approve transaction if number of approvers has already crossed threshold even if we attempt a duplicate approval", func(t *testing.T) { + rt := builder.Build(t) + const numApprovals = 3 + const newThreshold = 2 + signers := []addr.Address{anne, bob, chuck} + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + proposalHash := actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // bob approves the transaction (number of approvals is now two but threshold is three) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + actor.approveOK(rt, txnID, proposalHash, nil) + + // reduce the threshold so the transaction is already approved + rt.SetCaller(receiver, builtin.MultisigActorCodeID) + rt.ExpectValidateCallerAddr(receiver) + actor.changeNumApprovalsThreshold(rt, newThreshold) + rt.Verify() + + // even if bob calls for an approval again(duplicate approval), transaction is executed because the threshold has been met. + rt.ExpectSend(chuck, fakeMethod, fakeParams, sendValue, nil, 0) + rt.SetBalance(sendValue) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.approveOK(rt, txnID, proposalHash, nil) + + // Transaction should be removed from actor state after send + actor.assertTransactions(rt) + }) + + t.Run("approve transaction if number of approvers has already crossed threshold and ensure non-signatory cannot approve a transaction", func(t *testing.T) { + rt := builder.Build(t) + const newThreshold = 1 + signers := []addr.Address{anne, bob} + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + proposalHash := actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // reduce the threshold so the transaction is already approved + rt.SetCaller(receiver, builtin.MultisigActorCodeID) + rt.ExpectValidateCallerAddr(receiver) + actor.changeNumApprovalsThreshold(rt, newThreshold) + rt.Verify() + + // alice cannot approve the transaction as alice is not a signatory + alice := tutil.NewIDAddr(t, 104) + rt.SetCaller(alice, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + _ = actor.approve(rt, txnID, proposalHash, nil) + }) + rt.Verify() + + // bob attempts to approve the transaction but it gets approved without + // processing his approval as it the threshold has been met. + rt.ExpectSend(chuck, fakeMethod, fakeParams, sendValue, nil, 0) + rt.SetBalance(sendValue) + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + actor.approveOK(rt, txnID, proposalHash, nil) + + // Transaction should be removed from actor state after send + actor.assertTransactions(rt) + }) +} + +func TestCancel(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + richard := tutil.NewIDAddr(t, 104) + receiver := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + bob := tutil.NewIDAddr(t, 102) + chuck := tutil.NewIDAddr(t, 103) + + const noUnlockDuration = int64(0) + const numApprovals = uint64(2) + const txnID = int64(0) + const fakeMethod = abi.MethodNum(42) + var fakeParams = []byte{1, 2, 3, 4, 5} + var sendValue = abi.NewTokenAmount(10) + var signers = []addr.Address{anne, bob} + + builder := mock.NewBuilder(context.Background(), receiver). + WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID). + WithHasher(blake2b.Sum256) + + t.Run("simple propose and cancel", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // anne cancels their transaction + rt.SetBalance(sendValue) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + actor.cancel(rt, txnID, proposalHashData) + rt.Verify() + + // Transaction should be removed from actor state after cancel + actor.assertTransactions(rt) + }) + + t.Run("fail cancel with bad proposal hash", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // anne cancels their transaction + rt.SetBalance(sendValue) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: bob, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{chuck}, + }) + actor.cancel(rt, txnID, proposalHashData) + }) + }) + + t.Run("signer fails to cancel transaction from another signer", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // bob (a signer) fails to cancel anne's transaction because bob didn't create it, nice try bob. + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + actor.cancel(rt, txnID, proposalHashData) + }) + rt.Verify() + + // Transaction should remain after invalid cancel + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("fail to cancel transaction when not signer", func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // richard (not a signer) fails to cancel anne's transaction because richard isn't a signer, go away richard. + rt.SetCaller(richard, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + actor.cancel(rt, txnID, proposalHashData) + }) + rt.Verify() + + // Transaction should remain after invalid cancel + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("fail to cancel a transaction that does not exist", func(t *testing.T) { + rt := builder.Build(t) + const dneTxnID = int64(1) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction ID: 0 + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + rt.Verify() + + // anne fails to cancel a transaction that does not exists ID: 1 (dneTxnID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrNotFound, func() { + proposalHashData := makeProposalHash(t, &multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + actor.cancel(rt, dneTxnID, proposalHashData) + }) + rt.Verify() + + // Transaction should remain after invalid cancel + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne}, + }) + }) + + t.Run("transaction can ONLY be cancelled by a proposer who is still the signer", func(t *testing.T) { + rt := builder.Build(t) + const numApprovals = 3 + signers := []addr.Address{anne, bob, chuck} + + txnId := int64(0) + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, signers...) + + // anne proposes a transaction ID: 0 + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + proposalHash := actor.proposeOK(rt, chuck, sendValue, fakeMethod, fakeParams, nil) + + // bob approves the transaction -> but he is the second approver and hence not the proposer + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.approveOK(rt, txnId, proposalHash, nil) + + // remove anne as a signer - tx creator + rt.SetCaller(receiver, builtin.MultisigActorCodeID) + rt.ExpectValidateCallerAddr(receiver) + actor.removeSigner(rt, anne, true) + + // anne fails to cancel a transaction - she is not a signer + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + actor.cancel(rt, txnID, proposalHash) + }) + + // bob fails to cancel the transaction -> he is not the proposer + rt.SetCaller(bob, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + rt.ExpectAbort(exitcode.ErrForbidden, func() { + actor.cancel(rt, txnID, proposalHash) + }) + + // Transaction should remain after invalid cancel + actor.assertTransactions(rt, multisig.Transaction{ + To: chuck, + Value: sendValue, + Method: fakeMethod, + Params: fakeParams, + Approved: []addr.Address{anne, bob}, + }) + + // add anne as a signer again + rt.SetCaller(receiver, builtin.MultisigActorCodeID) + rt.ExpectValidateCallerAddr(receiver) + actor.addSigner(rt, anne, true) + + // now anne can cancel the transaction + rt.SetCaller(anne, builtin.AccountActorCodeID) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + actor.cancel(rt, txnID, proposalHash) + actor.assertTransactions(rt) + }) +} + +type addSignerTestCase struct { + desc string + + idAddrsMapping map[addr.Address]addr.Address + initialSigners []addr.Address + initialApprovals uint64 + + addSigner addr.Address + increase bool + + expectSigners []addr.Address + expectApprovals uint64 + code exitcode.ExitCode +} + +func TestAddSigner(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + multisigWalletAdd := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + bob := tutil.NewIDAddr(t, 102) + chuck := tutil.NewIDAddr(t, 103) + chuckNonId := tutil.NewBLSAddr(t, 1) + + const noUnlockDuration = int64(0) + + testCases := []addSignerTestCase{ + { + desc: "happy path add signer", + + initialSigners: []addr.Address{anne, bob}, + initialApprovals: uint64(2), + + addSigner: chuck, + increase: false, + + expectSigners: []addr.Address{anne, bob, chuck}, + expectApprovals: uint64(2), + code: exitcode.Ok, + }, + { + desc: "add signer and increase threshold", + + initialSigners: []addr.Address{anne, bob}, + initialApprovals: uint64(2), + + addSigner: chuck, + increase: true, + + expectSigners: []addr.Address{anne, bob, chuck}, + expectApprovals: uint64(3), + code: exitcode.Ok, + }, + { + desc: "fail to add signer than already exists", + + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(3), + + addSigner: chuck, + increase: false, + + expectSigners: []addr.Address{anne, bob, chuck}, + expectApprovals: uint64(3), + code: exitcode.ErrIllegalArgument, + }, + { + desc: "fail to add signer with ID address that already exists(even though we ONLY have the non ID address as an approver)", + + idAddrsMapping: map[addr.Address]addr.Address{chuckNonId: chuck}, + initialSigners: []addr.Address{anne, bob, chuckNonId}, + initialApprovals: uint64(3), + + addSigner: chuck, + increase: false, + + expectSigners: []addr.Address{anne, bob, chuck}, + expectApprovals: uint64(3), + code: exitcode.ErrIllegalArgument, + }, + { + desc: "fail to add signer with non-ID address that already exists(even though we ONLY have the ID address as an approver)", + idAddrsMapping: map[addr.Address]addr.Address{chuckNonId: chuck}, + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(3), + + addSigner: chuckNonId, + increase: false, + + expectSigners: []addr.Address{anne, bob, chuck}, + expectApprovals: uint64(3), + code: exitcode.ErrIllegalArgument, + }, + } + + builder := mock.NewBuilder(context.Background(), multisigWalletAdd).WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, tc.initialApprovals, noUnlockDuration, tc.initialSigners...) + + rt.SetCaller(multisigWalletAdd, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(multisigWalletAdd) + for src, target := range tc.idAddrsMapping { + rt.AddIDAddress(src, target) + } + if tc.code != exitcode.Ok { + rt.ExpectAbort(tc.code, func() { + actor.addSigner(rt, tc.addSigner, tc.increase) + }) + } else { + actor.addSigner(rt, tc.addSigner, tc.increase) + var st multisig.State + rt.Readonly(&st) + assert.Equal(t, tc.expectSigners, st.Signers) + assert.Equal(t, tc.expectApprovals, st.NumApprovalsThreshold) + } + rt.Verify() + }) + } +} + +type removeSignerTestCase struct { + desc string + + initialSigners []addr.Address + initialApprovals uint64 + + removeSigner addr.Address + decrease bool + + expectSigners []addr.Address + expectApprovals uint64 + code exitcode.ExitCode +} + +func TestRemoveSigner(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + multisigWalletAdd := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + anneNonID := tutil.NewBLSAddr(t, 1) + + bob := tutil.NewIDAddr(t, 102) + chuck := tutil.NewIDAddr(t, 103) + richard := tutil.NewIDAddr(t, 104) + + const noUnlockDuration = int64(0) + + testCases := []removeSignerTestCase{ + { + desc: "happy path remove signer", + + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: chuck, + decrease: false, + + expectSigners: []addr.Address{anne, bob}, + expectApprovals: uint64(2), + code: exitcode.Ok, + }, + { + desc: "remove signer and decrease threshold", + + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: chuck, + decrease: true, + + expectSigners: []addr.Address{anne, bob}, + expectApprovals: uint64(1), + code: exitcode.Ok, + }, + { + desc: "remove signer when multi-sig is created with an ID address and then removed using it's non-ID address", + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: anneNonID, + decrease: true, + + expectSigners: []addr.Address{bob, chuck}, + expectApprovals: uint64(1), + code: exitcode.Ok, + }, + { + desc: "remove signer when multi-sig is created with a non-ID address and then removed using it's ID address", + initialSigners: []addr.Address{anneNonID, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: anne, + decrease: true, + + expectSigners: []addr.Address{bob, chuck}, + expectApprovals: uint64(1), + code: exitcode.Ok, + }, + { + desc: "remove signer when multi-sig is created with a non-ID address and then removed using it's non-ID address", + initialSigners: []addr.Address{anneNonID, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: anneNonID, + decrease: true, + + expectSigners: []addr.Address{bob, chuck}, + expectApprovals: uint64(1), + code: exitcode.Ok, + }, + { + desc: "remove signer when multi-sig is created with a ID address and then removed using it's ID address", + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: anne, + decrease: true, + + expectSigners: []addr.Address{bob, chuck}, + expectApprovals: uint64(1), + code: exitcode.Ok, + }, + { + desc: "fail remove signer if decrease set to false and number of signers below threshold", + + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(3), + + removeSigner: chuck, + decrease: false, + + expectSigners: []addr.Address{anne, bob}, + expectApprovals: uint64(2), + code: exitcode.ErrIllegalArgument, + }, + { + desc: "remove signer from single singer list", + + initialSigners: []addr.Address{anne}, + initialApprovals: uint64(1), + + removeSigner: anne, + decrease: false, + + expectSigners: nil, + expectApprovals: uint64(1), + code: exitcode.ErrForbidden, + }, + { + desc: "fail to remove non-signer", + + initialSigners: []addr.Address{anne, bob, chuck}, + initialApprovals: uint64(2), + + removeSigner: richard, + decrease: false, + + expectSigners: []addr.Address{anne, bob, chuck}, + expectApprovals: uint64(2), + code: exitcode.ErrNotFound, + }, + } + + builder := mock.NewBuilder(context.Background(), multisigWalletAdd).WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + rt := builder.Build(t) + rt.AddIDAddress(anneNonID, anne) + + actor.constructAndVerify(rt, tc.initialApprovals, noUnlockDuration, tc.initialSigners...) + + rt.SetCaller(multisigWalletAdd, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(multisigWalletAdd) + if tc.code != exitcode.Ok { + rt.ExpectAbort(tc.code, func() { + actor.removeSigner(rt, tc.removeSigner, tc.decrease) + }) + } else { + actor.removeSigner(rt, tc.removeSigner, tc.decrease) + var st multisig.State + rt.Readonly(&st) + assert.Equal(t, tc.expectSigners, st.Signers) + assert.Equal(t, tc.expectApprovals, st.NumApprovalsThreshold) + } + rt.Verify() + }) + } +} + +type swapTestCase struct { + initialSigner []addr.Address + desc string + to addr.Address + from addr.Address + expect []addr.Address + code exitcode.ExitCode +} + +func TestSwapSigners(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + multisigWalletAdd := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + + bob := tutil.NewIDAddr(t, 102) + bobNonId := tutil.NewBLSAddr(t, 1) + + chuck := tutil.NewIDAddr(t, 103) + darlene := tutil.NewIDAddr(t, 104) + + const noUnlockDuration = int64(0) + const numApprovals = uint64(1) + + testCases := []swapTestCase{ + { + desc: "happy path signer swap", + initialSigner: []addr.Address{anne, bob}, + to: chuck, + from: bob, + expect: []addr.Address{anne, chuck}, + code: exitcode.Ok, + }, + { + desc: "swap signer when multi-sig is created with it's ID address but we ask for a swap with it's non-ID address", + initialSigner: []addr.Address{anne, bob}, + to: chuck, + from: bobNonId, + expect: []addr.Address{anne, chuck}, + code: exitcode.Ok, + }, + { + desc: "swap signer when multi-sig is created with it's non-ID address but we ask for a swap with it's ID address", + initialSigner: []addr.Address{anne, bobNonId}, + to: chuck, + from: bob, + expect: []addr.Address{anne, chuck}, + code: exitcode.Ok, + }, + { + desc: "swap signer when multi-sig is created with it's non-ID address and we ask for a swap with it's non-ID address", + initialSigner: []addr.Address{anne, bobNonId}, + to: chuck, + from: bobNonId, + expect: []addr.Address{anne, chuck}, + code: exitcode.Ok, + }, + { + desc: "swap signer when multi-sig is created with it's ID address and we ask for a swap with it's ID address", + initialSigner: []addr.Address{anne, bob}, + to: chuck, + from: bob, + expect: []addr.Address{anne, chuck}, + code: exitcode.Ok, + }, + { + desc: "fail to swap when from signer not found", + initialSigner: []addr.Address{anne, bob}, + to: chuck, + from: darlene, + expect: []addr.Address{anne, chuck}, + code: exitcode.ErrNotFound, + }, + { + desc: "fail to swap when to signer already present", + initialSigner: []addr.Address{anne, bob}, + to: bob, + from: anne, + expect: []addr.Address{anne, chuck}, + code: exitcode.ErrIllegalArgument, + }, + { + desc: "fail to swap when to signer ID address already present(even though we have the non-ID address)", + initialSigner: []addr.Address{anne, bobNonId}, + to: bob, + from: anne, + expect: []addr.Address{anne, chuck}, + code: exitcode.ErrIllegalArgument, + }, + { + desc: "fail to swap when to signer non-ID address already present(even though we have the ID address)", + initialSigner: []addr.Address{anne, bob}, + to: bobNonId, + from: anne, + expect: []addr.Address{anne, chuck}, + code: exitcode.ErrIllegalArgument, + }, + } + + builder := mock.NewBuilder(context.Background(), multisigWalletAdd).WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + rt := builder.Build(t) + rt.AddIDAddress(bobNonId, bob) + + actor.constructAndVerify(rt, numApprovals, noUnlockDuration, tc.initialSigner...) + + rt.SetCaller(multisigWalletAdd, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(multisigWalletAdd) + if tc.code != exitcode.Ok { + rt.ExpectAbort(tc.code, func() { + actor.swapSigners(rt, tc.from, tc.to) + }) + } else { + actor.swapSigners(rt, tc.from, tc.to) + var st multisig.State + rt.Readonly(&st) + assert.Equal(t, tc.expect, st.Signers) + } + rt.Verify() + }) + } +} + +type thresholdTestCase struct { + desc string + initialThreshold uint64 + setThreshold uint64 + code exitcode.ExitCode +} + +func TestChangeThreshold(t *testing.T) { + actor := msActorHarness{multisig.Actor{}, t} + + multisigWalletAdd := tutil.NewIDAddr(t, 100) + anne := tutil.NewIDAddr(t, 101) + bob := tutil.NewIDAddr(t, 102) + chuck := tutil.NewIDAddr(t, 103) + + const noUnlockDuration = int64(0) + var initialSigner = []addr.Address{anne, bob, chuck} + + testCases := []thresholdTestCase{ + { + desc: "happy path decrease threshold", + initialThreshold: 2, + setThreshold: 1, + code: exitcode.Ok, + }, + { + desc: "happy path simple increase threshold", + initialThreshold: 2, + setThreshold: 3, + code: exitcode.Ok, + }, + { + desc: "fail to set threshold to zero", + initialThreshold: 2, + setThreshold: 0, + code: exitcode.ErrIllegalArgument, + }, + { + desc: "fail to set threshold above number of signers", + initialThreshold: 2, + setThreshold: uint64(len(initialSigner) + 1), + code: exitcode.ErrIllegalArgument, + }, + // TODO missing test case that needs definition: https://github.com/filecoin-project/specs-actors/issues/71 + // what happens when threshold is reduced below the number of approvers an existing transaction already ha + } + + builder := mock.NewBuilder(context.Background(), multisigWalletAdd).WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID) + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + rt := builder.Build(t) + + actor.constructAndVerify(rt, tc.initialThreshold, noUnlockDuration, initialSigner...) + + rt.SetCaller(multisigWalletAdd, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(multisigWalletAdd) + if tc.code != exitcode.Ok { + rt.ExpectAbort(tc.code, func() { + actor.changeNumApprovalsThreshold(rt, tc.setThreshold) + }) + } else { + actor.changeNumApprovalsThreshold(rt, tc.setThreshold) + var st multisig.State + rt.Readonly(&st) + assert.Equal(t, tc.setThreshold, st.NumApprovalsThreshold) + } + rt.Verify() + }) + } +} + +// +// Helper methods for calling multisig actor methods +// + +type msActorHarness struct { + a multisig.Actor + t testing.TB +} + +func (h *msActorHarness) constructAndVerify(rt *mock.Runtime, numApprovalsThresh uint64, unlockDuration int64, signers ...addr.Address) { + constructParams := multisig.ConstructorParams{ + Signers: signers, + NumApprovalsThreshold: numApprovalsThresh, + UnlockDuration: abi.ChainEpoch(unlockDuration), + } + + rt.ExpectValidateCallerAddr(builtin.InitActorAddr) + ret := rt.Call(h.a.Constructor, &constructParams) + assert.Nil(h.t, ret) + rt.Verify() +} + +func (h *msActorHarness) propose(rt *mock.Runtime, to addr.Address, value abi.TokenAmount, method abi.MethodNum, params []byte, out runtime.CBORUnmarshaler) exitcode.ExitCode { + proposeParams := &multisig.ProposeParams{ + To: to, + Value: value, + Method: method, + Params: params, + } + ret := rt.Call(h.a.Propose, proposeParams) + rt.Verify() + + proposeReturn, ok := ret.(*multisig.ProposeReturn) + if !ok { + h.t.Fatalf("unexpected type returned from call to Propose") + } + // if the transaction was applied and a return value is expected deserialize it to the out parameter + if proposeReturn.Applied { + if out != nil { + require.NoError(h.t, out.UnmarshalCBOR(bytes.NewReader(proposeReturn.Ret))) + } + } + return proposeReturn.Code +} + +// returns the proposal hash +func (h *msActorHarness) proposeOK(rt *mock.Runtime, to addr.Address, value abi.TokenAmount, method abi.MethodNum, params []byte, out runtime.CBORUnmarshaler) []byte { + code := h.propose(rt, to, value, method, params, out) + if code != exitcode.Ok { + h.t.Fatalf("unexpected exitcode %d from propose", code) + } + + proposalHashData, err := multisig.ComputeProposalHash(&multisig.Transaction{ + To: to, + Value: value, + Method: method, + Params: params, + Approved: []addr.Address{rt.Caller()}, + }, blake2b.Sum256) + require.NoError(h.t, err) + + return proposalHashData +} + +func (h *msActorHarness) approve(rt *mock.Runtime, txnID int64, proposalParams []byte, out runtime.CBORUnmarshaler) exitcode.ExitCode { + approveParams := &multisig.TxnIDParams{ID: multisig.TxnID(txnID), ProposalHash: proposalParams} + ret := rt.Call(h.a.Approve, approveParams) + rt.Verify() + approveReturn, ok := ret.(*multisig.ApproveReturn) + if !ok { + h.t.Fatalf("unexpected type returned from call to Approve") + } + // if the transaction was applied and a return value is expected deserialize it to the out parameter + if approveReturn.Applied { + if out != nil { + require.NoError(h.t, out.UnmarshalCBOR(bytes.NewReader(approveReturn.Ret))) + } + } + return approveReturn.Code +} + +func (h *msActorHarness) approveOK(rt *mock.Runtime, txnID int64, proposalParams []byte, out runtime.CBORUnmarshaler) { + code := h.approve(rt, txnID, proposalParams, out) + if code != exitcode.Ok { + h.t.Fatalf("unexpected exitcode %d from approve", code) + } +} + +func (h *msActorHarness) cancel(rt *mock.Runtime, txnID int64, proposalParams []byte) { + cancelParams := &multisig.TxnIDParams{ID: multisig.TxnID(txnID), ProposalHash: proposalParams} + rt.Call(h.a.Cancel, cancelParams) + rt.Verify() +} + +func (h *msActorHarness) addSigner(rt *mock.Runtime, signer addr.Address, increase bool) { + addSignerParams := &multisig.AddSignerParams{ + Signer: signer, + Increase: increase, + } + rt.Call(h.a.AddSigner, addSignerParams) + rt.Verify() +} + +func (h *msActorHarness) removeSigner(rt *mock.Runtime, signer addr.Address, decrease bool) { + rmSignerParams := &multisig.RemoveSignerParams{ + Signer: signer, + Decrease: decrease, + } + rt.Call(h.a.RemoveSigner, rmSignerParams) + rt.Verify() +} + +func (h *msActorHarness) swapSigners(rt *mock.Runtime, oldSigner, newSigner addr.Address) { + swpParams := &multisig.SwapSignerParams{ + From: oldSigner, + To: newSigner, + } + rt.Call(h.a.SwapSigner, swpParams) +} + +func (h *msActorHarness) changeNumApprovalsThreshold(rt *mock.Runtime, newThreshold uint64) { + thrshParams := &multisig.ChangeNumApprovalsThresholdParams{NewThreshold: newThreshold} + rt.Call(h.a.ChangeNumApprovalsThreshold, thrshParams) +} + +func (h *msActorHarness) assertTransactions(rt *mock.Runtime, expected ...multisig.Transaction) { + var st multisig.State + rt.GetState(&st) + + txns, err := adt.AsMap(adt.AsStore(rt), st.PendingTxns) + assert.NoError(h.t, err) + keys, err := txns.CollectKeys() + assert.NoError(h.t, err) + + require.Equal(h.t, len(expected), len(keys)) + for i, k := range keys { + var actual multisig.Transaction + found, err_ := txns.Get(asKey(k), &actual) + require.NoError(h.t, err_) + assert.True(h.t, found) + assert.Equal(h.t, expected[i], actual) + } +} + +func makeProposalHash(t *testing.T, txn *multisig.Transaction) []byte { + proposalHashData, err := multisig.ComputeProposalHash(txn, blake2b.Sum256) + require.NoError(t, err) + return proposalHashData +} + +type key string + +func (s key) Key() string { + return string(s) +} + +func asKey(in string) adt.Keyer { + return key(in) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/network.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/network.go new file mode 100644 index 000000000..12567d1da --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/network.go @@ -0,0 +1,30 @@ +package builtin + +import "fmt" + +// The duration of a chain epoch. +// This is used for deriving epoch-denominated periods that are more naturally expressed in clock time. +// TODO: In lieu of a real configuration mechanism for this value, we'd like to make it a var so that implementations +// can override it at runtime. Doing so requires changing all the static references to it in this repo to go through +// late-binding function calls, or they'll see the "wrong" value. +// https://github.com/filecoin-project/specs-actors/issues/353 +const EpochDurationSeconds = 25 +const SecondsInHour = 3600 +const SecondsInDay = 86400 +const SecondsInYear = 31556925 +const EpochsInHour = SecondsInHour / EpochDurationSeconds +const EpochsInDay = SecondsInDay / EpochDurationSeconds +const EpochsInYear = SecondsInYear / EpochDurationSeconds + +// The expected number of block producers in each epoch. +var ExpectedLeadersPerEpoch = int64(5) + +func init() { + //noinspection GoBoolExpressions + if SecondsInHour%EpochDurationSeconds != 0 { + // This even division is an assumption that other code might unwittingly make. + // Don't rely on it on purpose, though. + // While we're pretty sure everything will still work fine, we're safer maintaining this invariant anyway. + panic(fmt.Sprintf("epoch duration %d does not evenly divide one hour (%d)", EpochDurationSeconds, SecondsInHour)) + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/cbor_gen.go new file mode 100644 index 000000000..719debdf5 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/cbor_gen.go @@ -0,0 +1,1007 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package paych + +import ( + "fmt" + "io" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + crypto "github.com/filecoin-project/specs-actors/actors/crypto" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{134}); err != nil { + return err + } + + // t.From (address.Address) (struct) + if err := t.From.MarshalCBOR(w); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + + // t.ToSend (big.Int) (struct) + if err := t.ToSend.MarshalCBOR(w); err != nil { + return err + } + + // t.SettlingAt (abi.ChainEpoch) (int64) + if t.SettlingAt >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SettlingAt))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SettlingAt)-1)); err != nil { + return err + } + } + + // t.MinSettleHeight (abi.ChainEpoch) (int64) + if t.MinSettleHeight >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinSettleHeight))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.MinSettleHeight)-1)); err != nil { + return err + } + } + + // t.LaneStates ([]*paych.LaneState) (slice) + if len(t.LaneStates) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.LaneStates was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.LaneStates)))); err != nil { + return err + } + for _, v := range t.LaneStates { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 6 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.From (address.Address) (struct) + + { + + if err := t.From.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.From: %w", err) + } + + } + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + // t.ToSend (big.Int) (struct) + + { + + if err := t.ToSend.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.ToSend: %w", err) + } + + } + // t.SettlingAt (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SettlingAt = abi.ChainEpoch(extraI) + } + // t.MinSettleHeight (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.MinSettleHeight = abi.ChainEpoch(extraI) + } + // t.LaneStates ([]*paych.LaneState) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.LaneStates: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.LaneStates = make([]*LaneState, extra) + } + + for i := 0; i < int(extra); i++ { + + var v LaneState + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.LaneStates[i] = &v + } + + return nil +} + +func (t *LaneState) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.ID (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ID))); err != nil { + return err + } + + // t.Redeemed (big.Int) (struct) + if err := t.Redeemed.MarshalCBOR(w); err != nil { + return err + } + + // t.Nonce (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil { + return err + } + + return nil +} + +func (t *LaneState) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.ID (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.ID = uint64(extra) + + } + // t.Redeemed (big.Int) (struct) + + { + + if err := t.Redeemed.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Redeemed: %w", err) + } + + } + // t.Nonce (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Nonce = uint64(extra) + + } + return nil +} + +func (t *Merge) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Lane (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Lane))); err != nil { + return err + } + + // t.Nonce (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil { + return err + } + + return nil +} + +func (t *Merge) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Lane (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Lane = uint64(extra) + + } + // t.Nonce (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Nonce = uint64(extra) + + } + return nil +} + +func (t *ConstructorParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.From (address.Address) (struct) + if err := t.From.MarshalCBOR(w); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *ConstructorParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.From (address.Address) (struct) + + { + + if err := t.From.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.From: %w", err) + } + + } + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + return nil +} + +func (t *UpdateChannelStateParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.Sv (paych.SignedVoucher) (struct) + if err := t.Sv.MarshalCBOR(w); err != nil { + return err + } + + // t.Secret ([]uint8) (slice) + if len(t.Secret) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Secret was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Secret)))); err != nil { + return err + } + if _, err := w.Write(t.Secret); err != nil { + return err + } + + // t.Proof ([]uint8) (slice) + if len(t.Proof) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Proof was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil { + return err + } + if _, err := w.Write(t.Proof); err != nil { + return err + } + return nil +} + +func (t *UpdateChannelStateParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Sv (paych.SignedVoucher) (struct) + + { + + if err := t.Sv.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Sv: %w", err) + } + + } + // t.Secret ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Secret: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Secret = make([]byte, extra) + if _, err := io.ReadFull(br, t.Secret); err != nil { + return err + } + // t.Proof ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Proof: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Proof = make([]byte, extra) + if _, err := io.ReadFull(br, t.Proof); err != nil { + return err + } + return nil +} + +func (t *SignedVoucher) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{138}); err != nil { + return err + } + + // t.TimeLockMin (abi.ChainEpoch) (int64) + if t.TimeLockMin >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TimeLockMin))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.TimeLockMin)-1)); err != nil { + return err + } + } + + // t.TimeLockMax (abi.ChainEpoch) (int64) + if t.TimeLockMax >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TimeLockMax))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.TimeLockMax)-1)); err != nil { + return err + } + } + + // t.SecretPreimage ([]uint8) (slice) + if len(t.SecretPreimage) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.SecretPreimage was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.SecretPreimage)))); err != nil { + return err + } + if _, err := w.Write(t.SecretPreimage); err != nil { + return err + } + + // t.Extra (paych.ModVerifyParams) (struct) + if err := t.Extra.MarshalCBOR(w); err != nil { + return err + } + + // t.Lane (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Lane))); err != nil { + return err + } + + // t.Nonce (uint64) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil { + return err + } + + // t.Amount (big.Int) (struct) + if err := t.Amount.MarshalCBOR(w); err != nil { + return err + } + + // t.MinSettleHeight (abi.ChainEpoch) (int64) + if t.MinSettleHeight >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinSettleHeight))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.MinSettleHeight)-1)); err != nil { + return err + } + } + + // t.Merges ([]paych.Merge) (slice) + if len(t.Merges) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Merges was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Merges)))); err != nil { + return err + } + for _, v := range t.Merges { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + + // t.Signature (crypto.Signature) (struct) + if err := t.Signature.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *SignedVoucher) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 10 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.TimeLockMin (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.TimeLockMin = abi.ChainEpoch(extraI) + } + // t.TimeLockMax (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.TimeLockMax = abi.ChainEpoch(extraI) + } + // t.SecretPreimage ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.SecretPreimage: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.SecretPreimage = make([]byte, extra) + if _, err := io.ReadFull(br, t.SecretPreimage); err != nil { + return err + } + // t.Extra (paych.ModVerifyParams) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Extra = new(ModVerifyParams) + if err := t.Extra.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Extra pointer: %w", err) + } + } + + } + // t.Lane (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Lane = uint64(extra) + + } + // t.Nonce (uint64) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Nonce = uint64(extra) + + } + // t.Amount (big.Int) (struct) + + { + + if err := t.Amount.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Amount: %w", err) + } + + } + // t.MinSettleHeight (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.MinSettleHeight = abi.ChainEpoch(extraI) + } + // t.Merges ([]paych.Merge) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Merges: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Merges = make([]Merge, extra) + } + + for i := 0; i < int(extra); i++ { + + var v Merge + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.Merges[i] = v + } + + // t.Signature (crypto.Signature) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + t.Signature = new(crypto.Signature) + if err := t.Signature.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Signature pointer: %w", err) + } + } + + } + return nil +} + +func (t *ModVerifyParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.Actor (address.Address) (struct) + if err := t.Actor.MarshalCBOR(w); err != nil { + return err + } + + // t.Method (abi.MethodNum) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil { + return err + } + + // t.Data ([]uint8) (slice) + if len(t.Data) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Data was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Data)))); err != nil { + return err + } + if _, err := w.Write(t.Data); err != nil { + return err + } + return nil +} + +func (t *ModVerifyParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Actor (address.Address) (struct) + + { + + if err := t.Actor.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Actor: %w", err) + } + + } + // t.Method (abi.MethodNum) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Method = abi.MethodNum(extra) + + } + // t.Data ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Data: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Data = make([]byte, extra) + if _, err := io.ReadFull(br, t.Data); err != nil { + return err + } + return nil +} + +func (t *PaymentVerifyParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Extra ([]uint8) (slice) + if len(t.Extra) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Extra was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Extra)))); err != nil { + return err + } + if _, err := w.Write(t.Extra); err != nil { + return err + } + + // t.Proof ([]uint8) (slice) + if len(t.Proof) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Proof was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil { + return err + } + if _, err := w.Write(t.Proof); err != nil { + return err + } + return nil +} + +func (t *PaymentVerifyParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Extra ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Extra: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Extra = make([]byte, extra) + if _, err := io.ReadFull(br, t.Extra); err != nil { + return err + } + // t.Proof ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Proof: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Proof = make([]byte, extra) + if _, err := io.ReadFull(br, t.Proof); err != nil { + return err + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_actor.go new file mode 100644 index 000000000..8e2b55c98 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_actor.go @@ -0,0 +1,340 @@ +package paych + +import ( + "bytes" + "fmt" + "sort" + + addr "github.com/filecoin-project/go-address" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" + crypto "github.com/filecoin-project/specs-actors/actors/crypto" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// Maximum number of lanes in a channel. +const LaneLimit = 256 + +const SettleDelay = abi.ChainEpoch(1) // placeholder PARAM_FINISH + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.UpdateChannelState, + 3: a.Settle, + 4: a.Collect, + } +} + +var _ abi.Invokee = Actor{} + +type ConstructorParams struct { + From addr.Address // Payer + To addr.Address // Payee +} + +// Constructor creates a payment channel actor. See State for meaning of params. +func (pca *Actor) Constructor(rt vmr.Runtime, params *ConstructorParams) *adt.EmptyValue { + // Only InitActor can create a payment channel actor. It creates the actor on + // behalf of the payer/payee. + rt.ValidateImmediateCallerType(builtin.InitActorCodeID) + + // check that both parties are capable of signing vouchers + to, err := pca.resolveAccount(rt, params.To) + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, err.Error()) + } + from, err := pca.resolveAccount(rt, params.From) + if err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, err.Error()) + } + + st := ConstructState(from, to) + rt.State().Create(st) + + return nil +} + +// Resolves an address to a canonical ID address and requires it to address an account actor. +// The account actor constructor checks that the embedded address is associated with an appropriate key. +// An alternative (more expensive) would be to send a message to the actor to fetch its key. +func (pca *Actor) resolveAccount(rt vmr.Runtime, raw addr.Address) (addr.Address, error) { + resolved, ok := rt.ResolveAddress(raw) + if !ok { + return addr.Undef, fmt.Errorf("failed to resolve address %v", raw) + } + + codeCID, ok := rt.GetActorCodeCID(resolved) + if !ok { + return addr.Undef, fmt.Errorf("no code for address %v", resolved) + } + if codeCID != builtin.AccountActorCodeID { + return addr.Undef, fmt.Errorf("actor %v must be an account (%v), was %v", raw, builtin.AccountActorCodeID, codeCID) + } + return resolved, nil +} + +//////////////////////////////////////////////////////////////////////////////// +// Payment Channel state operations +//////////////////////////////////////////////////////////////////////////////// + +type UpdateChannelStateParams struct { + Sv SignedVoucher + Secret []byte + Proof []byte +} + +// A voucher is sent by `From` to `To` off-chain in order to enable +// `To` to redeem payments on-chain in the future +type SignedVoucher struct { + // TimeLockMin sets a min epoch before which the voucher cannot be redeemed + TimeLockMin abi.ChainEpoch + // TimeLockMax sets a max epoch beyond which the voucher cannot be redeemed + // TimeLockMax set to 0 means no timeout + TimeLockMax abi.ChainEpoch + // (optional) The SecretPreImage is used by `To` to validate + SecretPreimage []byte + // (optional) Extra can be specified by `From` to add a verification method to the voucher + Extra *ModVerifyParams + // Specifies which lane the Voucher merges into (will be created if does not exist) + Lane uint64 + // Nonce is set by `From` to prevent redemption of stale vouchers on a lane + Nonce uint64 + // Amount voucher can be redeemed for + Amount big.Int + // (optional) MinSettleHeight can extend channel MinSettleHeight if needed + MinSettleHeight abi.ChainEpoch + + // (optional) Set of lanes to be merged into `Lane` + Merges []Merge + + // Sender's signature over the voucher + Signature *crypto.Signature +} + +// Modular Verification method +type ModVerifyParams struct { + Actor addr.Address + Method abi.MethodNum + Data []byte +} + +type PaymentVerifyParams struct { + Extra []byte + Proof []byte +} + +func (pca Actor) UpdateChannelState(rt vmr.Runtime, params *UpdateChannelStateParams) *adt.EmptyValue { + var st State + rt.State().Readonly(&st) + + // both parties must sign voucher: one who submits it, the other explicitly signs it + rt.ValidateImmediateCallerIs(st.From, st.To) + var signer addr.Address + if rt.Message().Caller() == st.From { + signer = st.To + } else { + signer = st.From + } + sv := params.Sv + + if sv.Signature == nil { + rt.Abortf(exitcode.ErrIllegalArgument, "voucher has no signature") + } + + vb, nerr := sv.SigningBytes() + if nerr != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "failed to serialize signedvoucher") + } + + if err := rt.Syscalls().VerifySignature(*sv.Signature, signer, vb); err != nil { + rt.Abortf(exitcode.ErrIllegalArgument, "voucher signature invalid: %s", err) + } + + if rt.CurrEpoch() < sv.TimeLockMin { + rt.Abortf(exitcode.ErrIllegalArgument, "cannot use this voucher yet!") + } + + if sv.TimeLockMax != 0 && rt.CurrEpoch() > sv.TimeLockMax { + rt.Abortf(exitcode.ErrIllegalArgument, "this voucher has expired!") + } + + if len(sv.SecretPreimage) > 0 { + hashedSecret := rt.Syscalls().HashBlake2b(params.Secret) + if !bytes.Equal(hashedSecret[:], sv.SecretPreimage) { + rt.Abortf(exitcode.ErrIllegalArgument, "incorrect secret!") + } + } + + if sv.Extra != nil { + + _, code := rt.Send( + sv.Extra.Actor, + sv.Extra.Method, + &PaymentVerifyParams{ + sv.Extra.Data, + params.Proof, + }, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "spend voucher verification failed") + } + + rt.State().Transaction(&st, func() interface{} { + // Find the voucher lane, create and insert it in sorted order if necessary. + laneIdx, ls := findLane(st.LaneStates, sv.Lane) + if ls == nil { + if len(st.LaneStates) >= LaneLimit { + rt.Abortf(exitcode.ErrIllegalArgument, "lane limit exceeded") + } + ls = &LaneState{ + ID: sv.Lane, + Redeemed: big.Zero(), + Nonce: 0, + } + st.LaneStates = append(st.LaneStates[:laneIdx], append([]*LaneState{ls}, st.LaneStates[laneIdx:]...)...) + + } + + if ls.Nonce > sv.Nonce { + rt.Abortf(exitcode.ErrIllegalArgument, "voucher has an outdated nonce, cannot redeem") + } + + // The next section actually calculates the payment amounts to update the payment channel state + // 1. (optional) sum already redeemed value of all merging lanes + redeemedFromOthers := big.Zero() + for _, merge := range sv.Merges { + if merge.Lane == sv.Lane { + rt.Abortf(exitcode.ErrIllegalArgument, "voucher cannot merge lanes into its own lane") + } + + _, otherls := findLane(st.LaneStates, merge.Lane) + if otherls != nil { + if otherls.Nonce >= merge.Nonce { + rt.Abortf(exitcode.ErrIllegalArgument, "merged lane in voucher has outdated nonce, cannot redeem") + } + + redeemedFromOthers = big.Add(redeemedFromOthers, otherls.Redeemed) + otherls.Nonce = merge.Nonce + } else { + rt.Abortf(exitcode.ErrIllegalArgument, "voucher specifies invalid merge lane %v", merge.Lane) + } + } + + // 2. To prevent double counting, remove already redeemed amounts (from + // voucher or other lanes) from the voucher amount + ls.Nonce = sv.Nonce + balanceDelta := big.Sub(sv.Amount, big.Add(redeemedFromOthers, ls.Redeemed)) + // 3. set new redeemed value for merged-into lane + ls.Redeemed = sv.Amount + + newSendBalance := big.Add(st.ToSend, balanceDelta) + + // 4. check operation validity + if newSendBalance.LessThan(big.Zero()) { + rt.Abortf(exitcode.ErrIllegalState, "voucher would leave channel balance negative") + } + if newSendBalance.GreaterThan(rt.CurrentBalance()) { + rt.Abortf(exitcode.ErrIllegalState, "not enough funds in channel to cover voucher") + } + + // 5. add new redemption ToSend + st.ToSend = newSendBalance + + // update channel settlingAt and MinSettleHeight if delayed by voucher + if sv.MinSettleHeight != 0 { + if st.SettlingAt != 0 && st.SettlingAt < sv.MinSettleHeight { + st.SettlingAt = sv.MinSettleHeight + } + if st.MinSettleHeight < sv.MinSettleHeight { + st.MinSettleHeight = sv.MinSettleHeight + } + } + return nil + }) + return nil +} + +func (pca Actor) Settle(rt vmr.Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + var st State + rt.State().Transaction(&st, func() interface{} { + + rt.ValidateImmediateCallerIs(st.From, st.To) + + if st.SettlingAt != 0 { + rt.Abortf(exitcode.ErrIllegalState, "channel already settling") + } + + st.SettlingAt = rt.CurrEpoch() + SettleDelay + if st.SettlingAt < st.MinSettleHeight { + st.SettlingAt = st.MinSettleHeight + } + + return nil + }) + return nil +} + +func (pca Actor) Collect(rt vmr.Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + var st State + rt.State().Readonly(&st) + rt.ValidateImmediateCallerIs(st.From, st.To) + + if st.SettlingAt == 0 || rt.CurrEpoch() < st.SettlingAt { + rt.Abortf(exitcode.ErrForbidden, "payment channel not settling or settled") + } + + // send remaining balance to "From" + _, codeFrom := rt.Send( + st.From, + builtin.MethodSend, + nil, + big.Sub(rt.CurrentBalance(), st.ToSend), + ) + builtin.RequireSuccess(rt, codeFrom, "Failed to send balance to `From`") + + // send ToSend to "To" + _, codeTo := rt.Send( + st.To, + builtin.MethodSend, + nil, + st.ToSend, + ) + builtin.RequireSuccess(rt, codeTo, "Failed to send funds to `To`") + + rt.State().Transaction(&st, func() interface{} { + st.ToSend = big.Zero() + return nil + }) + return nil +} + +func (t *SignedVoucher) SigningBytes() ([]byte, error) { + osv := *t + osv.Signature = nil + + buf := new(bytes.Buffer) + if err := osv.MarshalCBOR(buf); err != nil { + return nil, err + } + + return buf.Bytes(), nil +} + +// Returns the insertion index for a lane ID, with the matching lane state if found, or nil. +func findLane(lanes []*LaneState, ID uint64) (int, *LaneState) { + insertionIdx := sort.Search(len(lanes), func(i int) bool { + return lanes[i].ID >= ID + }) + if insertionIdx == len(lanes) || lanes[insertionIdx].ID != uint64(insertionIdx) { + // Not found + return insertionIdx, nil + } + return insertionIdx, lanes[insertionIdx] +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_state.go new file mode 100644 index 000000000..75b398227 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_state.go @@ -0,0 +1,54 @@ +package paych + +import ( + addr "github.com/filecoin-project/go-address" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" +) + +// A given payment channel actor is established by From +// to enable off-chain microtransactions to To to be reconciled +// and tallied on chain. +type State struct { + // Channel owner, who has funded the actor + From addr.Address + // Recipient of payouts from channel + To addr.Address + + // Amount successfully redeemed through the payment channel, paid out on `Collect()` + ToSend abi.TokenAmount + + // Height at which the channel can be `Collected` + SettlingAt abi.ChainEpoch + // Height before which the channel `ToSend` cannot be collected + MinSettleHeight abi.ChainEpoch + + // Collections of lane states for the channel, maintained in ID order. + LaneStates []*LaneState +} + +// The Lane state tracks the latest (highest) voucher nonce used to merge the lane +// as well as the amount it has already redeemed. +type LaneState struct { + ID uint64 // Unique to this channel + Redeemed big.Int + Nonce uint64 +} + +// Specifies which `Lane`s to be merged with what `Nonce` on channelUpdate +type Merge struct { + Lane uint64 + Nonce uint64 +} + +func ConstructState(from addr.Address, to addr.Address) *State { + return &State{ + From: from, + To: to, + ToSend: big.Zero(), + SettlingAt: 0, + MinSettleHeight: 0, + LaneStates: []*LaneState{}, + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_test.go new file mode 100644 index 000000000..a0739885f --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/paych/paych_test.go @@ -0,0 +1,817 @@ +package paych_test + +import ( + "context" + "fmt" + "math" + "reflect" + "testing" + + addr "github.com/filecoin-project/go-address" + "github.com/ipfs/go-cid" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" + . "github.com/filecoin-project/specs-actors/actors/builtin/paych" + "github.com/filecoin-project/specs-actors/actors/crypto" + "github.com/filecoin-project/specs-actors/actors/runtime" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, Actor{}) +} + +func TestPaymentChannelActor_Constructor(t *testing.T) { + ctx := context.Background() + paychAddr := tutil.NewIDAddr(t, 100) + payerAddr := tutil.NewIDAddr(t, 101) + payeeAddr := tutil.NewIDAddr(t, 102) + callerAddr := tutil.NewIDAddr(t, 102) + + actor := pcActorHarness{Actor{}, t, paychAddr, payerAddr, payeeAddr} + + t.Run("can create a payment channel actor", func(t *testing.T) { + builder := mock.NewBuilder(ctx, paychAddr). + WithCaller(callerAddr, builtin.InitActorCodeID). + WithActorType(payerAddr, builtin.AccountActorCodeID). + WithActorType(payeeAddr, builtin.AccountActorCodeID) + rt := builder.Build(t) + actor.constructAndVerify(t, rt, payerAddr, payeeAddr) + }) + + testCases := []struct { + desc string + paymentChannelAddr addr.Address + callerCode cid.Cid + newActorCode cid.Cid + payerCode cid.Cid + expExitCode exitcode.ExitCode + }{ + {"fails if target (to) is not account actor", + paychAddr, + builtin.InitActorCodeID, + builtin.MultisigActorCodeID, + builtin.AccountActorCodeID, + exitcode.ErrIllegalArgument, + }, {"fails if sender (from) is not account actor", + paychAddr, + builtin.InitActorCodeID, + builtin.MultisigActorCodeID, + builtin.AccountActorCodeID, + exitcode.ErrIllegalArgument, + }, {"fails if addr is not ID type", + tutil.NewSECP256K1Addr(t, "beach blanket babylon"), + builtin.InitActorCodeID, + builtin.AccountActorCodeID, + builtin.AccountActorCodeID, + exitcode.ErrIllegalArgument, + }, + } + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + builder := mock.NewBuilder(ctx, paychAddr). + WithCaller(callerAddr, tc.callerCode). + WithActorType(tc.paymentChannelAddr, tc.newActorCode). + WithActorType(payerAddr, tc.payerCode) + rt := builder.Build(t) + rt.ExpectValidateCallerType(builtin.InitActorCodeID) + rt.ExpectAbort(tc.expExitCode, func() { + rt.Call(actor.Constructor, &ConstructorParams{To: tc.paymentChannelAddr}) + }) + }) + } + + t.Run("fails if actor does not exist with: no code for address", func(t *testing.T) { + builder := mock.NewBuilder(ctx, paychAddr). + WithCaller(callerAddr, builtin.InitActorCodeID). + WithActorType(payerAddr, builtin.AccountActorCodeID) + rt := builder.Build(t) + rt.ExpectValidateCallerType(builtin.InitActorCodeID) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.Constructor, &ConstructorParams{To: paychAddr}) + }) + }) +} + +func TestPaymentChannelActor_CreateLane(t *testing.T) { + ctx := context.Background() + initActorAddr := tutil.NewIDAddr(t, 100) + paychAddr := tutil.NewIDAddr(t, 101) + payerAddr := tutil.NewIDAddr(t, 102) + payeeAddr := tutil.NewIDAddr(t, 103) + payChBalance := abi.NewTokenAmount(9) + + actor := pcActorHarness{Actor{}, t, paychAddr, payerAddr, payeeAddr} + sig := &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("doesn't matter")} + + testCases := []struct { + desc string + targetCode cid.Cid + + balance int64 + received int64 + epoch int64 + + tlmin int64 + tlmax int64 + lane uint64 + nonce uint64 + amt int64 + + secretPreimage []byte + sig *crypto.Signature + verifySig bool + expExitCode exitcode.ExitCode + }{ + {desc: "succeeds", targetCode: builtin.AccountActorCodeID, + amt: 1, epoch: 1, tlmin: 1, tlmax: 0, + sig: sig, verifySig: true, + expExitCode: exitcode.Ok}, + {desc: "fails if balance too low", targetCode: builtin.AccountActorCodeID, + amt: 10, epoch: 1, tlmin: 1, tlmax: 0, + sig: sig, verifySig: true, + expExitCode: exitcode.ErrIllegalState}, + {desc: "fails if new send balance is negative", targetCode: builtin.AccountActorCodeID, + amt: -1, epoch: 1, tlmin: 1, tlmax: 0, + sig: sig, verifySig: true, + expExitCode: exitcode.ErrIllegalState}, + {desc: "fails if signature not valid", targetCode: builtin.AccountActorCodeID, + amt: 1, epoch: 1, tlmin: 1, tlmax: 0, + sig: nil, verifySig: true, + expExitCode: exitcode.ErrIllegalArgument}, + {desc: "fails if too early for voucher", targetCode: builtin.AccountActorCodeID, + amt: 1, epoch: 1, tlmin: 10, tlmax: 0, + sig: sig, verifySig: true, + expExitCode: exitcode.ErrIllegalArgument}, + {desc: "fails if beyond TimeLockMax", targetCode: builtin.AccountActorCodeID, + amt: 1, epoch: 10, tlmin: 1, tlmax: 5, + sig: sig, verifySig: true, + expExitCode: exitcode.ErrIllegalArgument}, + {desc: "fails if signature not verified", targetCode: builtin.AccountActorCodeID, + amt: 1, epoch: 1, tlmin: 1, tlmax: 0, + sig: sig, verifySig: false, + expExitCode: exitcode.ErrIllegalArgument}, + {desc: "fails if SigningBytes fails", targetCode: builtin.AccountActorCodeID, + amt: 1, epoch: 1, tlmin: 1, tlmax: 0, + sig: sig, verifySig: true, + secretPreimage: make([]byte, 2<<21), + expExitCode: exitcode.ErrIllegalArgument}, + } + + for _, tc := range testCases { + t.Run(tc.desc, func(t *testing.T) { + hasher := func(data []byte) [32]byte { return [32]byte{} } + + builder := mock.NewBuilder(ctx, paychAddr). + WithBalance(payChBalance, abi.NewTokenAmount(tc.received)). + WithEpoch(abi.ChainEpoch(tc.epoch)). + WithCaller(initActorAddr, builtin.InitActorCodeID). + WithActorType(payeeAddr, builtin.AccountActorCodeID). + WithActorType(payerAddr, builtin.AccountActorCodeID). + WithHasher(hasher) + + rt := builder.Build(t) + actor.constructAndVerify(t, rt, payerAddr, payeeAddr) + + sv := SignedVoucher{ + TimeLockMin: abi.ChainEpoch(tc.tlmin), + TimeLockMax: abi.ChainEpoch(tc.tlmax), + Lane: tc.lane, + Nonce: tc.nonce, + Amount: big.NewInt(tc.amt), + Signature: tc.sig, + SecretPreimage: tc.secretPreimage, + } + ucp := &UpdateChannelStateParams{Sv: sv} + + rt.SetCaller(payeeAddr, tc.targetCode) + rt.ExpectValidateCallerAddr(payerAddr, payeeAddr) + if tc.sig != nil && tc.secretPreimage == nil { + var result error + if !tc.verifySig { + result = fmt.Errorf("bad signature") + } + rt.ExpectVerifySignature(*sv.Signature, payerAddr, voucherBytes(t, &sv), result) + } + + if tc.expExitCode == exitcode.Ok { + rt.Call(actor.UpdateChannelState, ucp) + var st State + rt.GetState(&st) + assert.Len(t, st.LaneStates, 1) + ls := st.LaneStates[0] + assert.Equal(t, sv.Amount, ls.Redeemed) + assert.Equal(t, sv.Nonce, ls.Nonce) + assert.Equal(t, sv.Lane, ls.ID) + } else { + rt.ExpectAbort(tc.expExitCode, func() { + rt.Call(actor.UpdateChannelState, ucp) + }) + // verify state unchanged; no lane was created + verifyInitialState(t, rt, payerAddr, payeeAddr) + } + rt.Verify() + }) + } +} + +func TestActor_UpdateChannelStateRedeem(t *testing.T) { + ctx := context.Background() + newVoucherAmt := big.NewInt(9) + + t.Run("redeeming voucher updates correctly with one lane", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, ctx, 1) + var st1 State + rt.GetState(&st1) + + ucp := &UpdateChannelStateParams{Sv: *sv} + ucp.Sv.Amount = newVoucherAmt + + // Sending to same lane updates the lane with "new" state + rt.SetCaller(actor.payee, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, actor.payer, voucherBytes(t, &ucp.Sv), nil) + ret := rt.Call(actor.UpdateChannelState, ucp) + require.Nil(t, ret) + rt.Verify() + + expLs := LaneState{ + ID: 0, + Redeemed: newVoucherAmt, + Nonce: 1, + } + expState := State{ + From: st1.From, + To: st1.To, + ToSend: newVoucherAmt, + SettlingAt: st1.SettlingAt, + MinSettleHeight: st1.MinSettleHeight, + LaneStates: []*LaneState{&expLs}, + } + verifyState(t, rt, 1, expState) + }) + + t.Run("redeems voucher for correct lane", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, ctx, 3) + var st1, st2 State + rt.GetState(&st1) + + initialAmt := st1.ToSend + + ucp := &UpdateChannelStateParams{Sv: *sv} + ucp.Sv.Amount = newVoucherAmt + ucp.Sv.Lane = 1 + lsToUpdate := st1.LaneStates[ucp.Sv.Lane] + ucp.Sv.Nonce = lsToUpdate.Nonce + 1 + + // Sending to same lane updates the lane with "new" state + rt.SetCaller(actor.payee, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, actor.payer, voucherBytes(t, &ucp.Sv), nil) + ret := rt.Call(actor.UpdateChannelState, ucp) + require.Nil(t, ret) + rt.Verify() + + rt.GetState(&st2) + lUpdated := st2.LaneStates[ucp.Sv.Lane] + + bDelta := big.Sub(ucp.Sv.Amount, lsToUpdate.Redeemed) + expToSend := big.Add(initialAmt, bDelta) + assert.Equal(t, expToSend, st2.ToSend) + assert.Equal(t, ucp.Sv.Amount, lUpdated.Redeemed) + assert.Equal(t, ucp.Sv.Nonce, lUpdated.Nonce) + }) +} + +func TestActor_UpdateChannelStateMergeSuccess(t *testing.T) { + // Check that a lane merge correctly updates lane states + numLanes := 3 + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), numLanes) + + var st1 State + rt.GetState(&st1) + rt.SetCaller(st1.From, builtin.AccountActorCodeID) + + mergeTo := st1.LaneStates[0] + mergeFrom := st1.LaneStates[1] + + // Note sv.Amount = 4 + sv.Lane = mergeTo.ID + mergeNonce := mergeTo.Nonce + 10 + + merges := []Merge{{Lane: mergeFrom.ID, Nonce: mergeNonce}} + sv.Merges = merges + + ucp := &UpdateChannelStateParams{Sv: *sv} + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, actor.payee, voucherBytes(t, &ucp.Sv), nil) + ret := rt.Call(actor.UpdateChannelState, ucp) + require.Nil(t, ret) + rt.Verify() + + expMergeTo := LaneState{ID: mergeTo.ID, Redeemed: sv.Amount, Nonce: sv.Nonce} + expMergeFrom := LaneState{ID: mergeFrom.ID, Redeemed: mergeFrom.Redeemed, Nonce: mergeNonce} + + // calculate ToSend amount + redeemed := big.Add(mergeFrom.Redeemed, mergeTo.Redeemed) + expDelta := big.Sub(sv.Amount, redeemed) + expSendAmt := big.Add(st1.ToSend, expDelta) + + // last lane should be unchanged + expState := st1 + expState.ToSend = expSendAmt + expState.LaneStates = []*LaneState{&expMergeTo, &expMergeFrom, st1.LaneStates[2]} + verifyState(t, rt, numLanes, expState) +} + +func TestActor_UpdateChannelStateMergeFailure(t *testing.T) { + testCases := []struct { + name string + balance int64 + lane, voucherNonce, mergeNonce uint64 + expExitCode exitcode.ExitCode + }{ + { + name: "fails: merged lane in voucher has outdated nonce, cannot redeem", + lane: 1, voucherNonce: 10, mergeNonce: 1, + expExitCode: exitcode.ErrIllegalArgument, + }, + { + name: "fails: voucher has an outdated nonce, cannot redeem", + lane: 1, voucherNonce: 0, mergeNonce: 10, + expExitCode: exitcode.ErrIllegalArgument, + }, + { + name: "fails: not enough funds in channel to cover voucher", + lane: 1, balance: 1, voucherNonce: 10, mergeNonce: 10, + expExitCode: exitcode.ErrIllegalState, + }, + { + name: "fails: voucher cannot merge lanes into its own lane", + lane: 0, voucherNonce: 10, mergeNonce: 10, + expExitCode: exitcode.ErrIllegalArgument, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), 2) + if tc.balance > 0 { + rt.SetBalance(abi.NewTokenAmount(tc.balance)) + } + + var st1 State + rt.GetState(&st1) + mergeTo := st1.LaneStates[0] + mergeFrom := st1.LaneStates[tc.lane] + + sv.Lane = mergeTo.ID + sv.Nonce = tc.voucherNonce + merges := []Merge{{Lane: mergeFrom.ID, Nonce: tc.mergeNonce}} + sv.Merges = merges + ucp := &UpdateChannelStateParams{Sv: *sv} + + rt.SetCaller(st1.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, actor.payee, voucherBytes(t, &ucp.Sv), nil) + rt.ExpectAbort(tc.expExitCode, func() { + rt.Call(actor.UpdateChannelState, ucp) + }) + rt.Verify() + + }) + } + t.Run("When lane doesn't exist, fails with: voucher specifies invalid merge lane 999", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), 2) + + var st1 State + rt.GetState(&st1) + mergeTo := st1.LaneStates[0] + mergeFrom := LaneState{ID: 999, Nonce: 2} + + sv.Lane = mergeTo.ID + sv.Nonce = 10 + merges := []Merge{{Lane: mergeFrom.ID, Nonce: sv.Nonce}} + sv.Merges = merges + ucp := &UpdateChannelStateParams{Sv: *sv} + + rt.SetCaller(st1.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, actor.payee, voucherBytes(t, &ucp.Sv), nil) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.UpdateChannelState, ucp) + }) + rt.Verify() + }) + + t.Run("Too many lanes, fails with: lane limit exceeded", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), LaneLimit) + + var st1 State + rt.GetState(&st1) + sv.Lane++ + sv.Nonce++ + sv.Amount = abi.NewTokenAmount(100) + ucp := &UpdateChannelStateParams{Sv: *sv} + rt.SetCaller(st1.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, actor.payee, voucherBytes(t, &ucp.Sv), nil) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.UpdateChannelState, ucp) + }) + rt.Verify() + }) +} + +func TestActor_UpdateChannelStateExtra(t *testing.T) { + mnum := builtin.MethodsPaych.UpdateChannelState + fakeParams := runtime.CBORBytes([]byte{1, 2, 3, 4}) + expSendParams := &PaymentVerifyParams{fakeParams, nil} + otherAddr := tutil.NewIDAddr(t, 104) + ex := &ModVerifyParams{ + Actor: otherAddr, + Method: mnum, + Data: fakeParams, + } + + t.Run("Succeeds if extra call succeeds", func(t *testing.T) { + rt, actor1, sv1 := requireCreateChannelWithLanes(t, context.Background(), 1) + var st1 State + rt.GetState(&st1) + rt.SetCaller(st1.From, builtin.AccountActorCodeID) + + ucp := &UpdateChannelStateParams{Sv: *sv1} + ucp.Sv.Extra = ex + + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, st1.To, voucherBytes(t, &ucp.Sv), nil) + rt.ExpectSend(otherAddr, mnum, expSendParams, big.Zero(), nil, exitcode.Ok) + rt.Call(actor1.UpdateChannelState, ucp) + rt.Verify() + }) + t.Run("If Extra call fails, fails with: spend voucher verification failed", func(t *testing.T) { + rt, actor1, sv1 := requireCreateChannelWithLanes(t, context.Background(), 1) + var st1 State + rt.GetState(&st1) + rt.SetCaller(st1.From, builtin.AccountActorCodeID) + + ucp := &UpdateChannelStateParams{Sv: *sv1} + ucp.Sv.Extra = ex + + rt.ExpectValidateCallerAddr(st1.From, st1.To) + rt.ExpectSend(otherAddr, mnum, expSendParams, big.Zero(), nil, exitcode.ErrPlaceholder) + rt.ExpectVerifySignature(*ucp.Sv.Signature, st1.To, voucherBytes(t, &ucp.Sv), nil) + rt.ExpectAbort(exitcode.ErrPlaceholder, func() { + rt.Call(actor1.UpdateChannelState, ucp) + }) + rt.Verify() + }) +} + +func TestActor_UpdateChannelStateSettling(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), 1) + + ep := abi.ChainEpoch(10) + rt.SetEpoch(ep) + var st State + rt.GetState(&st) + + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.Call(actor.Settle, nil) + + expSettlingAt := ep + SettleDelay + rt.GetState(&st) + require.Equal(t, expSettlingAt, st.SettlingAt) + require.Equal(t, abi.ChainEpoch(0), st.MinSettleHeight) + + ucp := &UpdateChannelStateParams{Sv: *sv} + + testCases := []struct { + name string + minSettleHeight, expSettlingAt, expMinSettleHeight abi.ChainEpoch + //expExitCode exitcode.ExitCode + }{ + {name: "No change", + minSettleHeight: 0, expMinSettleHeight: st.MinSettleHeight, + expSettlingAt: st.SettlingAt}, + {name: "Updates MinSettleHeight only", + minSettleHeight: abi.ChainEpoch(2), expMinSettleHeight: abi.ChainEpoch(2), + expSettlingAt: st.SettlingAt}, + {name: "Updates both SettlingAt and MinSettleHeight", + minSettleHeight: abi.ChainEpoch(12), expMinSettleHeight: abi.ChainEpoch(12), + expSettlingAt: abi.ChainEpoch(12)}, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + var newSt State + ucp.Sv.MinSettleHeight = tc.minSettleHeight + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, st.To, voucherBytes(t, &ucp.Sv), nil) + rt.Call(actor.UpdateChannelState, ucp) + rt.GetState(&newSt) + assert.Equal(t, tc.expSettlingAt, newSt.SettlingAt) + assert.Equal(t, tc.expMinSettleHeight, newSt.MinSettleHeight) + }) + } +} + +func TestActor_UpdateChannelStateSecretPreimage(t *testing.T) { + t.Run("Succeeds with correct secret", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), 1) + var st State + rt.GetState(&st) + + rt.SetHasher(func(data []byte) [32]byte { + aux := []byte("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") + var res [32]byte + copy(res[:], aux) + copy(res[:], data) + return res + }) + ucp := &UpdateChannelStateParams{ + Sv: *sv, + Secret: []byte("Profesr"), + Proof: nil, + } + ucp.Sv.SecretPreimage = []byte("ProfesrXXXXXXXXXXXXXXXXXXXXXXXXX") + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, st.To, voucherBytes(t, &ucp.Sv), nil) + rt.Call(actor.UpdateChannelState, ucp) + rt.Verify() + }) + + t.Run("If bad secret preimage, fails with: incorrect secret!", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), 1) + var st State + rt.GetState(&st) + ucp := &UpdateChannelStateParams{ + Sv: *sv, + Secret: []byte("Profesr"), + Proof: nil, + } + ucp.Sv.SecretPreimage = append([]byte("Magneto"), make([]byte, 25)...) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, st.To, voucherBytes(t, &ucp.Sv), nil) + rt.ExpectAbort(exitcode.ErrIllegalArgument, func() { + rt.Call(actor.UpdateChannelState, ucp) + }) + rt.Verify() + }) +} + +func TestActor_Settle(t *testing.T) { + ep := abi.ChainEpoch(10) + + t.Run("Settle adjusts SettlingAt", func(t *testing.T) { + rt, actor, _ := requireCreateChannelWithLanes(t, context.Background(), 1) + rt.SetEpoch(ep) + var st State + rt.GetState(&st) + + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.Call(actor.Settle, nil) + + expSettlingAt := ep + SettleDelay + rt.GetState(&st) + assert.Equal(t, expSettlingAt, st.SettlingAt) + assert.Equal(t, abi.ChainEpoch(0), st.MinSettleHeight) + }) + + t.Run("settle fails if called twice: channel already settling", func(t *testing.T) { + rt, actor, _ := requireCreateChannelWithLanes(t, context.Background(), 1) + rt.SetEpoch(ep) + var st State + rt.GetState(&st) + + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.Call(actor.Settle, nil) + + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.ExpectAbort(exitcode.ErrIllegalState, func() { + rt.Call(actor.Settle, nil) + }) + }) + + t.Run("Settle changes SettleHeight again if MinSettleHeight is less", func(t *testing.T) { + rt, actor, sv := requireCreateChannelWithLanes(t, context.Background(), 1) + rt.SetEpoch(ep) + var st State + rt.GetState(&st) + + // UpdateChannelState to increase MinSettleHeight only + ucp := &UpdateChannelStateParams{Sv: *sv} + ucp.Sv.MinSettleHeight = (ep + SettleDelay) + 1 + + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.ExpectVerifySignature(*ucp.Sv.Signature, st.To, voucherBytes(t, &ucp.Sv), nil) + rt.Call(actor.UpdateChannelState, ucp) + + var newSt State + rt.GetState(&newSt) + // SettlingAt should remain the same. + require.Equal(t, abi.ChainEpoch(0), newSt.SettlingAt) + require.Equal(t, ucp.Sv.MinSettleHeight, newSt.MinSettleHeight) + + // Settle. + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.Call(actor.Settle, nil) + + // SettlingAt should = MinSettleHeight, not epoch + SettleDelay. + rt.GetState(&newSt) + assert.Equal(t, ucp.Sv.MinSettleHeight, newSt.SettlingAt) + }) +} + +func TestActor_Collect(t *testing.T) { + t.Run("Happy path", func(t *testing.T) { + rt, actor, _ := requireCreateChannelWithLanes(t, context.Background(), 1) + rt.SetEpoch(10) + var st State + rt.GetState(&st) + + // Settle. + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.Call(actor.Settle, nil) + + rt.GetState(&st) + require.Equal(t, abi.ChainEpoch(11), st.SettlingAt) + rt.ExpectValidateCallerAddr(st.From, st.To) + + // "wait" for SettlingAt epoch + rt.SetEpoch(12) + + bal := rt.Balance() + sentToFrom := big.Sub(bal, st.ToSend) + rt.ExpectSend(st.From, builtin.MethodSend, nil, sentToFrom, nil, exitcode.Ok) + rt.ExpectSend(st.To, builtin.MethodSend, nil, st.ToSend, nil, exitcode.Ok) + + // Collect. + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + res := rt.Call(actor.Collect, nil) + assert.Nil(t, res) + + var newSt State + rt.GetState(&newSt) + assert.Equal(t, big.Zero(), newSt.ToSend) + }) + + testCases := []struct { + name string + expSendToCode, expSendFromCode, expCollectExit exitcode.ExitCode + dontSettle bool + }{ + {name: "fails if not settling with: payment channel not settling or settled", dontSettle: true, expCollectExit: exitcode.ErrForbidden}, + {name: "fails if Failed to send balance to `From`", expSendFromCode: exitcode.ErrPlaceholder, expCollectExit: exitcode.ErrPlaceholder}, + {name: "fails if Failed to send funds to `To`", expSendToCode: exitcode.ErrPlaceholder, expCollectExit: exitcode.ErrPlaceholder}, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + rt, actor, _ := requireCreateChannelWithLanes(t, context.Background(), 1) + rt.SetEpoch(10) + var st State + rt.GetState(&st) + + if !tc.dontSettle { + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.Call(actor.Settle, nil) + rt.GetState(&st) + require.Equal(t, abi.ChainEpoch(11), st.SettlingAt) + } + + // "wait" for SettlingAt epoch + rt.SetEpoch(12) + + sentToFrom := big.Sub(rt.Balance(), st.ToSend) + rt.ExpectSend(st.From, builtin.MethodSend, nil, sentToFrom, nil, tc.expSendFromCode) + rt.ExpectSend(st.To, builtin.MethodSend, nil, st.ToSend, nil, tc.expSendToCode) + + // Collect. + rt.SetCaller(st.From, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(st.From, st.To) + rt.ExpectAbort(tc.expCollectExit, func() { + rt.Call(actor.Collect, nil) + }) + }) + } +} + +type pcActorHarness struct { + Actor + t testing.TB + + addr addr.Address + payer addr.Address + payee addr.Address +} + +type laneParams struct { + epochNum int64 + from, to addr.Address + amt big.Int + lane, nonce uint64 +} + +func requireCreateChannelWithLanes(t *testing.T, ctx context.Context, numLanes int) (*mock.Runtime, *pcActorHarness, *SignedVoucher) { + paychAddr := tutil.NewIDAddr(t, 100) + payerAddr := tutil.NewIDAddr(t, 102) + payeeAddr := tutil.NewIDAddr(t, 103) + balance := abi.NewTokenAmount(100000) + received := abi.NewTokenAmount(0) + + curEpoch := 2 + hasher := func(data []byte) [32]byte { return [32]byte{} } + + builder := mock.NewBuilder(ctx, paychAddr). + WithBalance(balance, received). + WithEpoch(abi.ChainEpoch(curEpoch)). + WithCaller(builtin.InitActorAddr, builtin.InitActorCodeID). + WithActorType(payerAddr, builtin.AccountActorCodeID). + WithActorType(payeeAddr, builtin.AccountActorCodeID). + WithHasher(hasher) + + actor := pcActorHarness{Actor{}, t, paychAddr, payerAddr, payeeAddr} + + rt := builder.Build(t) + actor.constructAndVerify(t, rt, payerAddr, payeeAddr) + + var lastSv *SignedVoucher + for i := 0; i < numLanes; i++ { + amt := big.NewInt(int64(i + 1)) + lastSv = requireAddNewLane(t, rt, &actor, laneParams{ + epochNum: int64(curEpoch), + from: payerAddr, + to: payeeAddr, + amt: amt, + lane: uint64(i), + nonce: uint64(i + 1), + }) + } + return rt, &actor, lastSv +} + +func requireAddNewLane(t *testing.T, rt *mock.Runtime, actor *pcActorHarness, params laneParams) *SignedVoucher { + sig := &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte{0, 1, 2, 3, 4, 5, 6, 7}} + tl := abi.ChainEpoch(params.epochNum) + sv := SignedVoucher{TimeLockMin: tl, TimeLockMax: math.MaxInt64, Lane: params.lane, Nonce: params.nonce, Amount: params.amt, Signature: sig} + ucp := &UpdateChannelStateParams{Sv: sv} + + rt.SetCaller(params.from, builtin.AccountActorCodeID) + rt.ExpectValidateCallerAddr(params.from, params.to) + rt.ExpectVerifySignature(*sv.Signature, actor.payee, voucherBytes(t, &sv), nil) + ret := rt.Call(actor.UpdateChannelState, ucp) + require.Nil(t, ret) + rt.Verify() + return &sv +} + +func (h *pcActorHarness) constructAndVerify(t *testing.T, rt *mock.Runtime, sender, receiver addr.Address) { + params := &ConstructorParams{To: receiver, From: sender} + + rt.ExpectValidateCallerType(builtin.InitActorCodeID) + ret := rt.Call(h.Actor.Constructor, params) + assert.Nil(h.t, ret) + rt.Verify() + verifyInitialState(t, rt, sender, receiver) +} + +func verifyInitialState(t *testing.T, rt *mock.Runtime, sender, receiver addr.Address) { + var st State + rt.GetState(&st) + expectedState := State{From: sender, To: receiver, ToSend: abi.NewTokenAmount(0)} + verifyState(t, rt, -1, expectedState) +} + +func verifyState(t *testing.T, rt *mock.Runtime, expLanes int, expectedState State) { + var st State + rt.GetState(&st) + assert.Equal(t, expectedState.To, st.To) + assert.Equal(t, expectedState.From, st.From) + assert.Equal(t, expectedState.MinSettleHeight, st.MinSettleHeight) + assert.Equal(t, expectedState.SettlingAt, st.SettlingAt) + assert.Equal(t, expectedState.ToSend, st.ToSend) + if expLanes >= 0 { + require.Len(t, st.LaneStates, expLanes) + assert.True(t, reflect.DeepEqual(expectedState.LaneStates, st.LaneStates)) + } else { + assert.Len(t, st.LaneStates, 0) + } +} + +func voucherBytes(t *testing.T, sv *SignedVoucher) []byte { + bytes, err := sv.SigningBytes() + require.NoError(t, err) + return bytes +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/cbor_gen.go new file mode 100644 index 000000000..dc6ee51bb --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/cbor_gen.go @@ -0,0 +1,1187 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package power + +import ( + "fmt" + "io" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{139}); err != nil { + return err + } + + // t.TotalRawBytePower (big.Int) (struct) + if err := t.TotalRawBytePower.MarshalCBOR(w); err != nil { + return err + } + + // t.TotalBytesCommitted (big.Int) (struct) + if err := t.TotalBytesCommitted.MarshalCBOR(w); err != nil { + return err + } + + // t.TotalQualityAdjPower (big.Int) (struct) + if err := t.TotalQualityAdjPower.MarshalCBOR(w); err != nil { + return err + } + + // t.TotalQABytesCommitted (big.Int) (struct) + if err := t.TotalQABytesCommitted.MarshalCBOR(w); err != nil { + return err + } + + // t.TotalPledgeCollateral (big.Int) (struct) + if err := t.TotalPledgeCollateral.MarshalCBOR(w); err != nil { + return err + } + + // t.MinerCount (int64) (int64) + if t.MinerCount >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinerCount))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.MinerCount)-1)); err != nil { + return err + } + } + + // t.CronEventQueue (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.CronEventQueue); err != nil { + return xerrors.Errorf("failed to write cid field t.CronEventQueue: %w", err) + } + + // t.LastEpochTick (abi.ChainEpoch) (int64) + if t.LastEpochTick >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.LastEpochTick))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.LastEpochTick)-1)); err != nil { + return err + } + } + + // t.Claims (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.Claims); err != nil { + return xerrors.Errorf("failed to write cid field t.Claims: %w", err) + } + + // t.MinerAboveMinPowerCount (int64) (int64) + if t.MinerAboveMinPowerCount >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinerAboveMinPowerCount))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.MinerAboveMinPowerCount)-1)); err != nil { + return err + } + } + + // t.ProofValidationBatch (cid.Cid) (struct) + + if t.ProofValidationBatch == nil { + if _, err := w.Write(cbg.CborNull); err != nil { + return err + } + } else { + if err := cbg.WriteCid(w, *t.ProofValidationBatch); err != nil { + return xerrors.Errorf("failed to write cid field t.ProofValidationBatch: %w", err) + } + } + + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 11 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.TotalRawBytePower (big.Int) (struct) + + { + + if err := t.TotalRawBytePower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalRawBytePower: %w", err) + } + + } + // t.TotalBytesCommitted (big.Int) (struct) + + { + + if err := t.TotalBytesCommitted.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalBytesCommitted: %w", err) + } + + } + // t.TotalQualityAdjPower (big.Int) (struct) + + { + + if err := t.TotalQualityAdjPower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalQualityAdjPower: %w", err) + } + + } + // t.TotalQABytesCommitted (big.Int) (struct) + + { + + if err := t.TotalQABytesCommitted.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalQABytesCommitted: %w", err) + } + + } + // t.TotalPledgeCollateral (big.Int) (struct) + + { + + if err := t.TotalPledgeCollateral.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.TotalPledgeCollateral: %w", err) + } + + } + // t.MinerCount (int64) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.MinerCount = int64(extraI) + } + // t.CronEventQueue (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.CronEventQueue: %w", err) + } + + t.CronEventQueue = c + + } + // t.LastEpochTick (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.LastEpochTick = abi.ChainEpoch(extraI) + } + // t.Claims (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.Claims: %w", err) + } + + t.Claims = c + + } + // t.MinerAboveMinPowerCount (int64) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.MinerAboveMinPowerCount = int64(extraI) + } + // t.ProofValidationBatch (cid.Cid) (struct) + + { + + pb, err := br.PeekByte() + if err != nil { + return err + } + if pb == cbg.CborNull[0] { + var nbuf [1]byte + if _, err := br.Read(nbuf[:]); err != nil { + return err + } + } else { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.ProofValidationBatch: %w", err) + } + + t.ProofValidationBatch = &c + } + + } + return nil +} + +func (t *Claim) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.RawBytePower (big.Int) (struct) + if err := t.RawBytePower.MarshalCBOR(w); err != nil { + return err + } + + // t.QualityAdjPower (big.Int) (struct) + if err := t.QualityAdjPower.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *Claim) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.RawBytePower (big.Int) (struct) + + { + + if err := t.RawBytePower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RawBytePower: %w", err) + } + + } + // t.QualityAdjPower (big.Int) (struct) + + { + + if err := t.QualityAdjPower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.QualityAdjPower: %w", err) + } + + } + return nil +} + +func (t *CronEvent) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.MinerAddr (address.Address) (struct) + if err := t.MinerAddr.MarshalCBOR(w); err != nil { + return err + } + + // t.CallbackPayload ([]uint8) (slice) + if len(t.CallbackPayload) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.CallbackPayload was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.CallbackPayload)))); err != nil { + return err + } + if _, err := w.Write(t.CallbackPayload); err != nil { + return err + } + return nil +} + +func (t *CronEvent) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.MinerAddr (address.Address) (struct) + + { + + if err := t.MinerAddr.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.MinerAddr: %w", err) + } + + } + // t.CallbackPayload ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.CallbackPayload: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.CallbackPayload = make([]byte, extra) + if _, err := io.ReadFull(br, t.CallbackPayload); err != nil { + return err + } + return nil +} + +func (t *CreateMinerParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{133}); err != nil { + return err + } + + // t.Owner (address.Address) (struct) + if err := t.Owner.MarshalCBOR(w); err != nil { + return err + } + + // t.Worker (address.Address) (struct) + if err := t.Worker.MarshalCBOR(w); err != nil { + return err + } + + // t.SealProofType (abi.RegisteredSealProof) (int64) + if t.SealProofType >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProofType))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProofType)-1)); err != nil { + return err + } + } + + // t.Peer ([]uint8) (slice) + if len(t.Peer) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Peer was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Peer)))); err != nil { + return err + } + if _, err := w.Write(t.Peer); err != nil { + return err + } + + // t.Multiaddrs ([][]uint8) (slice) + if len(t.Multiaddrs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Multiaddrs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Multiaddrs)))); err != nil { + return err + } + for _, v := range t.Multiaddrs { + if len(v) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field v was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(v)))); err != nil { + return err + } + if _, err := w.Write(v); err != nil { + return err + } + } + return nil +} + +func (t *CreateMinerParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 5 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Owner (address.Address) (struct) + + { + + if err := t.Owner.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Owner: %w", err) + } + + } + // t.Worker (address.Address) (struct) + + { + + if err := t.Worker.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Worker: %w", err) + } + + } + // t.SealProofType (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProofType = abi.RegisteredSealProof(extraI) + } + // t.Peer ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Peer: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Peer = make([]byte, extra) + if _, err := io.ReadFull(br, t.Peer); err != nil { + return err + } + // t.Multiaddrs ([][]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Multiaddrs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Multiaddrs = make([][]uint8, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Multiaddrs[i]: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Multiaddrs[i] = make([]byte, extra) + if _, err := io.ReadFull(br, t.Multiaddrs[i]); err != nil { + return err + } + } + } + + return nil +} + +func (t *EnrollCronEventParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.EventEpoch (abi.ChainEpoch) (int64) + if t.EventEpoch >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.EventEpoch))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.EventEpoch)-1)); err != nil { + return err + } + } + + // t.Payload ([]uint8) (slice) + if len(t.Payload) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Payload was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Payload)))); err != nil { + return err + } + if _, err := w.Write(t.Payload); err != nil { + return err + } + return nil +} + +func (t *EnrollCronEventParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.EventEpoch (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.EventEpoch = abi.ChainEpoch(extraI) + } + // t.Payload ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Payload: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Payload = make([]byte, extra) + if _, err := io.ReadFull(br, t.Payload); err != nil { + return err + } + return nil +} + +func (t *UpdateClaimedPowerParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.RawByteDelta (big.Int) (struct) + if err := t.RawByteDelta.MarshalCBOR(w); err != nil { + return err + } + + // t.QualityAdjustedDelta (big.Int) (struct) + if err := t.QualityAdjustedDelta.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *UpdateClaimedPowerParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.RawByteDelta (big.Int) (struct) + + { + + if err := t.RawByteDelta.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RawByteDelta: %w", err) + } + + } + // t.QualityAdjustedDelta (big.Int) (struct) + + { + + if err := t.QualityAdjustedDelta.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.QualityAdjustedDelta: %w", err) + } + + } + return nil +} + +func (t *CreateMinerReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.IDAddress (address.Address) (struct) + if err := t.IDAddress.MarshalCBOR(w); err != nil { + return err + } + + // t.RobustAddress (address.Address) (struct) + if err := t.RobustAddress.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *CreateMinerReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.IDAddress (address.Address) (struct) + + { + + if err := t.IDAddress.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.IDAddress: %w", err) + } + + } + // t.RobustAddress (address.Address) (struct) + + { + + if err := t.RobustAddress.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RobustAddress: %w", err) + } + + } + return nil +} + +func (t *CurrentTotalPowerReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.RawBytePower (big.Int) (struct) + if err := t.RawBytePower.MarshalCBOR(w); err != nil { + return err + } + + // t.QualityAdjPower (big.Int) (struct) + if err := t.QualityAdjPower.MarshalCBOR(w); err != nil { + return err + } + + // t.PledgeCollateral (big.Int) (struct) + if err := t.PledgeCollateral.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *CurrentTotalPowerReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.RawBytePower (big.Int) (struct) + + { + + if err := t.RawBytePower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RawBytePower: %w", err) + } + + } + // t.QualityAdjPower (big.Int) (struct) + + { + + if err := t.QualityAdjPower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.QualityAdjPower: %w", err) + } + + } + // t.PledgeCollateral (big.Int) (struct) + + { + + if err := t.PledgeCollateral.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.PledgeCollateral: %w", err) + } + + } + return nil +} + +func (t *MinerConstructorParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{133}); err != nil { + return err + } + + // t.OwnerAddr (address.Address) (struct) + if err := t.OwnerAddr.MarshalCBOR(w); err != nil { + return err + } + + // t.WorkerAddr (address.Address) (struct) + if err := t.WorkerAddr.MarshalCBOR(w); err != nil { + return err + } + + // t.SealProofType (abi.RegisteredSealProof) (int64) + if t.SealProofType >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealProofType))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.SealProofType)-1)); err != nil { + return err + } + } + + // t.PeerId ([]uint8) (slice) + if len(t.PeerId) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.PeerId was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.PeerId)))); err != nil { + return err + } + if _, err := w.Write(t.PeerId); err != nil { + return err + } + + // t.Multiaddrs ([][]uint8) (slice) + if len(t.Multiaddrs) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.Multiaddrs was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Multiaddrs)))); err != nil { + return err + } + for _, v := range t.Multiaddrs { + if len(v) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field v was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(v)))); err != nil { + return err + } + if _, err := w.Write(v); err != nil { + return err + } + } + return nil +} + +func (t *MinerConstructorParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 5 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.OwnerAddr (address.Address) (struct) + + { + + if err := t.OwnerAddr.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.OwnerAddr: %w", err) + } + + } + // t.WorkerAddr (address.Address) (struct) + + { + + if err := t.WorkerAddr.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.WorkerAddr: %w", err) + } + + } + // t.SealProofType (abi.RegisteredSealProof) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.SealProofType = abi.RegisteredSealProof(extraI) + } + // t.PeerId ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.PeerId: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.PeerId = make([]byte, extra) + if _, err := io.ReadFull(br, t.PeerId); err != nil { + return err + } + // t.Multiaddrs ([][]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.Multiaddrs: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.Multiaddrs = make([][]uint8, extra) + } + + for i := 0; i < int(extra); i++ { + { + var maj byte + var extra uint64 + var err error + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Multiaddrs[i]: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Multiaddrs[i] = make([]byte, extra) + if _, err := io.ReadFull(br, t.Multiaddrs[i]); err != nil { + return err + } + } + } + + return nil +} + +func (t *SectorStorageWeightDesc) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.SectorSize (abi.SectorSize) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorSize))); err != nil { + return err + } + + // t.Duration (abi.ChainEpoch) (int64) + if t.Duration >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Duration))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Duration)-1)); err != nil { + return err + } + } + + // t.DealWeight (big.Int) (struct) + if err := t.DealWeight.MarshalCBOR(w); err != nil { + return err + } + + // t.VerifiedDealWeight (big.Int) (struct) + if err := t.VerifiedDealWeight.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *SectorStorageWeightDesc) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.SectorSize (abi.SectorSize) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.SectorSize = abi.SectorSize(extra) + + } + // t.Duration (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Duration = abi.ChainEpoch(extraI) + } + // t.DealWeight (big.Int) (struct) + + { + + if err := t.DealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.DealWeight: %w", err) + } + + } + // t.VerifiedDealWeight (big.Int) (struct) + + { + + if err := t.VerifiedDealWeight.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.VerifiedDealWeight: %w", err) + } + + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/policy.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/policy.go new file mode 100644 index 000000000..6b937ee62 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/policy.go @@ -0,0 +1,11 @@ +package power + +import ( + abi "github.com/filecoin-project/specs-actors/actors/abi" +) + +// Minimum number of registered miners for the minimum miner size limit to effectively limit consensus power. +const ConsensusMinerMinMiners = 3 + +// Minimum power of an individual miner to meet the threshold for leader election. +var ConsensusMinerMinPower = abi.NewStoragePower(1 << 40) // PARAM_FINISH diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_actor.go new file mode 100644 index 000000000..6a121a98a --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_actor.go @@ -0,0 +1,489 @@ +package power + +import ( + "bytes" + + "github.com/filecoin-project/go-address" + addr "github.com/filecoin-project/go-address" + errors "github.com/pkg/errors" + xerrors "golang.org/x/xerrors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + initact "github.com/filecoin-project/specs-actors/actors/builtin/init" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + . "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Runtime = vmr.Runtime + +type SectorTermination int64 + +const ( + SectorTerminationExpired SectorTermination = iota // Implicit termination after all deals expire + SectorTerminationManual // Unscheduled explicit termination by the miner + SectorTerminationFaulty // Implicit termination due to unrecovered fault +) + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.CreateMiner, + 3: a.UpdateClaimedPower, + 4: a.EnrollCronEvent, + 5: a.OnEpochTickEnd, + 6: a.UpdatePledgeTotal, + 7: a.OnConsensusFault, + 8: a.SubmitPoRepForBulkVerify, + 9: a.CurrentTotalPower, + } +} + +var _ abi.Invokee = Actor{} + +// Storage miner actor constructor params are defined here so the power actor can send them to the init actor +// to instantiate miners. +type MinerConstructorParams struct { + OwnerAddr addr.Address + WorkerAddr addr.Address + SealProofType abi.RegisteredSealProof + PeerId abi.PeerID + Multiaddrs []abi.Multiaddrs +} + +type SectorStorageWeightDesc struct { + SectorSize abi.SectorSize + Duration abi.ChainEpoch + DealWeight abi.DealWeight + VerifiedDealWeight abi.DealWeight +} + +//////////////////////////////////////////////////////////////////////////////// +// Actor methods +//////////////////////////////////////////////////////////////////////////////// + +func (a Actor) Constructor(rt Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + + emptyMap, err := adt.MakeEmptyMap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to create storage power state: %v", err) + } + emptyMMapCid, err := adt.MakeEmptyMultimap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to get empty multimap cid") + } + + st := ConstructState(emptyMap, emptyMMapCid) + rt.State().Create(st) + return nil +} + +type CreateMinerParams struct { + Owner addr.Address + Worker addr.Address + SealProofType abi.RegisteredSealProof + Peer abi.PeerID + Multiaddrs []abi.Multiaddrs +} + +type CreateMinerReturn struct { + IDAddress addr.Address // The canonical ID-based address for the actor. + RobustAddress addr.Address // A more expensive but re-org-safe address for the newly created actor. +} + +func (a Actor) CreateMiner(rt Runtime, params *CreateMinerParams) *CreateMinerReturn { + rt.ValidateImmediateCallerType(builtin.CallerTypesSignable...) + + ctorParams := MinerConstructorParams{ + OwnerAddr: params.Owner, + WorkerAddr: params.Worker, + SealProofType: params.SealProofType, + PeerId: params.Peer, + Multiaddrs: params.Multiaddrs, + } + ctorParamBuf := new(bytes.Buffer) + err := ctorParams.MarshalCBOR(ctorParamBuf) + if err != nil { + rt.Abortf(exitcode.ErrPlaceholder, "failed to serialize miner constructor params %v: %v", ctorParams, err) + } + ret, code := rt.Send( + builtin.InitActorAddr, + builtin.MethodsInit.Exec, + &initact.ExecParams{ + CodeCID: builtin.StorageMinerActorCodeID, + ConstructorParams: ctorParamBuf.Bytes(), + }, + rt.Message().ValueReceived(), // Pass on any value to the new actor. + ) + builtin.RequireSuccess(rt, code, "failed to init new actor") + var addresses initact.ExecReturn + err = ret.Into(&addresses) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "unmarshaling exec return value: %v", err) + } + + var st State + rt.State().Transaction(&st, func() interface{} { + store := adt.AsStore(rt) + err = st.setClaim(store, addresses.IDAddress, &Claim{abi.NewStoragePower(0), abi.NewStoragePower(0)}) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to put power in claimed table while creating miner: %v", err) + } + st.MinerCount += 1 + return nil + }) + return &CreateMinerReturn{ + IDAddress: addresses.IDAddress, + RobustAddress: addresses.RobustAddress, + } +} + +type UpdateClaimedPowerParams struct { + RawByteDelta abi.StoragePower + QualityAdjustedDelta abi.StoragePower +} + +// Adds or removes claimed power for the calling actor. +// May only be invoked by a miner actor. +func (a Actor) UpdateClaimedPower(rt Runtime, params *UpdateClaimedPowerParams) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + minerAddr := rt.Message().Caller() + var st State + rt.State().Transaction(&st, func() interface{} { + err := st.AddToClaim(adt.AsStore(rt), minerAddr, params.RawByteDelta, params.QualityAdjustedDelta) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "failed to update power raw %s, qa %s", params.RawByteDelta, params.QualityAdjustedDelta) + return nil + }) + return nil +} + +type EnrollCronEventParams struct { + EventEpoch abi.ChainEpoch + Payload []byte +} + +func (a Actor) EnrollCronEvent(rt Runtime, params *EnrollCronEventParams) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + minerAddr := rt.Message().Caller() + minerEvent := CronEvent{ + MinerAddr: minerAddr, + CallbackPayload: params.Payload, + } + + var st State + rt.State().Transaction(&st, func() interface{} { + err := st.appendCronEvent(adt.AsStore(rt), params.EventEpoch, &minerEvent) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to enroll cron event: %v", err) + } + return nil + }) + return nil +} + +// Called by Cron. +func (a Actor) OnEpochTickEnd(rt Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.CronActorAddr) + + if err := a.processDeferredCronEvents(rt); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to process deferred cron events: %v", err) + } + + if err := a.processBatchProofVerifies(rt); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to process batch proof verification: %s", err) + } + + var st State + rt.State().Readonly(&st) + + // update network KPI in RewardActor + _, code := rt.Send( + builtin.RewardActorAddr, + builtin.MethodsReward.UpdateNetworkKPI, + &st.TotalRawBytePower, + abi.NewTokenAmount(0), + ) + builtin.RequireSuccess(rt, code, "failed to update network KPI with Reward Actor") + + return nil +} + +func (a Actor) UpdatePledgeTotal(rt Runtime, pledgeDelta *abi.TokenAmount) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + var st State + rt.State().Transaction(&st, func() interface{} { + st.addPledgeTotal(*pledgeDelta) + return nil + }) + return nil +} + +func (a Actor) OnConsensusFault(rt Runtime, pledgeAmount *abi.TokenAmount) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + minerAddr := rt.Message().Caller() + + var st State + rt.State().Transaction(&st, func() interface{} { + claim, powerOk, err := st.GetClaim(adt.AsStore(rt), minerAddr) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to read claimed power for fault: %v", err) + } + if !powerOk { + rt.Abortf(exitcode.ErrIllegalArgument, "miner %v not registered (already slashed?)", minerAddr) + } + Assert(claim.RawBytePower.GreaterThanEqual(big.Zero())) + Assert(claim.QualityAdjPower.GreaterThanEqual(big.Zero())) + err = st.AddToClaim(adt.AsStore(rt), minerAddr, claim.QualityAdjPower.Neg(), claim.RawBytePower.Neg()) + builtin.RequireNoErr(rt, err, exitcode.ErrIllegalState, "could not add to claim for %s after loading existing claim for this address", minerAddr) + + st.addPledgeTotal(pledgeAmount.Neg()) + return nil + }) + + err := a.deleteMinerActor(rt, minerAddr) + AssertNoError(err) + + return nil +} + +// GasOnSubmitVerifySeal is amount of gas charged for SubmitPoRepForBulkVerify +// This number is empirically determined +const GasOnSubmitVerifySeal = 132166313 + +func (a Actor) SubmitPoRepForBulkVerify(rt Runtime, sealInfo *abi.SealVerifyInfo) *adt.EmptyValue { + rt.ValidateImmediateCallerType(builtin.StorageMinerActorCodeID) + + minerAddr := rt.Message().Caller() + + rt.ChargeGas("OnSubmitVerifySeal", GasOnSubmitVerifySeal, 0) + var st State + rt.State().Transaction(&st, func() interface{} { + store := adt.AsStore(rt) + var mmap *adt.Multimap + if st.ProofValidationBatch == nil { + mmap = adt.MakeEmptyMultimap(store) + } else { + var err error + mmap, err = adt.AsMultimap(adt.AsStore(rt), *st.ProofValidationBatch) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to load proof batching set: %s", err) + } + } + + if err := mmap.Add(adt.AddrKey(minerAddr), sealInfo); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to insert proof into set: %s", err) + } + + mmrc, err := mmap.Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to flush proofs batch map: %s", err) + } + st.ProofValidationBatch = &mmrc + return nil + }) + + return nil +} + +type CurrentTotalPowerReturn struct { + RawBytePower abi.StoragePower + QualityAdjPower abi.StoragePower + PledgeCollateral abi.TokenAmount +} + +// Returns the total power and pledge recorded by the power actor. +// TODO hold these values constant during an epoch for stable calculations, https://github.com/filecoin-project/specs-actors/issues/495 +func (a Actor) CurrentTotalPower(rt Runtime, _ *adt.EmptyValue) *CurrentTotalPowerReturn { + rt.ValidateImmediateCallerAcceptAny() + var st State + rt.State().Readonly(&st) + + rawBytePower, qaPower := CurrentTotalPower(&st) + return &CurrentTotalPowerReturn{ + RawBytePower: rawBytePower, + QualityAdjPower: qaPower, + PledgeCollateral: st.TotalPledgeCollateral, + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Method utility functions +//////////////////////////////////////////////////////////////////////////////// + +func (a Actor) processBatchProofVerifies(rt Runtime) error { + var st State + + var miners []address.Address + verifies := make(map[address.Address][]abi.SealVerifyInfo) + + rt.State().Transaction(&st, func() interface{} { + store := adt.AsStore(rt) + if st.ProofValidationBatch == nil { + return nil + } + mmap, err := adt.AsMultimap(store, *st.ProofValidationBatch) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to load proofs validation batch: %s", err) + } + + err = mmap.ForAll(func(k string, arr *adt.Array) error { + a, err := address.NewFromBytes([]byte(k)) + if err != nil { + return xerrors.Errorf("failed to parse address key: %w", err) + } + + miners = append(miners, a) + + var infos []abi.SealVerifyInfo + var svi abi.SealVerifyInfo + err = arr.ForEach(&svi, func(i int64) error { + infos = append(infos, svi) + return nil + }) + if err != nil { + return xerrors.Errorf("failed to iterate over proof verify array for miner %s: %w", a, err) + } + verifies[a] = infos + return nil + }) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to iterate proof batch: %s", err) + } + + st.ProofValidationBatch = nil + + return nil + }) + + res, err := rt.Syscalls().BatchVerifySeals(verifies) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to batch verify: %s", err) + } + + for _, m := range miners { + vres, ok := res[m] + if !ok { + rt.Abortf(exitcode.ErrNotFound, "batch verify seals syscall implemented incorrectly") + } + + verifs := verifies[m] + + seen := map[abi.SectorNumber]struct{}{} + var successful []abi.SectorNumber + for i, r := range vres { + if r { + snum := verifs[i].SectorID.Number + + if _, exists := seen[snum]; exists { + // filter-out duplicates + continue + } + + seen[snum] = struct{}{} + successful = append(successful, snum) + } + } + + // The exit code is explicitly ignored + _, _ = rt.Send( + m, + builtin.MethodsMiner.ConfirmSectorProofsValid, + &builtin.ConfirmSectorProofsParams{Sectors: successful}, + abi.NewTokenAmount(0), + ) + } + + return nil +} + +func (a Actor) processDeferredCronEvents(rt Runtime) error { + rtEpoch := rt.CurrEpoch() + + var cronEvents []CronEvent + var st State + rt.State().Transaction(&st, func() interface{} { + store := adt.AsStore(rt) + + for epoch := st.LastEpochTick + 1; epoch <= rtEpoch; epoch++ { + epochEvents, err := st.loadCronEvents(store, epoch) + if err != nil { + return errors.Wrapf(err, "failed to load cron events at %v", epoch) + } + + cronEvents = append(cronEvents, epochEvents...) + + if len(epochEvents) > 0 { + err = st.clearCronEvents(store, epoch) + if err != nil { + return errors.Wrapf(err, "failed to clear cron events at %v", epoch) + } + } + } + + st.LastEpochTick = rtEpoch + return nil + }) + failedMinerCrons := make([]addr.Address, 0) + for _, event := range cronEvents { + _, code := rt.Send( + event.MinerAddr, + builtin.MethodsMiner.OnDeferredCronEvent, + vmr.CBORBytes(event.CallbackPayload), + abi.NewTokenAmount(0), + ) + // If a callback fails, this actor continues to invoke other callbacks + // and persists state removing the failed event from the event queue. It won't be tried again. + // Failures are unexpected here but will result in removal of miner power + // A log message would really help here. + if code != exitcode.Ok { + rt.Log(vmr.WARN, "OnDeferredCronEvent failed for miner %s: exitcode %d", event.MinerAddr, code) + failedMinerCrons = append(failedMinerCrons, event.MinerAddr) + } + } + rt.State().Transaction(&st, func() interface{} { + store := adt.AsStore(rt) + // Remove power and leave miner frozen + for _, minerAddr := range failedMinerCrons { + claim, found, err := st.GetClaim(store, minerAddr) + if err != nil { + rt.Log(vmr.ERROR, "failed to get claim for miner %s after failing OnDeferredCronEvent: %s", minerAddr, err) + continue + } + if !found { + rt.Log(vmr.WARN, "miner OnDeferredCronEvent failed for miner %s with no power", minerAddr) + continue + } + + // zero out miner power + err = st.AddToClaim(store, minerAddr, claim.RawBytePower.Neg(), claim.QualityAdjPower.Neg()) + if err != nil { + rt.Log(vmr.WARN, "failed to remove (%d, %d) power for miner %s after to failed cron", claim.RawBytePower, claim.QualityAdjPower, minerAddr) + continue + } + } + return nil + }) + return nil +} + +func (a Actor) deleteMinerActor(rt Runtime, miner addr.Address) error { + var st State + var err error + rt.State().Transaction(&st, func() interface{} { + err = st.deleteClaim(adt.AsStore(rt), miner) + if err != nil { + err = errors.Wrapf(err, "failed to delete %v from claimed power table", miner) + return nil + } + + st.MinerCount -= 1 + return nil + }) + return err +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_state.go new file mode 100644 index 000000000..d2ec9f963 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_state.go @@ -0,0 +1,269 @@ +package power + +import ( + "reflect" + + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + . "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type State struct { + TotalRawBytePower abi.StoragePower + // TotalBytesCommitted includes claims from miners below min power threshold + TotalBytesCommitted abi.StoragePower + TotalQualityAdjPower abi.StoragePower + // TotalQABytesCommitted includes claims from miners below min power threshold + TotalQABytesCommitted abi.StoragePower + TotalPledgeCollateral abi.TokenAmount + MinerCount int64 + // Number of miners having proven the minimum consensus power. + MinerAboveMinPowerCount int64 + + // A queue of events to be triggered by cron, indexed by epoch. + CronEventQueue cid.Cid // Multimap, (HAMT[ChainEpoch]AMT[CronEvent] + + // Last chain epoch OnEpochTickEnd was called on + LastEpochTick abi.ChainEpoch + + // Claimed power for each miner. + Claims cid.Cid // Map, HAMT[address]Claim + + ProofValidationBatch *cid.Cid +} + +type Claim struct { + // Sum of raw byte power for a miner's sectors. + RawBytePower abi.StoragePower + + // Sum of quality adjusted power for a miner's sectors. + QualityAdjPower abi.StoragePower +} + +type CronEvent struct { + MinerAddr addr.Address + CallbackPayload []byte +} + +type AddrKey = adt.AddrKey + +func ConstructState(emptyMapCid, emptyMMapCid cid.Cid) *State { + return &State{ + TotalRawBytePower: abi.NewStoragePower(0), + TotalBytesCommitted: abi.NewStoragePower(0), + TotalQualityAdjPower: abi.NewStoragePower(0), + TotalQABytesCommitted: abi.NewStoragePower(0), + TotalPledgeCollateral: abi.NewTokenAmount(0), + LastEpochTick: -1, + CronEventQueue: emptyMapCid, + Claims: emptyMapCid, + MinerCount: 0, + MinerAboveMinPowerCount: 0, + } +} + +// MinerNominalPowerMeetsConsensusMinimum is used to validate Election PoSt +// winners outside the chain state. If the miner has over a threshold of power +// the miner meets the minimum. If the network is a below a threshold of +// miners and has power > zero the miner meets the minimum. +func (st *State) MinerNominalPowerMeetsConsensusMinimum(s adt.Store, miner addr.Address) (bool, error) { //nolint:deadcode,unused + claim, ok, err := st.GetClaim(s, miner) + if err != nil { + return false, err + } + if !ok { + return false, errors.Errorf("no claim for actor %v", miner) + } + + minerNominalPower := claim.QualityAdjPower + + // if miner is larger than min power requirement, we're set + if minerNominalPower.GreaterThanEqual(ConsensusMinerMinPower) { + return true, nil + } + + // otherwise, if ConsensusMinerMinMiners miners meet min power requirement, return false + if st.MinerAboveMinPowerCount > ConsensusMinerMinMiners { + return false, nil + } + + // If fewer than ConsensusMinerMinMiners over threshold miner can win a block with non-zero power + return minerNominalPower.GreaterThanEqual(abi.NewStoragePower(0)), nil +} + +// Parameters may be negative to subtract. +func (st *State) AddToClaim(s adt.Store, miner addr.Address, power abi.StoragePower, qapower abi.StoragePower) error { + oldClaim, ok, err := st.GetClaim(s, miner) + if err != nil { + return err + } + if !ok { + return errors.Errorf("no claim for actor %v", miner) + } + + // TotalBytes always update directly + st.TotalQABytesCommitted = big.Add(st.TotalQABytesCommitted, qapower) + st.TotalBytesCommitted = big.Add(st.TotalBytesCommitted, power) + + newClaim := Claim{ + RawBytePower: big.Add(oldClaim.RawBytePower, power), + QualityAdjPower: big.Add(oldClaim.QualityAdjPower, qapower), + } + + prevBelow := oldClaim.QualityAdjPower.LessThan(ConsensusMinerMinPower) + stillBelow := newClaim.QualityAdjPower.LessThan(ConsensusMinerMinPower) + + if prevBelow && !stillBelow { + // just passed min miner size + st.MinerAboveMinPowerCount++ + st.TotalQualityAdjPower = big.Add(st.TotalQualityAdjPower, newClaim.QualityAdjPower) + st.TotalRawBytePower = big.Add(st.TotalRawBytePower, newClaim.RawBytePower) + } else if !prevBelow && stillBelow { + // just went below min miner size + st.MinerAboveMinPowerCount-- + st.TotalQualityAdjPower = big.Sub(st.TotalQualityAdjPower, oldClaim.QualityAdjPower) + st.TotalRawBytePower = big.Sub(st.TotalRawBytePower, oldClaim.RawBytePower) + } else if !prevBelow && !stillBelow { + // Was above the threshold, still above + st.TotalQualityAdjPower = big.Add(st.TotalQualityAdjPower, qapower) + st.TotalRawBytePower = big.Add(st.TotalRawBytePower, power) + } + + AssertMsg(newClaim.RawBytePower.GreaterThanEqual(big.Zero()), "negative claimed raw byte power: %v", newClaim.RawBytePower) + AssertMsg(newClaim.QualityAdjPower.GreaterThanEqual(big.Zero()), "negative claimed quality adjusted power: %v", newClaim.QualityAdjPower) + AssertMsg(st.MinerAboveMinPowerCount >= 0, "negative number of miners larger than min: %v", st.MinerAboveMinPowerCount) + return st.setClaim(s, miner, &newClaim) +} + +func (st *State) GetClaim(s adt.Store, a addr.Address) (*Claim, bool, error) { + hm, err := adt.AsMap(s, st.Claims) + if err != nil { + return nil, false, err + } + + var out Claim + found, err := hm.Get(AddrKey(a), &out) + if err != nil { + return nil, false, errors.Wrapf(err, "failed to get claim for address %v from store %s", a, st.Claims) + } + if !found { + return nil, false, nil + } + return &out, true, nil +} + +func (st *State) addPledgeTotal(amount abi.TokenAmount) { + st.TotalPledgeCollateral = big.Add(st.TotalPledgeCollateral, amount) + Assert(st.TotalPledgeCollateral.GreaterThanEqual(big.Zero())) +} + +func (st *State) appendCronEvent(store adt.Store, epoch abi.ChainEpoch, event *CronEvent) error { + mmap, err := adt.AsMultimap(store, st.CronEventQueue) + if err != nil { + return err + } + + err = mmap.Add(epochKey(epoch), event) + if err != nil { + return errors.Wrapf(err, "failed to store cron event at epoch %v for miner %v", epoch, event) + } + st.CronEventQueue, err = mmap.Root() + if err != nil { + return err + } + return nil +} + +func (st *State) loadCronEvents(store adt.Store, epoch abi.ChainEpoch) ([]CronEvent, error) { + mmap, err := adt.AsMultimap(store, st.CronEventQueue) + if err != nil { + return nil, err + } + + var events []CronEvent + var ev CronEvent + err = mmap.ForEach(epochKey(epoch), &ev, func(i int64) error { + events = append(events, ev) + return nil + }) + return events, err +} + +func (st *State) clearCronEvents(store adt.Store, epoch abi.ChainEpoch) error { + mmap, err := adt.AsMultimap(store, st.CronEventQueue) + if err != nil { + return err + } + + err = mmap.RemoveAll(epochKey(epoch)) + if err != nil { + return errors.Wrapf(err, "failed to clear cron events") + } + st.CronEventQueue, err = mmap.Root() + if err != nil { + return err + } + return nil +} + +func (st *State) setClaim(s adt.Store, a addr.Address, claim *Claim) error { + Assert(claim.RawBytePower.GreaterThanEqual(big.Zero())) + Assert(claim.QualityAdjPower.GreaterThanEqual(big.Zero())) + + hm, err := adt.AsMap(s, st.Claims) + if err != nil { + return err + } + + if err = hm.Put(AddrKey(a), claim); err != nil { + return errors.Wrapf(err, "failed to put claim with address %s power %v in store %s", a, claim, st.Claims) + } + + st.Claims, err = hm.Root() + if err != nil { + return err + } + return nil +} + +func (st *State) deleteClaim(s adt.Store, a addr.Address) error { + hm, err := adt.AsMap(s, st.Claims) + if err != nil { + return err + } + + if err = hm.Delete(AddrKey(a)); err != nil { + return errors.Wrapf(err, "failed to delete claim at address %s from store %s", a, st.Claims) + } + st.Claims, err = hm.Root() + if err != nil { + return err + } + return nil +} + +// CurrentTotalPower returns current power values accounting for minimum miner +// and minimum power +func CurrentTotalPower(st *State) (abi.StoragePower, abi.StoragePower) { + if st.MinerAboveMinPowerCount < ConsensusMinerMinMiners { + return st.TotalBytesCommitted, st.TotalQABytesCommitted + } + return st.TotalRawBytePower, st.TotalQualityAdjPower +} + +func epochKey(e abi.ChainEpoch) adt.Keyer { + return adt.IntKey(int64(e)) +} + +func init() { + // Check that ChainEpoch is indeed a signed integer to confirm that epochKey is making the right interpretation. + var e abi.ChainEpoch + if reflect.TypeOf(e).Kind() != reflect.Int64 { + panic("incorrect chain epoch encoding") + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_test.go new file mode 100644 index 000000000..b58f740f5 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/power/power_test.go @@ -0,0 +1,528 @@ +package power_test + +import ( + "bytes" + "context" + "strconv" + "testing" + + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + assert "github.com/stretchr/testify/assert" + require "github.com/stretchr/testify/require" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + initact "github.com/filecoin-project/specs-actors/actors/builtin/init" + power "github.com/filecoin-project/specs-actors/actors/builtin/power" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" + mock "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, power.Actor{}) +} + +func TestConstruction(t *testing.T) { + actor := newHarness(t) + owner := tutil.NewIDAddr(t, 101) + miner := tutil.NewIDAddr(t, 103) + actr := tutil.NewActorAddr(t, "actor") + + builder := mock.NewBuilder(context.Background(), builtin.StoragePowerActorAddr).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("simple construction", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + }) + + t.Run("create miner", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + actor.createMiner(rt, owner, owner, miner, actr, abi.PeerID("miner"), []abi.Multiaddrs{{1}}, abi.RegisteredSealProof_StackedDrg2KiBV1, abi.NewTokenAmount(10)) + + var st power.State + rt.GetState(&st) + assert.Equal(t, int64(1), st.MinerCount) + assert.Equal(t, abi.NewStoragePower(0), st.TotalQualityAdjPower) + assert.Equal(t, abi.NewStoragePower(0), st.TotalRawBytePower) + assert.Equal(t, int64(0), st.MinerAboveMinPowerCount) + + claim, err := adt.AsMap(adt.AsStore(rt), st.Claims) + assert.NoError(t, err) + keys, err := claim.CollectKeys() + require.NoError(t, err) + assert.Equal(t, 1, len(keys)) + var actualClaim power.Claim + found, err_ := claim.Get(asKey(keys[0]), &actualClaim) + require.NoError(t, err_) + assert.True(t, found) + assert.Equal(t, power.Claim{big.Zero(), big.Zero()}, actualClaim) // miner has not proven anything + + verifyEmptyMap(t, rt, st.CronEventQueue) + }) +} + +func TestPowerAndPledgeAccounting(t *testing.T) { + actor := newHarness(t) + owner := tutil.NewIDAddr(t, 101) + miner1 := tutil.NewIDAddr(t, 111) + miner2 := tutil.NewIDAddr(t, 112) + miner3 := tutil.NewIDAddr(t, 113) + miner4 := tutil.NewIDAddr(t, 114) + miner5 := tutil.NewIDAddr(t, 115) + + // These tests use the min power for consensus to check the accounting above and below that value. + powerUnit := power.ConsensusMinerMinPower + mul := func(a big.Int, b int64) big.Int { + return big.Mul(a, big.NewInt(b)) + } + div := func(a big.Int, b int64) big.Int { + return big.Div(a, big.NewInt(b)) + } + smallPowerUnit := big.NewInt(1_000_000) + require.True(t, smallPowerUnit.LessThan(powerUnit), "power.CosensusMinerMinPower has changed requiring update to this test") + // Subtests implicitly rely on ConsensusMinerMinMiners = 3 + require.Equal(t, 3, power.ConsensusMinerMinMiners) + + builder := mock.NewBuilder(context.Background(), builtin.StoragePowerActorAddr). + WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("power & pledge accounted below threshold", func(t *testing.T) { + + rt := builder.Build(t) + actor.constructAndVerify(rt) + + actor.createMinerBasic(rt, owner, owner, miner1) + actor.createMinerBasic(rt, owner, owner, miner2) + + ret := actor.currentPowerTotal(rt) + assert.Equal(t, big.Zero(), ret.RawBytePower) + assert.Equal(t, big.Zero(), ret.QualityAdjPower) + assert.Equal(t, big.Zero(), ret.PledgeCollateral) + + // Add power for miner1 + actor.updateClaimedPower(rt, miner1, smallPowerUnit, mul(smallPowerUnit, 2)) + ret = actor.currentPowerTotal(rt) + assert.Equal(t, smallPowerUnit, ret.RawBytePower) + assert.Equal(t, mul(smallPowerUnit, 2), ret.QualityAdjPower) + assert.Equal(t, big.Zero(), ret.PledgeCollateral) + + // Add power and pledge for miner2 + actor.updateClaimedPower(rt, miner2, smallPowerUnit, smallPowerUnit) + actor.updatePledgeTotal(rt, miner1, abi.NewTokenAmount(1e6)) + ret = actor.currentPowerTotal(rt) + assert.Equal(t, mul(smallPowerUnit, 2), ret.RawBytePower) + assert.Equal(t, mul(smallPowerUnit, 3), ret.QualityAdjPower) + assert.Equal(t, abi.NewTokenAmount(1e6), ret.PledgeCollateral) + + rt.Verify() + + // Verify claims in state. + var st power.State + rt.GetState(&st) + claim1, found, err := st.GetClaim(rt.AdtStore(), miner1) + require.NoError(t, err) + require.True(t, found) + require.Equal(t, smallPowerUnit, claim1.RawBytePower) + require.Equal(t, mul(smallPowerUnit, 2), claim1.QualityAdjPower) + + claim2, found, err := st.GetClaim(rt.AdtStore(), miner2) + require.NoError(t, err) + require.True(t, found) + require.Equal(t, smallPowerUnit, claim2.RawBytePower) + require.Equal(t, smallPowerUnit, claim2.QualityAdjPower) + + // Subtract power and some pledge for miner2 + actor.updateClaimedPower(rt, miner2, smallPowerUnit.Neg(), smallPowerUnit.Neg()) + actor.updatePledgeTotal(rt, miner2, abi.NewTokenAmount(1e5).Neg()) + ret = actor.currentPowerTotal(rt) + assert.Equal(t, mul(smallPowerUnit, 1), ret.RawBytePower) + assert.Equal(t, mul(smallPowerUnit, 2), ret.QualityAdjPower) + assert.Equal(t, abi.NewTokenAmount(9e5), ret.PledgeCollateral) + + rt.GetState(&st) + claim2, found, err = st.GetClaim(rt.AdtStore(), miner2) + require.NoError(t, err) + require.True(t, found) + require.Equal(t, big.Zero(), claim2.RawBytePower) + require.Equal(t, big.Zero(), claim2.QualityAdjPower) + }) + + t.Run("power accounting crossing threshold", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + actor.createMinerBasic(rt, owner, owner, miner1) + actor.createMinerBasic(rt, owner, owner, miner2) + actor.createMinerBasic(rt, owner, owner, miner3) + actor.createMinerBasic(rt, owner, owner, miner4) + actor.createMinerBasic(rt, owner, owner, miner5) + + actor.updateClaimedPower(rt, miner1, div(smallPowerUnit, 2), smallPowerUnit) + actor.updateClaimedPower(rt, miner2, div(smallPowerUnit, 2), smallPowerUnit) + actor.updateClaimedPower(rt, miner3, div(smallPowerUnit, 2), smallPowerUnit) + + actor.updateClaimedPower(rt, miner4, div(powerUnit, 2), powerUnit) + actor.updateClaimedPower(rt, miner5, div(powerUnit, 2), powerUnit) + + // Below threshold small miner power is counted + expectedTotalBelow := big.Sum(mul(smallPowerUnit, 3), mul(powerUnit, 2)) + actor.expectTotalPower(rt, div(expectedTotalBelow, 2), expectedTotalBelow) + + // Above threshold (power.ConsensusMinerMinMiners = 3) small miner power is ignored + delta := big.Sub(powerUnit, smallPowerUnit) + actor.updateClaimedPower(rt, miner3, div(delta, 2), delta) + expectedTotalAbove := mul(powerUnit, 3) + actor.expectTotalPower(rt, div(expectedTotalAbove, 2), expectedTotalAbove) + + st := getState(rt) + assert.Equal(t, int64(3), st.MinerAboveMinPowerCount) + + // Less than 3 miners above threshold again small miner power is counted again + + actor.updateClaimedPower(rt, miner3, div(delta.Neg(), 2), delta.Neg()) + actor.expectTotalPower(rt, div(expectedTotalBelow, 2), expectedTotalBelow) + }) + + t.Run("all of one miner's power dissapears when that miner dips below min power threshold", func(t *testing.T) { + // Setup four miners above threshold + rt := builder.Build(t) + actor.constructAndVerify(rt) + + actor.createMinerBasic(rt, owner, owner, miner1) + actor.createMinerBasic(rt, owner, owner, miner2) + actor.createMinerBasic(rt, owner, owner, miner3) + actor.createMinerBasic(rt, owner, owner, miner4) + + actor.updateClaimedPower(rt, miner1, powerUnit, powerUnit) + actor.updateClaimedPower(rt, miner2, powerUnit, powerUnit) + actor.updateClaimedPower(rt, miner3, powerUnit, powerUnit) + actor.updateClaimedPower(rt, miner4, powerUnit, powerUnit) + + expectedTotal := mul(powerUnit, 4) + actor.expectTotalPower(rt, expectedTotal, expectedTotal) + + // miner4 dips just below threshold + actor.updateClaimedPower(rt, miner4, smallPowerUnit.Neg(), smallPowerUnit.Neg()) + + expectedTotal = mul(powerUnit, 3) + actor.expectTotalPower(rt, expectedTotal, expectedTotal) + }) + + t.Run("threshold only depends on qa power, not raw byte", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + actor.createMinerBasic(rt, owner, owner, miner1) + actor.createMinerBasic(rt, owner, owner, miner2) + actor.createMinerBasic(rt, owner, owner, miner3) + + actor.updateClaimedPower(rt, miner1, powerUnit, big.Zero()) + actor.updateClaimedPower(rt, miner2, powerUnit, big.Zero()) + actor.updateClaimedPower(rt, miner3, powerUnit, big.Zero()) + st := getState(rt) + assert.Equal(t, int64(0), st.MinerAboveMinPowerCount) + + actor.updateClaimedPower(rt, miner1, big.Zero(), powerUnit) + actor.updateClaimedPower(rt, miner2, big.Zero(), powerUnit) + actor.updateClaimedPower(rt, miner3, big.Zero(), powerUnit) + st = getState(rt) + assert.Equal(t, int64(3), st.MinerAboveMinPowerCount) + }) + + t.Run("slashing miner that is already below minimum does not impact power", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + actor.createMinerBasic(rt, owner, owner, miner1) + actor.createMinerBasic(rt, owner, owner, miner2) + actor.createMinerBasic(rt, owner, owner, miner3) + + actor.updateClaimedPower(rt, miner1, powerUnit, powerUnit) + actor.updateClaimedPower(rt, miner2, powerUnit, powerUnit) + actor.updateClaimedPower(rt, miner3, powerUnit, powerUnit) + + // create small miner + actor.createMinerBasic(rt, owner, owner, miner4) + + actor.updateClaimedPower(rt, miner4, smallPowerUnit, smallPowerUnit) + + actor.expectTotalPower(rt, mul(powerUnit, 3), mul(powerUnit, 3)) + + // fault small miner + zeroPledge := abi.NewTokenAmount(0) + actor.onConsensusFault(rt, miner4, &zeroPledge) + + // power unchanged + actor.expectTotalPower(rt, mul(powerUnit, 3), mul(powerUnit, 3)) + + }) +} + +func TestCron(t *testing.T) { + actor := newHarness(t) + miner1 := tutil.NewIDAddr(t, 101) + miner2 := tutil.NewIDAddr(t, 102) + owner := tutil.NewIDAddr(t, 103) + + builder := mock.NewBuilder(context.Background(), builtin.StoragePowerActorAddr).WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("calls reward actor", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + expectedPower := big.NewInt(0) + rt.SetEpoch(1) + rt.ExpectValidateCallerAddr(builtin.CronActorAddr) + rt.ExpectSend(builtin.RewardActorAddr, builtin.MethodsReward.UpdateNetworkKPI, &expectedPower, abi.NewTokenAmount(0), nil, 0) + rt.SetCaller(builtin.CronActorAddr, builtin.CronActorCodeID) + rt.Call(actor.Actor.OnEpochTickEnd, nil) + rt.Verify() + }) + + t.Run("event scheduled in null round called next round", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + // 0 - genesis + // 1 - block - registers events + // 2 - null - has event + // 3 - null + // 4 - block - has event + + rt.SetEpoch(1) + actor.enrollCronEvent(rt, miner1, 2, []byte{0x1, 0x3}) + actor.enrollCronEvent(rt, miner2, 4, []byte{0x2, 0x3}) + + expectedRawBytePower := big.NewInt(0) + rt.SetEpoch(4) + rt.ExpectValidateCallerAddr(builtin.CronActorAddr) + rt.ExpectSend(miner1, builtin.MethodsMiner.OnDeferredCronEvent, vmr.CBORBytes([]byte{0x1, 0x3}), big.Zero(), nil, exitcode.Ok) + rt.ExpectSend(miner2, builtin.MethodsMiner.OnDeferredCronEvent, vmr.CBORBytes([]byte{0x2, 0x3}), big.Zero(), nil, exitcode.Ok) + rt.ExpectSend(builtin.RewardActorAddr, builtin.MethodsReward.UpdateNetworkKPI, &expectedRawBytePower, big.Zero(), nil, exitcode.Ok) + rt.SetCaller(builtin.CronActorAddr, builtin.CronActorCodeID) + rt.Call(actor.Actor.OnEpochTickEnd, nil) + rt.Verify() + }) + + t.Run("handles failed call", func(t *testing.T) { + rt := builder.Build(t) + actor.constructAndVerify(rt) + + rt.SetEpoch(1) + actor.enrollCronEvent(rt, miner1, 2, []byte{}) + actor.enrollCronEvent(rt, miner2, 2, []byte{}) + + actor.createMinerBasic(rt, owner, owner, miner1) + actor.createMinerBasic(rt, owner, owner, miner2) + + rawPow := power.ConsensusMinerMinPower + qaPow := rawPow + actor.updateClaimedPower(rt, miner1, rawPow, qaPow) + startPow := actor.currentPowerTotal(rt) + assert.Equal(t, rawPow, startPow.RawBytePower) + assert.Equal(t, qaPow, startPow.QualityAdjPower) + + expectedPower := big.NewInt(0) + rt.SetEpoch(2) + rt.ExpectValidateCallerAddr(builtin.CronActorAddr) + // First send fails + rt.ExpectSend(miner1, builtin.MethodsMiner.OnDeferredCronEvent, vmr.CBORBytes([]byte{}), big.Zero(), nil, exitcode.ErrIllegalState) + // Subsequent one still invoked + rt.ExpectSend(miner2, builtin.MethodsMiner.OnDeferredCronEvent, vmr.CBORBytes([]byte{}), big.Zero(), nil, exitcode.Ok) + // Reward actor still invoked + rt.ExpectSend(builtin.RewardActorAddr, builtin.MethodsReward.UpdateNetworkKPI, &expectedPower, big.Zero(), nil, exitcode.Ok) + rt.SetCaller(builtin.CronActorAddr, builtin.CronActorCodeID) + rt.Call(actor.Actor.OnEpochTickEnd, nil) + rt.Verify() + + // expect cron failure was logged + rt.ExpectLogsContain("OnDeferredCronEvent failed for miner") + + newPow := actor.currentPowerTotal(rt) + assert.Equal(t, abi.NewStoragePower(0), newPow.RawBytePower) + assert.Equal(t, abi.NewStoragePower(0), newPow.QualityAdjPower) + + // Next epoch, only the reward actor is invoked + rt.SetEpoch(3) + rt.ExpectValidateCallerAddr(builtin.CronActorAddr) + rt.ExpectSend(builtin.RewardActorAddr, builtin.MethodsReward.UpdateNetworkKPI, &expectedPower, big.Zero(), nil, exitcode.Ok) + rt.SetCaller(builtin.CronActorAddr, builtin.CronActorCodeID) + rt.Call(actor.Actor.OnEpochTickEnd, nil) + rt.Verify() + }) +} + +// +// Misc. Utility Functions +// + +type key string + +func asKey(in string) adt.Keyer { + return key(in) +} + +func verifyEmptyMap(t testing.TB, rt *mock.Runtime, cid cid.Cid) { + mapChecked, err := adt.AsMap(adt.AsStore(rt), cid) + assert.NoError(t, err) + keys, err := mapChecked.CollectKeys() + require.NoError(t, err) + assert.Empty(t, keys) +} + +type spActorHarness struct { + power.Actor + t *testing.T + minerSeq int +} + +func newHarness(t *testing.T) *spActorHarness { + return &spActorHarness{ + Actor: power.Actor{}, + t: t, + } +} + +func (h *spActorHarness) constructAndVerify(rt *mock.Runtime) { + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + ret := rt.Call(h.Actor.Constructor, nil) + assert.Nil(h.t, ret) + rt.Verify() + + var st power.State + rt.GetState(&st) + assert.Equal(h.t, abi.NewStoragePower(0), st.TotalRawBytePower) + assert.Equal(h.t, abi.NewStoragePower(0), st.TotalBytesCommitted) + assert.Equal(h.t, abi.NewStoragePower(0), st.TotalQualityAdjPower) + assert.Equal(h.t, abi.NewStoragePower(0), st.TotalQABytesCommitted) + assert.Equal(h.t, abi.NewTokenAmount(0), st.TotalPledgeCollateral) + assert.Equal(h.t, abi.ChainEpoch(-1), st.LastEpochTick) + assert.Equal(h.t, int64(0), st.MinerCount) + assert.Equal(h.t, int64(0), st.MinerAboveMinPowerCount) + + verifyEmptyMap(h.t, rt, st.Claims) + verifyEmptyMap(h.t, rt, st.CronEventQueue) +} + +func (h *spActorHarness) createMiner(rt *mock.Runtime, owner, worker, miner, robust addr.Address, peer abi.PeerID, + multiaddrs []abi.Multiaddrs, sealProofType abi.RegisteredSealProof, value abi.TokenAmount) { + createMinerParams := &power.CreateMinerParams{ + Owner: owner, + Worker: worker, + SealProofType: sealProofType, + Peer: peer, + Multiaddrs: multiaddrs, + } + + // owner send CreateMiner to Actor + rt.SetCaller(owner, builtin.AccountActorCodeID) + rt.SetReceived(value) + rt.SetBalance(value) + rt.ExpectValidateCallerType(builtin.AccountActorCodeID, builtin.MultisigActorCodeID) + + createMinerRet := &power.CreateMinerReturn{ + IDAddress: miner, // miner actor id address + RobustAddress: robust, // should be long miner actor address + } + + msgParams := &initact.ExecParams{ + CodeCID: builtin.StorageMinerActorCodeID, + ConstructorParams: initCreateMinerBytes(h.t, owner, worker, peer, multiaddrs, sealProofType), + } + rt.ExpectSend(builtin.InitActorAddr, builtin.MethodsInit.Exec, msgParams, value, createMinerRet, 0) + rt.Call(h.Actor.CreateMiner, createMinerParams) + rt.Verify() +} + +func (h *spActorHarness) createMinerBasic(rt *mock.Runtime, owner, worker, miner addr.Address) { + label := strconv.Itoa(h.minerSeq) + actrAddr := tutil.NewActorAddr(h.t, label) + h.minerSeq += 1 + h.createMiner(rt, owner, worker, miner, actrAddr, abi.PeerID(label), nil, abi.RegisteredSealProof_StackedDrg2KiBV1, big.Zero()) +} + +func (h *spActorHarness) updateClaimedPower(rt *mock.Runtime, miner addr.Address, rawDelta, qaDelta abi.StoragePower) { + params := power.UpdateClaimedPowerParams{ + RawByteDelta: rawDelta, + QualityAdjustedDelta: qaDelta, + } + rt.SetCaller(miner, builtin.StorageMinerActorCodeID) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.Call(h.UpdateClaimedPower, ¶ms) + rt.Verify() +} + +func (h *spActorHarness) updatePledgeTotal(rt *mock.Runtime, miner addr.Address, delta abi.TokenAmount) { + rt.SetCaller(miner, builtin.StorageMinerActorCodeID) + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.Call(h.UpdatePledgeTotal, &delta) + rt.Verify() +} + +func (h *spActorHarness) currentPowerTotal(rt *mock.Runtime) *power.CurrentTotalPowerReturn { + rt.ExpectValidateCallerAny() + ret := rt.Call(h.CurrentTotalPower, nil).(*power.CurrentTotalPowerReturn) + rt.Verify() + return ret +} + +func (h *spActorHarness) enrollCronEvent(rt *mock.Runtime, miner addr.Address, epoch abi.ChainEpoch, payload []byte) { + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(miner, builtin.StorageMinerActorCodeID) + rt.Call(h.Actor.EnrollCronEvent, &power.EnrollCronEventParams{ + EventEpoch: epoch, + Payload: payload, + }) + rt.Verify() +} + +func (h *spActorHarness) onConsensusFault(rt *mock.Runtime, minerAddr addr.Address, pledgeAmount *abi.TokenAmount) { + rt.ExpectValidateCallerType(builtin.StorageMinerActorCodeID) + rt.SetCaller(minerAddr, builtin.StorageMinerActorCodeID) + rt.Call(h.Actor.OnConsensusFault, pledgeAmount) + rt.Verify() + + // verify that miner claim is erased from state + st := getState(rt) + _, found, err := st.GetClaim(rt.AdtStore(), minerAddr) + require.NoError(h.t, err) + require.False(h.t, found) +} + + +func (h *spActorHarness) expectTotalPower(rt *mock.Runtime, expectedRaw, expectedQA abi.StoragePower) { + ret := h.currentPowerTotal(rt) + assert.Equal(h.t, expectedRaw, ret.RawBytePower) + assert.Equal(h.t, expectedQA, ret.QualityAdjPower) +} + +func initCreateMinerBytes(t testing.TB, owner, worker addr.Address, peer abi.PeerID, multiaddrs []abi.Multiaddrs, sealProofType abi.RegisteredSealProof) []byte { + params := &power.MinerConstructorParams{ + OwnerAddr: owner, + WorkerAddr: worker, + SealProofType: sealProofType, + PeerId: peer, + Multiaddrs: multiaddrs, + } + + buf := new(bytes.Buffer) + require.NoError(t, params.MarshalCBOR(buf)) + return buf.Bytes() +} + +func (s key) Key() string { + return string(s) +} + +func getState(rt *mock.Runtime) *power.State { + var st power.State + rt.GetState(&st) + return &st +} \ No newline at end of file diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/cbor_gen.go new file mode 100644 index 000000000..f352db9b4 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/cbor_gen.go @@ -0,0 +1,298 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package reward + +import ( + "fmt" + "io" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{137}); err != nil { + return err + } + + // t.BaselinePower (big.Int) (struct) + if err := t.BaselinePower.MarshalCBOR(w); err != nil { + return err + } + + // t.RealizedPower (big.Int) (struct) + if err := t.RealizedPower.MarshalCBOR(w); err != nil { + return err + } + + // t.CumsumBaseline (big.Int) (struct) + if err := t.CumsumBaseline.MarshalCBOR(w); err != nil { + return err + } + + // t.CumsumRealized (big.Int) (struct) + if err := t.CumsumRealized.MarshalCBOR(w); err != nil { + return err + } + + // t.EffectiveNetworkTime (big.Int) (struct) + if err := t.EffectiveNetworkTime.MarshalCBOR(w); err != nil { + return err + } + + // t.SimpleSupply (big.Int) (struct) + if err := t.SimpleSupply.MarshalCBOR(w); err != nil { + return err + } + + // t.BaselineSupply (big.Int) (struct) + if err := t.BaselineSupply.MarshalCBOR(w); err != nil { + return err + } + + // t.ThisEpochReward (big.Int) (struct) + if err := t.ThisEpochReward.MarshalCBOR(w); err != nil { + return err + } + + // t.RewardEpochsPaid (abi.ChainEpoch) (int64) + if t.RewardEpochsPaid >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.RewardEpochsPaid))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.RewardEpochsPaid)-1)); err != nil { + return err + } + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 9 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.BaselinePower (big.Int) (struct) + + { + + if err := t.BaselinePower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.BaselinePower: %w", err) + } + + } + // t.RealizedPower (big.Int) (struct) + + { + + if err := t.RealizedPower.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RealizedPower: %w", err) + } + + } + // t.CumsumBaseline (big.Int) (struct) + + { + + if err := t.CumsumBaseline.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.CumsumBaseline: %w", err) + } + + } + // t.CumsumRealized (big.Int) (struct) + + { + + if err := t.CumsumRealized.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.CumsumRealized: %w", err) + } + + } + // t.EffectiveNetworkTime (big.Int) (struct) + + { + + if err := t.EffectiveNetworkTime.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.EffectiveNetworkTime: %w", err) + } + + } + // t.SimpleSupply (big.Int) (struct) + + { + + if err := t.SimpleSupply.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.SimpleSupply: %w", err) + } + + } + // t.BaselineSupply (big.Int) (struct) + + { + + if err := t.BaselineSupply.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.BaselineSupply: %w", err) + } + + } + // t.ThisEpochReward (big.Int) (struct) + + { + + if err := t.ThisEpochReward.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.ThisEpochReward: %w", err) + } + + } + // t.RewardEpochsPaid (abi.ChainEpoch) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.RewardEpochsPaid = abi.ChainEpoch(extraI) + } + return nil +} + +func (t *AwardBlockRewardParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.Miner (address.Address) (struct) + if err := t.Miner.MarshalCBOR(w); err != nil { + return err + } + + // t.Penalty (big.Int) (struct) + if err := t.Penalty.MarshalCBOR(w); err != nil { + return err + } + + // t.GasReward (big.Int) (struct) + if err := t.GasReward.MarshalCBOR(w); err != nil { + return err + } + + // t.WinCount (int64) (int64) + if t.WinCount >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.WinCount))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.WinCount)-1)); err != nil { + return err + } + } + return nil +} + +func (t *AwardBlockRewardParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Miner (address.Address) (struct) + + { + + if err := t.Miner.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Miner: %w", err) + } + + } + // t.Penalty (big.Int) (struct) + + { + + if err := t.Penalty.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Penalty: %w", err) + } + + } + // t.GasReward (big.Int) (struct) + + { + + if err := t.GasReward.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.GasReward: %w", err) + } + + } + // t.WinCount (int64) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.WinCount = int64(extraI) + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_actor.go new file mode 100644 index 000000000..93562801e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_actor.go @@ -0,0 +1,114 @@ +package reward + +import ( + "github.com/filecoin-project/go-address" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + . "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.AwardBlockReward, + 3: a.ThisEpochReward, + 4: a.UpdateNetworkKPI, + } +} + +var _ abi.Invokee = Actor{} + +func (a Actor) Constructor(rt vmr.Runtime, currRealizedPower *abi.StoragePower) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + + st := ConstructState(currRealizedPower) + rt.State().Create(st) + return nil +} + +type AwardBlockRewardParams struct { + Miner address.Address + Penalty abi.TokenAmount // penalty for including bad messages in a block + GasReward abi.TokenAmount // gas reward from all gas fees in a block + WinCount int64 +} + +// Awards a reward to a block producer. +// This method is called only by the system actor, implicitly, as the last message in the evaluation of a block. +// The system actor thus computes the parameters and attached value. +// +// The reward includes two components: +// - the epoch block reward, computed and paid from the reward actor's balance, +// - the block gas reward, expected to be transferred to the reward actor with this invocation. +// +// The reward is reduced before the residual is credited to the block producer, by: +// - a penalty amount, provided as a parameter, which is burnt, +func (a Actor) AwardBlockReward(rt vmr.Runtime, params *AwardBlockRewardParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + AssertMsg(rt.CurrentBalance().GreaterThanEqual(params.GasReward), + "actor current balance %v insufficient to pay gas reward %v", rt.CurrentBalance(), params.GasReward) + + minerAddr, ok := rt.ResolveAddress(params.Miner) + if !ok { + rt.Abortf(exitcode.ErrIllegalState, "failed to resolve given owner address") + } + + priorBalance := rt.CurrentBalance() + + penalty := abi.NewTokenAmount(0) + var st State + rt.State().Readonly(&st) + blockReward := big.Div(st.ThisEpochReward, big.NewInt(builtin.ExpectedLeadersPerEpoch)) + blockReward = big.Mul(blockReward, big.NewInt(params.WinCount)) + totalReward := big.Add(blockReward, params.GasReward) + + // Cap the penalty at the total reward value. + penalty = big.Min(params.Penalty, totalReward) + + // Reduce the payable reward by the penalty. + rewardPayable := big.Sub(totalReward, penalty) + + AssertMsg(big.Add(rewardPayable, penalty).LessThanEqual(priorBalance), + "reward payable %v + penalty %v exceeds balance %v", rewardPayable, penalty, priorBalance) + + _, code := rt.Send(minerAddr, builtin.MethodsMiner.AddLockedFund, &rewardPayable, rewardPayable) + builtin.RequireSuccess(rt, code, "failed to send reward to miner: %s", minerAddr) + + // Burn the penalty amount. + _, code = rt.Send(builtin.BurntFundsActorAddr, builtin.MethodSend, nil, penalty) + builtin.RequireSuccess(rt, code, "failed to send penalty to burnt funds actor") + + return nil +} + +func (a Actor) ThisEpochReward(rt vmr.Runtime, _ *adt.EmptyValue) *abi.TokenAmount { + rt.ValidateImmediateCallerAcceptAny() + + var st State + rt.State().Readonly(&st) + return &st.ThisEpochReward +} + +// Called at the end of each epoch by the power actor (in turn by its cron hook). +// This is only invoked for non-empty tipsets. The impact of this is that block rewards are paid out over +// a schedule defined by non-empty tipsets, not by elapsed time/epochs. +// This is not necessarily what we want, and may change. +func (a Actor) UpdateNetworkKPI(rt vmr.Runtime, currRealizedPower *abi.StoragePower) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.StoragePowerActorAddr) + + var st State + rt.State().Transaction(&st, func() interface{} { + // By the time this is called, the rewards for this epoch have been paid to miners. + st.RewardEpochsPaid++ + st.updateToNextEpochReward(currRealizedPower) + return nil + }) + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_state.go new file mode 100644 index 000000000..7d3fa5078 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_state.go @@ -0,0 +1,307 @@ +package reward + +import ( + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// Fractional representation of NetworkTime with an implicit denominator of (2^MintingInputFixedPoint). +type NetworkTime = big.Int + +// A quantity of space * time (in byte-epochs) representing power committed to the network for some duration. +type Spacetime = big.Int + +type State struct { + BaselinePower abi.StoragePower + RealizedPower abi.StoragePower + CumsumBaseline Spacetime + CumsumRealized Spacetime + EffectiveNetworkTime NetworkTime + + SimpleSupply abi.TokenAmount // current supply + BaselineSupply abi.TokenAmount // current supply + + // The reward to be paid in total to block producers, if exactly the expected number of them produce a block. + // The actual reward total paid out depends on the number of winners in any round. + // This is computed at the end of the previous epoch, and should really be called ThisEpochReward. + ThisEpochReward abi.TokenAmount + + // The count of epochs for which a reward has been paid. + // This should equal the number of non-empty tipsets after the genesis, aka "chain height". + RewardEpochsPaid abi.ChainEpoch +} + +type AddrKey = adt.AddrKey + +// These numbers are placeholders, but should be in units of attoFIL, 10^-18 FIL +var SimpleTotal = big.Mul(big.NewInt(100e6), big.NewInt(1e18)) // 100M for testnet, PARAM_FINISH +var BaselineTotal = big.Mul(big.NewInt(900e6), big.NewInt(1e18)) // 900M for testnet, PARAM_FINISH + +func ConstructState(currRealizedPower *abi.StoragePower) *State { + st := &State{ + BaselinePower: big.Zero(), + RealizedPower: big.Zero(), + CumsumBaseline: big.Zero(), + CumsumRealized: big.Zero(), + EffectiveNetworkTime: big.Zero(), + + SimpleSupply: big.Zero(), + BaselineSupply: big.Zero(), + ThisEpochReward: big.Zero(), + RewardEpochsPaid: 0, + } + st.updateToNextEpochReward(currRealizedPower) + + return st +} + +// Takes in a current realized power for a reward epoch and computes +// and updates reward state to track reward for the next epoch +func (st *State) updateToNextEpochReward(currRealizedPower *abi.StoragePower) { + st.RealizedPower = *currRealizedPower + + st.BaselinePower = st.newBaselinePower() + st.CumsumBaseline = big.Add(st.CumsumBaseline, st.BaselinePower) + + // Cap realized power in computing CumsumRealized so that progress is only relative to the current epoch. + cappedRealizedPower := big.Min(st.BaselinePower, st.RealizedPower) + st.CumsumRealized = big.Add(st.CumsumRealized, cappedRealizedPower) + + st.EffectiveNetworkTime = st.getEffectiveNetworkTime() + + st.computePerEpochReward() +} + +// Updates the simple/baseline supply state and last epoch reward with computation for for a single epoch. +func (st *State) computePerEpochReward() abi.TokenAmount { + // TODO: PARAM_FINISH + clockTime := st.RewardEpochsPaid + networkTime := st.EffectiveNetworkTime + newSimpleSupply := mintingFunction(SimpleTotal, big.Lsh(big.NewInt(int64(clockTime)), MintingInputFixedPoint)) + newBaselineSupply := mintingFunction(BaselineTotal, networkTime) + + newSimpleMinted := big.Max(big.Sub(newSimpleSupply, st.SimpleSupply), big.Zero()) + newBaselineMinted := big.Max(big.Sub(newBaselineSupply, st.BaselineSupply), big.Zero()) + + // TODO: this isn't actually counting emitted reward, but expected reward (which will generally over-estimate). + // It's difficult to extract this from the minting function in its current form. + // https://github.com/filecoin-project/specs-actors/issues/317 + st.SimpleSupply = newSimpleSupply + st.BaselineSupply = newBaselineSupply + + perEpochReward := big.Add(newSimpleMinted, newBaselineMinted) + st.ThisEpochReward = perEpochReward + + return perEpochReward +} + +const baselinePower = 1 << 50 // 1PiB for testnet, PARAM_FINISH +func (st *State) newBaselinePower() abi.StoragePower { + // TODO: this is not the final baseline function or value, PARAM_FINISH + return big.NewInt(baselinePower) +} + +func (st *State) getEffectiveNetworkTime() NetworkTime { + // TODO: this function depends on the final baseline + // EffectiveNetworkTime is a fractional input with an implicit denominator of (2^MintingInputFixedPoint). + // realizedCumsum is thus left shifted by MintingInputFixedPoint before converted into a FixedPoint fraction + // through division (which is an inverse function for the integral of the baseline). + return big.Div(big.Lsh(st.CumsumRealized, MintingInputFixedPoint), big.NewInt(baselinePower)) +} + +// Minting Function: Taylor series expansion +// +// Intent +// The intent of the following code is to compute the desired fraction of +// coins that should have been minted at a given epoch according to the +// simple exponential decay supply. This function is used both directly, +// to compute simple minting, and indirectly, to compute baseline minting +// by providing a synthetic "effective network time" instead of an actual +// epoch number. The prose specification of the simple exponential decay is +// that the unminted supply should decay exponentially with a half-life of +// 6 years. The formalization of the minted fraction at epoch t is thus: +// +// ( t ) +// ( ------------------------ ) +// ( 1 )^( [# of epochs in 6 years] ) +// f(t) = 1 - ( - ) +// ( 2 ) +// Challenges +// +// 1. Since we cannot rely on floating-point computations in this setting, we +// have resorted to using an ad-hoc fixed-point standard. Experimental +// testing with the relevant scales of inputs and with a desired "atto" +// level of output precision yielded a recommendation of a 97-bit fractional +// part, which was stored in the constant "MintingOutputFixedPoint". +// Fractional input is only necessary when considering "effective network +// time"; there, the desired precision is determined by the minimum +// plausible ratio between realized network power and network baseline, +// which is set in "MintingInputFixedPoint". +// +// !IMPORTANT!: the time input to this function should be a factor of +// 2^MintingInputFixedPoint greater than the semantically intended value, and +// the return value from this function is a factor of 2^MintingOutputFixedPoint +// greater. The semantics of the output value will always be a fraction +// between 0 and 1, but will be represented as an integer between 0 and +// 2^FixedPoint. The expectation is that callers will multiply the result by +// some number, and THEN right-shift the result of the multiplication by +// FixedPoint bits, thus implementing fixed-point multiplication by the +// returned fraction. Analogously, if callers intend to pass in an integer +// "t", it should be left-shifted by MintingInputFixedPoint before being +// passed; if it is fractional, its fractional part should be +// MintingInputFixedPoint bits long. +// +// 2. Since we do not have a math library in this setting, we cannot directly +// implement the intended closed form using stock implementations of +// elementary functions like exp and ln. Not even powf is available. +// Instead, we have manipulated the function into a form with a tractable +// Taylor expansion, and then implemented the fixed-point Taylor expansion +// in an efficient way. +// +// Mathematical Derivation +// +// Note that the function f above is analytically equivalent to: +// +// ( ( 1 ) 1 ) +// ( ln( - ) * ------------------------ * t ) +// ( ( 2 ) [# of epochs in 6 years] ) +// f(t) = 1 - e +// +// We define λ = -ln(1/2)/[# of epochs in 6 years] +// = -ln(1/2)*([Seconds per epoch] / (6 * [Seconds per year])) +// such that +// -λt +// f(t) = 1 - e +// +// Now, we substitute for the exponential its well-known Taylor series at 0: +// +// infinity n +// \```` (-λt) +// f(t) = 1 - > ------ +// /,,,, n! +// n = 0 +// +// Simplifying, and truncating to the empirically necessary precision: +// +// 24 n +// \```` (-1)(-λt) +// f(t) = > ---------- +// /,,,, n! +// n = 1 +// +// This is the final mathematical form of what is computed below. What remains +// is to explain how the series calculation is carried out in fixed-point. +// +// Algorithm +// +// The key observation is that each successive term can be represented as a +// rational number, and derived from the previous term by simple +// multiplications on the numerator and denominator. In particular: +// * the numerator is the previous numerator multiplied by (-λt) +// * the denominator is the previous denominator multiplied by n +// We also need to represent λ itself as a rational, so the denominator of +// the series term is actually multiplied by both n and the denominator of +// lambda. +// +// When we have the numerator and denominator for a given term set up, we +// compute their fixed-point fraction by left-shifting the numerator before +// performing integer division. +// +// Finally, at the end of each loop, we remove unnecessary bits of precision +// from both the numerator and denominator accumulators to control the +// computational complexity of the bigint multiplications. + +// Fixed-point precision (in bits) used for minting function's input "t" +const MintingInputFixedPoint = 30 + +// Fixed-point precision (in bits) used internally and for output +const MintingOutputFixedPoint = 97 + +// The following are the numerator and denominator of -ln(1/2)=ln(2), +// represented as a rational with sufficient precision. They are parsed from +// strings because literals cannot be this long; they are stored as separate +// variables only because the string parsing function has multiple returns. +var LnTwoNum, _ = big.FromString("6931471805599453094172321215") +var LnTwoDen, _ = big.FromString("10000000000000000000000000000") + +// We multiply the fraction ([Seconds per epoch] / (6 * [Seconds per year])) +// into the rational representation of -ln(1/2) which was just loaded, to +// produce the final, constant, rational representation of λ. +var LambdaNum = big.Mul(big.NewInt(builtin.EpochDurationSeconds), LnTwoNum) +var LambdaDen = big.Mul(big.NewInt(6*builtin.SecondsInYear), LnTwoDen) + +// This function implements f(t) as described in the large comment block above, +// with the important caveat that its return value must not be interpreted +// semantically as an integer, but rather as a fixed-point number with +// FixedPoint bits of fractional part. +func taylorSeriesExpansion(lambdaNum big.Int, lambdaDen big.Int, t big.Int) big.Int { + // `numeratorBase` is the numerator of the rational representation of (-λt). + numeratorBase := big.Mul(lambdaNum.Neg(), t) + // The denominator of (-λt) is the denominator of λ times the denominator of t, + // which is a fixed 2^MintingInputFixedPoint. Multiplying by this is a left shift. + denominatorBase := big.Lsh(lambdaDen, MintingInputFixedPoint) + + // `numerator` is the accumulator for numerators of the series terms. The + // first term is simply (-1)(-λt). To include that factor of (-1), which + // appears in every term, we introduce this negation into the numerator of + // the first term. (All terms will be negated by this, because each term is + // derived from the last by multiplying into it.) + numerator := numeratorBase.Neg() + // `denominator` is the accumulator for denominators of the series terms. + denominator := denominatorBase + + // `ret` is an _additive_ accumulator for partial sums of the series, and + // carries a _fixed-point_ representation rather than a rational + // representation. This just means it has an implicit denominator of + // 2^(FixedPoint). + ret := big.Zero() + + // The first term computed has order 1; the final term has order 24. + for n := int64(1); n < int64(25); n++ { + + // Multiplying the denominator by `n` on every loop accounts for the + // `n!` (factorial) in the denominator of the series. + denominator = big.Mul(denominator, big.NewInt(n)) + + // Left-shift and divide to convert rational into fixed-point. + term := big.Div(big.Lsh(numerator, MintingOutputFixedPoint), denominator) + + // Accumulate the fixed-point result into the return accumulator. + ret = big.Add(ret, term) + + // Multiply the rational representation of (-λt) into the term accumulators + // for the next iteration. Doing this here in the loop allows us to save a + // couple bigint operations by initializing numerator and denominator + // directly instead of multiplying by 1. + numerator = big.Mul(numerator, numeratorBase) + denominator = big.Mul(denominator, denominatorBase) + + // If the denominator has grown beyond the necessary precision, then we can + // truncate it by right-shifting. As long as we right-shift the numerator + // by the same number of bits, all we have done is lose unnecessary + // precision that would slow down the next iteration's multiplies. + denominatorLen := big.BitLen(denominator) + unnecessaryBits := denominatorLen - MintingOutputFixedPoint + + numerator = big.Rsh(numerator, unnecessaryBits) + denominator = big.Rsh(denominator, unnecessaryBits) + + } + + return ret +} + +// Minting Function Wrapper +// +// Intent +// The necessary calling conventions for the function above are unwieldy: +// the common case is to supply the canonical Lambda, multiply by some other +// number, and right-shift down by MintingOutputFixedPoint. This convenience +// wrapper implements those conventions. However, it does NOT implement +// left-shifting the input by the MintingInputFixedPoint, because baseline +// minting will actually supply a fractional input. +func mintingFunction(factor big.Int, t big.Int) big.Int { + return big.Rsh(big.Mul(factor, taylorSeriesExpansion(LambdaNum, LambdaDen, t)), MintingOutputFixedPoint) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_state_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_state_test.go new file mode 100644 index 000000000..008dadd9c --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_state_test.go @@ -0,0 +1,67 @@ +package reward + +import ( + "testing" + + "github.com/filecoin-project/specs-actors/actors/abi/big" +) + +// Minting function test vectors +// +// Intent +// Check that for the first 7 years, the current minting function +// approximation is exact to the desired precision, namely 1 attoFIL out of 1 +// gigaFIL. +// +// Approach +// The desired precision is, in particular lg(1e9/1e-18) ≈ 90 bits. +// An offline calculation with arbitrary-precision arithmetic was used to +// establish ground truth about the first 90 bits of the minting function, +// f(t):=1-exp(t*ln(1/2)*SecondsPerEpoch/(6*SecondsPerYear)), for epoch +// numbers corresponding to the endpoints of the first 7 years with +// SecondsPerEpoch set to 30. These numbers were written below as strings, +// because they contain more digits than literals support. + +var mintingTestVectorPrecision = uint(90) + +var mintingTestVectors = []struct { + in int64 + out string +}{ + {1051897, "135060784589637453410950129"}, + {2103794, "255386271058940593613485187"}, + {3155691, "362584098600550296025821387"}, + {4207588, "458086510989070493849325308"}, + {5259485, "543169492437427724953202180"}, + {6311382, "618969815707708523300124489"}, + {7363279, "686500230252085183344830372"}, +} + +const SecondsInYear = 31556925 +const TestEpochDurationSeconds = 30 + +var TestLambdaNum = big.Mul(big.NewInt(TestEpochDurationSeconds), LnTwoNum) +var TestLambdaDen = big.Mul(big.NewInt(6*SecondsInYear), LnTwoDen) + +func TestMintingFunction(t *testing.T) { + for _, vector := range mintingTestVectors { + // In order to supply an integer as an input to the minting function, we + // first left-shift zeroes into the fractional part of its fixed-point + // representation. + ts_input := big.Lsh(big.NewInt(vector.in), MintingInputFixedPoint) + + ts_output := taylorSeriesExpansion(TestLambdaNum, TestLambdaDen, ts_input) + + // ts_output will always range between 0 and 2^FixedPoint. If we + // right-shifted by FixedPoint, without first multiplying by something, we + // would discard _all_ the bits and get 0. Instead, we want to discard only + // those bits in the FixedPoint representation that we don't also want to + // require to exactly match the test vectors. + ts_truncated_fractional_part := big.Rsh(ts_output, MintingOutputFixedPoint-mintingTestVectorPrecision) + + expected_truncated_fractional_part, _ := big.FromString(vector.out) + if !(ts_truncated_fractional_part.Equals(expected_truncated_fractional_part)) { + t.Errorf("minting function: on input %q, computed %q, expected %q", ts_input, ts_truncated_fractional_part, expected_truncated_fractional_part) + } + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_test.go new file mode 100644 index 000000000..48546a5bc --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/reward/reward_test.go @@ -0,0 +1,91 @@ +package reward_test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/builtin" + "github.com/filecoin-project/specs-actors/actors/builtin/reward" + "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, reward.Actor{}) +} + +func TestConstructor(t *testing.T) { + actor := rewardHarness{reward.Actor{}, t} + + t.Run("construct with 0 power", func(t *testing.T) { + rt := mock.NewBuilder(context.Background(), builtin.RewardActorAddr). + WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID). + Build(t) + startRealizedPower := abi.NewStoragePower(0) + actor.constructAndVerify(rt, &startRealizedPower) + }) + t.Run("construct with some power", func(t *testing.T) { + rt := mock.NewBuilder(context.Background(), builtin.RewardActorAddr). + WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID). + Build(t) + startRealizedPower := abi.NewStoragePower(1 << 25) + actor.constructAndVerify(rt, &startRealizedPower) + st := getState(rt) + assert.Equal(t, abi.ChainEpoch(0), st.RewardEpochsPaid) // constructor shouldn't bump count of rewards + assert.Equal(t, startRealizedPower, st.RealizedPower) + assert.Equal(t, startRealizedPower, st.CumsumRealized) + + // Note this check is sensative to the value of startRealizedPower and the minting function + // so it is somewhat brittle. Values of startRealizedPower below 1<<20 mint no coins + assert.NotEqual(t, big.Zero(), st.ThisEpochReward) + }) +} + +func TestAwardBlockReward(t *testing.T) { + actor := rewardHarness{reward.Actor{}, t} + builder := mock.NewBuilder(context.Background(), builtin.RewardActorAddr). + WithCaller(builtin.SystemActorAddr, builtin.SystemActorCodeID) + + t.Run("assertion failure when current balance is less than gas reward", func(t *testing.T) { + rt := builder.Build(t) + startRealizedPower := abi.NewStoragePower(0) + actor.constructAndVerify(rt, &startRealizedPower) + miner := tutil.NewIDAddr(t, 1000) + + gasreward := abi.NewTokenAmount(10) + rt.SetBalance(abi.NewTokenAmount(0)) + + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + rt.ExpectAssertionFailure("actor current balance 0 insufficient to pay gas reward 10", func() { + rt.Call(actor.AwardBlockReward, &reward.AwardBlockRewardParams{ + Miner: miner, + Penalty: big.Zero(), + GasReward: gasreward, + }) + }) + rt.Verify() + }) +} + +type rewardHarness struct { + reward.Actor + t testing.TB +} + +func (h *rewardHarness) constructAndVerify(rt *mock.Runtime, currRawPower *abi.StoragePower) { + rt.ExpectValidateCallerAddr(builtin.SystemActorAddr) + ret := rt.Call(h.Constructor, currRawPower) + assert.Nil(h.t, ret) + rt.Verify() + +} + +func getState(rt *mock.Runtime) *reward.State { + var st reward.State + rt.GetState(&st) + return &st +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/shared.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/shared.go new file mode 100644 index 000000000..e2d95e22d --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/shared.go @@ -0,0 +1,55 @@ +package builtin + +import ( + addr "github.com/filecoin-project/go-address" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + runtime "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + autil "github.com/filecoin-project/specs-actors/actors/util" +) + +///// Code shared by multiple built-in actors. ///// + +// Aborts with an ErrIllegalArgument if predicate is not true. +func RequireParam(rt runtime.Runtime, predicate bool, msg string, args ...interface{}) { + if !predicate { + rt.Abortf(exitcode.ErrIllegalArgument, msg, args...) + } +} + +// Propagates a failed send by aborting the current method with the same exit code. +func RequireSuccess(rt runtime.Runtime, e exitcode.ExitCode, msg string, args ...interface{}) { + if !e.IsSuccess() { + rt.Abortf(e, msg, args...) + } +} + +// Aborts with a formatted message if err is not nil. +// The provided message will be suffixed by ": %s" and the provided args suffixed by the err. +func RequireNoErr(rt runtime.Runtime, err error, code exitcode.ExitCode, msg string, args ...interface{}) { + if err != nil { + newMsg := msg + ": %s" + newArgs := append(args, err) + rt.Abortf(code, newMsg, newArgs...) + } +} + +func RequestMinerControlAddrs(rt runtime.Runtime, minerAddr addr.Address) (ownerAddr addr.Address, workerAddr addr.Address) { + ret, code := rt.Send(minerAddr, MethodsMiner.ControlAddresses, nil, abi.NewTokenAmount(0)) + RequireSuccess(rt, code, "failed fetching control addresses") + var addrs MinerAddrs + autil.AssertNoError(ret.Into(&addrs)) + + return addrs.Owner, addrs.Worker +} + +// This type duplicates the Miner.ControlAddresses return type, to work around a circular dependency between actors. +type MinerAddrs struct { + Owner addr.Address + Worker addr.Address +} + +type ConfirmSectorProofsParams struct { + Sectors []abi.SectorNumber +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/singletons.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/singletons.go new file mode 100644 index 000000000..8fb55fbcf --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/singletons.go @@ -0,0 +1,40 @@ +package builtin + +import ( + addr "github.com/filecoin-project/go-address" + autil "github.com/filecoin-project/specs-actors/actors/util" + "github.com/ipfs/go-cid" +) + +// Addresses for singleton system actors. +var ( + // Distinguished AccountActor that is the source of system implicit messages. + SystemActorAddr = mustMakeAddress(0) + InitActorAddr = mustMakeAddress(1) + RewardActorAddr = mustMakeAddress(2) + CronActorAddr = mustMakeAddress(3) + StoragePowerActorAddr = mustMakeAddress(4) + StorageMarketActorAddr = mustMakeAddress(5) + VerifiedRegistryActorAddr = mustMakeAddress(6) + // Distinguished AccountActor that is the destination of all burnt funds. + BurntFundsActorAddr = mustMakeAddress(99) +) + +const FirstNonSingletonActorId = 100 + +func mustMakeAddress(id uint64) addr.Address { + address, err := addr.NewIDAddress(id) + autil.AssertNoError(err) + return address +} + +// IsSingletonActor returns true if the code belongs to a singleton actor. +func IsSingletonActor(code cid.Cid) bool { + return code.Equals(SystemActorCodeID) || + code.Equals(InitActorCodeID) || + code.Equals(RewardActorCodeID) || + code.Equals(CronActorCodeID) || + code.Equals(StoragePowerActorCodeID) || + code.Equals(StorageMarketActorCodeID) || + code.Equals(VerifiedRegistryActorCodeID) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/cbor_gen.go new file mode 100644 index 000000000..512e4bbf3 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/cbor_gen.go @@ -0,0 +1,42 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package system + +import ( + "fmt" + "io" + + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{128}); err != nil { + return err + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 0 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/system_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/system_actor.go new file mode 100644 index 000000000..65adba751 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/system_actor.go @@ -0,0 +1,27 @@ +package system + +import ( + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + runtime "github.com/filecoin-project/specs-actors/actors/runtime" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + } +} + +var _ abi.Invokee = Actor{} + +func (a Actor) Constructor(rt runtime.Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + + rt.State().Create(&State{}) + return nil +} + +type State struct{} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/system_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/system_test.go new file mode 100644 index 000000000..4a7dfb8a3 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/system/system_test.go @@ -0,0 +1,12 @@ +package system_test + +import ( + "testing" + + "github.com/filecoin-project/specs-actors/actors/builtin/system" + "github.com/filecoin-project/specs-actors/support/mock" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, system.Actor{}) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/cbor_gen.go new file mode 100644 index 000000000..c96423fb4 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/cbor_gen.go @@ -0,0 +1,321 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package verifreg + +import ( + "fmt" + "io" + + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{131}); err != nil { + return err + } + + // t.RootKey (address.Address) (struct) + if err := t.RootKey.MarshalCBOR(w); err != nil { + return err + } + + // t.Verifiers (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.Verifiers); err != nil { + return xerrors.Errorf("failed to write cid field t.Verifiers: %w", err) + } + + // t.VerifiedClients (cid.Cid) (struct) + + if err := cbg.WriteCid(w, t.VerifiedClients); err != nil { + return xerrors.Errorf("failed to write cid field t.VerifiedClients: %w", err) + } + + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 3 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.RootKey (address.Address) (struct) + + { + + if err := t.RootKey.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.RootKey: %w", err) + } + + } + // t.Verifiers (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.Verifiers: %w", err) + } + + t.Verifiers = c + + } + // t.VerifiedClients (cid.Cid) (struct) + + { + + c, err := cbg.ReadCid(br) + if err != nil { + return xerrors.Errorf("failed to read cid field t.VerifiedClients: %w", err) + } + + t.VerifiedClients = c + + } + return nil +} + +func (t *AddVerifierParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Address (address.Address) (struct) + if err := t.Address.MarshalCBOR(w); err != nil { + return err + } + + // t.Allowance (big.Int) (struct) + if err := t.Allowance.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *AddVerifierParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Address (address.Address) (struct) + + { + + if err := t.Address.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Address: %w", err) + } + + } + // t.Allowance (big.Int) (struct) + + { + + if err := t.Allowance.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Allowance: %w", err) + } + + } + return nil +} + +func (t *AddVerifiedClientParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Address (address.Address) (struct) + if err := t.Address.MarshalCBOR(w); err != nil { + return err + } + + // t.Allowance (big.Int) (struct) + if err := t.Allowance.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *AddVerifiedClientParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Address (address.Address) (struct) + + { + + if err := t.Address.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Address: %w", err) + } + + } + // t.Allowance (big.Int) (struct) + + { + + if err := t.Allowance.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Allowance: %w", err) + } + + } + return nil +} + +func (t *UseBytesParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Address (address.Address) (struct) + if err := t.Address.MarshalCBOR(w); err != nil { + return err + } + + // t.DealSize (big.Int) (struct) + if err := t.DealSize.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *UseBytesParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Address (address.Address) (struct) + + { + + if err := t.Address.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Address: %w", err) + } + + } + // t.DealSize (big.Int) (struct) + + { + + if err := t.DealSize.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.DealSize: %w", err) + } + + } + return nil +} + +func (t *RestoreBytesParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Address (address.Address) (struct) + if err := t.Address.MarshalCBOR(w); err != nil { + return err + } + + // t.DealSize (big.Int) (struct) + if err := t.DealSize.MarshalCBOR(w); err != nil { + return err + } + return nil +} + +func (t *RestoreBytesParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Address (address.Address) (struct) + + { + + if err := t.Address.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Address: %w", err) + } + + } + // t.DealSize (big.Int) (struct) + + { + + if err := t.DealSize.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.DealSize: %w", err) + } + + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_actor.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_actor.go new file mode 100644 index 000000000..6d5316bfc --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_actor.go @@ -0,0 +1,219 @@ +package verifreg + +import ( + addr "github.com/filecoin-project/go-address" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + . "github.com/filecoin-project/specs-actors/actors/util" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.AddVerifier, + 3: a.RemoveVerifier, + 4: a.AddVerifiedClient, + 5: a.UseBytes, + 6: a.RestoreBytes, + } +} + +var _ abi.Invokee = Actor{} + +//////////////////////////////////////////////////////////////////////////////// +// Actor methods +//////////////////////////////////////////////////////////////////////////////// + +func (a Actor) Constructor(rt vmr.Runtime, rootKey *addr.Address) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.SystemActorAddr) + + emptyMap, err := adt.MakeEmptyMap(adt.AsStore(rt)).Root() + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to create verified registry state: %v", err) + } + + st := ConstructState(emptyMap, *rootKey) + rt.State().Create(st) + return nil +} + +type AddVerifierParams struct { + Address addr.Address + Allowance DataCap +} + +func (a Actor) AddVerifier(rt vmr.Runtime, params *AddVerifierParams) *adt.EmptyValue { + var st State + rt.State().Readonly(&st) + rt.ValidateImmediateCallerIs(st.RootKey) + + rt.State().Transaction(&st, func() interface{} { + err := st.PutVerifier(adt.AsStore(rt), params.Address, params.Allowance) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to add verifier: %v", err) + } + return nil + }) + + return nil +} + +func (a Actor) RemoveVerifier(rt vmr.Runtime, verifierAddr *addr.Address) *adt.EmptyValue { + var st State + rt.State().Readonly(&st) + rt.ValidateImmediateCallerIs(st.RootKey) + + rt.State().Transaction(&st, func() interface{} { + err := st.DeleteVerifier(adt.AsStore(rt), *verifierAddr) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to delete verifier: %v", err) + } + return nil + }) + + return nil +} + +type AddVerifiedClientParams struct { + Address addr.Address + Allowance DataCap +} + +func (a Actor) AddVerifiedClient(rt vmr.Runtime, params *AddVerifiedClientParams) *adt.EmptyValue { + if params.Allowance.LessThanEqual(MinVerifiedDealSize) { + rt.Abortf(exitcode.ErrIllegalArgument, "Allowance %d below MinVerifiedDealSize for add verified client %v", params.Allowance, params.Address) + } + rt.ValidateImmediateCallerAcceptAny() + + var st State + rt.State().Transaction(&st, func() interface{} { + // Validate caller is one of the verifiers. + verifierAddr := rt.Message().Caller() + verifierCap, found, err := st.GetVerifier(adt.AsStore(rt), verifierAddr) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to get Verifier for %v", err) + } else if !found { + rt.Abortf(exitcode.ErrNotFound, "Invalid verifier %v", verifierAddr) + } + + // Compute new verifier cap and update. + if verifierCap.LessThan(params.Allowance) { + rt.Abortf(exitcode.ErrIllegalArgument, "Add more DataCap (%d) for VerifiedClient than allocated %d", params.Allowance, verifierCap) + } + newVerifierCap := big.Sub(*verifierCap, params.Allowance) + + if err := st.PutVerifier(adt.AsStore(rt), verifierAddr, newVerifierCap); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to update new verifier cap (%d) for %v", newVerifierCap, verifierAddr) + } + + // Write-once entry and does not get changed for simplicity. + // If parties neeed more allowance, they can get another VerifiedClient account. + // This is a one-time, upfront allocation. + // Returns error if VerifiedClient already exists. + _, found, err = st.GetVerifiedClient(adt.AsStore(rt), params.Address) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to load verified client state for %v", params.Address) + } else if found { + rt.Abortf(exitcode.ErrIllegalArgument, "Verified client already exists: %v", params.Address) + } + + if err := st.PutVerifiedClient(adt.AsStore(rt), params.Address, params.Allowance); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to add verified client %v with cap %d", params.Address, params.Allowance) + } + return nil + }) + + return nil +} + +type UseBytesParams struct { + Address addr.Address // Address of verified client. + DealSize abi.StoragePower // Number of bytes to use. +} + +// Called by StorageMarketActor during PublishStorageDeals. +// Do not allow partially verified deals (DealSize must be greater than equal to allowed cap). +// Delete VerifiedClient if remaining DataCap is smaller than minimum VerifiedDealSize. +func (a Actor) UseBytes(rt vmr.Runtime, params *UseBytesParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.StorageMarketActorAddr) + + if params.DealSize.LessThan(MinVerifiedDealSize) { + rt.Abortf(exitcode.ErrIllegalArgument, "VerifiedDealSize: %d below minimum in UseBytes", params.DealSize) + } + + var st State + rt.State().Transaction(&st, func() interface{} { + vcCap, found, err := st.GetVerifiedClient(adt.AsStore(rt), params.Address) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to get verified client state for %v", params.Address) + } else if !found { + rt.Abortf(exitcode.ErrIllegalArgument, "Invalid address for verified client %v", params.Address) + } + Assert(vcCap.GreaterThanEqual(big.Zero())) + + if params.DealSize.GreaterThan(vcCap) { + rt.Abortf(exitcode.ErrIllegalArgument, "DealSize %d exceeds allowable cap: %d for VerifiedClient %v", params.DealSize, vcCap, params.Address) + } + + newVcCap := big.Sub(vcCap, params.DealSize) + if newVcCap.LessThan(MinVerifiedDealSize) { + // Delete entry if remaining DataCap is less than MinVerifiedDealSize. + // Will be restored later if the deal did not get activated with a ProvenSector. + err = st.DeleteVerifiedClient(adt.AsStore(rt), params.Address) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to delete verified client %v with cap %d when %d bytes are used.", params.Address, vcCap, params.DealSize) + } + } else { + err = st.PutVerifiedClient(adt.AsStore(rt), params.Address, newVcCap) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to update verified client %v when %d bytes are used.", params.Address, params.DealSize) + } + } + + return nil + }) + + return nil +} + +type RestoreBytesParams struct { + Address addr.Address + DealSize abi.StoragePower +} + +// Called by HandleInitTimeoutDeals from StorageMarketActor when a VerifiedDeal fails to init. +// Restore allowable cap for the client, creating new entry if the client has been deleted. +func (a Actor) RestoreBytes(rt vmr.Runtime, params *RestoreBytesParams) *adt.EmptyValue { + rt.ValidateImmediateCallerIs(builtin.StorageMarketActorAddr) + + if params.DealSize.LessThan(MinVerifiedDealSize) { + rt.Abortf(exitcode.ErrIllegalArgument, "Below minimum VerifiedDealSize requested in RestoreBytes: %d", params.DealSize) + } + + var st State + rt.State().Transaction(&st, func() interface{} { + vcCap, found, err := st.GetVerifiedClient(adt.AsStore(rt), params.Address) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to get verified client state for %v", params.Address) + } + + if !found { + vcCap = big.Zero() + } + + newVcCap := big.Add(vcCap, params.DealSize) + if err := st.PutVerifiedClient(adt.AsStore(rt), params.Address, newVcCap); err != nil { + rt.Abortf(exitcode.ErrIllegalState, "Failed to restore verified client state for %v", params.Address) + } + return nil + }) + + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_state.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_state.go new file mode 100644 index 000000000..64909b0ad --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_state.go @@ -0,0 +1,132 @@ +package verifreg + +import ( + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + big "github.com/filecoin-project/specs-actors/actors/abi/big" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// DataCap is an integer number of bytes. +// We can introduce policy changes and replace this in the future. +type DataCap = abi.StoragePower +type AddrKey = adt.AddrKey + +type State struct { + // Root key holder multisig. + // Authorize and remove verifiers. + RootKey addr.Address + + // Verifiers authorize VerifiedClients. + // Verifiers delegate their DataCap. + Verifiers cid.Cid // HAMT[addr.Address]DataCap + + // VerifiedClients can add VerifiedClientData, up to DataCap. + VerifiedClients cid.Cid // HAMT[addr.Address]DataCap +} + +var MinVerifiedDealSize abi.StoragePower = big.NewInt(1 << 20) // PARAM_FINISH + +// rootKeyAddress comes from genesis. +func ConstructState(emptyMapCid cid.Cid, rootKeyAddress addr.Address) *State { + return &State{ + RootKey: rootKeyAddress, + Verifiers: emptyMapCid, + VerifiedClients: emptyMapCid, + } +} + +func (st *State) PutVerifier(store adt.Store, verifierAddr addr.Address, verifierCap DataCap) error { + verifiers, err := adt.AsMap(store, st.Verifiers) + if err != nil { + return err + } + + if err := verifiers.Put(AddrKey(verifierAddr), &verifierCap); err != nil { + return errors.Wrapf(err, "failed to put verifier %v with a cap of %v", verifierAddr, verifierCap) + } + st.Verifiers, err = verifiers.Root() + if err != nil { + return errors.Wrapf(err, "failed to flush Verifiers in PutVerifier") + } + return nil +} + +func (st *State) GetVerifier(store adt.Store, address addr.Address) (*DataCap, bool, error) { + verifiers, err := adt.AsMap(store, st.Verifiers) + if err != nil { + return nil, false, err + } + + var allowance DataCap + found, err := verifiers.Get(AddrKey(address), &allowance) + if err != nil { + return nil, false, errors.Wrapf(err, "failed to load verifier for address %v", address) + } + return &allowance, found, nil +} + +func (st *State) DeleteVerifier(store adt.Store, address addr.Address) error { + verifiers, err := adt.AsMap(store, st.Verifiers) + if err != nil { + return err + } + + if err := verifiers.Delete(AddrKey(address)); err != nil { + return errors.Wrapf(err, "failed to delete verifier for address %v", address) + } + st.Verifiers, err = verifiers.Root() + if err != nil { + return errors.Wrapf(err, "failed to flush Verifiers in DeleteVerifier") + } + return nil +} + +func (st *State) PutVerifiedClient(store adt.Store, vcAddress addr.Address, vcCap DataCap) error { + vc, err := adt.AsMap(store, st.VerifiedClients) + if err != nil { + return err + } + + if err := vc.Put(AddrKey(vcAddress), &vcCap); err != nil { + return err + } + st.VerifiedClients, err = vc.Root() + if err != nil { + return errors.Wrapf(err, "failed to flush VerifiedClients in PutVerifiedClient") + } + return nil +} + +func (st *State) GetVerifiedClient(store adt.Store, vcAddress addr.Address) (DataCap, bool, error) { + vc, err := adt.AsMap(store, st.VerifiedClients) + if err != nil { + return big.Zero(), false, err + } + + var allowance DataCap + found, err := vc.Get(AddrKey(vcAddress), &allowance) + if err != nil { + return big.Zero(), false, errors.Wrapf(err, "failed to load verified client for address %v", vcAddress) + } + return allowance, found, nil +} + +func (st *State) DeleteVerifiedClient(store adt.Store, vcAddress addr.Address) error { + vc, err := adt.AsMap(store, st.VerifiedClients) + if err != nil { + return err + } + + if err := vc.Delete(AddrKey(vcAddress)); err != nil { + return errors.Wrapf(err, "failed to delete verified client for address %v", vcAddress) + } + st.VerifiedClients, err = vc.Root() + if err != nil { + return errors.Wrapf(err, "failed to flush VerifiedClients in DeleteVerifiedClient") + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_test.go new file mode 100644 index 000000000..8c02f6f90 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/builtin/verifreg/verified_registry_test.go @@ -0,0 +1,12 @@ +package verifreg_test + +import ( + "testing" + + "github.com/filecoin-project/specs-actors/actors/builtin/verifreg" + "github.com/filecoin-project/specs-actors/support/mock" +) + +func TestExports(t *testing.T) { + mock.CheckActorExports(t, verifreg.Actor{}) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/crypto/randomness.go b/_vendor/github.com/filecoin-project/specs-actors/actors/crypto/randomness.go new file mode 100644 index 000000000..aa04ef353 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/crypto/randomness.go @@ -0,0 +1,14 @@ +package crypto + +// Specifies a domain for randomness generation. +type DomainSeparationTag int + +const ( + DomainSeparationTag_TicketProduction DomainSeparationTag = 1 + iota + DomainSeparationTag_ElectionProofProduction + DomainSeparationTag_WinningPoStChallengeSeed + DomainSeparationTag_WindowedPoStChallengeSeed + DomainSeparationTag_SealRandomness + DomainSeparationTag_InteractiveSealChallengeSeed + DomainSeparationTag_WindowedPoStDeadlineAssignment +) diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/crypto/signature.go b/_vendor/github.com/filecoin-project/specs-actors/actors/crypto/signature.go new file mode 100644 index 000000000..e2bf0be97 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/crypto/signature.go @@ -0,0 +1,119 @@ +package crypto + +import ( + "bytes" + "fmt" + "io" + "math" + + cbg "github.com/whyrusleeping/cbor-gen" +) + +type SigType byte + +const ( + SigTypeUnknown = SigType(math.MaxUint8) + + SigTypeSecp256k1 = SigType(iota) + SigTypeBLS +) + +func (t SigType) Name() (string, error) { + switch t { + case SigTypeUnknown: + return "unknown", nil + case SigTypeSecp256k1: + return "secp256k1", nil + case SigTypeBLS: + return "bls", nil + default: + return "", fmt.Errorf("invalid signature type: %d", t) + } +} + +const SignatureMaxLength = 200 + +type Signature struct { + Type SigType + Data []byte +} + +func (s *Signature) Equals(o *Signature) bool { + if s == nil || o == nil { + return s == o + } + return s.Type == o.Type && bytes.Equal(s.Data, o.Data) +} + +func (s *Signature) MarshalCBOR(w io.Writer) error { + if s == nil { + _, err := w.Write(cbg.CborNull) + return err + } + + header := cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(s.Data)+1)) + if _, err := w.Write(header); err != nil { + return err + } + if _, err := w.Write([]byte{byte(s.Type)}); err != nil { + return err + } + if _, err := w.Write(s.Data); err != nil { + return err + } + return nil +} + +func (s *Signature) UnmarshalCBOR(br io.Reader) error { + maj, l, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + + if maj != cbg.MajByteString { + return fmt.Errorf("cbor input for signature was not a byte string") + } + if l > SignatureMaxLength { + return fmt.Errorf("cbor byte array for signature was too long") + } + buf := make([]byte, l) + if _, err = io.ReadFull(br, buf); err != nil { + return err + } + switch SigType(buf[0]) { + default: + return fmt.Errorf("invalid signature type in cbor input: %d", buf[0]) + case SigTypeSecp256k1: + s.Type = SigTypeSecp256k1 + case SigTypeBLS: + s.Type = SigTypeBLS + } + s.Data = buf[1:] + return nil +} + +func (s *Signature) MarshalBinary() ([]byte, error) { + bs := make([]byte, len(s.Data)+1) + bs[0] = byte(s.Type) + copy(bs[1:], s.Data) + return bs, nil +} + +func (s *Signature) UnmarshalBinary(bs []byte) error { + if len(bs) == 0 { + return fmt.Errorf("invalid signature bytes of length 0") + } + switch SigType(bs[0]) { + default: + // Do not error during unmarshal but leave a standard value. + // unmarshal(marshal(zero valued sig)) is valuable for test + // and type needs to be checked by caller anyway. + s.Type = SigTypeUnknown + case SigTypeSecp256k1: + s.Type = SigTypeSecp256k1 + case SigTypeBLS: + s.Type = SigTypeBLS + } + s.Data = bs[1:] + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/cbor_gen.go b/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/cbor_gen.go new file mode 100644 index 000000000..5aaeb73d1 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/cbor_gen.go @@ -0,0 +1,287 @@ +// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT. + +package puppet + +import ( + "fmt" + "io" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + cbg "github.com/whyrusleeping/cbor-gen" + xerrors "golang.org/x/xerrors" +) + +var _ = xerrors.Errorf + +func (t *State) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{129}); err != nil { + return err + } + + // t.OptFailToMarshalCBOR ([]*puppet.FailToMarshalCBOR) (slice) + if len(t.OptFailToMarshalCBOR) > cbg.MaxLength { + return xerrors.Errorf("Slice value in field t.OptFailToMarshalCBOR was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.OptFailToMarshalCBOR)))); err != nil { + return err + } + for _, v := range t.OptFailToMarshalCBOR { + if err := v.MarshalCBOR(w); err != nil { + return err + } + } + return nil +} + +func (t *State) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 1 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.OptFailToMarshalCBOR ([]*puppet.FailToMarshalCBOR) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.MaxLength { + return fmt.Errorf("t.OptFailToMarshalCBOR: array too large (%d)", extra) + } + + if maj != cbg.MajArray { + return fmt.Errorf("expected cbor array") + } + + if extra > 0 { + t.OptFailToMarshalCBOR = make([]*FailToMarshalCBOR, extra) + } + + for i := 0; i < int(extra); i++ { + + var v FailToMarshalCBOR + if err := v.UnmarshalCBOR(br); err != nil { + return err + } + + t.OptFailToMarshalCBOR[i] = &v + } + + return nil +} + +func (t *SendParams) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{132}); err != nil { + return err + } + + // t.To (address.Address) (struct) + if err := t.To.MarshalCBOR(w); err != nil { + return err + } + + // t.Value (big.Int) (struct) + if err := t.Value.MarshalCBOR(w); err != nil { + return err + } + + // t.Method (abi.MethodNum) (uint64) + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil { + return err + } + + // t.Params ([]uint8) (slice) + if len(t.Params) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Params was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil { + return err + } + if _, err := w.Write(t.Params); err != nil { + return err + } + return nil +} + +func (t *SendParams) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 4 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.To (address.Address) (struct) + + { + + if err := t.To.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.To: %w", err) + } + + } + // t.Value (big.Int) (struct) + + { + + if err := t.Value.UnmarshalCBOR(br); err != nil { + return xerrors.Errorf("unmarshaling t.Value: %w", err) + } + + } + // t.Method (abi.MethodNum) (uint64) + + { + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajUnsignedInt { + return fmt.Errorf("wrong type for uint64 field") + } + t.Method = abi.MethodNum(extra) + + } + // t.Params ([]uint8) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Params: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Params = make([]byte, extra) + if _, err := io.ReadFull(br, t.Params); err != nil { + return err + } + return nil +} + +func (t *SendReturn) MarshalCBOR(w io.Writer) error { + if t == nil { + _, err := w.Write(cbg.CborNull) + return err + } + if _, err := w.Write([]byte{130}); err != nil { + return err + } + + // t.Return (runtime.CBORBytes) (slice) + if len(t.Return) > cbg.ByteArrayMaxLen { + return xerrors.Errorf("Byte array in field t.Return was too long") + } + + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Return)))); err != nil { + return err + } + if _, err := w.Write(t.Return); err != nil { + return err + } + + // t.Code (exitcode.ExitCode) (int64) + if t.Code >= 0 { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Code))); err != nil { + return err + } + } else { + if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajNegativeInt, uint64(-t.Code)-1)); err != nil { + return err + } + } + return nil +} + +func (t *SendReturn) UnmarshalCBOR(r io.Reader) error { + br := cbg.GetPeeker(r) + + maj, extra, err := cbg.CborReadHeader(br) + if err != nil { + return err + } + if maj != cbg.MajArray { + return fmt.Errorf("cbor input should be of type array") + } + + if extra != 2 { + return fmt.Errorf("cbor input had wrong number of fields") + } + + // t.Return (runtime.CBORBytes) (slice) + + maj, extra, err = cbg.CborReadHeader(br) + if err != nil { + return err + } + + if extra > cbg.ByteArrayMaxLen { + return fmt.Errorf("t.Return: byte array too large (%d)", extra) + } + if maj != cbg.MajByteString { + return fmt.Errorf("expected byte array") + } + t.Return = make([]byte, extra) + if _, err := io.ReadFull(br, t.Return); err != nil { + return err + } + // t.Code (exitcode.ExitCode) (int64) + { + maj, extra, err := cbg.CborReadHeader(br) + var extraI int64 + if err != nil { + return err + } + switch maj { + case cbg.MajUnsignedInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 positive overflow") + } + case cbg.MajNegativeInt: + extraI = int64(extra) + if extraI < 0 { + return fmt.Errorf("int64 negative oveflow") + } + extraI = -1 - extraI + default: + return fmt.Errorf("wrong type for int64 field: %d", maj) + } + + t.Code = exitcode.ExitCode(extraI) + } + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/puppet.go b/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/puppet.go new file mode 100644 index 000000000..ffddaae1e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/puppet.go @@ -0,0 +1,156 @@ +package puppet + +import ( + "fmt" + "io" + + addr "github.com/filecoin-project/go-address" + "github.com/ipfs/go-cid" + mh "github.com/multiformats/go-multihash" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + builtin "github.com/filecoin-project/specs-actors/actors/builtin" + runtime "github.com/filecoin-project/specs-actors/actors/runtime" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + adt "github.com/filecoin-project/specs-actors/actors/util/adt" +) + +// The Puppet Actor exists to aid testing the runtime and environment in which it's embedded. It provides direct access +// to the runtime methods, including sending arbitrary messages to other actors, without any preconditions or invariants +// to get in the way. +type Actor struct{} + +func (a Actor) Exports() []interface{} { + return []interface{}{ + builtin.MethodConstructor: a.Constructor, + 2: a.Send, + 3: a.SendMarshalCBORFailure, + 4: a.ReturnMarshalCBORFailure, + 5: a.RuntimeTransactionMarshalCBORFailure, + } +} + +var _ abi.Invokee = Actor{} + +func (a Actor) Constructor(rt runtime.Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerAcceptAny() + + rt.State().Create(&State{}) + return nil +} + +type SendParams struct { + To addr.Address + Value abi.TokenAmount + Method abi.MethodNum + Params []byte +} + +type SendReturn struct { + Return runtime.CBORBytes + Code exitcode.ExitCode +} + +func (a Actor) Send(rt runtime.Runtime, params *SendParams) *SendReturn { + rt.ValidateImmediateCallerAcceptAny() + ret, code := rt.Send( + params.To, + params.Method, + runtime.CBORBytes(params.Params), + params.Value, + ) + out, err := handleSendReturn(ret) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to unmarshal send return: %v", err) + } + return &SendReturn{ + Return: out, + Code: code, + } +} + +func (a Actor) SendMarshalCBORFailure(rt runtime.Runtime, params *SendParams) *SendReturn { + rt.ValidateImmediateCallerAcceptAny() + ret, code := rt.Send( + params.To, + params.Method, + &FailToMarshalCBOR{}, + params.Value, + ) + out, err := handleSendReturn(ret) + if err != nil { + rt.Abortf(exitcode.ErrIllegalState, "failed to unmarshal send return: %v", err) + } + return &SendReturn{ + Return: out, + Code: code, + } +} + +func (a Actor) ReturnMarshalCBORFailure(rt runtime.Runtime, _ *adt.EmptyValue) *FailToMarshalCBOR { + rt.ValidateImmediateCallerAcceptAny() + return &FailToMarshalCBOR{} +} + +func (a Actor) RuntimeTransactionMarshalCBORFailure(rt runtime.Runtime, _ *adt.EmptyValue) *adt.EmptyValue { + rt.ValidateImmediateCallerAcceptAny() + + var st State + + rt.State().Transaction(&st, func() interface{} { + st.OptFailToMarshalCBOR = []*FailToMarshalCBOR{{}} + return nil + }) + + return nil +} + +func handleSendReturn(ret runtime.SendReturn) (runtime.CBORBytes, error) { + if ret != nil { + var out runtime.CBORBytes + if err := ret.Into(&out); err != nil { + return nil, err + } + return out, nil + } + // nothing was returned + return nil, nil +} + +type FailToMarshalCBOR struct{} + +func (t *FailToMarshalCBOR) UnmarshalCBOR(io.Reader) error { + return fmt.Errorf("failed to unmarshal cbor") +} + +func (t *FailToMarshalCBOR) MarshalCBOR(w io.Writer) error { + return fmt.Errorf("failed to marshal cbor") +} + +type State struct { + // OptFailToMarshalCBOR is to be used as an Option or Maybe, with T + // specialized to *FailToMarshalCBOR. If the slice contains no values, the + // State struct will encode as CBOR without issue. If the slice contains + // more than zero values, the CBOR encoding will fail. + OptFailToMarshalCBOR []*FailToMarshalCBOR +} + +func init() { + builder := cid.V1Builder{Codec: cid.Raw, MhType: mh.IDENTITY} + c, err := builder.Sum([]byte("fil/1/puppet")) + if err != nil { + panic(err) + } + PuppetActorCodeID = c +} + +// The actor code ID & Methods +var PuppetActorCodeID cid.Cid + +var MethodsPuppet = struct { + Constructor abi.MethodNum + Send abi.MethodNum + SendMarshalCBORFailure abi.MethodNum + ReturnMarshalCBORFailure abi.MethodNum + RuntimeTransactionMarshalCBORFailure abi.MethodNum +}{builtin.MethodConstructor, 2, 3, 4, 5} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/puppet_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/puppet_test.go new file mode 100644 index 000000000..5cc6df179 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/puppet/puppet_test.go @@ -0,0 +1,72 @@ +package puppet_test + +import ( + "context" + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/puppet" + "github.com/filecoin-project/specs-actors/actors/runtime" + "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" + "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" + "github.com/stretchr/testify/assert" + "testing" +) + +func TestSend(t *testing.T) { + + receiver := tutil.NewIDAddr(t, 100) + builder := mock.NewBuilder(context.Background(), receiver) + + t.Run("Simple Send", func(t *testing.T) { + rt := builder.Build(t) + a := newHarness(t) + a.constructAndVerify(rt) + + toAddr := tutil.NewIDAddr(t, 101) + amount := abi.NewTokenAmount(100) + params := []byte{1, 2, 3, 4, 5} + methodNum := abi.MethodNum(1) + sendParams := &puppet.SendParams{ + To: toAddr, + Value: amount, + Method: methodNum, + Params: params, + } + + rt.SetBalance(amount) + expRet := runtime.CBORBytes([]byte{6, 7, 8, 9, 10}) + rt.ExpectSend(toAddr, 1, runtime.CBORBytes(params), amount, expRet, exitcode.Ok) + ret := a.puppetSend(rt, sendParams) + + assert.Equal(t, expRet, ret.Return) + + }) +} + +type actorHarness struct { + a puppet.Actor + t testing.TB +} + +func newHarness(t testing.TB) *actorHarness { + return &actorHarness{ + a: puppet.Actor{}, + t: t, + } +} + +func (h *actorHarness) constructAndVerify(rt *mock.Runtime) { + rt.ExpectValidateCallerAny() + ret := rt.Call(h.a.Constructor, nil) + assert.Nil(h.t, ret) + rt.Verify() +} + +func (h *actorHarness) puppetSend(rt *mock.Runtime, params *puppet.SendParams) *puppet.SendReturn { + rt.ExpectValidateCallerAny() + ret := rt.Call(h.a.Send, params) + assert.NotNil(h.t, ret) + out := ret.(*puppet.SendReturn) + rt.Verify() + return out +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/exitcode/common.go b/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/exitcode/common.go new file mode 100644 index 000000000..841929bda --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/exitcode/common.go @@ -0,0 +1,21 @@ +package exitcode + +// Common error codes that may be shared by different actors. +// Actors may also define their own codes, including redefining these values. + +const ( + // Indicates a method parameter is invalid. + ErrIllegalArgument = FirstActorErrorCode + iota + // Indicates a requested resource does not exist. + ErrNotFound + // Indicates an action is disallowed. + ErrForbidden + // Indicates a balance of funds is insufficient. + ErrInsufficientFunds + // Indicates an actor's internal state is invalid. + ErrIllegalState + // Indicates de/serialization failure within actor code. + ErrSerialization + // An error code intended to be replaced by different code structure or a more descriptive error. + ErrPlaceholder = ExitCode(1000) +) diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/exitcode/reserved.go b/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/exitcode/reserved.go new file mode 100644 index 000000000..acf6197f3 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/exitcode/reserved.go @@ -0,0 +1,119 @@ +package exitcode + +import ( + "fmt" + "strconv" +) + +type ExitCode int64 + +func (x ExitCode) IsSuccess() bool { + return x == Ok +} + +func (x ExitCode) IsError() bool { + return !x.IsSuccess() +} + +// Whether an exit code indicates a message send failure. +// A send failure means that the caller's CallSeqNum is not incremented and the caller has not paid +// gas fees for the message (because the caller doesn't exist or can't afford it). +// A receipt with send failure does not indicate that the message (or another one carrying the same CallSeqNum) +// could not apply in the future, against a different state. +func (x ExitCode) IsSendFailure() bool { + return x == SysErrSenderInvalid || x == SysErrSenderStateInvalid +} + +// A non-canonical string representation for human inspection. +func (x ExitCode) String() string { + name, ok := names[x] + if ok { + return fmt.Sprintf("%s(%d)", name, x) + } + return strconv.FormatInt(int64(x), 10) +} + +// Implement error to trigger Go compiler checking of exit code return values. +func (x ExitCode) Error() string { + return x.String() +} + +// The system error codes are reserved for use by the runtime. +// No actor may use one explicitly. Correspondingly, no runtime invocation should abort with an exit +// code outside this list. +// We could move these definitions out of this package and into the runtime spec. +const ( + Ok = ExitCode(0) + + // Indicates that the actor identified as the sender of a message is not valid as a message sender: + // - not present in the state tree + // - not an account actor (for top-level messages) + // - code CID is not found or invalid + // (not found in the state tree, not an account, has no code). + SysErrSenderInvalid = ExitCode(1) + + // Indicates that the sender of a message is not in a state to send the message: + // - invocation out of sequence (mismatched CallSeqNum) + // - insufficient funds to cover execution + SysErrSenderStateInvalid = ExitCode(2) + + // Indicates failure to find a method in an actor. + SysErrInvalidMethod = ExitCode(3) + + // Indicates non-decodeable or syntactically invalid parameters for a method. + SysErrInvalidParameters = ExitCode(4) + + // Indicates that the receiver of a message is not valid (and cannot be implicitly created). + SysErrInvalidReceiver = ExitCode(5) + + // Indicates that a message sender has insufficient balance for the value being sent. + // Note that this is distinct from SysErrSenderStateInvalid when a top-level sender can't cover + // value transfer + gas. This code is only expected to come from inter-actor sends. + SysErrInsufficientFunds = ExitCode(6) + + // Indicates message execution (including subcalls) used more gas than the specified limit. + SysErrOutOfGas = ExitCode(7) + + // Indicates message execution is forbidden for the caller by runtime caller validation. + SysErrForbidden = ExitCode(8) + + // Indicates actor code performed a disallowed operation. Disallowed operations include: + // - mutating state outside of a state acquisition block + // - failing to invoke caller validation + // - aborting with a reserved exit code (including success or a system error). + SysErrorIllegalActor = ExitCode(9) + + // Indicates an invalid argument passed to a runtime method. + SysErrorIllegalArgument = ExitCode(10) + + // Indicates an object failed to de/serialize for storage. + SysErrSerialization = ExitCode(11) + + SysErrorReserved3 = ExitCode(12) + SysErrorReserved4 = ExitCode(13) + SysErrorReserved5 = ExitCode(14) + SysErrorReserved6 = ExitCode(15) +) + +// The initial range of exit codes is reserved for system errors. +// Actors may define codes starting with this one. +const FirstActorErrorCode = ExitCode(16) + +var names = map[ExitCode]string{ + Ok: "Ok", + SysErrSenderInvalid: "SysErrSenderInvalid", + SysErrSenderStateInvalid: "SysErrSenderStateInvalid", + SysErrInvalidMethod: "SysErrInvalidMethod", + SysErrInvalidParameters: "SysErrInvalidParameters", + SysErrInvalidReceiver: "SysErrInvalidReceiver", + SysErrInsufficientFunds: "SysErrInsufficientFunds", + SysErrOutOfGas: "SysErrOutOfGas", + SysErrForbidden: "SysErrForbidden", + SysErrorIllegalActor: "SysErrorIllegalActor", + SysErrorIllegalArgument: "SysErrorIllegalArgument", + SysErrSerialization: "SysErrSerialization", + SysErrorReserved3: "SysErrorReserved3", + SysErrorReserved4: "SysErrorReserved4", + SysErrorReserved5: "SysErrorReserved5", + SysErrorReserved6: "SysErrorReserved6", +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/runtime.go b/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/runtime.go new file mode 100644 index 000000000..051125e16 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/runtime/runtime.go @@ -0,0 +1,271 @@ +package runtime + +import ( + "bytes" + "context" + "io" + + "github.com/filecoin-project/go-address" + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + + abi "github.com/filecoin-project/specs-actors/actors/abi" + crypto "github.com/filecoin-project/specs-actors/actors/crypto" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" +) + +// Specifies importance of message, LogLevel numbering is consistent with the uber-go/zap package. +type LogLevel int + +const ( + // DebugLevel logs are typically voluminous, and are usually disabled in + // production. + DEBUG LogLevel = iota - 1 + // InfoLevel is the default logging priority. + INFO + // WarnLevel logs are more important than Info, but don't need individual + // human review. + WARN + // ErrorLevel logs are high-priority. If an application is running smoothly, + // it shouldn't generate any error-level logs. + ERROR +) + +// Runtime is the VM's internal runtime object. +// this is everything that is accessible to actors, beyond parameters. +type Runtime interface { + // Information related to the current message being executed. + Message() Message + + // The current chain epoch number. The genesis block has epoch zero. + CurrEpoch() abi.ChainEpoch + + // Validates the caller against some predicate. + // Exported actor methods must invoke at least one caller validation before returning. + ValidateImmediateCallerAcceptAny() + ValidateImmediateCallerIs(addrs ...addr.Address) + ValidateImmediateCallerType(types ...cid.Cid) + + // The balance of the receiver. + CurrentBalance() abi.TokenAmount + + // Resolves an address of any protocol to an ID address (via the Init actor's table). + // This allows resolution of externally-provided SECP, BLS, or actor addresses to the canonical form. + // If the argument is an ID address it is returned directly. + ResolveAddress(address addr.Address) (addr.Address, bool) + + // Look up the code ID at an actor address. + GetActorCodeCID(addr addr.Address) (ret cid.Cid, ok bool) + + // Randomness returns a (pseudo)random byte array drawing from a + // random beacon at a given epoch and incorporating reequisite entropy + GetRandomness(personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) abi.Randomness + + // Provides a handle for the actor's state object. + State() StateHandle + + Store() Store + + // Sends a message to another actor, returning the exit code and return value envelope. + // If the invoked method does not return successfully, its state changes (and that of any messages it sent in turn) + // will be rolled back. + // The result is never a bare nil, but may be (a wrapper of) adt.Empty. + Send(toAddr addr.Address, methodNum abi.MethodNum, params CBORMarshaler, value abi.TokenAmount) (SendReturn, exitcode.ExitCode) + + // Halts execution upon an error from which the receiver cannot recover. The caller will receive the exitcode and + // an empty return value. State changes made within this call will be rolled back. + // This method does not return. + // The message and args are for diagnostic purposes and do not persist on chain. They should be suitable for + // passing to fmt.Errorf(msg, args...). + Abortf(errExitCode exitcode.ExitCode, msg string, args ...interface{}) + + // Computes an address for a new actor. The returned address is intended to uniquely refer to + // the actor even in the event of a chain re-org (whereas an ID-address might refer to a + // different actor after messages are re-ordered). + // Always an ActorExec address. + NewActorAddress() addr.Address + + // Creates an actor with code `codeID` and address `address`, with empty state. May only be called by Init actor. + CreateActor(codeId cid.Cid, address addr.Address) + + // Deletes the executing actor from the state tree, transferring any balance to beneficiary. + // Aborts if the beneficiary does not exist. + // May only be called by the actor itself. + DeleteActor(beneficiary addr.Address) + + // Provides the system call interface. + Syscalls() Syscalls + + // Returns the total token supply in circulation at the beginning of the current epoch. + // The circulating supply is the sum of: + // - rewards emitted by the reward actor, + // - funds vested from lock-ups in the genesis state, + // less the sum of: + // - funds burnt, + // - pledge collateral locked in storage miner actors (recorded in the storage power actor) + // - deal collateral locked by the storage market actor + TotalFilCircSupply() abi.TokenAmount + + // Provides a Go context for use by HAMT, etc. + // The VM is intended to provide an idealised machine abstraction, with infinite storage etc, so this context + // should not be used by actor code directly. + Context() context.Context + + // Starts a new tracing span. The span must be End()ed explicitly, typically with a deferred invocation. + StartSpan(name string) TraceSpan + + // ChargeGas charges specified amount of `gas` for execution. + // `name` provides information about gas charging point + // `virtual` sets virtual amount of gas to charge, this amount is not counted + // toward execution cost. This functionality is used for observing global changes + // in total gas charged if amount of gas charged was to be changed. + ChargeGas(name string, gas int64, virtual int64) + + // Note events that may make debugging easier + Log(level LogLevel, msg string, args ...interface{}) +} + +// Store defines the storage module exposed to actors. +type Store interface { + // Retrieves and deserializes an object from the store into `o`. Returns whether successful. + Get(c cid.Cid, o CBORUnmarshaler) bool + // Serializes and stores an object, returning its CID. + Put(x CBORMarshaler) cid.Cid +} + +// Message contains information available to the actor about the executing message. +type Message interface { + // The address of the immediate calling actor. Always an ID-address. + Caller() addr.Address + + // The address of the actor receiving the message. Always an ID-address. + Receiver() addr.Address + + // The value attached to the message being processed, implicitly added to CurrentBalance() before method invocation. + ValueReceived() abi.TokenAmount +} + +// Pure functions implemented as primitives by the runtime. +type Syscalls interface { + // Verifies that a signature is valid for an address and plaintext. + VerifySignature(signature crypto.Signature, signer addr.Address, plaintext []byte) error + // Hashes input data using blake2b with 256 bit output. + HashBlake2b(data []byte) [32]byte + // Computes an unsealed sector CID (CommD) from its constituent piece CIDs (CommPs) and sizes. + ComputeUnsealedSectorCID(reg abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) + // Verifies a sector seal proof. + VerifySeal(vi abi.SealVerifyInfo) error + + BatchVerifySeals(vis map[address.Address][]abi.SealVerifyInfo) (map[address.Address][]bool, error) + + // Verifies a proof of spacetime. + VerifyPoSt(vi abi.WindowPoStVerifyInfo) error + // Verifies that two block headers provide proof of a consensus fault: + // - both headers mined by the same actor + // - headers are different + // - first header is of the same or lower epoch as the second + // - the headers provide evidence of a fault (see the spec for the different fault types). + // The parameters are all serialized block headers. The third "extra" parameter is consulted only for + // the "parent grinding fault", in which case it must be the sibling of h1 (same parent tipset) and one of the + // blocks in an ancestor of h2. + // Returns nil and an error if the headers don't prove a fault. + VerifyConsensusFault(h1, h2, extra []byte) (*ConsensusFault, error) +} + +// The return type from a message send from one actor to another. This abstracts over the internal representation of +// the return, in particular whether it has been serialized to bytes or just passed through. +// Production code is expected to de/serialize, but test and other code may pass the value straight through. +type SendReturn interface { + Into(CBORUnmarshaler) error +} + +// Provides (minimal) tracing facilities to actor code. +type TraceSpan interface { + // Ends the span + End() +} + +// StateHandle provides mutable, exclusive access to actor state. +type StateHandle interface { + // Create initializes the state object. + // This is only valid in a constructor function and when the state has not yet been initialized. + Create(obj CBORMarshaler) + + // Readonly loads a readonly copy of the state into the argument. + // + // Any modification to the state is illegal and will result in an abort. + Readonly(obj CBORUnmarshaler) + + // Transaction loads a mutable version of the state into the `obj` argument and protects + // the execution from side effects (including message send). + // + // The second argument is a function which allows the caller to mutate the state. + // The return value from that function will be returned from the call to Transaction(). + // + // If the state is modified after this function returns, execution will abort. + // + // The gas cost of this method is that of a Store.Put of the mutated state object. + // + // Note: the Go signature is not ideal due to lack of type system power. + // + // # Usage + // ```go + // var state SomeState + // ret := rt.State().Transaction(&state, func() (interface{}) { + // // make some changes + // st.ImLoaded = True + // return st.Thing, nil + // }) + // // state.ImLoaded = False // BAD!! state is readonly outside the lambda, it will panic + // ``` + Transaction(obj CBORer, f func() interface{}) interface{} +} + +// Result of checking two headers for a consensus fault. +type ConsensusFault struct { + // Address of the miner at fault (always an ID address). + Target addr.Address + // Epoch of the fault, which is the higher epoch of the two blocks causing it. + Epoch abi.ChainEpoch + // Type of fault. + Type ConsensusFaultType +} + +type ConsensusFaultType int64 + +const ( + //ConsensusFaultNone ConsensusFaultType = 0 + ConsensusFaultDoubleForkMining ConsensusFaultType = 1 + ConsensusFaultParentGrinding ConsensusFaultType = 2 + ConsensusFaultTimeOffsetMining ConsensusFaultType = 3 +) + +// These interfaces are intended to match those from whyrusleeping/cbor-gen, such that code generated from that +// system is automatically usable here (but not mandatory). +type CBORMarshaler interface { + MarshalCBOR(w io.Writer) error +} + +type CBORUnmarshaler interface { + UnmarshalCBOR(r io.Reader) error +} + +type CBORer interface { + CBORMarshaler + CBORUnmarshaler +} + +// Wraps already-serialized bytes as CBOR-marshalable. +type CBORBytes []byte + +func (b CBORBytes) MarshalCBOR(w io.Writer) error { + _, err := w.Write(b) + return err +} + +func (b *CBORBytes) UnmarshalCBOR(r io.Reader) error { + var c bytes.Buffer + _, err := c.ReadFrom(r) + *b = c.Bytes() + return err +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/adt_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/adt_test.go new file mode 100644 index 000000000..8abc1205e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/adt_test.go @@ -0,0 +1,24 @@ +package adt_test + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/util/adt" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestAddrKey(t *testing.T) { + id_address_1 := tutil.NewIDAddr(t, 101) + id_address_2 := tutil.NewIDAddr(t, 102) + actor_address_1 := tutil.NewActorAddr(t, "actor1") + actor_address_2 := tutil.NewActorAddr(t, "222") + + t.Run("address to key string conversion", func(t *testing.T) { + assert.Equal(t, "\x00\x65", adt.AddrKey(id_address_1).Key()) + assert.Equal(t, "\x00\x66", adt.AddrKey(id_address_2).Key()) + assert.Equal(t, "\x02\x58\xbe\x4f\xd7\x75\xa0\xc8\xcd\x9a\xed\x86\x4e\x73\xab\xb1\x86\x46\x5f\xef\xe1", adt.AddrKey(actor_address_1).Key()) + assert.Equal(t, "\x02\xaa\xd0\xb2\x98\xa9\xde\xab\xbb\xb6\u007f\x80\x5f\x66\xaa\x68\x8c\xdd\x89\xad\xf5", adt.AddrKey(actor_address_2).Key()) + }) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/array.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/array.go new file mode 100644 index 000000000..35d8d621c --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/array.go @@ -0,0 +1,108 @@ +package adt + +import ( + "bytes" + + amt "github.com/filecoin-project/go-amt-ipld/v2" + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + runtime "github.com/filecoin-project/specs-actors/actors/runtime" +) + +// Array stores a sparse sequence of values in an AMT. +type Array struct { + root *amt.Root + store Store +} + +// AsArray interprets a store as an AMT-based array with root `r`. +func AsArray(s Store, r cid.Cid) (*Array, error) { + root, err := amt.LoadAMT(s.Context(), s, r) + if err != nil { + return nil, xerrors.Errorf("failed to root: %w", err) + } + + return &Array{ + root: root, + store: s, + }, nil +} + +// Creates a new map backed by an empty HAMT and flushes it to the store. +func MakeEmptyArray(s Store) *Array { + root := amt.NewAMT(s) + return &Array{ + root: root, + store: s, + } +} + +// Returns the root CID of the underlying AMT. +func (a *Array) Root() (cid.Cid, error) { + return a.root.Flush(a.store.Context()) +} + +// Appends a value to the end of the array. Assumes continuous array. +// If the array isn't continuous use Set and a separate counter +func (a *Array) AppendContinuous(value runtime.CBORMarshaler) error { + if err := a.root.Set(a.store.Context(), a.root.Count, value); err != nil { + return errors.Wrapf(err, "array append failed to set index %v value %v in root %v, ", a.root.Count, value, a.root) + } + return nil +} + +func (a *Array) Set(i uint64, value runtime.CBORMarshaler) error { + if err := a.root.Set(a.store.Context(), i, value); err != nil { + return xerrors.Errorf("array set failed to set index %v in root %v: %w", i, a.root, err) + } + return nil +} + +func (a *Array) Delete(i uint64) error { + if err := a.root.Delete(a.store.Context(), i); err != nil { + return xerrors.Errorf("array delete failed to delete index %v in root %v: %w", i, a.root, err) + } + return nil +} + +func (a *Array) BatchDelete(ix []uint64) error { + if err := a.root.BatchDelete(a.store.Context(), ix); err != nil { + return xerrors.Errorf("array delete failed to batchdelete: %w", err) + } + return nil +} + +// Iterates all entries in the array, deserializing each value in turn into `out` and then calling a function. +// Iteration halts if the function returns an error. +// If the output parameter is nil, deserialization is skipped. +func (a *Array) ForEach(out runtime.CBORUnmarshaler, fn func(i int64) error) error { + return a.root.ForEach(a.store.Context(), func(k uint64, val *cbg.Deferred) error { + if out != nil { + // Why doesn't amt.ForEach() just return the value as bytes? + if err := out.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return err + } + } + return fn(int64(k)) + }) +} + +func (a *Array) Length() uint64 { + return a.root.Count +} + +// Get retrieves array element into the 'out' unmarshaler, returning a boolean +// indicating whether the element was found in the array +func (a *Array) Get(k uint64, out runtime.CBORUnmarshaler) (bool, error) { + + if err := a.root.Get(a.store.Context(), k, out); err == nil { + return true, nil + } else if _, nf := err.(*amt.ErrNotFound); nf { + return false, nil + } else { + return false, err + } +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/array_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/array_test.go new file mode 100644 index 000000000..e402889c0 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/array_test.go @@ -0,0 +1,22 @@ +package adt_test + +import ( + "context" + "testing" + + "github.com/filecoin-project/go-address" + "github.com/stretchr/testify/require" + + "github.com/filecoin-project/specs-actors/actors/util/adt" + "github.com/filecoin-project/specs-actors/support/mock" +) + +func TestArrayNotFound(t *testing.T) { + rt := mock.NewBuilder(context.Background(), address.Undef).Build(t) + store := adt.AsStore(rt) + arr := adt.MakeEmptyArray(store) + + found, err := arr.Get(7, nil) + require.NoError(t, err) + require.False(t, found) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/balancetable.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/balancetable.go new file mode 100644 index 000000000..d36c37414 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/balancetable.go @@ -0,0 +1,144 @@ +package adt + +import ( + "errors" + "fmt" + + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" +) + +// A specialization of a map of addresses to token amounts. +type BalanceTable Map + +// Interprets a store as balance table with root `r`. +func AsBalanceTable(s Store, r cid.Cid) (*BalanceTable, error) { + m, err := AsMap(s, r) + if err != nil { + return nil, err + } + + return &BalanceTable{ + root: m.root, + store: s, + }, nil +} + +// Returns the root cid of underlying HAMT. +func (t *BalanceTable) Root() (cid.Cid, error) { + return (*Map)(t).Root() +} + +// Gets the balance for a key. The entry must have been previously initialized. +func (t *BalanceTable) Get(key addr.Address) (abi.TokenAmount, error) { + var value abi.TokenAmount + found, err := (*Map)(t).Get(AddrKey(key), &value) + if err != nil { + return big.Zero(), err // The errors from Map carry good information, no need to wrap here. + } + if !found { + return big.Zero(), ErrNotFound{t.lastCid, key} + } + return value, nil +} + +// Has checks if the balance for a key exists +func (t *BalanceTable) Has(key addr.Address) (bool, error) { + var value abi.TokenAmount + return (*Map)(t).Get(AddrKey(key), &value) +} + +// Sets the balance for an address, overwriting any previous balance. +func (t *BalanceTable) Set(key addr.Address, value abi.TokenAmount) error { + return (*Map)(t).Put(AddrKey(key), &value) +} + +// Adds an amount to a balance. The entry must have been previously initialized. +func (t *BalanceTable) Add(key addr.Address, value abi.TokenAmount) error { + prev, err := t.Get(key) + if err != nil { + return err + } + sum := big.Add(prev, value) + return (*Map)(t).Put(AddrKey(key), &sum) +} + +// Adds an amount to a balance. Create entry if not exists +func (t *BalanceTable) AddCreate(key addr.Address, value abi.TokenAmount) error { + var prev abi.TokenAmount + found, err := (*Map)(t).Get(AddrKey(key), &prev) + if err != nil { + return err + } + if found { + value = big.Add(prev, value) + } + + return (*Map)(t).Put(AddrKey(key), &value) +} + +// Subtracts up to the specified amount from a balance, without reducing the balance below some minimum. +// Returns the amount subtracted (always positive or zero). +func (t *BalanceTable) SubtractWithMinimum(key addr.Address, req abi.TokenAmount, floor abi.TokenAmount) (abi.TokenAmount, error) { + prev, err := t.Get(key) + if err != nil { + return big.Zero(), err + } + available := big.Max(big.Zero(), big.Sub(prev, floor)) + sub := big.Min(available, req) + if sub.Sign() > 0 { + err = t.Add(key, sub.Neg()) + if err != nil { + return big.Zero(), err + } + } + return sub, nil +} + +func (t *BalanceTable) MustSubtract(key addr.Address, req abi.TokenAmount) error { + subst, err := t.SubtractWithMinimum(key, req, big.Zero()) + if err != nil { + return err + } + if !subst.Equals(req) { + return errors.New("couldn't subtract the requested amount") + } + return nil +} + +// Removes an entry from the table, returning the prior value. The entry must have been previously initialized. +func (t *BalanceTable) Remove(key addr.Address) (abi.TokenAmount, error) { + prev, err := t.Get(key) + if err != nil { + return big.Zero(), err + } + err = (*Map)(t).Delete(AddrKey(key)) + if err != nil { + return big.Zero(), err + } + return prev, nil +} + +// Returns the total balance held by this BalanceTable +func (t *BalanceTable) Total() (abi.TokenAmount, error) { + total := big.Zero() + var cur abi.TokenAmount + err := (*Map)(t).ForEach(&cur, func(key string) error { + total = big.Add(total, cur) + return nil + }) + return total, err +} + +// Error type returned when an expected key is absent. +type ErrNotFound struct { + Root cid.Cid + Key interface{} +} + +func (e ErrNotFound) Error() string { + return fmt.Sprintf("no key %v in map root %v", e.Key, e.Root) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/balancetable_test.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/balancetable_test.go new file mode 100644 index 000000000..27826262a --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/balancetable_test.go @@ -0,0 +1,80 @@ +package adt_test + +import ( + "context" + "testing" + + "github.com/filecoin-project/go-address" + "github.com/stretchr/testify/assert" + + "github.com/filecoin-project/specs-actors/actors/abi" + "github.com/filecoin-project/specs-actors/actors/abi/big" + "github.com/filecoin-project/specs-actors/actors/util/adt" + "github.com/filecoin-project/specs-actors/support/mock" + tutil "github.com/filecoin-project/specs-actors/support/testing" +) + +func TestBalanceTable(t *testing.T) { + t.Run("AddCreate adds or creates", func(t *testing.T) { + addr := tutil.NewIDAddr(t, 100) + rt := mock.NewBuilder(context.Background(), address.Undef).Build(t) + store := adt.AsStore(rt) + emptyMap := adt.MakeEmptyMap(store) + + bt, err := adt.AsBalanceTable(store, tutil.MustRoot(t, emptyMap)) + assert.NoError(t, err) + + has, err := bt.Has(addr) + assert.NoError(t, err) + assert.False(t, has) + + err = bt.AddCreate(addr, abi.NewTokenAmount(10)) + assert.NoError(t, err) + + amount, err := bt.Get(addr) + assert.NoError(t, err) + assert.Equal(t, abi.NewTokenAmount(10), amount) + + err = bt.AddCreate(addr, abi.NewTokenAmount(20)) + assert.NoError(t, err) + + amount, err = bt.Get(addr) + assert.NoError(t, err) + assert.Equal(t, abi.NewTokenAmount(30), amount) + }) + + t.Run("Total returns total amount tracked", func(t *testing.T) { + addr1 := tutil.NewIDAddr(t, 100) + addr2 := tutil.NewIDAddr(t, 101) + + rt := mock.NewBuilder(context.Background(), address.Undef).Build(t) + store := adt.AsStore(rt) + emptyMap := adt.MakeEmptyMap(store) + + bt, err := adt.AsBalanceTable(store, tutil.MustRoot(t, emptyMap)) + assert.NoError(t, err) + total, err := bt.Total() + assert.NoError(t, err) + assert.Equal(t, big.Zero(), total) + + testCases := []struct { + amount int64 + addr address.Address + total int64 + }{ + {10, addr1, 10}, + {20, addr1, 30}, + {40, addr2, 70}, + {50, addr2, 120}, + } + + for _, tc := range testCases { + err = bt.AddCreate(tc.addr, abi.NewTokenAmount(tc.amount)) + assert.NoError(t, err) + + total, err = bt.Total() + assert.NoError(t, err) + assert.Equal(t, abi.NewTokenAmount(tc.total), total) + } + }) +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/empty.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/empty.go new file mode 100644 index 000000000..d91a029ad --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/empty.go @@ -0,0 +1,38 @@ +package adt + +import ( + "fmt" + "io" + + runtime "github.com/filecoin-project/specs-actors/actors/runtime" +) + +// The empty value represents absence of a value. It is used for parameter and return types for actor methods +// that don't take/return any data. This saves a byte in serialization of messages and receipts: the serialized +// form is an empty byte slice, rather than a byte slice containing a single byte CBOR encoding of nil/empty/etc. +// +// The only expected use of this is as the type of a nil reference. Don't instantiate this type. +// +// This is primarily necessary due to Go's lack of a void type and our interface-based serialization scheme. +type EmptyValue struct{} + +// A typed nil pointer to EmptyValue. +var Empty *EmptyValue = nil + +var _ runtime.CBORMarshaler = (*EmptyValue)(nil) +var _ runtime.CBORUnmarshaler = (*EmptyValue)(nil) + +func (v *EmptyValue) MarshalCBOR(_ io.Writer) error { + // An attempt to serialize a non-nil value indicates a caller mis-using this type. + if v != nil { + return fmt.Errorf("cannot marshal empty value, try nil instead") + } + // Allow nil to write zero bytes as a convenience so callers don't need to nil-check all values before + // attempting serialization. + return nil +} + +func (v *EmptyValue) UnmarshalCBOR(_ io.Reader) error { + // Read zero bytes. + return nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/map.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/map.go new file mode 100644 index 000000000..31dcdb932 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/map.go @@ -0,0 +1,118 @@ +package adt + +import ( + "bytes" + + cid "github.com/ipfs/go-cid" + hamt "github.com/ipfs/go-hamt-ipld" + errors "github.com/pkg/errors" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + runtime "github.com/filecoin-project/specs-actors/actors/runtime" +) + +// Branching factor of the HAMT. +// This value has been empirically chosen, but the optimal value for maps with different mutation profiles +// may differ, in which case we can expose it for configuration. +const hamtBitwidth = 5 + +// Map stores key-value pairs in a HAMT. +type Map struct { + lastCid cid.Cid + root *hamt.Node + store Store +} + +// AsMap interprets a store as a HAMT-based map with root `r`. +func AsMap(s Store, r cid.Cid) (*Map, error) { + nd, err := hamt.LoadNode(s.Context(), s, r, hamt.UseTreeBitWidth(hamtBitwidth)) + if err != nil { + return nil, xerrors.Errorf("failed to load hamt node: %w", err) + } + + return &Map{ + lastCid: r, + root: nd, + store: s, + }, nil +} + +// Creates a new map backed by an empty HAMT and flushes it to the store. +func MakeEmptyMap(s Store) *Map { + nd := hamt.NewNode(s, hamt.UseTreeBitWidth(hamtBitwidth)) + return &Map{ + lastCid: cid.Undef, + root: nd, + store: s, + } +} + +// Returns the root cid of underlying HAMT. +func (m *Map) Root() (cid.Cid, error) { + if err := m.root.Flush(m.store.Context()); err != nil { + return cid.Undef, xerrors.Errorf("failed to flush map root: %w", err) + } + + c, err := m.store.Put(m.store.Context(), m.root) + if err != nil { + return cid.Undef, xerrors.Errorf("writing map root object: %w", err) + } + m.lastCid = c + + return c, nil +} + +// Put adds value `v` with key `k` to the hamt store. +func (m *Map) Put(k Keyer, v runtime.CBORMarshaler) error { + if err := m.root.Set(m.store.Context(), k.Key(), v); err != nil { + return errors.Wrapf(err, "map put failed set in node %v with key %v value %v", m.lastCid, k.Key(), v) + } + return nil +} + +// Get puts the value at `k` into `out`. +func (m *Map) Get(k Keyer, out runtime.CBORUnmarshaler) (bool, error) { + if err := m.root.Find(m.store.Context(), k.Key(), out); err != nil { + if err == hamt.ErrNotFound { + return false, nil + } + return false, errors.Wrapf(err, "map get failed find in node %v with key %v", m.lastCid, k.Key()) + } + return true, nil +} + +// Delete removes the value at `k` from the hamt store. +func (m *Map) Delete(k Keyer) error { + if err := m.root.Delete(m.store.Context(), k.Key()); err != nil { + return errors.Wrapf(err, "map delete failed in node %v key %v", m.root, k.Key()) + } + + return nil +} + +// Iterates all entries in the map, deserializing each value in turn into `out` and then +// calling a function with the corresponding key. +// Iteration halts if the function returns an error. +// If the output parameter is nil, deserialization is skipped. +func (m *Map) ForEach(out runtime.CBORUnmarshaler, fn func(key string) error) error { + return m.root.ForEach(m.store.Context(), func(k string, val interface{}) error { + if out != nil { + // Why doesn't hamt.ForEach() just return the value as bytes? + err := out.UnmarshalCBOR(bytes.NewReader(val.(*cbg.Deferred).Raw)) + if err != nil { + return err + } + } + return fn(k) + }) +} + +// Collects all the keys from the map into a slice of strings. +func (m *Map) CollectKeys() (out []string, err error) { + err = m.ForEach(nil, func(key string) error { + out = append(out, key) + return nil + }) + return +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/multimap.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/multimap.go new file mode 100644 index 000000000..9fa9e9472 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/multimap.go @@ -0,0 +1,123 @@ +package adt + +import ( + cid "github.com/ipfs/go-cid" + errors "github.com/pkg/errors" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + runtime "github.com/filecoin-project/specs-actors/actors/runtime" +) + +// Multimap stores multiple values per key in a HAMT of AMTs. +// The order of insertion of values for each key is retained. +type Multimap struct { + mp *Map +} + +// Interprets a store as a HAMT-based map of AMTs with root `r`. +func AsMultimap(s Store, r cid.Cid) (*Multimap, error) { + m, err := AsMap(s, r) + if err != nil { + return nil, err + } + + return &Multimap{m}, nil +} + +// Creates a new map backed by an empty HAMT and flushes it to the store. +func MakeEmptyMultimap(s Store) *Multimap { + m := MakeEmptyMap(s) + return &Multimap{m} +} + +// Returns the root cid of the underlying HAMT. +func (mm *Multimap) Root() (cid.Cid, error) { + return mm.mp.Root() +} + +// Adds a value for a key. +func (mm *Multimap) Add(key Keyer, value runtime.CBORMarshaler) error { + // Load the array under key, or initialize a new empty one if not found. + array, found, err := mm.Get(key) + if err != nil { + return err + } + if !found { + array = MakeEmptyArray(mm.mp.store) + } + + // Append to the array. + if err = array.AppendContinuous(value); err != nil { + return errors.Wrapf(err, "failed to add multimap key %v value %v", key, value) + } + + c, err := array.Root() + if err != nil { + return xerrors.Errorf("failed to flush child array: %w", err) + } + + // Store the new array root under key. + newArrayRoot := cbg.CborCid(c) + err = mm.mp.Put(key, &newArrayRoot) + if err != nil { + return errors.Wrapf(err, "failed to store multimap values") + } + return nil +} + +// Removes all values for a key. +func (mm *Multimap) RemoveAll(key Keyer) error { + err := mm.mp.Delete(key) + if err != nil { + return errors.Wrapf(err, "failed to delete multimap key %v root %v", key, mm.mp.root) + } + return nil +} + +// Iterates all entries for a key in the order they were inserted, deserializing each value in turn into `out` and then +// calling a function. +// Iteration halts if the function returns an error. +// If the output parameter is nil, deserialization is skipped. +func (mm *Multimap) ForEach(key Keyer, out runtime.CBORUnmarshaler, fn func(i int64) error) error { + array, found, err := mm.Get(key) + if err != nil { + return err + } + if found { + return array.ForEach(out, fn) + } + return nil +} + +func (mm *Multimap) ForAll(fn func(k string, arr *Array) error) error { + var arrRoot cbg.CborCid + if err := mm.mp.ForEach(&arrRoot, func(k string) error { + arr, err := AsArray(mm.mp.store, cid.Cid(arrRoot)) + if err != nil { + return err + } + + return fn(k, arr) + }); err != nil { + return err + } + + return nil +} + +func (mm *Multimap) Get(key Keyer) (*Array, bool, error) { + var arrayRoot cbg.CborCid + found, err := mm.mp.Get(key, &arrayRoot) + if err != nil { + return nil, false, errors.Wrapf(err, "failed to load multimap key %v", key) + } + var array *Array + if found { + array, err = AsArray(mm.mp.store, cid.Cid(arrayRoot)) + if err != nil { + return nil, false, xerrors.Errorf("failed to load value %v as an array: %w", key, err) + } + } + return array, found, nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/set.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/set.go new file mode 100644 index 000000000..21e486d9e --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/set.go @@ -0,0 +1,59 @@ +package adt + +import ( + cid "github.com/ipfs/go-cid" +) + +// Set interprets a Map as a set, storing keys (with empty values) in a HAMT. +type Set struct { + m *Map +} + +// AsSet interprets a store as a HAMT-based set with root `r`. +func AsSet(s Store, r cid.Cid) (*Set, error) { + m, err := AsMap(s, r) + if err != nil { + return nil, err + } + + return &Set{ + m: m, + }, nil +} + +// NewSet creates a new HAMT with root `r` and store `s`. +func MakeEmptySet(s Store) *Set { + m := MakeEmptyMap(s) + return &Set{m} +} + +// Root return the root cid of HAMT. +func (h *Set) Root() (cid.Cid, error) { + return h.m.Root() +} + +// Put adds `k` to the set. +func (h *Set) Put(k Keyer) error { + return h.m.Put(k, nil) +} + +// Has returns true iff `k` is in the set. +func (h *Set) Has(k Keyer) (bool, error) { + return h.m.Get(k, nil) +} + +// Delete removes `k` from the set. +func (h *Set) Delete(k Keyer) error { + return h.m.Delete(k) +} + +// ForEach iterates over all values in the set, calling the callback for each value. +// Returning error from the callback stops the iteration. +func (h *Set) ForEach(cb func(k string) error) error { + return h.m.ForEach(nil, cb) +} + +// Collects all the keys from the set into a slice of strings. +func (h *Set) CollectKeys() (out []string, err error) { + return h.m.CollectKeys() +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/store.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/store.go new file mode 100644 index 000000000..16bbe3878 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/adt/store.go @@ -0,0 +1,138 @@ +package adt + +import ( + "context" + "encoding/binary" + + addr "github.com/filecoin-project/go-address" + cid "github.com/ipfs/go-cid" + cbor "github.com/ipfs/go-ipld-cbor" + "github.com/pkg/errors" + + vmr "github.com/filecoin-project/specs-actors/actors/runtime" + exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode" +) + +// Store defines an interface required to back the ADTs in this package. +type Store interface { + Context() context.Context + cbor.IpldStore +} + +// Adapts a vanilla IPLD store as an ADT store. +func WrapStore(ctx context.Context, store cbor.IpldStore) Store { + return &wstore{ + ctx: ctx, + IpldStore: store, + } +} + +type wstore struct { + ctx context.Context + cbor.IpldStore +} + +var _ Store = &wstore{} + +func (s *wstore) Context() context.Context { + return s.ctx +} + +// Adapter for a Runtime as an ADT Store. + +// Adapts a Runtime as an ADT store. +func AsStore(rt vmr.Runtime) Store { + return rtStore{rt} +} + +type rtStore struct { + vmr.Runtime +} + +var _ Store = &rtStore{} + +func (r rtStore) Context() context.Context { + return r.Runtime.Context() +} + +func (r rtStore) Get(_ context.Context, c cid.Cid, out interface{}) error { + // The Go context is (un/fortunately?) dropped here. + // See https://github.com/filecoin-project/specs-actors/issues/140 + if !r.Store().Get(c, out.(vmr.CBORUnmarshaler)) { + r.Abortf(exitcode.ErrNotFound, "not found") + } + return nil +} + +func (r rtStore) Put(_ context.Context, v interface{}) (cid.Cid, error) { + // The Go context is (un/fortunately?) dropped here. + // See https://github.com/filecoin-project/specs-actors/issues/140 + return r.Store().Put(v.(vmr.CBORMarshaler)), nil +} + +// Keyer defines an interface required to put values in mapping. +type Keyer interface { + Key() string +} + +// Adapts an address as a mapping key. +type AddrKey addr.Address + +func (k AddrKey) Key() string { + return string(addr.Address(k).Bytes()) +} + +type CidKey cid.Cid + +func (k CidKey) Key() string { + return cid.Cid(k).KeyString() +} + +// Adapts an int64 as a mapping key. +type intKey struct { + int64 +} + +//noinspection GoExportedFuncWithUnexportedType +func IntKey(k int64) intKey { + return intKey{k} +} + +func (k intKey) Key() string { + buf := make([]byte, 10) + n := binary.PutVarint(buf, k.int64) + return string(buf[:n]) +} + +//noinspection GoUnusedExportedFunction +func ParseIntKey(k string) (int64, error) { + i, n := binary.Varint([]byte(k)) + if n != len(k) { + return 0, errors.New("failed to decode varint key") + } + return i, nil +} + +// Adapts a uint64 as a mapping key. +type uintKey struct { + uint64 +} + +//noinspection GoExportedFuncWithUnexportedType +func UIntKey(k uint64) uintKey { + return uintKey{k} +} + +func (k uintKey) Key() string { + buf := make([]byte, 10) + n := binary.PutUvarint(buf, k.uint64) + return string(buf[:n]) +} + +func ParseUIntKey(k string) (uint64, error) { + i, n := binary.Uvarint([]byte(k)) + if n != len(k) { + return 0, errors.New("failed to decode varint key") + } + return i, nil +} diff --git a/_vendor/github.com/filecoin-project/specs-actors/actors/util/assert.go b/_vendor/github.com/filecoin-project/specs-actors/actors/util/assert.go new file mode 100644 index 000000000..a903f2b70 --- /dev/null +++ b/_vendor/github.com/filecoin-project/specs-actors/actors/util/assert.go @@ -0,0 +1,25 @@ +package util + +import "fmt" + +// Indicates a condition that should never happen. If encountered, execution will halt and the +// resulting state is undefined. +func AssertMsg(b bool, format string, a ...interface{}) { + if !b { + panic(fmt.Sprintf(format, a...)) + } +} + +func Assert(b bool) { + AssertMsg(b, "assertion failed") +} + +func AssertNoError(e error) { + if e != nil { + panic(e.Error()) + } +} + +// Indicating behavior not yet specified, and may require other spec changes. +func TODO(...interface{}) { +} diff --git a/_vendor/modules.txt b/_vendor/modules.txt new file mode 100644 index 000000000..35b64efef --- /dev/null +++ b/_vendor/modules.txt @@ -0,0 +1 @@ +# github.com/filecoin-project/specs-actors v0.7.2 diff --git a/next/.site/assets/_custom.scss b/assets/_custom.scss similarity index 100% rename from next/.site/assets/_custom.scss rename to assets/_custom.scss diff --git a/next/.site/assets/_fonts.scss b/assets/_fonts.scss similarity index 100% rename from next/.site/assets/_fonts.scss rename to assets/_fonts.scss diff --git a/next/.site/assets/_variables.scss b/assets/_variables.scss similarity index 100% rename from next/.site/assets/_variables.scss rename to assets/_variables.scss diff --git a/next/.site/assets/plugins/_dark.scss b/assets/plugins/_dark.scss similarity index 100% rename from next/.site/assets/plugins/_dark.scss rename to assets/plugins/_dark.scss diff --git a/next/.site/assets/plugins/_numbered.scss b/assets/plugins/_numbered.scss similarity index 100% rename from next/.site/assets/plugins/_numbered.scss rename to assets/plugins/_numbered.scss diff --git a/next/.site/assets/plugins/_scrollbars.scss b/assets/plugins/_scrollbars.scss similarity index 100% rename from next/.site/assets/plugins/_scrollbars.scss rename to assets/plugins/_scrollbars.scss diff --git a/next/.site/assets/site.webmanifest b/assets/site.webmanifest similarity index 100% rename from next/.site/assets/site.webmanifest rename to assets/site.webmanifest diff --git a/bin/.gitignore b/bin/.gitignore deleted file mode 100644 index 95656c14e..000000000 --- a/bin/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -codeGen -.emacs -watcher diff --git a/bin/build-pdf.sh b/bin/build-pdf.sh deleted file mode 100644 index e185ae610..000000000 --- a/bin/build-pdf.sh +++ /dev/null @@ -1,74 +0,0 @@ -#!/bin/sh - -#------- WIP FLAG -echo "Hold up, this isn't ready yet." -echo "if you need it, ping @jbenet to fix it" -exit 1; -#------- - -set -e - -short=$(git rev-parse --short HEAD) -tag=${1-$short} - -files=( - INTRO.md - data-structures.md - address.md - signatures.md - proofs.md - validation.md - network-protocols.md - bootstrap.md - data-propagation.md - sync.md - state-machine.md - local-storage.md - operation.md - actors.md - mining.md - storage-market.md - retrieval-market.md - faults.md - zigzag-circuit.md - zigzag-porep.md - definitions.md - style.md - process.md -) - -rm -rf .pdfworking -mkdir -p .pdfworking -mkdir -p pdf-build - -i=0 -for f in ${files[@]}; do - printf -v n "%03d" $i - cp "./${f}" "./.pdfworking/${n}_${f}" - i=$((i + 1)) -done - -find ./.pdfworking -type f -exec sed -i "" 's/{{%.*%}}//g' {} \; - -pandoc ./.pdfworking/*.md \ - --pdf-engine xelatex \ - -o "pdf-build/filecoin-spec-$tag".pdf \ - --from markdown+grid_tables \ - --template ./pdf/eisvogel.tex \ - -H ./pdf/helpers.tex \ - --listings \ - --toc \ - -V titlepage=true \ - -V titlepage-color=FFFFFF \ - -V titlepage-rule-color=FFFFFF \ - -V titlepage-rule-height=0 \ - -V logo="./pdf/cover-src.jpg" \ - -V logo-width="120" \ - -V listings-disable-line-numbers=true \ - -V block-headings=true \ - -V mainfont="Georgia" \ - --metadata title="Filecoin Specification $tag" - -rm -rf .pdfbuild - -echo "filecoin-spec-$tag.pdf" diff --git a/bin/build-spec-orient.sh b/bin/build-spec-orient.sh deleted file mode 100755 index 47e569bf1..000000000 --- a/bin/build-spec-orient.sh +++ /dev/null @@ -1,22 +0,0 @@ -output_dir=build/orient -input_dir=src/orient -diagram_dir=src/diagrams/orient - -if [[ -z "${ORIENT_DCALC}" ]]; then - orient_bin=orient/bin/orient -else - orient_bin=orient/bin/dcalc - input_dir=/orientd/$input_dir - diagram_dir=/orientd/$diagram_dir -fi; - -mkdir -p $output_dir -mkdir -p $diagram_dir - -$orient_bin solve --system=$input_dir/filecoin.orient --in=$input_dir/snark-table.json | jq > $output_dir/snark-table.json -$orient_bin solve --system=$input_dir/filecoin.orient --in=$input_dir/filecoin.json | jq > build/orient/solved-parameters.json -$orient_bin solve --system=$input_dir/filecoin.orient --in=$input_dir/multi-params.json | jq > $output_dir/multi-solved-parameters.json -$orient_bin solve --system=$input_dir/fast-porep.orient --in=$input_dir/fast-porep.json | jq > $output_dir/fast-porep.json -$orient_bin report --system=$input_dir/filecoin.orient --in=$input_dir/filecoin.json > $output_dir/filecoin-report.html -$orient_bin dump --system=$input_dir/filecoin.orient | jq > $output_dir/filecoin.json -$orient_bin graph --system=$input_dir/filecoin.orient --in=$input_dir/filecoin.json > $diagram_dir/filecoin.dot diff --git a/bin/emacs-init-build.el b/bin/emacs-init-build.el deleted file mode 100644 index 7c439ae0b..000000000 --- a/bin/emacs-init-build.el +++ /dev/null @@ -1,37 +0,0 @@ -;; Sandbox -(setq - user-emacs-directory (concat (file-name-directory load-file-name) ".emacs/") - package-user-dir (concat user-emacs-directory "elpa/") - use-package-always-ensure t - inhibit-message t) ; if there are errors, remove this. - ; debug-on-error t) ; if there are errors, add this. - -;; require package -(require 'package) - -;; enable melpa, if not there. -(add-to-list - 'package-archives - '("melpa" . "https://melpa.org/packages/") - t) - -;; Update package list -(package-initialize) -(unless (require 'use-package nil 'noerror) - (package-refresh-contents) - (package-install 'use-package)) - -;; Load packages we need -(use-package ox-hugo) - -;; slime is used in orient + orgmode -(use-package slime - :init - (load (expand-file-name "deps/quicklisp/slime-helper.el")) - (setq inferior-lisp-program "bin/sbclw") - (add-to-list 'slime-contribs 'slime-repl)) - -(org-babel-do-load-languages - 'org-babel-load-languages - '((lisp . t))) - diff --git a/bin/emacs-init-user.el b/bin/emacs-init-user.el deleted file mode 100644 index 8b74fb929..000000000 --- a/bin/emacs-init-user.el +++ /dev/null @@ -1,29 +0,0 @@ -;; Options -(setq - use-package-always-ensure t) - -;; require package -(require 'package) - -;; enable melpa, if not there. -(add-to-list - 'package-archives - '("melpa" . "https://melpa.org/packages/") - t) - -;; Update package list -(package-initialize) -(unless (require 'use-package nil 'noerror) - (package-refresh-contents) - (package-install 'use-package)) - -;; Load packages we need -(use-package ox-hugo) - -;; slime is used in orient + orgmode -(use-package slime - :init - (global-set-key (kbd "C-c z") 'slime-repl) - (load (substitute-in-file-name "$HOME/quicklisp/slime-helper.el")) - (setq inferior-lisp-program "sbcl") ; TODO: verify this doesn't require full path to binary - (add-to-list 'slime-contribs 'slime-repl)) diff --git a/bin/install-deps-basic.sh b/bin/install-deps-basic.sh deleted file mode 100755 index bcd16dd6d..000000000 --- a/bin/install-deps-basic.sh +++ /dev/null @@ -1,43 +0,0 @@ -#!/bin/bash - -source "$(dirname $0)/lib.sh" - -# usage() { -# cat << USAGE -# SYNOPSIS -# install dependencies for the filecoin spec buildsys -# usage: $0 [-y] -# -# OPTIONS -# -h,--help show usage -# -y,--yes pass yes to installers and confirmation prompts -# USAGE -# } -# -# parse_args() { -# while [ $# -gt 0 ]; do -# case "$1" in -# -y|--yes) y=y ;; -# -h|--help) usage ; exit 0 ;; -# *) die "unrecognized argument: $1 (-h shows usage)" ;; -# esac -# shift -# done -# } - -main() { - must_run_from_spec_root - - # package manager packages - tryinstall hugo hugo - tryinstall rsync rsync - - # submodules required for hugo themes - prun git submodule update --init --recursive - - # other packages - require_version "$(hugo version)" hugo 0.58 "recommended install from package manager" - require_version "$(go version)" go 1.13 "recommended install from https://golang.org/dl/" - return 0 -} -main diff --git a/bin/install-deps-diagrams.sh b/bin/install-deps-diagrams.sh deleted file mode 100755 index 7aeb045df..000000000 --- a/bin/install-deps-diagrams.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/bash - -source "$(dirname $0)/lib.sh" - -main() { - must_run_from_spec_root - - # package manager packages - tryinstall dot graphviz - tryinstall node node - - # other packages - require_version "$(node --version)" node 10.10 "recommended install from https://nodejs.org/en/" - require_version "$(npm --version)" npm 5.0 "recommended install from https://nodejs.org/en/" - - # npm deps - echo "> installing npm deps" - cwd=$(pwd) - cd deps - npm install || die "npm install failed" - cd "$cwd" - return 0 -} -main diff --git a/bin/install-deps-ga.sh b/bin/install-deps-ga.sh deleted file mode 100755 index b2168e6af..000000000 --- a/bin/install-deps-ga.sh +++ /dev/null @@ -1,45 +0,0 @@ -#!/bin/bash - -source "$(dirname $0)/lib.sh" - -# usage() { -# cat << USAGE -# SYNOPSIS -# install dependencies for the filecoin spec buildsys -# usage: $0 [-y] -# -# OPTIONS -# -h,--help show usage -# -y,--yes pass yes to installers and confirmation prompts -# USAGE -# } -# -# parse_args() { -# while [ $# -gt 0 ]; do -# case "$1" in -# -y|--yes) y=y ;; -# -h|--help) usage ; exit 0 ;; -# *) die "unrecognized argument: $1 (-h shows usage)" ;; -# esac -# shift -# done -# } - -main() { - must_run_from_spec_root - - # package manager packages - tryinstall rsync rsync - - # Github Actions requires this version of hugo. - snap install hugo --channel=extended - - # submodules required for hugo themes - prun git submodule update --init --recursive - - # other packages - require_version "$(go version)" go 1.13 "recommended install from https://golang.org/dl/" - - return 0 -} -main diff --git a/bin/install-deps-orient-user.sh b/bin/install-deps-orient-user.sh deleted file mode 100755 index 046c91bdd..000000000 --- a/bin/install-deps-orient-user.sh +++ /dev/null @@ -1,132 +0,0 @@ -#!/bin/bash - -# common code -source "$(dirname $0)/lib.sh" - -sbclr() { - sbcl --noinform --non-interactive "$@" --quit -} - -is_quicklisp_installed() { - echo "> check whether quicklisp is already installed." - - lisp_qlcheck="\ - (if\ - (find-package '#:ql)\ - (write-line \"quicklisp is installed\")\ - (write-line \"quicklisp is not installed\"))\ - " - - qli=$(sbclr --eval "$lisp_qlcheck") - [ $? -eq 0 ] || die "failed to check" - - # show whether quicklisp is installed to the user reading the trace - echo "$qli" - - # check if quicklisp is installed - return $(echo "$qli" | grep 'quicklisp is installed' >/dev/null) -} - -install_quicklisp() { - echo "> installing quicklisp and asdf" - - is_quicklisp_installed - if [ $? -ne 0 ]; then - qlif="$(pwd)/deps/quicklisp-install.lisp" - download_if_not_present "https://beta.quicklisp.org/quicklisp.lisp" "$qlif" - - sbclr --load "$qlif" \ - --eval "(quicklisp-quickstart:install :path \"$HOME/quicklisp\")" \ - --eval "(ql-util:without-prompting (ql:add-to-init-file))" - [ $? -eq 0 ] || die "failed to run quicklisp-install.lisp" - - is_quicklisp_installed || die "failed to install quicklisp" - fi -} - -install_slime() { - echo "> installing slime" - sbclr --eval "(ql:quickload \"quicklisp-slime-helper\")" - [ $? -eq 0 ] || die "failed to install slime" -} - -link_orient_to_quicklisp() { - echo "> integrating quicklisp with orient" - - dst="$(pwd)/orient/orient.asd" - src="$HOME/quicklisp/local-projects/orient.asd" - ensure_symlink "$dst" "$src" - - # this is a symlink. brittle! - # if we move orient or quicklisp (relative to each other) we have to change this. -} - -install_cllaunch() { - cll="cl-launch.sh" - dst="/usr/local/bin/cl" - src="https://common-lisp.net/project/xcvb/cl-launch/$cll" - - download_if_not_present "$src" "$dst" - [ $? -eq 0 ] || die "failed to install cl-launch" -} - -install_emacs_deps() { - # loading the init file will do - emacs_init="bin/emacs-init-user.el" - echo "> installing emacs deps from $emacs_init" - emacs --script "$emacs_init" - [ $? -eq 0 ] || die "failed to install emacs deps" -} - -main() { - must_run_from_spec_root - - # warn the user - echo "WARNING: $0 is work in progress." - echo " This warning will be removed once it is done." - - echo "WARNING: this may mess up your user environment, especially if you use:" - echo " emacs" - echo " sbcl" - - # get confirmation from user - if [ "$1" != "-y" ]; then - get_user_confirmation - fi - - # package manager packages - tryinstall wget wget - tryinstall emacs emacs - tryinstall sbcl sbcl - mkdir -p deps/bin - - # lisp / emacs - install_quicklisp - install_slime - install_cllaunch - install_emacs_deps - - # git repos - prun git submodule update --init --recursive - - # orient - link_orient_to_quicklisp - - # TODO: make this automated. - emacs_init="$(pwd)/bin/emacs-init-user.el" - cat <<- EOF - - =============== ORIENT DEPS INSTALL FINISHED =============== - - We need to link emacs, slime, orgmode, and so on. - Do this by loading this file: $emacs_init - - To load it, use this elisp code in an emacs session, or put it in your emacs init file: - (load "$emacs_init") - - Your emacs user init file is usually ~/.emacs, or ~/.emacs.el, or ~/emacs.d/init.el - (TODO automate this) -EOF - return 0 -} -main $1 diff --git a/bin/install-deps-orient.sh b/bin/install-deps-orient.sh deleted file mode 100755 index c129a4ea2..000000000 --- a/bin/install-deps-orient.sh +++ /dev/null @@ -1,113 +0,0 @@ -#!/bin/bash - -#------- modes -# set -e - -# load lib -source "$(dirname $0)/lib.sh" - -is_quicklisp_installed() { - echo "> check whether quicklisp is already installed." - bin/sbclw --script >deps/quicklisp.installed-or-not << LISP - (load "bin/sbcl-userinit.lisp") ; --script means --no-userinit - (if - (find-package '#:ql) - (write-line "quicklisp is installed") - (write-line "quicklisp is not installed")) -LISP - [ $? -eq 0 ] || die "failed to check" - - # show whether quicklisp is installed to the user reading the trace - grep 'quicklisp' deps/quicklisp.installed-or-not - - # check if quicklisp is installed - return $(grep 'quicklisp is installed' deps/quicklisp.installed-or-not >/dev/null) -} - -install_quicklisp() { - - # install quicklisp & asdf - echo "> installing quicklisp and asdf" - - is_quicklisp_installed - if [ $? -ne 0 ]; then - download_if_not_present "https://beta.quicklisp.org/quicklisp.lisp" "deps/quicklisp-install.lisp" - - # load quicklisp into sbcl - # bin/sbclw is a wrapper that sets some options first (for isolation) - bin/sbclw --script << LISP - (load "deps/quicklisp-install.lisp") - (quicklisp-quickstart:install :path "$(pwd)/deps/quicklisp") -LISP - [ $? -eq 0 ] || die "failed to run quicklisp-install.lisp" - - is_quicklisp_installed || die "failed to install quicklisp" - fi -} - -install_slime() { - echo "> installing slime" - bin/sbclw --eval "(ql:quickload \"quicklisp-slime-helper\")" --quit - [ $? -eq 0 ] || die "failed to install slime" -} - -link_orient_to_quicklisp() { - echo "> integrating quicklisp with orient" - dst="../../orient/orient.asd" - src="deps/quicklisp/local-projects/orient.asd" - ensure_symlink "$dst" "$src" - - # this is a symlink. brittle! - # if we move orient or quicklisp (relative to each other) we have to change this. -} - -install_cllaunch() { - cll="cl-launch.sh" - dst="deps/bin/cl" - src="https://common-lisp.net/project/xcvb/cl-launch/$cll" - - download_if_not_present "$src" "$dst" - [ $? -eq 0 ] || die "failed to install cl-launch" -} - -install_emacs_deps() { - # loading the init file will do - emacs_init="bin/emacs-init-build.el" - echo "> installing emacs deps from $emacs_init" - HOME=$HOME emacs -Q --script "$emacs_init" - [ $? -eq 0 ] || die "failed to install emacs deps" -} - -main() { - must_run_from_spec_root - - # warn the user - echo "WARNING: $0 is work in progress." - echo " This warning will be removed once it is done." - - # get confirmation from user - if [ "$1" != "-y" ]; then - get_user_confirmation - fi - - # package manager packages - tryinstall wget wget - tryinstall emacs emacs - require_version "$(emacs -version)" emacs 26.3 "recommended install from you package manager" - tryinstall sbcl sbcl - mkdir -p deps/bin - - # lisp / emacs - install_quicklisp - install_slime - install_cllaunch - install_emacs_deps - - # git repos - prun git submodule update --init --recursive - - # orient - link_orient_to_quicklisp - return 0 -} -main $1 diff --git a/bin/lib.sh b/bin/lib.sh deleted file mode 100644 index a23d91007..000000000 --- a/bin/lib.sh +++ /dev/null @@ -1,158 +0,0 @@ -# no shbang, not meant to be run directly - -find_pkgmgr() { - pkgmgrs=(brew snap apt-get) - for pm in ${pkgmgrs[@]}; do - which "$pm" >/dev/null && printf "$pm" && return 0 - done - printf "" -} -pkgmgr=$(find_pkgmgr) - -die() { - echo >&2 "error: $@" - exit 1 -} - -prun() { - echo "> $@" - $@ -} - -which_v() { - printf "which $1: " - which "$1" 2>/dev/null && return 0 - echo "not found" && return 1 -} - -require() { - which_v "$1" || die "$1 required - install package: $2 -$4" -} - -require_version() { - require "$2" "$2" $4 - - v_actual=$(echo "$1" | get_version) - v_expect=$3 - compare_versions "$v_actual" "$v_expect" - case $? in - 0) return ;; - 1) return ;; - 2) die "$2 version $v_expect or greater required. you have $v_actual -$4" ;; - esac -} - -tryinstall() { - # no pkg mgr? bail w/ require msg. - if [ "" = "$pkgmgr" ]; then - require "$1" "$2" - else - which_v "$1" && return 0 # have it - fi - version="$3" - - # pkg mgr, try using it - if [ "$pkgmgr" = "apt-get" ]; then - prun sudo "$pkgmgr" install "$2" - else - prun "$pkgmgr" install "$2" - fi -} - -get_user_confirmation() { - while : ; do - read -p "Continue (y/n)? " choice - case "$choice" in - y|yes ) break ;; - n|no ) die "aborting" ;; - esac - done -} - -download_if_not_present() { - src="$1" - dst="$2" - echo "> installing $dst" - if [ -f "$dst" ]; then - echo "$dst already exists. skipping download. to force redownload, remove the file." - else - echo "downloading $src to $dst" - prun wget -O "$2" "$1" - fi -} - -ensure_symlink() { - dst="$1" - src="$2" - - echo "> linking $src -> $dst" - if [ -L "$src" ]; then - # link already exists - dst2=$(readlink "$src") - if [ "$dst" = "$dst2" ]; then - # link is what we expect. done - return - else - # link exists, but is different. dont clobber - echo "link exists, but has different value:" - echo "\texpected: $src -> $dst" - echo "\tactual: $src -> $dst2" - echo "" - echo "either fix link manually or rm it and rerun this script" - return 1 - fi - elif [ -e "$src" ]; then - # some other file is at "$src" - die "$src exists, but is not a link" - else - # link doesn't exist, make itt - prun ln -s "$dst" "$src" - fi -} - -must_run_from_spec_root() { - # assert we're running from spec root dir - err="please run $(basename $0) from spec root directory" - [ -f "$(pwd)/bin/$(basename $0)" ] || die "$err" - grep 'filecoin-project/specs' "$(pwd)/.git/config" >/dev/null || die "$err" - grep -i 'filecoin spec' "$(pwd)/README.md" >/dev/null || die "$err" -} - - -# from https://stackoverflow.com/questions/4023830/how-to-compare-two-strings-in-dot-separated-version-format-in-bash -compare_versions() { - if [[ $1 == $2 ]] - then - return 0 - fi - local IFS=. - local i ver1=($1) ver2=($2) - # fill empty fields in ver1 with zeros - for ((i=${#ver1[@]}; i<${#ver2[@]}; i++)) - do - ver1[i]=0 - done - for ((i=0; i<${#ver1[@]}; i++)) - do - if [[ -z ${ver2[i]} ]] - then - # fill empty fields in ver2 with zeros - ver2[i]=0 - fi - if ((10#${ver1[i]} > 10#${ver2[i]})) - then - return 1 - fi - if ((10#${ver1[i]} < 10#${ver2[i]})) - then - return 2 - fi - done - return 0 -} - -get_version() { - grep -o '[0-9]\+\(\.[0-9]\+\)\+' -} diff --git a/bin/lib_test.sh b/bin/lib_test.sh deleted file mode 100755 index 497898871..000000000 --- a/bin/lib_test.sh +++ /dev/null @@ -1,17 +0,0 @@ -#!/bin/bash - -source "$(dirname $0)/lib.sh" - -# test require -require emacs emacs -require go go - -# test version compare -compare_versions 10.10 10.11 -compare_versions 1.2.3 1.3.2 -compare_versions 1 999.999.999 - -# test require version -require_version "$(emacs -version)" emacs 26.3 "recommended install from you package manager" -require_version "$(go version)" go 1.10 "recommended install from https://golang.org/dl/" -require_version "$(go version)" go 1.13 "recommended install from https://golang.org/dl/" diff --git a/bin/org2hugomd.el b/bin/org2hugomd.el deleted file mode 100755 index c2bdb74a1..000000000 --- a/bin/org2hugomd.el +++ /dev/null @@ -1,18 +0,0 @@ -#!/usr/bin/env -S emacs -Q --script - -;; load info -(load (concat (file-name-directory load-file-name) "emacs-init-build.el")) - -(setq org-confirm-babel-evaluate nil) - -;; process input -(with-temp-buffer - (progn - (condition-case nil - (let (line) - (while (setq line (read-from-minibuffer "")) - (insert line) - (insert "\n"))) - (error nil)) - (princ (org-export-as 'hugo)))) - diff --git a/bin/publish-to-gh-pages.sh b/bin/publish-to-gh-pages.sh deleted file mode 100755 index 0c54aa10e..000000000 --- a/bin/publish-to-gh-pages.sh +++ /dev/null @@ -1,49 +0,0 @@ -#!/bin/sh - -source "$(dirname $0)/lib.sh" - -website=build/website -ghpages=build/gh-pages - -## -- warnings -echo "WARNING: this will publish to github pages." -# get confirmation from user -if [ "$1" != "-y" ]; then - get_user_confirmation -fi - -## -- checks -must_run_from_spec_root -# [[ $(git status -s -uno) ]] && die "the working directory is dirty.\n\ -# Please commit any pending changes and test, before publishing." -[ -d "$website" ] || die "$website not found. did you run: make website ?" - - -## -- work tree setup -echo "Setting up worktree in build/gh-pages" -git fetch origin gh-pages -git worktree remove gh-pages -rm -rf "$ghpages" -git worktree add -B gh-pages "$ghpages" origin/gh-pages - -## -- updating website content -echo "Removing existing files" -dotgit=$(cat "$ghpages/.git") # preserve .git -rm -rf "$ghpages" -cp -r "$website" "$ghpages" -echo "$dotgit" >"$ghpages/.git" # paste .git - -# echo "Generating PDF" -# name=$(bin/build-pdf.sh) -# echo $name -# cp "pdf-build/$name" "static/$name" -# msg="You can also download the full spec in [PDF format](.\/$name)." -# sed -i "" "s/<\!\-\- REPLACE_ME_PDF_LINK \-\->/$msg/" INTRO.md - -echo "Updating gh-pages branch" -shash=$(git rev-parse --short HEAD) -cd "$ghpages" && git add --all && git commit -m "Publishing $shash ($0)" - -## -- publishing -echo "Publishing to github" -git push origin gh-pages diff --git a/bin/publish-to-ipfs.sh b/bin/publish-to-ipfs.sh deleted file mode 100755 index 7b9da90da..000000000 --- a/bin/publish-to-ipfs.sh +++ /dev/null @@ -1,16 +0,0 @@ -#!/bin/bash - -source "$(dirname $0)/lib.sh" -must_run_from_spec_root - -dir=build/website - -ipfs swarm peers >/dev/null 2>/dev/null || \ - die "is ipfs daemon not running?" - -[ -d "$dir" ] || die "$dir not found. did you run: make website ?" - -hash=$(ipfs add -Q -r "$dir") -echo "published /ipfs/$hash" -echo "http://localhost:8080/ipfs/$hash" -echo "https://ipfs.io/ipfs/$hash" diff --git a/bin/sbcl-userinit.lisp b/bin/sbcl-userinit.lisp deleted file mode 100644 index 43ee789b8..000000000 --- a/bin/sbcl-userinit.lisp +++ /dev/null @@ -1,31 +0,0 @@ -; sbcl-userinit -; -; this file is here because it's tricky to edit the userinit file -; reliably from within sbcl as called by a shell script. i decided -; to do this manually. -; -; use load-quicklisp-verbose if you need to debug quicklisp loading - -(defvar *quicklisp-init-file* - (merge-pathnames "deps/quicklisp/setup.lisp" (user-homedir-pathname))) - -(defun load-quicklisp-verbose () - (write-line (format nil "looking for quicklisp in ~A" *quicklisp-init-file*)) - (if (probe-file *quicklisp-init-file*) - (progn - (write-line "quicklisp found") - (if (load *quicklisp-init-file*) - (write-line "quicklisp loaded") - (write-line "Warning: quicklisp failed to load")) - t) - (progn - (write-line "Warning: quicklisp not found") - t))) - -(defun load-quicklisp-silent () - (when (probe-file *quicklisp-init-file*) - (load *quicklisp-init-file*))) - -; actually run load-quicklisp function. comment one of these out. -; (load-quicklisp-verbose) -(load-quicklisp-silent) diff --git a/bin/sbclw b/bin/sbclw deleted file mode 100755 index cae09044f..000000000 --- a/bin/sbclw +++ /dev/null @@ -1,16 +0,0 @@ -#!/bin/sh - -# wrapper around sbcl in order to pass in common params to -# run it as part of the build system. - -die() { - echo >&2 "error: $@" - exit 1 -} - -sbclrc="bin/sbcl-userinit.lisp" -stat $sbclrc >/dev/null || die "$sbclrc not found" -which sbcl >/dev/null || die "sbcl not found, is it installed?" - -cmd="sbcl --noinform --disable-debugger --userinit $sbclrc --no-sysinit" -HOME=$(pwd) $cmd "$@" diff --git a/bin/solve-orient.sh b/bin/solve-orient.sh deleted file mode 100755 index d6c79930c..000000000 --- a/bin/solve-orient.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/bin/bash - -system_file=$1 -input_file=$2 -output_file=$3 - -if [[ -z "${ORIENT_DCALC}" ]]; then - orient_bin=orient/bin/orient -else - orient_bin=orient/bin/dcalc - system_file=/orientd/$system_file - input_file=/orientd/$input_file -fi; - -mkdir -p $output_file && rmdir $output_file # Dirty hack to ensure output_file directory exists. - -echo $output_file - -$orient_bin solve --system=$system_file --in=$input_file | jq > $output_file diff --git a/bin/write-spec-version.sh b/bin/write-spec-version.sh deleted file mode 100755 index 1f389c4f0..000000000 --- a/bin/write-spec-version.sh +++ /dev/null @@ -1,16 +0,0 @@ -#!/bin/bash - -source "$(dirname $0)/lib.sh" - -main() { - must_run_from_spec_root - - hash=$(git rev-parse HEAD) - shorthash=$(git rev-parse --short HEAD) - date=$(date -u '+%Y-%m-%d_%H:%M:%SZ') - - while read line; do - eval echo "$line" - done -} -main diff --git a/next/.site/config.toml b/config.toml similarity index 91% rename from next/.site/config.toml rename to config.toml index 1287d682d..db2212157 100644 --- a/next/.site/config.toml +++ b/config.toml @@ -1,9 +1,6 @@ -# hugo server --minify --themesDir ... --baseURL=http://0.0.0.0:1313/theme/hugo-book/ - # baseURL = '/' title = 'Filecoin Spec' theme = 'book' -dataDir = 'data' # Book configuration disablePathToLower = true @@ -25,12 +22,12 @@ enableGitInfo = true [languages] [languages.en] languageName = 'English' - contentDir = './../content' + contentDir = 'content' weight = 1 [languages.pt] languageName = 'Português' - contentDir = './../content-pt' + contentDir = 'content-pt' weight = 2 # [languages.zh] @@ -71,12 +68,12 @@ enableGitInfo = true # Enable "Edit this page" links for 'doc' page type. # Disabled by default. Uncomment to enable. Requires 'BookRepo' param. # Edit path must point to root directory of repo. - BookEditPath = 'edit/master/exampleSite' + BookEditPath = 'edit/master' # Configure the date format used on the pages # - In git information # - In blog posts - BookDateFormat = 'January 2, 2006' + BookDateFormat = 'July 3, 2006' # (Optional, default true) Enables search function with flexsearch, # Index is built on fly, therefore it might slowdown your website. @@ -98,3 +95,10 @@ enableGitInfo = true # /!\ This is an experimental feature, might be removed or changed at any time # (Optional, experimental, default false) Enables service worker that caches visited pages and resources for offline use. BookServiceWorker = false + +[module] + [[module.imports]] + path = "github.com/filecoin-project/specs-actors" + [[module.imports.mounts]] + source = "actors" + target = "content/modules/actors" diff --git a/next/content-pt/_index.md b/content-pt/_index.md similarity index 100% rename from next/content-pt/_index.md rename to content-pt/_index.md diff --git a/next/content-pt/intro/_index.md b/content-pt/intro/_index.md similarity index 100% rename from next/content-pt/intro/_index.md rename to content-pt/intro/_index.md diff --git a/next/content/.assets/filecoin.dot.svg b/content/.assets/filecoin.dot.svg similarity index 100% rename from next/content/.assets/filecoin.dot.svg rename to content/.assets/filecoin.dot.svg diff --git a/next/content/.assets/full-deals-on-chain.mmd.svg b/content/.assets/full-deals-on-chain.mmd.svg similarity index 100% rename from next/content/.assets/full-deals-on-chain.mmd.svg rename to content/.assets/full-deals-on-chain.mmd.svg diff --git a/next/content/.assets/overview.dot.svg b/content/.assets/overview.dot.svg similarity index 100% rename from next/content/.assets/overview.dot.svg rename to content/.assets/overview.dot.svg diff --git a/next/content/_index.md b/content/_index.md similarity index 100% rename from next/content/_index.md rename to content/_index.md diff --git a/next/content/algorithms/_index.md b/content/algorithms/_index.md similarity index 100% rename from next/content/algorithms/_index.md rename to content/algorithms/_index.md diff --git a/next/content/algorithms/block_reception.md b/content/algorithms/block_reception.md similarity index 100% rename from next/content/algorithms/block_reception.md rename to content/algorithms/block_reception.md diff --git a/next/content/algorithms/block_sync.md b/content/algorithms/block_sync.md similarity index 100% rename from next/content/algorithms/block_sync.md rename to content/algorithms/block_sync.md diff --git a/next/content/algorithms/crypto/_index.md b/content/algorithms/crypto/_index.md similarity index 100% rename from next/content/algorithms/crypto/_index.md rename to content/algorithms/crypto/_index.md diff --git a/next/content/algorithms/crypto/bls.go b/content/algorithms/crypto/bls.go similarity index 100% rename from next/content/algorithms/crypto/bls.go rename to content/algorithms/crypto/bls.go diff --git a/next/content/algorithms/crypto/bls.id b/content/algorithms/crypto/bls.id similarity index 100% rename from next/content/algorithms/crypto/bls.id rename to content/algorithms/crypto/bls.id diff --git a/next/content/algorithms/crypto/ecdsa.id b/content/algorithms/crypto/ecdsa.id similarity index 100% rename from next/content/algorithms/crypto/ecdsa.id rename to content/algorithms/crypto/ecdsa.id diff --git a/next/content/algorithms/crypto/randomness.md b/content/algorithms/crypto/randomness.md similarity index 100% rename from next/content/algorithms/crypto/randomness.md rename to content/algorithms/crypto/randomness.md diff --git a/next/content/algorithms/crypto/signatures.go b/content/algorithms/crypto/signatures.go similarity index 100% rename from next/content/algorithms/crypto/signatures.go rename to content/algorithms/crypto/signatures.go diff --git a/next/content/algorithms/crypto/signatures.id b/content/algorithms/crypto/signatures.id similarity index 100% rename from next/content/algorithms/crypto/signatures.id rename to content/algorithms/crypto/signatures.id diff --git a/next/content/algorithms/crypto/signatures.md b/content/algorithms/crypto/signatures.md similarity index 100% rename from next/content/algorithms/crypto/signatures.md rename to content/algorithms/crypto/signatures.md diff --git a/next/content/algorithms/crypto/vrf.go b/content/algorithms/crypto/vrf.go similarity index 100% rename from next/content/algorithms/crypto/vrf.go rename to content/algorithms/crypto/vrf.go diff --git a/next/content/algorithms/crypto/vrf.id b/content/algorithms/crypto/vrf.id similarity index 100% rename from next/content/algorithms/crypto/vrf.id rename to content/algorithms/crypto/vrf.id diff --git a/next/content/algorithms/crypto/vrf.md b/content/algorithms/crypto/vrf.md similarity index 100% rename from next/content/algorithms/crypto/vrf.md rename to content/algorithms/crypto/vrf.md diff --git a/next/content/algorithms/cryptoecon/_index.md b/content/algorithms/cryptoecon/_index.md similarity index 100% rename from next/content/algorithms/cryptoecon/_index.md rename to content/algorithms/cryptoecon/_index.md diff --git a/next/content/algorithms/expected_consensus/_index.md b/content/algorithms/expected_consensus/_index.md similarity index 100% rename from next/content/algorithms/expected_consensus/_index.md rename to content/algorithms/expected_consensus/_index.md diff --git a/next/content/algorithms/expected_consensus/diagrams/double_fork.dot b/content/algorithms/expected_consensus/diagrams/double_fork.dot similarity index 100% rename from next/content/algorithms/expected_consensus/diagrams/double_fork.dot rename to content/algorithms/expected_consensus/diagrams/double_fork.dot diff --git a/next/content/algorithms/expected_consensus/diagrams/double_fork.dot.svg b/content/algorithms/expected_consensus/diagrams/double_fork.dot.svg similarity index 100% rename from next/content/algorithms/expected_consensus/diagrams/double_fork.dot.svg rename to content/algorithms/expected_consensus/diagrams/double_fork.dot.svg diff --git a/next/content/algorithms/expected_consensus/diagrams/parent_grinding.dot b/content/algorithms/expected_consensus/diagrams/parent_grinding.dot similarity index 100% rename from next/content/algorithms/expected_consensus/diagrams/parent_grinding.dot rename to content/algorithms/expected_consensus/diagrams/parent_grinding.dot diff --git a/next/content/algorithms/expected_consensus/diagrams/parent_grinding.dot.svg b/content/algorithms/expected_consensus/diagrams/parent_grinding.dot.svg similarity index 100% rename from next/content/algorithms/expected_consensus/diagrams/parent_grinding.dot.svg rename to content/algorithms/expected_consensus/diagrams/parent_grinding.dot.svg diff --git a/next/content/algorithms/expected_consensus/diagrams/time_offset.dot b/content/algorithms/expected_consensus/diagrams/time_offset.dot similarity index 100% rename from next/content/algorithms/expected_consensus/diagrams/time_offset.dot rename to content/algorithms/expected_consensus/diagrams/time_offset.dot diff --git a/next/content/algorithms/expected_consensus/diagrams/time_offset.dot.svg b/content/algorithms/expected_consensus/diagrams/time_offset.dot.svg similarity index 100% rename from next/content/algorithms/expected_consensus/diagrams/time_offset.dot.svg rename to content/algorithms/expected_consensus/diagrams/time_offset.dot.svg diff --git a/next/content/algorithms/gossip_sub.md b/content/algorithms/gossip_sub.md similarity index 100% rename from next/content/algorithms/gossip_sub.md rename to content/algorithms/gossip_sub.md diff --git a/next/content/algorithms/payment_channels.md b/content/algorithms/payment_channels.md similarity index 100% rename from next/content/algorithms/payment_channels.md rename to content/algorithms/payment_channels.md diff --git a/next/content/algorithms/porep/_index.md b/content/algorithms/porep/_index.md similarity index 100% rename from next/content/algorithms/porep/_index.md rename to content/algorithms/porep/_index.md diff --git a/next/content/algorithms/porep/porep_commitments/_index.md b/content/algorithms/porep/porep_commitments/_index.md similarity index 100% rename from next/content/algorithms/porep/porep_commitments/_index.md rename to content/algorithms/porep/porep_commitments/_index.md diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/_index.org b/content/algorithms/porep/porep_commitments/sdr_commitments/_index.org similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/_index.org rename to content/algorithms/porep/porep_commitments/sdr_commitments/_index.org diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/data-layer.png b/content/algorithms/porep/porep_commitments/sdr_commitments/data-layer.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/data-layer.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/data-layer.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-0.png b/content/algorithms/porep/porep_commitments/sdr_commitments/layer-0.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-0.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/layer-0.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-1.png b/content/algorithms/porep/porep_commitments/sdr_commitments/layer-1.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-1.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/layer-1.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-2.png b/content/algorithms/porep/porep_commitments/sdr_commitments/layer-2.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-2.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/layer-2.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-3.png b/content/algorithms/porep/porep_commitments/sdr_commitments/layer-3.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-3.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/layer-3.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-4.png b/content/algorithms/porep/porep_commitments/sdr_commitments/layer-4.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-4.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/layer-4.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-5.png b/content/algorithms/porep/porep_commitments/sdr_commitments/layer-5.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/layer-5.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/layer-5.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/legend-even.png b/content/algorithms/porep/porep_commitments/sdr_commitments/legend-even.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/legend-even.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/legend-even.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/legend-odd.png b/content/algorithms/porep/porep_commitments/sdr_commitments/legend-odd.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/legend-odd.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/legend-odd.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/legend.png b/content/algorithms/porep/porep_commitments/sdr_commitments/legend.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/legend.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/legend.png diff --git a/next/content/algorithms/porep/porep_commitments/sdr_commitments/replica-layer.png b/content/algorithms/porep/porep_commitments/sdr_commitments/replica-layer.png similarity index 100% rename from next/content/algorithms/porep/porep_commitments/sdr_commitments/replica-layer.png rename to content/algorithms/porep/porep_commitments/sdr_commitments/replica-layer.png diff --git a/next/content/algorithms/porep/stacked_drg.md b/content/algorithms/porep/stacked_drg.md similarity index 100% rename from next/content/algorithms/porep/stacked_drg.md rename to content/algorithms/porep/stacked_drg.md diff --git a/next/content/algorithms/porep/stacked_drg_circuit.md b/content/algorithms/porep/stacked_drg_circuit.md similarity index 100% rename from next/content/algorithms/porep/stacked_drg_circuit.md rename to content/algorithms/porep/stacked_drg_circuit.md diff --git a/next/content/algorithms/post/_index.md b/content/algorithms/post/_index.md similarity index 100% rename from next/content/algorithms/post/_index.md rename to content/algorithms/post/_index.md diff --git a/next/content/algorithms/post/election_post.md b/content/algorithms/post/election_post.md similarity index 100% rename from next/content/algorithms/post/election_post.md rename to content/algorithms/post/election_post.md diff --git a/next/content/algorithms/post/proof_of_spacetime_parameters.org b/content/algorithms/post/proof_of_spacetime_parameters.org similarity index 100% rename from next/content/algorithms/post/proof_of_spacetime_parameters.org rename to content/algorithms/post/proof_of_spacetime_parameters.org diff --git a/next/content/algorithms/sdr/_index.md b/content/algorithms/sdr/_index.md similarity index 100% rename from next/content/algorithms/sdr/_index.md rename to content/algorithms/sdr/_index.md diff --git a/next/content/algorithms/sdr/notation.md b/content/algorithms/sdr/notation.md similarity index 100% rename from next/content/algorithms/sdr/notation.md rename to content/algorithms/sdr/notation.md diff --git a/next/content/algorithms/sdr/spec.md b/content/algorithms/sdr/spec.md similarity index 100% rename from next/content/algorithms/sdr/spec.md rename to content/algorithms/sdr/spec.md diff --git a/next/content/appendix/_index.md b/content/appendix/_index.md similarity index 100% rename from next/content/appendix/_index.md rename to content/appendix/_index.md diff --git a/next/content/appendix/address.md b/content/appendix/address.md similarity index 100% rename from next/content/appendix/address.md rename to content/appendix/address.md diff --git a/next/content/appendix/network_params.md b/content/appendix/network_params.md similarity index 100% rename from next/content/appendix/network_params.md rename to content/appendix/network_params.md diff --git a/next/content/appendix/orient.org b/content/appendix/orient.org similarity index 100% rename from next/content/appendix/orient.org rename to content/appendix/orient.org diff --git a/next/content/appendix/sharray.md b/content/appendix/sharray.md similarity index 100% rename from next/content/appendix/sharray.md rename to content/appendix/sharray.md diff --git a/next/content/glossary/_index.md b/content/glossary/_index.md similarity index 100% rename from next/content/glossary/_index.md rename to content/glossary/_index.md diff --git a/next/content/intro/_index.md b/content/intro/_index.md similarity index 100% rename from next/content/intro/_index.md rename to content/intro/_index.md diff --git a/next/content/intro/arch.md b/content/intro/arch.md similarity index 100% rename from next/content/intro/arch.md rename to content/intro/arch.md diff --git a/next/content/intro/concepts.md b/content/intro/concepts.md similarity index 100% rename from next/content/intro/concepts.md rename to content/intro/concepts.md diff --git a/next/content/intro/filecoin_vm.md b/content/intro/filecoin_vm.md similarity index 100% rename from next/content/intro/filecoin_vm.md rename to content/intro/filecoin_vm.md diff --git a/next/content/intro/systems/_index.md b/content/intro/systems/_index.md similarity index 100% rename from next/content/intro/systems/_index.md rename to content/intro/systems/_index.md diff --git a/next/content/intro/systems/impl_systems.md b/content/intro/systems/impl_systems.md similarity index 100% rename from next/content/intro/systems/impl_systems.md rename to content/intro/systems/impl_systems.md diff --git a/next/content/intro/systems/system.id b/content/intro/systems/system.id similarity index 100% rename from next/content/intro/systems/system.id rename to content/intro/systems/system.id diff --git a/next/content/intro/systems/why_systems.md b/content/intro/systems/why_systems.md similarity index 100% rename from next/content/intro/systems/why_systems.md rename to content/intro/systems/why_systems.md diff --git a/next/content/libraries/_index.md b/content/libraries/_index.md similarity index 100% rename from next/content/libraries/_index.md rename to content/libraries/_index.md diff --git a/next/content/libraries/fcs/_index.md b/content/libraries/fcs/_index.md similarity index 100% rename from next/content/libraries/fcs/_index.md rename to content/libraries/fcs/_index.md diff --git a/next/content/libraries/filcrypto/_index.md b/content/libraries/filcrypto/_index.md similarity index 100% rename from next/content/libraries/filcrypto/_index.md rename to content/libraries/filcrypto/_index.md diff --git a/next/content/libraries/filcrypto/filproofs/_index.md b/content/libraries/filcrypto/filproofs/_index.md similarity index 100% rename from next/content/libraries/filcrypto/filproofs/_index.md rename to content/libraries/filcrypto/filproofs/_index.md diff --git a/next/content/libraries/filcrypto/filproofs/algorithms.go b/content/libraries/filcrypto/filproofs/algorithms.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/algorithms.go rename to content/libraries/filcrypto/filproofs/algorithms.go diff --git a/next/content/libraries/filcrypto/filproofs/algorithms.id b/content/libraries/filcrypto/filproofs/algorithms.id similarity index 100% rename from next/content/libraries/filcrypto/filproofs/algorithms.id rename to content/libraries/filcrypto/filproofs/algorithms.id diff --git a/next/content/libraries/filcrypto/filproofs/feistel.go b/content/libraries/filcrypto/filproofs/feistel.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/feistel.go rename to content/libraries/filcrypto/filproofs/feistel.go diff --git a/next/content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go b/content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go rename to content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go diff --git a/next/content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id b/content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id similarity index 100% rename from next/content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id rename to content/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id diff --git a/next/content/libraries/filcrypto/filproofs/hashing.go b/content/libraries/filcrypto/filproofs/hashing.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/hashing.go rename to content/libraries/filcrypto/filproofs/hashing.go diff --git a/next/content/libraries/filcrypto/filproofs/tree.go b/content/libraries/filcrypto/filproofs/tree.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/tree.go rename to content/libraries/filcrypto/filproofs/tree.go diff --git a/next/content/libraries/filcrypto/filproofs/util.go b/content/libraries/filcrypto/filproofs/util.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/util.go rename to content/libraries/filcrypto/filproofs/util.go diff --git a/next/content/libraries/filcrypto/filproofs/win_stacked_sdr.go b/content/libraries/filcrypto/filproofs/win_stacked_sdr.go similarity index 100% rename from next/content/libraries/filcrypto/filproofs/win_stacked_sdr.go rename to content/libraries/filcrypto/filproofs/win_stacked_sdr.go diff --git a/next/content/libraries/ipfs/_index.md b/content/libraries/ipfs/_index.md similarity index 100% rename from next/content/libraries/ipfs/_index.md rename to content/libraries/ipfs/_index.md diff --git a/next/content/libraries/ipfs/bitswap.md b/content/libraries/ipfs/bitswap.md similarity index 100% rename from next/content/libraries/ipfs/bitswap.md rename to content/libraries/ipfs/bitswap.md diff --git a/next/content/libraries/ipfs/graphsync.md b/content/libraries/ipfs/graphsync.md similarity index 100% rename from next/content/libraries/ipfs/graphsync.md rename to content/libraries/ipfs/graphsync.md diff --git a/next/content/libraries/ipfs/unixfs.md b/content/libraries/ipfs/unixfs.md similarity index 100% rename from next/content/libraries/ipfs/unixfs.md rename to content/libraries/ipfs/unixfs.md diff --git a/next/content/libraries/ipld/_index.md b/content/libraries/ipld/_index.md similarity index 100% rename from next/content/libraries/ipld/_index.md rename to content/libraries/ipld/_index.md diff --git a/next/content/libraries/ipld/cid.md b/content/libraries/ipld/cid.md similarity index 100% rename from next/content/libraries/ipld/cid.md rename to content/libraries/ipld/cid.md diff --git a/next/content/libraries/ipld/datamodel.md b/content/libraries/ipld/datamodel.md similarity index 100% rename from next/content/libraries/ipld/datamodel.md rename to content/libraries/ipld/datamodel.md diff --git a/next/content/libraries/ipld/ipld.id b/content/libraries/ipld/ipld.id similarity index 100% rename from next/content/libraries/ipld/ipld.id rename to content/libraries/ipld/ipld.id diff --git a/next/content/libraries/ipld/selectors.id b/content/libraries/ipld/selectors.id similarity index 100% rename from next/content/libraries/ipld/selectors.id rename to content/libraries/ipld/selectors.id diff --git a/next/content/libraries/ipld/selectors.md b/content/libraries/ipld/selectors.md similarity index 100% rename from next/content/libraries/ipld/selectors.md rename to content/libraries/ipld/selectors.md diff --git a/next/content/libraries/libp2p/_index.md b/content/libraries/libp2p/_index.md similarity index 100% rename from next/content/libraries/libp2p/_index.md rename to content/libraries/libp2p/_index.md diff --git a/next/content/libraries/libp2p/fil_libp2p_nodes.md b/content/libraries/libp2p/fil_libp2p_nodes.md similarity index 100% rename from next/content/libraries/libp2p/fil_libp2p_nodes.md rename to content/libraries/libp2p/fil_libp2p_nodes.md diff --git a/next/content/libraries/libp2p/gossipsub.md b/content/libraries/libp2p/gossipsub.md similarity index 100% rename from next/content/libraries/libp2p/gossipsub.md rename to content/libraries/libp2p/gossipsub.md diff --git a/next/content/libraries/libp2p/kad_dht.md b/content/libraries/libp2p/kad_dht.md similarity index 100% rename from next/content/libraries/libp2p/kad_dht.md rename to content/libraries/libp2p/kad_dht.md diff --git a/next/content/libraries/libp2p/libp2p.id b/content/libraries/libp2p/libp2p.id similarity index 100% rename from next/content/libraries/libp2p/libp2p.id rename to content/libraries/libp2p/libp2p.id diff --git a/next/content/libraries/multiformats/_index.md b/content/libraries/multiformats/_index.md similarity index 100% rename from next/content/libraries/multiformats/_index.md rename to content/libraries/multiformats/_index.md diff --git a/next/content/libraries/multiformats/multiaddr.id b/content/libraries/multiformats/multiaddr.id similarity index 100% rename from next/content/libraries/multiformats/multiaddr.id rename to content/libraries/multiformats/multiaddr.id diff --git a/next/content/libraries/multiformats/multihash.id b/content/libraries/multiformats/multihash.id similarity index 100% rename from next/content/libraries/multiformats/multihash.id rename to content/libraries/multiformats/multihash.id diff --git a/next/content/listings/_index.md b/content/listings/_index.md similarity index 100% rename from next/content/listings/_index.md rename to content/listings/_index.md diff --git a/next/content/listings/actors.md b/content/listings/actors.md similarity index 100% rename from next/content/listings/actors.md rename to content/listings/actors.md diff --git a/next/content/listings/data_structures.md b/content/listings/data_structures.md similarity index 100% rename from next/content/listings/data_structures.md rename to content/listings/data_structures.md diff --git a/next/content/listings/libp2p_protocols/_index.md b/content/listings/libp2p_protocols/_index.md similarity index 100% rename from next/content/listings/libp2p_protocols/_index.md rename to content/listings/libp2p_protocols/_index.md diff --git a/next/content/listings/libp2p_protocols/data_transfer_protocol.md b/content/listings/libp2p_protocols/data_transfer_protocol.md similarity index 100% rename from next/content/listings/libp2p_protocols/data_transfer_protocol.md rename to content/listings/libp2p_protocols/data_transfer_protocol.md diff --git a/next/content/listings/reserved_ranges.md b/content/listings/reserved_ranges.md similarity index 100% rename from next/content/listings/reserved_ranges.md rename to content/listings/reserved_ranges.md diff --git a/next/content/listings/system_map.md b/content/listings/system_map.md similarity index 100% rename from next/content/listings/system_map.md rename to content/listings/system_map.md diff --git a/next/content/math-mode.md b/content/math-mode.md similarity index 100% rename from next/content/math-mode.md rename to content/math-mode.md diff --git a/next/content/systems/_index.md b/content/systems/_index.md similarity index 100% rename from next/content/systems/_index.md rename to content/systems/_index.md diff --git a/next/content/systems/filecoin_blockchain/_index.md b/content/systems/filecoin_blockchain/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/_index.md rename to content/systems/filecoin_blockchain/_index.md diff --git a/next/content/systems/filecoin_blockchain/blockchain.id b/content/systems/filecoin_blockchain/blockchain.id similarity index 100% rename from next/content/systems/filecoin_blockchain/blockchain.id rename to content/systems/filecoin_blockchain/blockchain.id diff --git a/next/content/systems/filecoin_blockchain/bootstrap/index.md b/content/systems/filecoin_blockchain/bootstrap/index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/bootstrap/index.md rename to content/systems/filecoin_blockchain/bootstrap/index.md diff --git a/next/content/systems/filecoin_blockchain/chainsync/_index.md b/content/systems/filecoin_blockchain/chainsync/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/chainsync/_index.md rename to content/systems/filecoin_blockchain/chainsync/_index.md diff --git a/next/content/systems/filecoin_blockchain/chainsync/chainsync.go b/content/systems/filecoin_blockchain/chainsync/chainsync.go similarity index 100% rename from next/content/systems/filecoin_blockchain/chainsync/chainsync.go rename to content/systems/filecoin_blockchain/chainsync/chainsync.go diff --git a/next/content/systems/filecoin_blockchain/chainsync/chainsync.id b/content/systems/filecoin_blockchain/chainsync/chainsync.id similarity index 100% rename from next/content/systems/filecoin_blockchain/chainsync/chainsync.id rename to content/systems/filecoin_blockchain/chainsync/chainsync.id diff --git a/next/content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot b/content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot similarity index 100% rename from next/content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot rename to content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot diff --git a/next/content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot.svg b/content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot.svg similarity index 100% rename from next/content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot.svg rename to content/systems/filecoin_blockchain/chainsync/chainsync_fsm.dot.svg diff --git a/next/content/systems/filecoin_blockchain/message_pool/_index.md b/content/systems/filecoin_blockchain/message_pool/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/message_pool/_index.md rename to content/systems/filecoin_blockchain/message_pool/_index.md diff --git a/next/content/systems/filecoin_blockchain/message_pool/message_pool_subsystem.id b/content/systems/filecoin_blockchain/message_pool/message_pool_subsystem.id similarity index 100% rename from next/content/systems/filecoin_blockchain/message_pool/message_pool_subsystem.id rename to content/systems/filecoin_blockchain/message_pool/message_pool_subsystem.id diff --git a/next/content/systems/filecoin_blockchain/message_pool/message_storage.md b/content/systems/filecoin_blockchain/message_pool/message_storage.md similarity index 100% rename from next/content/systems/filecoin_blockchain/message_pool/message_storage.md rename to content/systems/filecoin_blockchain/message_pool/message_storage.md diff --git a/next/content/systems/filecoin_blockchain/message_pool/message_syncer.id b/content/systems/filecoin_blockchain/message_pool/message_syncer.id similarity index 100% rename from next/content/systems/filecoin_blockchain/message_pool/message_syncer.id rename to content/systems/filecoin_blockchain/message_pool/message_syncer.id diff --git a/next/content/systems/filecoin_blockchain/message_pool/message_syncer.md b/content/systems/filecoin_blockchain/message_pool/message_syncer.md similarity index 100% rename from next/content/systems/filecoin_blockchain/message_pool/message_syncer.md rename to content/systems/filecoin_blockchain/message_pool/message_syncer.md diff --git a/next/content/systems/filecoin_blockchain/storage_power_consensus/_index.md b/content/systems/filecoin_blockchain/storage_power_consensus/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/storage_power_consensus/_index.md rename to content/systems/filecoin_blockchain/storage_power_consensus/_index.md diff --git a/next/content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.go b/content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.go similarity index 100% rename from next/content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.go rename to content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.go diff --git a/next/content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id b/content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id similarity index 100% rename from next/content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id rename to content/systems/filecoin_blockchain/storage_power_consensus/expected_consensus.id diff --git a/next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md b/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md similarity index 95% rename from next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md rename to content/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md index 6feb15dc6..55862b182 100644 --- a/next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md +++ b/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_actor.md @@ -7,11 +7,11 @@ title: Storage Power Actor ## `StoragePowerActorState` implementation -{{< embed src="/docs/actors/actors/builtin/storage_power/storage_power_actor_state.go" lang="go" >}} +{{}} ## `StoragePowerActor` implementation -{{< embed src="/docs/actors/actors/builtin/storage_power/storage_power_actor.go" lang="go" >}} +{{}} ## The Power Table diff --git a/next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go b/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go similarity index 100% rename from next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go rename to content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.go diff --git a/next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id b/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id similarity index 100% rename from next/content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id rename to content/systems/filecoin_blockchain/storage_power_consensus/storage_power_consensus_subsystem.id diff --git a/next/content/systems/filecoin_blockchain/struct/_index.md b/content/systems/filecoin_blockchain/struct/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/_index.md rename to content/systems/filecoin_blockchain/struct/_index.md diff --git a/next/content/systems/filecoin_blockchain/struct/block/_index.md b/content/systems/filecoin_blockchain/struct/block/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block/_index.md rename to content/systems/filecoin_blockchain/struct/block/_index.md diff --git a/next/content/systems/filecoin_blockchain/struct/block/block.go b/content/systems/filecoin_blockchain/struct/block/block.go similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block/block.go rename to content/systems/filecoin_blockchain/struct/block/block.go diff --git a/next/content/systems/filecoin_blockchain/struct/block/block.id b/content/systems/filecoin_blockchain/struct/block/block.id similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block/block.id rename to content/systems/filecoin_blockchain/struct/block/block.id diff --git a/next/content/systems/filecoin_blockchain/struct/block/election.go b/content/systems/filecoin_blockchain/struct/block/election.go similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block/election.go rename to content/systems/filecoin_blockchain/struct/block/election.go diff --git a/next/content/systems/filecoin_blockchain/struct/block/election.id b/content/systems/filecoin_blockchain/struct/block/election.id similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block/election.id rename to content/systems/filecoin_blockchain/struct/block/election.id diff --git a/next/content/systems/filecoin_blockchain/struct/block_producer/_index.md b/content/systems/filecoin_blockchain/struct/block_producer/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block_producer/_index.md rename to content/systems/filecoin_blockchain/struct/block_producer/_index.md diff --git a/next/content/systems/filecoin_blockchain/struct/block_producer/block_producer.id b/content/systems/filecoin_blockchain/struct/block_producer/block_producer.id similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/block_producer/block_producer.id rename to content/systems/filecoin_blockchain/struct/block_producer/block_producer.id diff --git a/next/content/systems/filecoin_blockchain/struct/chain/_index.md b/content/systems/filecoin_blockchain/struct/chain/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/chain/_index.md rename to content/systems/filecoin_blockchain/struct/chain/_index.md diff --git a/next/content/systems/filecoin_blockchain/struct/chain/chain.go b/content/systems/filecoin_blockchain/struct/chain/chain.go similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/chain/chain.go rename to content/systems/filecoin_blockchain/struct/chain/chain.go diff --git a/next/content/systems/filecoin_blockchain/struct/chain/chain.id b/content/systems/filecoin_blockchain/struct/chain/chain.id similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/chain/chain.id rename to content/systems/filecoin_blockchain/struct/chain/chain.id diff --git a/next/content/systems/filecoin_blockchain/struct/chain/tipset.id b/content/systems/filecoin_blockchain/struct/chain/tipset.id similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/chain/tipset.id rename to content/systems/filecoin_blockchain/struct/chain/tipset.id diff --git a/next/content/systems/filecoin_blockchain/struct/chain_manager/_index.md b/content/systems/filecoin_blockchain/struct/chain_manager/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/chain_manager/_index.md rename to content/systems/filecoin_blockchain/struct/chain_manager/_index.md diff --git a/next/content/systems/filecoin_blockchain/struct/tipset/_index.md b/content/systems/filecoin_blockchain/struct/tipset/_index.md similarity index 100% rename from next/content/systems/filecoin_blockchain/struct/tipset/_index.md rename to content/systems/filecoin_blockchain/struct/tipset/_index.md diff --git a/next/content/systems/filecoin_files/_index.md b/content/systems/filecoin_files/_index.md similarity index 100% rename from next/content/systems/filecoin_files/_index.md rename to content/systems/filecoin_files/_index.md diff --git a/next/content/systems/filecoin_files/data_transfer/_index.md b/content/systems/filecoin_files/data_transfer/_index.md similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/_index.md rename to content/systems/filecoin_files/data_transfer/_index.md diff --git a/next/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd b/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd rename to content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd diff --git a/next/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.css b/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.css similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.css rename to content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.css diff --git a/next/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.svg b/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.svg similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.svg rename to content/systems/filecoin_files/data_transfer/alternate-pull-flow.mmd.svg diff --git a/next/content/systems/filecoin_files/data_transfer/data-transfer-modules.png b/content/systems/filecoin_files/data_transfer/data-transfer-modules.png similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/data-transfer-modules.png rename to content/systems/filecoin_files/data_transfer/data-transfer-modules.png diff --git a/next/content/systems/filecoin_files/data_transfer/data_transfer_subsystem.id b/content/systems/filecoin_files/data_transfer/data_transfer_subsystem.id similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/data_transfer_subsystem.id rename to content/systems/filecoin_files/data_transfer/data_transfer_subsystem.id diff --git a/next/content/systems/filecoin_files/data_transfer/pull-flow.mmd b/content/systems/filecoin_files/data_transfer/pull-flow.mmd similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/pull-flow.mmd rename to content/systems/filecoin_files/data_transfer/pull-flow.mmd diff --git a/next/content/systems/filecoin_files/data_transfer/pull-flow.mmd.css b/content/systems/filecoin_files/data_transfer/pull-flow.mmd.css similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/pull-flow.mmd.css rename to content/systems/filecoin_files/data_transfer/pull-flow.mmd.css diff --git a/next/content/systems/filecoin_files/data_transfer/pull-flow.mmd.svg b/content/systems/filecoin_files/data_transfer/pull-flow.mmd.svg similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/pull-flow.mmd.svg rename to content/systems/filecoin_files/data_transfer/pull-flow.mmd.svg diff --git a/next/content/systems/filecoin_files/data_transfer/push-flow.mmd b/content/systems/filecoin_files/data_transfer/push-flow.mmd similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/push-flow.mmd rename to content/systems/filecoin_files/data_transfer/push-flow.mmd diff --git a/next/content/systems/filecoin_files/data_transfer/push-flow.mmd.css b/content/systems/filecoin_files/data_transfer/push-flow.mmd.css similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/push-flow.mmd.css rename to content/systems/filecoin_files/data_transfer/push-flow.mmd.css diff --git a/next/content/systems/filecoin_files/data_transfer/push-flow.mmd.svg b/content/systems/filecoin_files/data_transfer/push-flow.mmd.svg similarity index 100% rename from next/content/systems/filecoin_files/data_transfer/push-flow.mmd.svg rename to content/systems/filecoin_files/data_transfer/push-flow.mmd.svg diff --git a/next/content/systems/filecoin_files/error_correction/_index.md b/content/systems/filecoin_files/error_correction/_index.md similarity index 100% rename from next/content/systems/filecoin_files/error_correction/_index.md rename to content/systems/filecoin_files/error_correction/_index.md diff --git a/next/content/systems/filecoin_files/error_correction/erasure_coding/_index.md b/content/systems/filecoin_files/error_correction/erasure_coding/_index.md similarity index 100% rename from next/content/systems/filecoin_files/error_correction/erasure_coding/_index.md rename to content/systems/filecoin_files/error_correction/erasure_coding/_index.md diff --git a/next/content/systems/filecoin_files/error_correction/erasure_coding/coding.id b/content/systems/filecoin_files/error_correction/erasure_coding/coding.id similarity index 100% rename from next/content/systems/filecoin_files/error_correction/erasure_coding/coding.id rename to content/systems/filecoin_files/error_correction/erasure_coding/coding.id diff --git a/next/content/systems/filecoin_files/error_correction/error_correcting_codes/_index.md b/content/systems/filecoin_files/error_correction/error_correcting_codes/_index.md similarity index 100% rename from next/content/systems/filecoin_files/error_correction/error_correcting_codes/_index.md rename to content/systems/filecoin_files/error_correction/error_correcting_codes/_index.md diff --git a/next/content/systems/filecoin_files/error_correction/error_correcting_codes/coding.id b/content/systems/filecoin_files/error_correction/error_correcting_codes/coding.id similarity index 100% rename from next/content/systems/filecoin_files/error_correction/error_correcting_codes/coding.id rename to content/systems/filecoin_files/error_correction/error_correcting_codes/coding.id diff --git a/next/content/systems/filecoin_files/file/_index.md b/content/systems/filecoin_files/file/_index.md similarity index 100% rename from next/content/systems/filecoin_files/file/_index.md rename to content/systems/filecoin_files/file/_index.md diff --git a/next/content/systems/filecoin_files/file/file.go b/content/systems/filecoin_files/file/file.go similarity index 100% rename from next/content/systems/filecoin_files/file/file.go rename to content/systems/filecoin_files/file/file.go diff --git a/next/content/systems/filecoin_files/file/file.id b/content/systems/filecoin_files/file/file.id similarity index 100% rename from next/content/systems/filecoin_files/file/file.id rename to content/systems/filecoin_files/file/file.id diff --git a/next/content/systems/filecoin_files/file/filestore.id b/content/systems/filecoin_files/file/filestore.id similarity index 100% rename from next/content/systems/filecoin_files/file/filestore.id rename to content/systems/filecoin_files/file/filestore.id diff --git a/next/content/systems/filecoin_files/file/filestore.md b/content/systems/filecoin_files/file/filestore.md similarity index 100% rename from next/content/systems/filecoin_files/file/filestore.md rename to content/systems/filecoin_files/file/filestore.md diff --git a/next/content/systems/filecoin_files/piece/_index.md b/content/systems/filecoin_files/piece/_index.md similarity index 100% rename from next/content/systems/filecoin_files/piece/_index.md rename to content/systems/filecoin_files/piece/_index.md diff --git a/next/content/systems/filecoin_files/piece/piece.id b/content/systems/filecoin_files/piece/piece.id similarity index 100% rename from next/content/systems/filecoin_files/piece/piece.id rename to content/systems/filecoin_files/piece/piece.id diff --git a/next/content/systems/filecoin_files/piece/piece_store.id b/content/systems/filecoin_files/piece/piece_store.id similarity index 100% rename from next/content/systems/filecoin_files/piece/piece_store.id rename to content/systems/filecoin_files/piece/piece_store.id diff --git a/next/content/systems/filecoin_files/piece/piece_store.md b/content/systems/filecoin_files/piece/piece_store.md similarity index 100% rename from next/content/systems/filecoin_files/piece/piece_store.md rename to content/systems/filecoin_files/piece/piece_store.md diff --git a/next/content/systems/filecoin_files/piece/pieces.png b/content/systems/filecoin_files/piece/pieces.png similarity index 100% rename from next/content/systems/filecoin_files/piece/pieces.png rename to content/systems/filecoin_files/piece/pieces.png diff --git a/next/content/systems/filecoin_files/serialization/_index.md b/content/systems/filecoin_files/serialization/_index.md similarity index 100% rename from next/content/systems/filecoin_files/serialization/_index.md rename to content/systems/filecoin_files/serialization/_index.md diff --git a/next/content/systems/filecoin_markets/_index.md b/content/systems/filecoin_markets/_index.md similarity index 100% rename from next/content/systems/filecoin_markets/_index.md rename to content/systems/filecoin_markets/_index.md diff --git a/next/content/systems/filecoin_markets/retrieval_market/_index.md b/content/systems/filecoin_markets/retrieval_market/_index.md similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/_index.md rename to content/systems/filecoin_markets/retrieval_market/_index.md diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_client.id b/content/systems/filecoin_markets/retrieval_market/retrieval_client.id similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_client.id rename to content/systems/filecoin_markets/retrieval_market/retrieval_client.id diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_client.md b/content/systems/filecoin_markets/retrieval_market/retrieval_client.md similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_client.md rename to content/systems/filecoin_markets/retrieval_market/retrieval_client.md diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd b/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd rename to content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.css b/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.css similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.css rename to content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.css diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.svg b/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.svg similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.svg rename to content/systems/filecoin_markets/retrieval_market/retrieval_flow_v0.mmd.svg diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd b/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd rename to content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.css b/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.css similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.css rename to content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.css diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.svg b/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.svg similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.svg rename to content/systems/filecoin_markets/retrieval_market/retrieval_flow_v1.mmd.svg diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.id b/content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.id similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.id rename to content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.id diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.md b/content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.md similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.md rename to content/systems/filecoin_markets/retrieval_market/retrieval_peer_resolver.md diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_protocols.md b/content/systems/filecoin_markets/retrieval_market/retrieval_protocols.md similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_protocols.md rename to content/systems/filecoin_markets/retrieval_market/retrieval_protocols.md diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_provider.id b/content/systems/filecoin_markets/retrieval_market/retrieval_provider.id similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_provider.id rename to content/systems/filecoin_markets/retrieval_market/retrieval_provider.id diff --git a/next/content/systems/filecoin_markets/retrieval_market/retrieval_provider.md b/content/systems/filecoin_markets/retrieval_market/retrieval_provider.md similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/retrieval_provider.md rename to content/systems/filecoin_markets/retrieval_market/retrieval_provider.md diff --git a/next/content/systems/filecoin_markets/retrieval_market/types.id b/content/systems/filecoin_markets/retrieval_market/types.id similarity index 100% rename from next/content/systems/filecoin_markets/retrieval_market/types.id rename to content/systems/filecoin_markets/retrieval_market/types.id diff --git a/next/content/systems/filecoin_markets/storage_market/_index.md b/content/systems/filecoin_markets/storage_market/_index.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/_index.md rename to content/systems/filecoin_markets/storage_market/_index.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_client.id b/content/systems/filecoin_markets/storage_market/storage_client.id similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_client.id rename to content/systems/filecoin_markets/storage_market/storage_client.id diff --git a/next/content/systems/filecoin_markets/storage_market/storage_client.md b/content/systems/filecoin_markets/storage_market/storage_client.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_client.md rename to content/systems/filecoin_markets/storage_market/storage_client.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/_index.md b/content/systems/filecoin_markets/storage_market/storage_deal/_index.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/_index.md rename to content/systems/filecoin_markets/storage_market/storage_deal/_index.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.css b/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.css similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.css rename to content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.css diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd b/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd rename to content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd.svg b/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd.svg similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd.svg rename to content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-flow.mmd.svg diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.css b/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.css similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.css rename to content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.css diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd b/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd rename to content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd.svg b/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd.svg similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd.svg rename to content/systems/filecoin_markets/storage_market/storage_deal/diagrams/deal-payment.mmd.svg diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/faults.md b/content/systems/filecoin_markets/storage_market/storage_deal/faults.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/faults.md rename to content/systems/filecoin_markets/storage_market/storage_deal/faults.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_flow.md b/content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_flow.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_flow.md rename to content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_flow.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_states.md b/content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_states.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_states.md rename to content/systems/filecoin_markets/storage_market/storage_deal/storage_deal_states.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_market.go b/content/systems/filecoin_markets/storage_market/storage_market.go similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_market.go rename to content/systems/filecoin_markets/storage_market/storage_market.go diff --git a/next/content/systems/filecoin_markets/storage_market/storage_market.id b/content/systems/filecoin_markets/storage_market/storage_market.id similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_market.id rename to content/systems/filecoin_markets/storage_market/storage_market.id diff --git a/next/content/systems/filecoin_markets/storage_market/storage_market_actor.md b/content/systems/filecoin_markets/storage_market/storage_market_actor.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_market_actor.md rename to content/systems/filecoin_markets/storage_market/storage_market_actor.md diff --git a/next/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd b/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd rename to content/systems/filecoin_markets/storage_market/storage_market_flow.mmd diff --git a/next/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.css b/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.css similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.css rename to content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.css diff --git a/next/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.svg b/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.svg similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.svg rename to content/systems/filecoin_markets/storage_market/storage_market_flow.mmd.svg diff --git a/next/content/systems/filecoin_markets/storage_market/storage_provider.id b/content/systems/filecoin_markets/storage_market/storage_provider.id similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_provider.id rename to content/systems/filecoin_markets/storage_market/storage_provider.id diff --git a/next/content/systems/filecoin_markets/storage_market/storage_provider.md b/content/systems/filecoin_markets/storage_market/storage_provider.md similarity index 100% rename from next/content/systems/filecoin_markets/storage_market/storage_provider.md rename to content/systems/filecoin_markets/storage_market/storage_provider.md diff --git a/next/content/systems/filecoin_mining/_index.md b/content/systems/filecoin_mining/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/_index.md rename to content/systems/filecoin_mining/_index.md diff --git a/next/content/systems/filecoin_mining/base_mining.id b/content/systems/filecoin_mining/base_mining.id similarity index 100% rename from next/content/systems/filecoin_mining/base_mining.id rename to content/systems/filecoin_mining/base_mining.id diff --git a/next/content/systems/filecoin_mining/sector/_index.md b/content/systems/filecoin_mining/sector/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/sector/_index.md rename to content/systems/filecoin_mining/sector/_index.md diff --git a/next/content/systems/filecoin_mining/sector/lifecycle.md b/content/systems/filecoin_mining/sector/lifecycle.md similarity index 100% rename from next/content/systems/filecoin_mining/sector/lifecycle.md rename to content/systems/filecoin_mining/sector/lifecycle.md diff --git a/next/content/systems/filecoin_mining/sector/posting.go b/content/systems/filecoin_mining/sector/posting.go similarity index 100% rename from next/content/systems/filecoin_mining/sector/posting.go rename to content/systems/filecoin_mining/sector/posting.go diff --git a/next/content/systems/filecoin_mining/sector/posting.id b/content/systems/filecoin_mining/sector/posting.id similarity index 100% rename from next/content/systems/filecoin_mining/sector/posting.id rename to content/systems/filecoin_mining/sector/posting.id diff --git a/next/content/systems/filecoin_mining/sector/posting.md b/content/systems/filecoin_mining/sector/posting.md similarity index 100% rename from next/content/systems/filecoin_mining/sector/posting.md rename to content/systems/filecoin_mining/sector/posting.md diff --git a/next/content/systems/filecoin_mining/sector/sealing.go b/content/systems/filecoin_mining/sector/sealing.go similarity index 100% rename from next/content/systems/filecoin_mining/sector/sealing.go rename to content/systems/filecoin_mining/sector/sealing.go diff --git a/next/content/systems/filecoin_mining/sector/sealing.id b/content/systems/filecoin_mining/sector/sealing.id similarity index 100% rename from next/content/systems/filecoin_mining/sector/sealing.id rename to content/systems/filecoin_mining/sector/sealing.id diff --git a/next/content/systems/filecoin_mining/sector/sealing.md b/content/systems/filecoin_mining/sector/sealing.md similarity index 100% rename from next/content/systems/filecoin_mining/sector/sealing.md rename to content/systems/filecoin_mining/sector/sealing.md diff --git a/next/content/systems/filecoin_mining/sector/sector.go b/content/systems/filecoin_mining/sector/sector.go similarity index 100% rename from next/content/systems/filecoin_mining/sector/sector.go rename to content/systems/filecoin_mining/sector/sector.go diff --git a/next/content/systems/filecoin_mining/sector/sector.id b/content/systems/filecoin_mining/sector/sector.id similarity index 100% rename from next/content/systems/filecoin_mining/sector/sector.id rename to content/systems/filecoin_mining/sector/sector.id diff --git a/next/content/systems/filecoin_mining/sector/sectors.png b/content/systems/filecoin_mining/sector/sectors.png similarity index 100% rename from next/content/systems/filecoin_mining/sector/sectors.png rename to content/systems/filecoin_mining/sector/sectors.png diff --git a/next/content/systems/filecoin_mining/sector/sectorset.go b/content/systems/filecoin_mining/sector/sectorset.go similarity index 100% rename from next/content/systems/filecoin_mining/sector/sectorset.go rename to content/systems/filecoin_mining/sector/sectorset.go diff --git a/next/content/systems/filecoin_mining/sector/sectorset.id b/content/systems/filecoin_mining/sector/sectorset.id similarity index 100% rename from next/content/systems/filecoin_mining/sector/sectorset.id rename to content/systems/filecoin_mining/sector/sectorset.id diff --git a/next/content/systems/filecoin_mining/sector/sectorset.md b/content/systems/filecoin_mining/sector/sectorset.md similarity index 100% rename from next/content/systems/filecoin_mining/sector/sectorset.md rename to content/systems/filecoin_mining/sector/sectorset.md diff --git a/next/content/systems/filecoin_mining/sector_index/_index.md b/content/systems/filecoin_mining/sector_index/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/_index.md rename to content/systems/filecoin_mining/sector_index/_index.md diff --git a/next/content/systems/filecoin_mining/sector_index/sector_builder.id b/content/systems/filecoin_mining/sector_index/sector_builder.id similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/sector_builder.id rename to content/systems/filecoin_mining/sector_index/sector_builder.id diff --git a/next/content/systems/filecoin_mining/sector_index/sector_builder.md b/content/systems/filecoin_mining/sector_index/sector_builder.md similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/sector_builder.md rename to content/systems/filecoin_mining/sector_index/sector_builder.md diff --git a/next/content/systems/filecoin_mining/sector_index/sector_index_subsystem.go b/content/systems/filecoin_mining/sector_index/sector_index_subsystem.go similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/sector_index_subsystem.go rename to content/systems/filecoin_mining/sector_index/sector_index_subsystem.go diff --git a/next/content/systems/filecoin_mining/sector_index/sector_index_subsystem.id b/content/systems/filecoin_mining/sector_index/sector_index_subsystem.id similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/sector_index_subsystem.id rename to content/systems/filecoin_mining/sector_index/sector_index_subsystem.id diff --git a/next/content/systems/filecoin_mining/sector_index/sector_store.id b/content/systems/filecoin_mining/sector_index/sector_store.id similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/sector_store.id rename to content/systems/filecoin_mining/sector_index/sector_store.id diff --git a/next/content/systems/filecoin_mining/sector_index/sector_store.md b/content/systems/filecoin_mining/sector_index/sector_store.md similarity index 100% rename from next/content/systems/filecoin_mining/sector_index/sector_store.md rename to content/systems/filecoin_mining/sector_index/sector_store.md diff --git a/next/content/systems/filecoin_mining/storage_mining/_index.md b/content/systems/filecoin_mining/storage_mining/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/_index.md rename to content/systems/filecoin_mining/storage_mining/_index.md diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot b/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot b/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.svg b/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/miner_post_state_machine_legend.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot b/content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/mining_cycle.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_chain_fsm.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm_chain.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm_chain.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm_chain.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_fsm_chain.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_offchain_fsm.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_fsm.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_legend.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.dot.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.svg b/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.svg similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.svg rename to content/systems/filecoin_mining/storage_mining/diagrams/sector_state_machine_legend.svg diff --git a/next/content/systems/filecoin_mining/storage_mining/mining_cycle/index.md b/content/systems/filecoin_mining/storage_mining/mining_cycle/index.md similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/mining_cycle/index.md rename to content/systems/filecoin_mining/storage_mining/mining_cycle/index.md diff --git a/next/content/systems/filecoin_mining/storage_mining/mining_cycle/timing.png b/content/systems/filecoin_mining/storage_mining/mining_cycle/timing.png similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/mining_cycle/timing.png rename to content/systems/filecoin_mining/storage_mining/mining_cycle/timing.png diff --git a/next/content/systems/filecoin_mining/storage_mining/storage_miner_actor.md b/content/systems/filecoin_mining/storage_mining/storage_miner_actor.md similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/storage_miner_actor.md rename to content/systems/filecoin_mining/storage_mining/storage_miner_actor.md diff --git a/next/content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go b/content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go rename to content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.go diff --git a/next/content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id b/content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id similarity index 100% rename from next/content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id rename to content/systems/filecoin_mining/storage_mining/storage_mining_subsystem.id diff --git a/next/content/systems/filecoin_mining/storage_proving/_index.md b/content/systems/filecoin_mining/storage_proving/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/_index.md rename to content/systems/filecoin_mining/storage_proving/_index.md diff --git a/next/content/systems/filecoin_mining/storage_proving/poster/_index.md b/content/systems/filecoin_mining/storage_proving/poster/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/poster/_index.md rename to content/systems/filecoin_mining/storage_proving/poster/_index.md diff --git a/next/content/systems/filecoin_mining/storage_proving/poster/post_generator.go b/content/systems/filecoin_mining/storage_proving/poster/post_generator.go similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/poster/post_generator.go rename to content/systems/filecoin_mining/storage_proving/poster/post_generator.go diff --git a/next/content/systems/filecoin_mining/storage_proving/poster/post_generator.id b/content/systems/filecoin_mining/storage_proving/poster/post_generator.id similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/poster/post_generator.id rename to content/systems/filecoin_mining/storage_proving/poster/post_generator.id diff --git a/next/content/systems/filecoin_mining/storage_proving/sealer/_index.md b/content/systems/filecoin_mining/storage_proving/sealer/_index.md similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/sealer/_index.md rename to content/systems/filecoin_mining/storage_proving/sealer/_index.md diff --git a/next/content/systems/filecoin_mining/storage_proving/sealer/sealer.go b/content/systems/filecoin_mining/storage_proving/sealer/sealer.go similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/sealer/sealer.go rename to content/systems/filecoin_mining/storage_proving/sealer/sealer.go diff --git a/next/content/systems/filecoin_mining/storage_proving/sealer/sealer.id b/content/systems/filecoin_mining/storage_proving/sealer/sealer.id similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/sealer/sealer.id rename to content/systems/filecoin_mining/storage_proving/sealer/sealer.id diff --git a/next/content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.go b/content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.go similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.go rename to content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.go diff --git a/next/content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.id b/content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.id similarity index 100% rename from next/content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.id rename to content/systems/filecoin_mining/storage_proving/storage_proving_subsystem.id diff --git a/next/content/systems/filecoin_nodes/_index.md b/content/systems/filecoin_nodes/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/_index.md rename to content/systems/filecoin_nodes/_index.md diff --git a/next/content/systems/filecoin_nodes/clock/_index.md b/content/systems/filecoin_nodes/clock/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/clock/_index.md rename to content/systems/filecoin_nodes/clock/_index.md diff --git a/next/content/systems/filecoin_nodes/clock/clock_subsystem.go b/content/systems/filecoin_nodes/clock/clock_subsystem.go similarity index 100% rename from next/content/systems/filecoin_nodes/clock/clock_subsystem.go rename to content/systems/filecoin_nodes/clock/clock_subsystem.go diff --git a/next/content/systems/filecoin_nodes/clock/clock_subsystem.id b/content/systems/filecoin_nodes/clock/clock_subsystem.id similarity index 100% rename from next/content/systems/filecoin_nodes/clock/clock_subsystem.id rename to content/systems/filecoin_nodes/clock/clock_subsystem.id diff --git a/next/content/systems/filecoin_nodes/network/_index.md b/content/systems/filecoin_nodes/network/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/network/_index.md rename to content/systems/filecoin_nodes/network/_index.md diff --git a/next/content/systems/filecoin_nodes/network/hello.id b/content/systems/filecoin_nodes/network/hello.id similarity index 100% rename from next/content/systems/filecoin_nodes/network/hello.id rename to content/systems/filecoin_nodes/network/hello.id diff --git a/next/content/systems/filecoin_nodes/network/network.id b/content/systems/filecoin_nodes/network/network.id similarity index 100% rename from next/content/systems/filecoin_nodes/network/network.id rename to content/systems/filecoin_nodes/network/network.id diff --git a/next/content/systems/filecoin_nodes/node_base/filecoin_node.id b/content/systems/filecoin_nodes/node_base/filecoin_node.id similarity index 100% rename from next/content/systems/filecoin_nodes/node_base/filecoin_node.id rename to content/systems/filecoin_nodes/node_base/filecoin_node.id diff --git a/next/content/systems/filecoin_nodes/node_base/network_params.go b/content/systems/filecoin_nodes/node_base/network_params.go similarity index 100% rename from next/content/systems/filecoin_nodes/node_base/network_params.go rename to content/systems/filecoin_nodes/node_base/network_params.go diff --git a/next/content/systems/filecoin_nodes/node_types/_index.md b/content/systems/filecoin_nodes/node_types/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/_index.md rename to content/systems/filecoin_nodes/node_types/_index.md diff --git a/next/content/systems/filecoin_nodes/node_types/client_node.md b/content/systems/filecoin_nodes/node_types/client_node.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/client_node.md rename to content/systems/filecoin_nodes/node_types/client_node.md diff --git a/next/content/systems/filecoin_nodes/node_types/node.md b/content/systems/filecoin_nodes/node_types/node.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/node.md rename to content/systems/filecoin_nodes/node_types/node.md diff --git a/next/content/systems/filecoin_nodes/node_types/node_types.md b/content/systems/filecoin_nodes/node_types/node_types.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/node_types.md rename to content/systems/filecoin_nodes/node_types/node_types.md diff --git a/next/content/systems/filecoin_nodes/node_types/relayer_node.md b/content/systems/filecoin_nodes/node_types/relayer_node.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/relayer_node.md rename to content/systems/filecoin_nodes/node_types/relayer_node.md diff --git a/next/content/systems/filecoin_nodes/node_types/retrieval_miner_node.md b/content/systems/filecoin_nodes/node_types/retrieval_miner_node.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/retrieval_miner_node.md rename to content/systems/filecoin_nodes/node_types/retrieval_miner_node.md diff --git a/next/content/systems/filecoin_nodes/node_types/storage_miner_node.id b/content/systems/filecoin_nodes/node_types/storage_miner_node.id similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/storage_miner_node.id rename to content/systems/filecoin_nodes/node_types/storage_miner_node.id diff --git a/next/content/systems/filecoin_nodes/node_types/storage_miner_node.md b/content/systems/filecoin_nodes/node_types/storage_miner_node.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/storage_miner_node.md rename to content/systems/filecoin_nodes/node_types/storage_miner_node.md diff --git a/next/content/systems/filecoin_nodes/node_types/verifier_node.md b/content/systems/filecoin_nodes/node_types/verifier_node.md similarity index 100% rename from next/content/systems/filecoin_nodes/node_types/verifier_node.md rename to content/systems/filecoin_nodes/node_types/verifier_node.md diff --git a/next/content/systems/filecoin_nodes/repository/_index.md b/content/systems/filecoin_nodes/repository/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/repository/_index.md rename to content/systems/filecoin_nodes/repository/_index.md diff --git a/next/content/systems/filecoin_nodes/repository/config/_index.md b/content/systems/filecoin_nodes/repository/config/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/repository/config/_index.md rename to content/systems/filecoin_nodes/repository/config/_index.md diff --git a/next/content/systems/filecoin_nodes/repository/config/config.id b/content/systems/filecoin_nodes/repository/config/config.id similarity index 100% rename from next/content/systems/filecoin_nodes/repository/config/config.id rename to content/systems/filecoin_nodes/repository/config/config.id diff --git a/next/content/systems/filecoin_nodes/repository/ipldstore/_index.md b/content/systems/filecoin_nodes/repository/ipldstore/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/repository/ipldstore/_index.md rename to content/systems/filecoin_nodes/repository/ipldstore/_index.md diff --git a/next/content/systems/filecoin_nodes/repository/key_store/_index.md b/content/systems/filecoin_nodes/repository/key_store/_index.md similarity index 100% rename from next/content/systems/filecoin_nodes/repository/key_store/_index.md rename to content/systems/filecoin_nodes/repository/key_store/_index.md diff --git a/next/content/systems/filecoin_nodes/repository/key_store/key_store.id b/content/systems/filecoin_nodes/repository/key_store/key_store.id similarity index 100% rename from next/content/systems/filecoin_nodes/repository/key_store/key_store.id rename to content/systems/filecoin_nodes/repository/key_store/key_store.id diff --git a/next/content/systems/filecoin_nodes/repository/repository_subsystem.id b/content/systems/filecoin_nodes/repository/repository_subsystem.id similarity index 100% rename from next/content/systems/filecoin_nodes/repository/repository_subsystem.id rename to content/systems/filecoin_nodes/repository/repository_subsystem.id diff --git a/next/content/systems/filecoin_token/_index.md b/content/systems/filecoin_token/_index.md similarity index 100% rename from next/content/systems/filecoin_token/_index.md rename to content/systems/filecoin_token/_index.md diff --git a/next/content/systems/filecoin_token/base.id b/content/systems/filecoin_token/base.id similarity index 100% rename from next/content/systems/filecoin_token/base.id rename to content/systems/filecoin_token/base.id diff --git a/next/content/systems/filecoin_token/multisig/_index.md b/content/systems/filecoin_token/multisig/_index.md similarity index 100% rename from next/content/systems/filecoin_token/multisig/_index.md rename to content/systems/filecoin_token/multisig/_index.md diff --git a/next/content/systems/filecoin_token/multisig/multisig_actor.md b/content/systems/filecoin_token/multisig/multisig_actor.md similarity index 100% rename from next/content/systems/filecoin_token/multisig/multisig_actor.md rename to content/systems/filecoin_token/multisig/multisig_actor.md diff --git a/next/content/systems/filecoin_token/payment_channels/_index.md b/content/systems/filecoin_token/payment_channels/_index.md similarity index 100% rename from next/content/systems/filecoin_token/payment_channels/_index.md rename to content/systems/filecoin_token/payment_channels/_index.md diff --git a/next/content/systems/filecoin_token/payment_channels/payment_channel_actor.md b/content/systems/filecoin_token/payment_channels/payment_channel_actor.md similarity index 100% rename from next/content/systems/filecoin_token/payment_channels/payment_channel_actor.md rename to content/systems/filecoin_token/payment_channels/payment_channel_actor.md diff --git a/next/content/systems/filecoin_token/wallets.md b/content/systems/filecoin_token/wallets.md similarity index 100% rename from next/content/systems/filecoin_token/wallets.md rename to content/systems/filecoin_token/wallets.md diff --git a/next/content/systems/filecoin_vm/_index.md b/content/systems/filecoin_vm/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/_index.md rename to content/systems/filecoin_vm/_index.md diff --git a/next/content/systems/filecoin_vm/actor/_index.md b/content/systems/filecoin_vm/actor/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/actor/_index.md rename to content/systems/filecoin_vm/actor/_index.md diff --git a/next/content/systems/filecoin_vm/actor/actor.go b/content/systems/filecoin_vm/actor/actor.go similarity index 100% rename from next/content/systems/filecoin_vm/actor/actor.go rename to content/systems/filecoin_vm/actor/actor.go diff --git a/next/content/systems/filecoin_vm/actor/actor.id b/content/systems/filecoin_vm/actor/actor.id similarity index 100% rename from next/content/systems/filecoin_vm/actor/actor.id rename to content/systems/filecoin_vm/actor/actor.id diff --git a/next/content/systems/filecoin_vm/indices/_index.md b/content/systems/filecoin_vm/indices/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/indices/_index.md rename to content/systems/filecoin_vm/indices/_index.md diff --git a/next/content/systems/filecoin_vm/interpreter/_index.md b/content/systems/filecoin_vm/interpreter/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/interpreter/_index.md rename to content/systems/filecoin_vm/interpreter/_index.md diff --git a/next/content/systems/filecoin_vm/interpreter/vm_interpreter.go b/content/systems/filecoin_vm/interpreter/vm_interpreter.go similarity index 100% rename from next/content/systems/filecoin_vm/interpreter/vm_interpreter.go rename to content/systems/filecoin_vm/interpreter/vm_interpreter.go diff --git a/next/content/systems/filecoin_vm/interpreter/vm_interpreter.id b/content/systems/filecoin_vm/interpreter/vm_interpreter.id similarity index 100% rename from next/content/systems/filecoin_vm/interpreter/vm_interpreter.id rename to content/systems/filecoin_vm/interpreter/vm_interpreter.id diff --git a/next/content/systems/filecoin_vm/interpreter/vm_interpreter_old.md b/content/systems/filecoin_vm/interpreter/vm_interpreter_old.md similarity index 100% rename from next/content/systems/filecoin_vm/interpreter/vm_interpreter_old.md rename to content/systems/filecoin_vm/interpreter/vm_interpreter_old.md diff --git a/next/content/systems/filecoin_vm/interpreter/vm_registry.go b/content/systems/filecoin_vm/interpreter/vm_registry.go similarity index 100% rename from next/content/systems/filecoin_vm/interpreter/vm_registry.go rename to content/systems/filecoin_vm/interpreter/vm_registry.go diff --git a/next/content/systems/filecoin_vm/message/_index.md b/content/systems/filecoin_vm/message/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/message/_index.md rename to content/systems/filecoin_vm/message/_index.md diff --git a/next/content/systems/filecoin_vm/message/message.go b/content/systems/filecoin_vm/message/message.go similarity index 100% rename from next/content/systems/filecoin_vm/message/message.go rename to content/systems/filecoin_vm/message/message.go diff --git a/next/content/systems/filecoin_vm/message/message.id b/content/systems/filecoin_vm/message/message.id similarity index 100% rename from next/content/systems/filecoin_vm/message/message.id rename to content/systems/filecoin_vm/message/message.id diff --git a/next/content/systems/filecoin_vm/runtime/_index.md b/content/systems/filecoin_vm/runtime/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/runtime/_index.md rename to content/systems/filecoin_vm/runtime/_index.md diff --git a/next/content/systems/filecoin_vm/runtime/gascost/_index.md b/content/systems/filecoin_vm/runtime/gascost/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/runtime/gascost/_index.md rename to content/systems/filecoin_vm/runtime/gascost/_index.md diff --git a/next/content/systems/filecoin_vm/runtime/gascost/vm_gascosts.go b/content/systems/filecoin_vm/runtime/gascost/vm_gascosts.go similarity index 100% rename from next/content/systems/filecoin_vm/runtime/gascost/vm_gascosts.go rename to content/systems/filecoin_vm/runtime/gascost/vm_gascosts.go diff --git a/next/content/systems/filecoin_vm/runtime/impl/codeload.go b/content/systems/filecoin_vm/runtime/impl/codeload.go similarity index 100% rename from next/content/systems/filecoin_vm/runtime/impl/codeload.go rename to content/systems/filecoin_vm/runtime/impl/codeload.go diff --git a/next/content/systems/filecoin_vm/runtime/impl/receipt.go b/content/systems/filecoin_vm/runtime/impl/receipt.go similarity index 100% rename from next/content/systems/filecoin_vm/runtime/impl/receipt.go rename to content/systems/filecoin_vm/runtime/impl/receipt.go diff --git a/next/content/systems/filecoin_vm/runtime/impl/runtime.go b/content/systems/filecoin_vm/runtime/impl/runtime.go similarity index 100% rename from next/content/systems/filecoin_vm/runtime/impl/runtime.go rename to content/systems/filecoin_vm/runtime/impl/runtime.go diff --git a/next/content/systems/filecoin_vm/runtime/impl/runtime_compute.go b/content/systems/filecoin_vm/runtime/impl/runtime_compute.go similarity index 100% rename from next/content/systems/filecoin_vm/runtime/impl/runtime_compute.go rename to content/systems/filecoin_vm/runtime/impl/runtime_compute.go diff --git a/next/content/systems/filecoin_vm/state_tree/_index.md b/content/systems/filecoin_vm/state_tree/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/state_tree/_index.md rename to content/systems/filecoin_vm/state_tree/_index.md diff --git a/next/content/systems/filecoin_vm/state_tree/convenience_api.id b/content/systems/filecoin_vm/state_tree/convenience_api.id similarity index 100% rename from next/content/systems/filecoin_vm/state_tree/convenience_api.id rename to content/systems/filecoin_vm/state_tree/convenience_api.id diff --git a/next/content/systems/filecoin_vm/state_tree/state_tree.go b/content/systems/filecoin_vm/state_tree/state_tree.go similarity index 100% rename from next/content/systems/filecoin_vm/state_tree/state_tree.go rename to content/systems/filecoin_vm/state_tree/state_tree.go diff --git a/next/content/systems/filecoin_vm/state_tree/state_tree.id b/content/systems/filecoin_vm/state_tree/state_tree.id similarity index 100% rename from next/content/systems/filecoin_vm/state_tree/state_tree.id rename to content/systems/filecoin_vm/state_tree/state_tree.id diff --git a/next/content/systems/filecoin_vm/sysactors/_index.md b/content/systems/filecoin_vm/sysactors/_index.md similarity index 100% rename from next/content/systems/filecoin_vm/sysactors/_index.md rename to content/systems/filecoin_vm/sysactors/_index.md diff --git a/next/content/systems/filecoin_vm/sysactors/account_actor.md b/content/systems/filecoin_vm/sysactors/account_actor.md similarity index 100% rename from next/content/systems/filecoin_vm/sysactors/account_actor.md rename to content/systems/filecoin_vm/sysactors/account_actor.md diff --git a/next/content/systems/filecoin_vm/sysactors/cron_actor.md b/content/systems/filecoin_vm/sysactors/cron_actor.md similarity index 100% rename from next/content/systems/filecoin_vm/sysactors/cron_actor.md rename to content/systems/filecoin_vm/sysactors/cron_actor.md diff --git a/next/content/systems/filecoin_vm/sysactors/init_actor.md b/content/systems/filecoin_vm/sysactors/init_actor.md similarity index 100% rename from next/content/systems/filecoin_vm/sysactors/init_actor.md rename to content/systems/filecoin_vm/sysactors/init_actor.md diff --git a/next/content/systems/filecoin_vm/sysactors/reward_actor.md b/content/systems/filecoin_vm/sysactors/reward_actor.md similarity index 100% rename from next/content/systems/filecoin_vm/sysactors/reward_actor.md rename to content/systems/filecoin_vm/sysactors/reward_actor.md diff --git a/next/content/systems/filecoin_vm/vm.id b/content/systems/filecoin_vm/vm.id similarity index 100% rename from next/content/systems/filecoin_vm/vm.id rename to content/systems/filecoin_vm/vm.id diff --git a/deps/package.json b/deps/package.json deleted file mode 100644 index 39286b72e..000000000 --- a/deps/package.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "name": "filecoin-spec-deps", - "version": "1.0.0", - "description": "", - "main": "index.js", - "dependencies": { - "mermaid": "8.4.3", - "mermaid.cli": "hannahhoward/mermaid.cli#0ced2973ab69ec04a0866b979a851f9d51d94677", - "phantomjs-prebuilt": "^2.1.16" - }, - "devDependencies": {}, - "scripts": { - "test": "echo \"Error: no test specified\" && exit 1" - }, - "author": "", - "license": "ISC" -} diff --git a/go.mod b/go.mod new file mode 100644 index 000000000..c9b6a249d --- /dev/null +++ b/go.mod @@ -0,0 +1,5 @@ +module github.com/filecoin-project/specs + +go 1.14 + +require github.com/filecoin-project/specs-actors v0.7.2 // indirect diff --git a/go.sum b/go.sum new file mode 100644 index 000000000..e6bd4ae5e --- /dev/null +++ b/go.sum @@ -0,0 +1,99 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/filecoin-project/go-address v0.0.2-0.20200218010043-eb9bb40ed5be/go.mod h1:SAOwJoakQ8EPjwNIsiakIQKsoKdkcbx8U3IapgCg9R0= +github.com/filecoin-project/go-amt-ipld/v2 v2.0.1-0.20200424220931-6263827e49f2/go.mod h1:boRtQhzmxNocrMxOXo1NYn4oUc1NGvR8tEa79wApNXg= +github.com/filecoin-project/go-bitfield v0.0.3/go.mod h1:Ry9/iUlWSyjPUzlAvdnfy4Gtvrq4kWmWDztCU1yEgJY= +github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ= +github.com/filecoin-project/specs-actors v0.7.2 h1:zMOU6LJS3gz7E9rwPPiPgTVawe7ypUWK9ugPBiaDZGc= +github.com/filecoin-project/specs-actors v0.7.2/go.mod h1:oJMdZvXSDZWWvjDxCkAywNz2MhgxV6dBzSCVg4vNf4o= +github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gopherjs/gopherjs v0.0.0-20190812055157-5d271430af9f/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU= +github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48= +github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY= +github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/go-cid v0.0.3/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog= +github.com/ipfs/go-hamt-ipld v0.0.15-0.20200131012125-dd88a59d3f2e/go.mod h1:9aQJu/i/TaRDW6jqB5U217dLIDopn50wxLdHXM2CTfE= +github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc= +github.com/ipfs/go-ipld-cbor v0.0.3/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc= +github.com/ipfs/go-ipld-cbor v0.0.4/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4= +github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dCDnkOJhcZkms= +github.com/ipfs/go-ipld-format v0.0.2/go.mod h1:4B6+FM2u9OJ9zCV+kSbgFAZlOrv1Hqbf0INGQgiKf9k= +github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= +github.com/ipfs/go-log v1.0.0/go.mod h1:JO7RzlMK6rA+CIxFMLOuB6Wf5b81GDiKElL7UPSIKjA= +github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52/go.mod h1:fdg+/X9Gg4AsAIzWpEHwnqd+QY3b7lajxyjE1m4hkq4= +github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= +github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ= +github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= +github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= +github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= +github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= +github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA= +github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= +github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U= +github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= +github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= +github.com/multiformats/go-varint v0.0.2/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= +github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= +github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/polydawn/refmt v0.0.0-20190221155625-df39d6c2d992/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o= +github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o= +github.com/polydawn/refmt v0.0.0-20190809202753-05966cbd336a/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/assertions v1.0.1/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM= +github.com/smartystreets/goconvey v0.0.0-20190222223459-a17d461953aa/go.mod h1:2RVY1rIf+2J2o/IM9+vPq9RzmHDSseB7FoXiSNIUsoU= +github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/warpfork/go-wish v0.0.0-20180510122957-5ad1f5abf436/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= +github.com/warpfork/go-wish v0.0.0-20190328234359-8b3e70f8e830/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= +github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY= +github.com/whyrusleeping/cbor-gen v0.0.0-20200123233031-1cdf64d27158/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI= +github.com/whyrusleeping/cbor-gen v0.0.0-20200414195334-429a0b5e922e/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI= +github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM= +go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/net v0.0.0-20190227160552-c95aed5357e7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/hugo/assets/_custom.scss b/hugo/assets/_custom.scss deleted file mode 100644 index 2ad02619d..000000000 --- a/hugo/assets/_custom.scss +++ /dev/null @@ -1,402 +0,0 @@ -// Colors -$darkGray: #373f52; -$mediumGray: #959595; -$gray: #e1e1e1; -$lightestGray: #d5dae6; -$white: #ffffff; -$black: #000000; -$purple: #8f6cd6; -$lightPurple: #7f60be; -$codeBackground: #f7f9fc; -$detailGray: #f7f7f7; -$groupGray: #dddddd; -$yellow: #f1c40f; -$orange: #e67e22; -$red: #e74c3c; -$darkBlue: #1f5b83; -$blue: #3498db; - -// width - -.container { - max-width: 90rem; -} - -.book-menu { - flex: 0 0 22rem; -} - -.book-menu nav { - width: 22rem; -} - - -// header-highlight - -$header-highlight: #e6fbfd; - -h1, h2, h3, h4, h5, h6 { - background: $header-highlight; -} - -h1 { - font-weight: bold; - padding: 20px; -} - -h2 { - padding: 18px; -} - -h3 { - padding: 16px; -} - -h4 { - padding: 14px; -} - -h5 { - padding: 12px; -} - -h6 { - padding: 10px; - font-size: 14px; - font-weight: normal; -} - -// section numbering - -$section-number-menu-color: #a9a9a9; - -// this has to happen once for the menu, once for the content -// so that the counting is right for both. -body, .book-menu, .book-page { - counter-reset : h1; -} - -h1, .menu-item.depth-1 { - counter-reset : h2; -} - -h2, .menu-item.depth-2 { - counter-reset : h3; -} - -h3, .menu-item.depth-3 { - counter-reset : h4; -} - -h4, .menu-item.depth-4 { - counter-reset : h5; -} - -h5, .menu-item.depth-5 { - counter-reset : h6; -} - -.menu-item:before { - color: $section-number-menu-color; -} - -h1:before, h2:before, h3:before, h4:before, h5:before, h6:before { - color: $section-number-menu-color; -} - -.menu-item.highlight { -// background: rgb(231, 252, 255); // probably not needed. here if we do -} - -article h1:before, .menu-item.depth-1:before { - content : counter(h1,decimal) ". "; - counter-increment : h1; -} - -article h2:before, .menu-item.depth-2:before { - content : counter(h1,decimal) "." counter(h2,decimal) ". "; - counter-increment : h2; -} - -article h3:before, .menu-item.depth-3:before { - content : counter(h1,decimal) "." counter(h2,decimal) "." counter(h3,decimal) ". "; - counter-increment : h3; -} - -article h4:before, .menu-item.depth-4:before { - content : counter(h1,decimal) "." counter(h2,decimal) "." counter(h3,decimal) "." counter(h4,decimal) ". "; - counter-increment : h4; -} - -article h5:before, .menu-item.depth-5:before { - content : counter(h1,decimal) "." counter(h2,decimal) "." counter(h3,decimal) "." counter(h4,decimal) "." counter(h5,decimal) ". "; - counter-increment : h5; -} - -article h6:before, .menu-item.depth-6:before { - content : counter(h1,decimal) "." counter(h2,decimal) "." counter(h3,decimal) "." counter(h4,decimal) "." counter(h5,decimal) "." counter(h6,decimal) ". "; - counter-increment : h6; -} - -h1.nocount:before, h2.nocount:before, h3.nocount:before, h4.nocount:before, h5.nocount:before, h6.nocount:before, -.menu-item.nocount:before { - content : ""; - counter-increment : none; -} - -// scrollspy highlighting - -#menu-toc li:not(.active-parent) > ul.maybe-hide > li:not(.active) { - display: none; -} - -#menu-toc ul li.active-parent, -#menu-toc ul.maybe-hide li.active-parent, -#menu-toc li.active-parent > ul.maybe-hide > li { - display: block; -} - -#menu-toc ul.maybe-hide li.active-parent > li - -#menu-toc ul li.active { - display: block; -} - -#menu-toc li > a { - padding-left: 5px; -} - -#menu-toc li.active > a { - background-color: $header-highlight; - padding: 8px 5px; - margin: -8px 0px; - // border-left: 3px solid $header-highlight; -} - -// diagram - -.diagram { - text-align: center; -} - -// header links - -h1:after, h2:after, h3:after, h4:after, h5:after, h6:after { - float:right; - content: "🔗"; - opacity: 0.25; -} - -h1:after, h2:after, h3:after, h4:after, h5:after, h6:after { - float:right; - content: "🔗"; - opacity: 0.25; -} - -h1:hover:after, h2:hover:after, h3:hover:after, h4:hover:after, h5:hover:after, h6:hover:after { - opacity: 1.0; - cursor: pointer; -} - - - -.header-link { - position: absolute; - left: -0.5em; - opacity: 0; - - transition: opacity 0.2s ease-in-out 0.1s; -} - -h1:hover .header-link, -h2:hover .header-link, -h3:hover .header-link, -h4:hover .header-link, -h5:hover .header-link, -h6:hover .header-link { - opacity: 1; -} - -// remove scrolling -html { - scroll-behavior: auto; -} - -// TocMap - -.tocMap { - position: relative; - width: 100%; - text-align: center; -} - -// hide the first label -.tocMap > .tocMap-item > .tocMap-item-label { - display: none; -} - -.tocMap-item { - background-color: inherit; - background-blend-mode: screen; - margin: 10px; - padding: 10px; - width: 120px; - font-size: 16px; - font-weight: bold; - height: 80px; - - display: inline-flex; - flex-direction: row; -} - -.tocMap-item.expanded { - width: 100%; - height: auto; - min-height: 80px; - display: flex; - flex-direction: row; - flex-wrap: nowrap; -} - - -.tocMap-children { -// position: absolute; -// right: 0px; -// top:0px; -// bottom:0px; - height: 100%; - display: none; -} - -.tocMap-item.expanded > .tocMap-children { - width: calc(100% - 120px); - flex-grow: 3; - display: inline-flex; - flex-direction: row; - flex-wrap: wrap; -} - -.tocMap-item-label { - font-size: 18px; - font-weight: bold; - width: 140px; - height: 100%; - color: #000; - line-height: 1.2em; - - display: inline-flex; - justify-content: center; - align-items: center; - position: relative; -} - -.tocMap-item-label i.menuIcon { - font-size: 30px; - font-style: inherit; -} - -.tocMap-item-label i.statusIcon { - position: absolute; - top: -10px; - right: -10px; - font-size: 20px; - font-style: inherit; - opacity: 0.50; -} - -.tocMap-item-label > a { - margin:0 auto; - flex: 1; -} - -.tocMap-item-label > a, -.tocMap-item-label > a:visited, -.tocMap-item-label > a:hover, -.tocMap-item-label > a:active { - margin:0 auto; - text-decoration: none; - color: inherit; -} - -.tocMap .tocMap-item .tocMap-item.expanded, -.tocMap .tocMap-item .tocMap-item.expanded .tocMap-item { - background-color: rgba(50, 50, 50, 0.10); -} - - -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+1), -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+1) .tocMap-item { - background-color: rgba(255, 0, 0, 0.10); -} - -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+2), -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+2) .tocMap-item { - background-color: rgba(255, 255, 0, 0.25); -} - -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+3), -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+3) .tocMap-item { - background-color: rgba(255, 0, 255, 0.10); -} - -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+4), -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+4) .tocMap-item { - background-color: rgba(0, 0, 255, 0.10); -} - -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+5), -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+5) .tocMap-item { - background-color: rgba(0, 255, 0, 0.10); -} - -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+6), -.tocMap.colorful .tocMap-item .tocMap-item.expanded:nth-of-type(6n+6) .tocMap-item { - background-color: rgba(0, 255, 255, 0.15); -} - - -.tocMap > .tocMap-item.expanded { - margin: 0px; - padding: 0px; - background: none; -} - -// -- Notices - -.todo_inline { - font-style: italic; -} - -.notices { - font-style: italic; - margin: .5em 0; - padding: .25em 1.5em; - border-left: 3px solid $gray; - display: inline-block; - - *:first-child { - padding-top: 0; - margin-top: 0; - } - - *:last-child { - padding-bottom: 0; - margin-bottom: 0; - } - - &.warning { - border-left: 3px solid $red; - } - - &.info { - border-left: 3px solid $blue; - } - - &.note { - border-left: 3px solid $yellow; - } - - &.todo { - border-left: 3px solid $orange; - } -} diff --git a/hugo/assets/custom.scss b/hugo/assets/custom.scss deleted file mode 100644 index 327beeaf9..000000000 --- a/hugo/assets/custom.scss +++ /dev/null @@ -1,328 +0,0 @@ -@import url('https://fonts.googleapis.com/css?family=Lato:300,700|Merriweather:300italic,300|Inconsolata:400,700'); - -// Font Families -$serifFontFamily: 'Merriweather', 'Book Antiqua', Georgia, 'Century Schoolbook', serif; -$sansFontFamily: 'Lato', sans-serif; -$monoFontFamily: 'Inconsolata', Menlo, Courier, monospace; - -// Typography -$baseFontSize: 18px; -$baseLineHeight: 1.5em; - - -// Colors -$darkGray: #373f52; -$mediumGray: #959595; -$gray: #e1e1e1; -$lightestGray: #d5dae6; -$white: #ffffff; -$black: #000000; -$purple: #8f6cd6; -$lightPurple: #7f60be; -$codeBackground: #f7f9fc; -$detailGray: #f7f7f7; -$groupGray: #dddddd; -$yellow: #f1c40f; -$orange: #e67e22; -$red: #e74c3c; -$darkBlue: #1f5b83; -$blue: #3498db; - - -html { - font-size: $font-size-base; - scroll-behavior: auto; -} - -html, -body { - box-sizing: border-box; - height: 100%; - width: 100%; - overflow-x: inherit; -} - -body { - background-color: $white; - font-size: 16px; - font-family: $sansFontFamily; - line-height: 1em; -} - - -.book-page { - font-family: $serifFontFamily; - font-size: 1em; - line-height: 1.6875em; -} - -.book-menu { - font-family: $sansFontFamily; - font-size: 16px; - line-height: 18px; -} - -.book-toc { - font-family: $sansFontFamily; - font-size: 14px; - line-height: 16px; -} - -.markdown { - max-width: 90%; - - h1, - h2, - h3, - h4, - h5, - h6 { - font-family: $sansFontFamily; - font-weight: 700; - line-height: 1.5em; - word-wrap: break-word; - } - - h1 { - font-size: 2.5em; - margin: 1em 0 .5em; - - &.signature { - margin: 0; - } - - &.section-heading { - margin: 1.5em 0 .5em; - } - - & small { - font-weight: 300; - } - - a.view-source { - font-size: 1.2rem; - } - } - - h2 { - font-size: 2.0em; - margin: 1em 0 .5em; - font-weight: 700; - } - - h3 { - font-size: 1.6em; - margin: 1em 0 .5em; - font-weight: 700; - } - - h4 { - font-size: 1.3em; - margin: 1em 0 .5em; - font-weight: 700; - } - - h5 { - font-size: 1.15em; - margin: 1em 0 .5em; - font-weight: 700; - } - - h6 { - font-size: 1.0em; - margin: 1em 0 .5em; - font-weight: 700; - } - - a.no-underline { - text-decoration: none; - } - - a.view-source { - float: right; - color: $mediumGray; - text-decoration: none; - border: none; - transition: color 0.3s ease-in-out; - margin-top: 1px; - - &:hover { - color: $darkGray; - } - } - - .note { - color: #959595; - margin-right: 5px; - font-size: 14px; - font-weight: normal; - } - - blockquote { - font-style: italic; - margin: .5em 0; - padding: .25em 1.5em; - border-left: 3px solid $gray; - display: inline-block; - - *:first-child { - padding-top: 0; - margin-top: 0; - } - - *:last-child { - padding-bottom: 0; - margin-bottom: 0; - } - } - - table { - margin: 2em 0; - table-layout:fixed; - width: 100%; - display: block; - - th { - text-align: left; - font-family: $sansFontFamily; - text-transform: uppercase; - font-weight: 700; - padding-bottom: .5em; - } - - tr { - border-bottom: 1px solid $lightestGray; - vertical-align: bottom; - height: 2.5em; - - td, th { - padding-left: 1em; - line-height: 1.5em; - vertical-align: top; - } - } - } -} - -img { - max-width: 100%; -} - - - - -// -- Code - -.markdown a:not(.codeLink), a:not(.codeLink), pre a:not(.codeLink) { - color: $darkBlue; - text-shadow: none; - text-decoration: none; - background-image: none; - - &:active, - &:focus, - &:hover { - color: $blue; - text-decoration: underline; - } -} - -.markdown { - pre { - background-color: transparent; - padding: 0; - margin: $baseLineHeight 0; - - code { - display: block; - overflow-x: auto; - white-space: inherit; - padding: 0.5em 1em; - background-color: $codeBackground; - } - } - - code { - font-family: $monoFontFamily; - font-style: normal; - line-height: 24px; - font-weight: 400; - background-color: $codeBackground; - vertical-align: baseline; - border-radius: 2px; - padding: .1em .2em; - border: 1px solid darken($codeBackground, 10%); - text-transform: none; - word-wrap: break-word; - } -} - -a.codeLink { - color: $darkBlue; - - &:active, - &:focus, - &:hover { - color: $purple; - text-decoration: none; - } -} - - -// -- Notices - -.todo_inline { - font-style: italic; -} - -.notices { - font-style: italic; - margin: .5em 0; - padding: .25em 1.5em; - border-left: 3px solid $gray; - display: inline-block; - - *:first-child { - padding-top: 0; - margin-top: 0; - } - - *:last-child { - padding-bottom: 0; - margin-bottom: 0; - } - - &.warning { - border-left: 3px solid $red; - } - - &.info { - border-left: 3px solid $blue; - } - - &.note { - border-left: 3px solid $yellow; - } - - &.todo { - border-left: 3px solid $orange; - } -} - -.definition { - font-style: italic; - margin: .5em 0; - padding: .25em 1.5em; - border-left: 3px solid $darkGray; - display: inline-block; - background-color: $detailGray; -} - - -.book-git-footer { - margin-top: 4em; - - img { - vertical-align: middle !important; - } -} diff --git a/hugo/config.toml b/hugo/config.toml deleted file mode 100644 index f7beac3c0..000000000 --- a/hugo/config.toml +++ /dev/null @@ -1,45 +0,0 @@ -# baseURL = "https://filecoin-project.github.io/specs/" -languageCode = "en-us" -title = "Filecoin Spec" -canonifyurls = false -relativeURLs = true - -theme = "book" -pygmentsCodeFences = true -pygmentsUseClasses = true -# enableGitInfo = true -disableKinds = ["taxonomy", "taxonomyTerm"] - -[params] -# (Optional, default true) Show or hide table of contents globally -# You can also specify this parameter per page in front matter -BookShowToC = true - -# (Optional, default none) Set leaf bundle to render as side menu -# When not specified file structure and weights will be used -BookMenuBundle = "/menu" - -# (Optional, default docs) Specify section of content to render as menu -# You can also set value to "*" to render all sections to menu -BookSection = "docs" - -# This value is duplicate of $link-color for making active link highlight in menu bundle mode -BookMenuBundleActiveLinkColor = "#0b3a53" - -# Include JS scripts in pages. Disabled by default. -# - Keep side menu on same scroll position during navigation -BookEnableJS = true - -# Set source repository location. -# Used for 'Last Modified' and 'Edit this page' links. -# BookRepo = "https://github.com/filecoin-project/specs" - -# Enable "Edit this page" links for 'doc' page type. -# Disabled by default. Uncomment to enable. Requires 'BookRepo' param. -# Path must point to 'content' directory of repo. -# BookEditPath = "edit/master" - -# Configure the date format used on the pages -# - In git information -# - In blog posts -BookDateFormat = "Jan 2, 2006" diff --git a/hugo/content/_index.md b/hugo/content/_index.md deleted file mode 100644 index 824b8bd29..000000000 --- a/hugo/content/_index.md +++ /dev/null @@ -1,9 +0,0 @@ ---- -title: "Filecoin Specification" -type: docs ---- - -{{}} - -{{}} - \ No newline at end of file diff --git a/hugo/content/menu/index.md b/hugo/content/menu/index.md deleted file mode 100644 index 605c7098a..000000000 --- a/hugo/content/menu/index.md +++ /dev/null @@ -1,6 +0,0 @@ ---- -headless: true ---- - -{{}} - \ No newline at end of file diff --git a/hugo/data/sections.yaml b/hugo/data/sections.yaml deleted file mode 100644 index e69de29bb..000000000 diff --git a/hugo/data/sref_locations.yaml b/hugo/data/sref_locations.yaml deleted file mode 100644 index fb2f069db..000000000 --- a/hugo/data/sref_locations.yaml +++ /dev/null @@ -1,79 +0,0 @@ -# general -crypto_signatures: [algorithms, crypto, signatures] -randomness: [algorithms, crypto, randomness] -data_structures: [data_structures] -app_address: [appendix, address] -vrf: [algorithms, crypto, vrf] - -# blockchain -message: [systems, filecoin_vm, message] -message_syntax: [systems, filecoin_vm, message, message_syntax] -sys_vm: [systems, filecoin_vm] -vm_interpreter: [systems, filecoin_vm, interpreter] - -### blockchain -block_producer: [systems, filecoin_blockchain, struct] -chain_sync: [systems, filecoin_blockchain, chainsync] -block: [systems, filecoin_blockchain, block] -block_validation: [systems, filecoin_blockchain, block, block_validation] -block_sync: [algorithms, block_sync] - - -### SPC -storage_power_consensus: [systems, filecoin_blockchain, storage_power_consensus] -storage_power: [systems, filecoin_blockchain, storage_power_consensus, storage_power] -tickets: [systems, filecoin_blockchain, storage_power_consensus, tickets] -ticket_chain: [systems, filecoin_blockchain, storage_power_consensus, ticket_chain] -ticket_generation: [systems, filecoin_blockchain, storage_power_consensus, ticket_generation] -min_miner_size: [systems, filecoin_blockchain, storage_power_consensus, min_miner_size] - -### Storage Market Actor -power_table: [systems, filecoin_blockchain, storage_power_consensus, storage_power_actor, power_table] -pledge_collateral: [systems, filecoin_blockchain, storage_power_consensus, storage_power_actor, pledge_collateral] - -### EC -expected_consensus: [algorithms, expected_consensus] -leader_election: [algorithms, expected_consensus, leader_election] -chain_selection: [algorithms, expected_consensus, chain_selection] -finality: [algorithms, expected_consensus, finality] -consensus_faults: [algorithms, expected_consensus, consensus_faults] - -### Chain Sync -chain_sync: [systems, filecoin_blockchain, chainsync] - - -### Message Pool -message_pool: [systems, filecoin_blockchain, message_pool] -message_syncer: [systems, filecoin_blockchain, message_pool, message_syncer] -message_storage: [systems, filecoin_blockchain, message_pool, message_storage] - -# files - -# markets -retrieval_market: [systems, filecoin_markets, retrieval_market] -storage_market: [systems, filecoin_markets, storage_market] -storage_deal_collateral: [systems, filecoin_markets, storage_market, storage_deal_collateral] -storage_faults: [systems, filecoin_markets, storage_market, faults] -deals: [systems, filecoin_markets, deal] -deal_states: [systems, filecoin_markets, deal, deal_states] - -# payments -payment_channels: [systems, filecoin_token, payment_channel, payment_channels] -payment_channel_actor: [systems, filecoin_token, payment_channel, payment_channels, payment_channel_actor] - -# mining -mining_cycle: [systems, filecoin_mining, storage_mining, mining_cycle] - -### Storage Mining -sector: [systems, filecoin_mining, sector] -storage_mining_subsystem: [systems, filecoin_mining, storage_mining] -storage_miner_actor: [systems, filecoin_mining, storage_mining, storage_miner_actor] -sector_sealer: [systems, filecoin_mining, storage_mining] -post_generator: [systems, filecoin_mining, storage_mining] -post: [algorithms, proof_of_spacetime] -election_post: [algorithms, proof_of_spacetime, election_post] - -# nodes -clock: [systems, filecoin_nodes, clock] - -# token diff --git a/hugo/data/sref_titles.yaml b/hugo/data/sref_titles.yaml deleted file mode 100644 index 25cbabb54..000000000 --- a/hugo/data/sref_titles.yaml +++ /dev/null @@ -1,75 +0,0 @@ -# general -crypto_signatures: "Signatures" -randomness: "Randomness" -data_structures: "Data Structures" -app_address: "Address" -vrf: "VRF" - -# blockchain -message: "Message" -message_syntax: "Message Syntax" -sys_vm: "VM" -vm_interpreter: "VM Interpreter" -block: "Block" - -### blockchain -block_producer: "Block Producer" -### SPC -storage_power_consensus: "Storage Power Consensus" -storage_power: "Storage Power" -tickets: "Tickets" -ticket_chain: "Ticket Chain" -ticket_generation: "Ticket Generation" -min_miner_size: "Minimum Miner Size" - -power_table: "Power Table" -pledge_collateral: "Pledge Collateral" - -expected_consensus: "Expected Consensus" -leader_election: "Secret Leader Election" -chain_selection: "Chain Selection" -finality: "EC Finality" -consensus_faults: "Consensus Faults" - -### Chain Sync -chain_sync: "Chain Sync" -block_validation: "Block Validation" - -block_sync: "Block Sync" - -### Message Pool -message_pool: "Message Pool" -message_syncer: "Message Syncer" -message_storage: "Message Storage" - -# files - -# markets -retrieval_market: "Retrieval Market" -storage_market: "Storage Market" -storage_deal_collateral: "Storage Deal Collateral" -storage_faults: "Storage Faults" -deals: "Deals" -deal_states: "Deal States" - -# payments -payment_channels: "Payment Channels" -payment_channel_actor: "Payment Channel Actor" - -# mining -mining_cycle: "Mining Cycle" - -### Storage Mining -sector: "Sector" -storage_mining_subsystem: "Storage Mining Subsystem" -storage_miner_actor: "Storage Miner Actor" -sector_sealer: "Sector Sealer" -post_generator: "PoSt Generator" -post: "Proof of Spacetime" -election_post: "Election PoSt" - - -# nodes -clock: "Clock" - -# token diff --git a/hugo/layouts/_default/menuLayout.html b/hugo/layouts/_default/menuLayout.html deleted file mode 100644 index 52e9c5aae..000000000 --- a/hugo/layouts/_default/menuLayout.html +++ /dev/null @@ -1,23 +0,0 @@ - diff --git a/hugo/layouts/_default/sectionLayout.html b/hugo/layouts/_default/sectionLayout.html deleted file mode 100644 index 015ebdbfa..000000000 --- a/hugo/layouts/_default/sectionLayout.html +++ /dev/null @@ -1 +0,0 @@ -{{ partial "sectionLayoutPartial.html" (dict "page" .Page "depth" 1) }} diff --git a/hugo/layouts/_default/tocMapLayout.html b/hugo/layouts/_default/tocMapLayout.html deleted file mode 100644 index 8b0a70a8d..000000000 --- a/hugo/layouts/_default/tocMapLayout.html +++ /dev/null @@ -1,23 +0,0 @@ -
- -
- - - - 3 -
- - {{ $page := print "/docs" | $.Site.GetPage }} - {{ if (not ($page.Param "suppressMenu")) }} -
    - {{ range ($page.Param "entries") }} -
  • - {{ with $page.GetPage . }} - {{ partial "menuLayoutPartial.html" (dict "page" . "depth" 1) }} - {{ end }} -
    • - {{ end }} -
- {{ end }} -
diff --git a/hugo/layouts/docs/single.html b/hugo/layouts/docs/single.html deleted file mode 100644 index c23d81291..000000000 --- a/hugo/layouts/docs/single.html +++ /dev/null @@ -1,9 +0,0 @@ -{{ define "main" }} -
- {{ .Content | replaceRE "href=\"([^.]+)\\.md(#.+)?\"" "href=\"../$1$2\"" | replaceRE "\t" " " | safeHTML }} -
-{{ end }} - -{{ define "toc" }} - {{ partial "docs/toc" . }} -{{ end }} diff --git a/hugo/layouts/partials/docs/git-footer.html b/hugo/layouts/partials/docs/git-footer.html deleted file mode 100644 index 3db62e56c..000000000 --- a/hugo/layouts/partials/docs/git-footer.html +++ /dev/null @@ -1,19 +0,0 @@ -{{ if or .GitInfo .Site.Params.BookEditPath }} -
- {{ with .GitInfo }} -
- {{ $date := .AuthorDate.Local.Format (default "January 2, 2006" $.Site.Params.BookDateFormat) }} - - Changed {{ $date }} - -
- {{ end }} - {{ with .Site.Params.BookEditPath }} -
- {{ if $.File }} - Edit Edit this page - {{ end }} -
- {{ end }} -
-{{ end }} diff --git a/hugo/layouts/partials/docs/html-head.html b/hugo/layouts/partials/docs/html-head.html deleted file mode 100644 index 79353ee06..000000000 --- a/hugo/layouts/partials/docs/html-head.html +++ /dev/null @@ -1,25 +0,0 @@ - - -{{- partial "docs/title" . }} | {{ .Site.Title -}} - - -{{ $styles := resources.Get "book.scss" | resources.ToCSS | resources.Minify | resources.Fingerprint }} - - - - - - - -{{ with .OutputFormats.Get "rss" -}} - {{ printf `` .Rel .MediaType.Type .Permalink $.Site.Title | safeHTML }} -{{ end -}} - - - - - -{{ "" | safeHTML }} diff --git a/hugo/layouts/partials/docs/inject/head.html b/hugo/layouts/partials/docs/inject/head.html deleted file mode 100644 index 670f45b51..000000000 --- a/hugo/layouts/partials/docs/inject/head.html +++ /dev/null @@ -1,4 +0,0 @@ - - - - diff --git a/hugo/layouts/partials/labelFromTitle.html b/hugo/layouts/partials/labelFromTitle.html deleted file mode 100644 index 20f797469..000000000 --- a/hugo/layouts/partials/labelFromTitle.html +++ /dev/null @@ -1,2 +0,0 @@ -{{- $ret := . | lower | replaceRE " " "_" | replaceRE "(\\(|\\))" "" | replaceRE "\\+" "" }} -{{- return $ret -}} diff --git a/hugo/layouts/partials/labelPartial.html b/hugo/layouts/partials/labelPartial.html deleted file mode 100644 index 7c0956f48..000000000 --- a/hugo/layouts/partials/labelPartial.html +++ /dev/null @@ -1,3 +0,0 @@ -{{- $tag := partial "tagFromPagePath" .pagePath -}} -
-{{- $unused := 17 -}} diff --git a/hugo/layouts/partials/menuLayoutPartial.html b/hugo/layouts/partials/menuLayoutPartial.html deleted file mode 100644 index 4623f8853..000000000 --- a/hugo/layouts/partials/menuLayoutPartial.html +++ /dev/null @@ -1,37 +0,0 @@ - -{{ $page := .page }} - -{{ $tokens := partial "tokensFromPagePath" $page.Path }} -{{ $name := partial "nameFromPagePath" $page.Path }} -{{ $tag := partial "tagFromPagePath" $page.Path }} - -{{ $depth := len $tokens }} - -{{ $title := $page.Param "title" }} -{{ if (not (eq nil ($page.Param "menuTitle"))) }} - {{ $title = ($page.Param "menuTitle") }} -{{ end }} - - - {{ $page.Param "menuIcon" }} - {{ if (eq $depth 1) }} - - {{ end }} - {{ $title | markdownify }} - {{ if (eq $depth 1) }} - - {{ end }} - - - -{{ if (not ($page.Param "suppressMenu")) }} -
    -{{ range ($page.Param "entries") }} -
  • - {{ with $page.GetPage . }} - {{ partial "menuLayoutPartial.html" (dict "page" . "depth" (add $depth 1)) }} - {{ end }} -
    • -{{ end }} -
-{{ end }} diff --git a/hugo/layouts/partials/nameFromPagePath.html b/hugo/layouts/partials/nameFromPagePath.html deleted file mode 100644 index 9d91f8a7b..000000000 --- a/hugo/layouts/partials/nameFromPagePath.html +++ /dev/null @@ -1,7 +0,0 @@ -{{ $inputPath := . }} - -{{ $tokens := partial "tokensFromPagePath" $inputPath }} - -{{ $pathLast := index $tokens (sub (len $tokens) 1) }} - -{{ return $pathLast }} diff --git a/hugo/layouts/partials/sectionLayoutPartial.html b/hugo/layouts/partials/sectionLayoutPartial.html deleted file mode 100644 index 092e9f9e1..000000000 --- a/hugo/layouts/partials/sectionLayoutPartial.html +++ /dev/null @@ -1,26 +0,0 @@ - -{{ $page := .page }} - -{{ $tokens := partial "tokensFromPagePath" $page.Path }} -{{ $name := partial "nameFromPagePath" $page.Path }} -{{ $tag := partial "tagFromPagePath" $page.Path }} - -{{ $depth := len $tokens }} - -
- -{{ printf "" $depth | safeHTML }} - {{ $page.Param "title" | markdownify }} -{{ printf "" $depth | safeHTML }} - -
-{{ partial "shiftHeadings.html" (dict "page" $page "level" $depth ) }} -
- -{{ range ($page.Param "entries") }} - {{ with $page.GetPage . }} - {{ partial "sectionLayoutPartial.html" (dict "page" . ) }} - {{ end }} -{{ end }} - -
diff --git a/hugo/layouts/partials/shiftHeadings.html b/hugo/layouts/partials/shiftHeadings.html deleted file mode 100644 index 0016c696c..000000000 --- a/hugo/layouts/partials/shiftHeadings.html +++ /dev/null @@ -1,37 +0,0 @@ -{{/* get the Markdown without front matter */}} -{{ $c := .page.Content }} - -{{/* set var to heading level + .level */}} -{{ $l1 := (add .level 1) }} -{{ $l2 := (add .level 2) }} -{{ $l3 := (add .level 3) }} -{{ $l4 := (add .level 4) }} -{{ $l5 := (add .level 5) }} -{{ $l6 := (add .level 6) }} - - -{{/* min/max */}} -{{ $l1 := cond (lt $l1 1) 1 (cond (gt $l1 6) 6 $l1) }} -{{ $l2 := cond (lt $l2 1) 1 (cond (gt $l2 6) 6 $l2) }} -{{ $l3 := cond (lt $l3 1) 1 (cond (gt $l3 6) 6 $l3) }} -{{ $l4 := cond (lt $l4 1) 1 (cond (gt $l4 6) 6 $l4) }} -{{ $l5 := cond (lt $l5 1) 1 (cond (gt $l5 6) 6 $l5) }} -{{ $l6 := cond (lt $l6 1) 1 (cond (gt $l6 6) 6 $l6) }} - -{{ $c := replace $c "
" (printf "" $l6) }} -{{ $c := replace $c "
" (printf "" $l5) }} -{{ $c := replace $c "" (printf "" $l4) }} -{{ $c := replace $c "" (printf "" $l3) }} -{{ $c := replace $c "" (printf "" $l2) }} -{{ $c := replace $c "" (printf "" $l1) }} - - -{{/* render the content */}} -{{ $c | safeHTML }} diff --git a/hugo/layouts/partials/tagFromPagePath.html b/hugo/layouts/partials/tagFromPagePath.html deleted file mode 100644 index 45dc91b88..000000000 --- a/hugo/layouts/partials/tagFromPagePath.html +++ /dev/null @@ -1,6 +0,0 @@ -{{- $inputPath := . -}} - -{{- $tokens := partial "tokensFromPagePath" $inputPath -}} -{{- $ret := delimit $tokens "__" -}} - -{{- return $ret -}} diff --git a/hugo/layouts/partials/tocMapPartial.html b/hugo/layouts/partials/tocMapPartial.html deleted file mode 100644 index 0831ade14..000000000 --- a/hugo/layouts/partials/tocMapPartial.html +++ /dev/null @@ -1,49 +0,0 @@ - -{{ $page := .Page }} -{{ $depth := .Depth }} -{{ $expand := 2 }} -{{ if (gt 0 .Expand) }} - {{ $expand = .Expand }} -{{ end }} - -{{ $tokens := partial "tokensFromPagePath" .Page.Path }} -{{ $name := partial "nameFromPagePath" .Page.Path }} -{{ $tag := partial "tagFromPagePath" .Page.Path }} - -{{ $title := .Page.Param "title" }} -{{ if (not (eq nil (.Page.Param "tocMapTitle"))) }} - {{ $title = (.Page.Param "tocMapTitle") }} -{{ else if (not (eq nil (.Page.Param "menuTitle"))) }} - {{ $title = (.Page.Param "menuTitle") }} -{{ end }} - -{{ $expandedclass := "expanded" }} -{{ if (gt $depth $expand) }} - {{ $expandedclass = "" }} -{{ end }} - -
-
- - {{ if (not (eq nil (.Page.Param "statusIcon"))) }} - {{ $page.Param "statusIcon" }} - {{ end }} - - {{ $title | markdownify }} - - {{ if (not (eq nil (.Page.Param "menuIcon"))) }} -

{{ $page.Param "menuIcon" }} - {{ end }} - -
- -
- {{ if (le $depth $expand) }} - {{ range (.Page.Param "entries") }} - {{ with $page.GetPage . }} - {{ partial "tocMapPartial.html" (dict "Page" . "Depth" (add $depth 1) "Expand" $expand) }} - {{ end }} - {{ end }} - {{ end }} -
-
diff --git a/hugo/layouts/partials/tokensFromPagePath.html b/hugo/layouts/partials/tokensFromPagePath.html deleted file mode 100644 index e873ea6d3..000000000 --- a/hugo/layouts/partials/tokensFromPagePath.html +++ /dev/null @@ -1,13 +0,0 @@ -{{- $inputPath := . -}} - -{{- $pathTokens := split $inputPath "/" -}} - -{{- $ret := slice -}} - -{{- range $pathTokens -}} - {{- if (not (eq . "_index.md")) -}} - {{- $ret = append (index (split . ".") 0) $ret -}} - {{- end -}} -{{- end -}} - -{{- return (after 1 $ret) -}} diff --git a/hugo/layouts/shortcodes/codeRef.html b/hugo/layouts/shortcodes/codeRef.html deleted file mode 100644 index f316345e6..000000000 --- a/hugo/layouts/shortcodes/codeRef.html +++ /dev/null @@ -1 +0,0 @@ -{{ .Get 0 }} diff --git a/hugo/layouts/shortcodes/comment.html b/hugo/layouts/shortcodes/comment.html deleted file mode 100644 index 718e8c3c5..000000000 --- a/hugo/layouts/shortcodes/comment.html +++ /dev/null @@ -1 +0,0 @@ -{{ $unused := .Inner }} diff --git a/hugo/layouts/shortcodes/definition.html b/hugo/layouts/shortcodes/definition.html deleted file mode 100644 index 5ff113c7e..000000000 --- a/hugo/layouts/shortcodes/definition.html +++ /dev/null @@ -1,3 +0,0 @@ -
- Definition: {{ .Inner | markdownify }} -
diff --git a/hugo/layouts/shortcodes/diagram.html b/hugo/layouts/shortcodes/diagram.html deleted file mode 100644 index 308091c03..000000000 --- a/hugo/layouts/shortcodes/diagram.html +++ /dev/null @@ -1,37 +0,0 @@ -{{/* Get the filepath */}} -{{/* If the first character is "/", the path is from the site's `baseURL`. */}} -{{ if eq (.Get "src" | printf "%.1s") "/" }} - -{{/* Use Hugo `readfile` behavior of path from site's `baseURL`. */}} -{{ $.Scratch.Set "filepath" ( .Get "src" ) }} - -{{ else }} - -{{/* Make relative: Fetch the current directory and then append it to the specified `file=""` value */}} -{{ $.Scratch.Set "filepath" $.Page.Dir }} -{{ $.Scratch.Add "filepath" ( .Get "src" ) }} - -{{ end }} - - - -
- -{{ .Get "title" }} - -{{/* Check if the specified file exists */}} -{{ if fileExists ($.Scratch.Get "filepath") }} - -(open in new tab) -
- - -{{/* Say something if the file is not found and display the path that was specified in the shortcode (`file=" "`). */}} -{{ else }} - -
-

Something's not right. The {{ .Get "src" }} file was not found.

- -{{ end }} - -
diff --git a/hugo/layouts/shortcodes/goFile.html b/hugo/layouts/shortcodes/goFile.html deleted file mode 100644 index c9c178ca0..000000000 --- a/hugo/layouts/shortcodes/goFile.html +++ /dev/null @@ -1,5 +0,0 @@ -
- {{ with $x := (readFile (print "content/code/" (.Get 0) ".go") | safeHTML) }} - {{ highlight $x "go" "" }} - {{ end }} -
diff --git a/hugo/layouts/shortcodes/hd.html b/hugo/layouts/shortcodes/hd.html deleted file mode 100644 index 041fe67eb..000000000 --- a/hugo/layouts/shortcodes/hd.html +++ /dev/null @@ -1,12 +0,0 @@ -{{- $level := .Get 0 -}} -{{- $text := .Get 1 -}} - -{{- $html_level := (add 2 (int $level)) -}} - -{{- if (eq (int $level) 1) -}} - {{- $labelToken := partial "labelFromTitle" $text -}} - {{- partial "labelPartial" (dict "labelToken" $labelToken "pagePath" $.Page.Path) -}} -{{- end -}} - -{{- $text -}} -{{- $unused := 17 -}} diff --git a/hugo/layouts/shortcodes/incMain.html b/hugo/layouts/shortcodes/incMain.html deleted file mode 100644 index acf0968f1..000000000 --- a/hugo/layouts/shortcodes/incMain.html +++ /dev/null @@ -1,4 +0,0 @@ -
- {{ $page := print "/docs" | $.Site.GetPage }} - {{ partial "sectionLayoutPartial.html" (dict "page" $page "depth" 0) }} -
diff --git a/hugo/layouts/shortcodes/incMenu.html b/hugo/layouts/shortcodes/incMenu.html deleted file mode 100644 index 0cad3f2e4..000000000 --- a/hugo/layouts/shortcodes/incMenu.html +++ /dev/null @@ -1,3 +0,0 @@ -{{ range (slice (.Site.GetPage "/docs")) }} - {{ .Render "menuLayout" }} -{{ end }} diff --git a/hugo/layouts/shortcodes/incTocMap.html b/hugo/layouts/shortcodes/incTocMap.html deleted file mode 100644 index 97bb00f17..000000000 --- a/hugo/layouts/shortcodes/incTocMap.html +++ /dev/null @@ -1,16 +0,0 @@ - -
- - - {{ $expand := (.Get 1) }} - {{ with .Site.GetPage (.Get 0) }} - {{ partial "tocMapPartial.html" (dict "Page" . "Depth" 1 "Expand" $expand) }} - {{ end }} - -
diff --git a/hugo/layouts/shortcodes/js.html b/hugo/layouts/shortcodes/js.html deleted file mode 100644 index 83780ddf3..000000000 --- a/hugo/layouts/shortcodes/js.html +++ /dev/null @@ -1,92 +0,0 @@ - diff --git a/hugo/layouts/shortcodes/label.html b/hugo/layouts/shortcodes/label.html deleted file mode 100644 index 5231ef1ab..000000000 --- a/hugo/layouts/shortcodes/label.html +++ /dev/null @@ -1 +0,0 @@ -{{- partial "labelPartial" (dict "labelToken" (.Get 0) "pagePath" $.Page.Path) -}} diff --git a/hugo/layouts/shortcodes/mermaid.html b/hugo/layouts/shortcodes/mermaid.html deleted file mode 100644 index a6a61a5de..000000000 --- a/hugo/layouts/shortcodes/mermaid.html +++ /dev/null @@ -1 +0,0 @@ -
{{ safeHTML .Inner }}
diff --git a/hugo/layouts/shortcodes/notice.html b/hugo/layouts/shortcodes/notice.html deleted file mode 100644 index 81797b8db..000000000 --- a/hugo/layouts/shortcodes/notice.html +++ /dev/null @@ -1 +0,0 @@ -
{{ .Inner | markdownify }}
diff --git a/hugo/layouts/shortcodes/readfile.html b/hugo/layouts/shortcodes/readfile.html deleted file mode 100644 index 562e9f88e..000000000 --- a/hugo/layouts/shortcodes/readfile.html +++ /dev/null @@ -1,121 +0,0 @@ -{{/* - -Overrides the Docsy theme's default -[`readfile` shortcode](https://github.com/google/docsy/blob/master/layouts/shortcodes/readfile.md). - - -Use this `readfile` shortcode to include the contents of a file into another file. -Specify the `readfile` shortcode in a specific location within the "parent" -file to "include" content from the source file. - -Default behavior is to obtain source files in a directory that is relative to -the parent file. See details below. - -IMPORTANT: You cannot nest shortcodes. When the Hugo build runs on a file, -any shortcodes within that file are processed. For example, if you use `readFile` -to include a source file, and that source file contains another shortcode, -none of those "nested shortcodes" are processed. Nesting a shortcode within another -shortcode results in incorrectly rendered content -(ie. `{{% the short code syntax shows in the HTML of the parent file %}}`). - -Syntax: -* For Markdown: Use %, `{{%...%}}`. This sends the source file to the Markdown - processor and also enables the in-page TOC (in the right-side nav). - - Examples: - * Include a `README.md` in the same folder's `_index.md` file: - `{{% readfile file="index.md" %}}` - - Important: For SEO, all README.md files that are not used by the required - `_index.md` (Hugo section definition) are renamed to index.md at build time. - If you want to use a `readFile` for some other `README.md` file - (a `README.md` file is not used by and `_index.md` section def), - you must specify `index.md` (no underscore). - - * Include any Markdown file, like `shared-content.md`, into another - parent file that lives in the same folder: - `{{% readfile file="shared-content.md" %}}` - -* For HTML: Use < >, `{{<...>}}`. This prevents Hugo from sending the content to - the Markdown processor and copies in the content as is. - - * Example of an HTML source file in same folder as the parent file: - `{{< readfile file="HTML.html" >}}` - -* For code: Use < >, `{{<...>}}` and specify the `code` and `lang` flags to include - syntax highlighting. See details about the parameter flags below. - Examples: - * A Go lang file (...go) in same folder as the parent file: - `{{< readfile file="code-written-in.go" code="true" lang="go" >}}` - * A Java file (...java) in a sub-folder (below the parent file): - `{{< readfile file="main/java/com/code-written-in.java" code="true" lang="java" >}}` - -Parameters: -* `file="the-source-file-path-and-or-name.here"`: REQUIRED. By default, - specifies the filepath that is relative to the parent file in which the `readfile` is called. - * DEFAULT: Relative filepath: - `{{% readfile file="example-source-file.md" %}}` - - Example folder - |--example-source-file.md - |--example-parent-file-with-readfile-call.md - - * OPTIONAL: Full filepath from site's `baseURL` (denoted by the require `/` forwardslash): - `{{% readfile file="/docs/one-or-more-sub-directories/example-source-file.md" %}}` - - Include a `/` as the prefix to the filepath reverts to the original behavior - of the Hugo `readFile` function, see details here: - https://gohugo.io/functions/readfile/ - - Important: Do not specify file paths that rely on the site's `baseURL` - for any content that is versioned or depends on versioned content - (note: everything in the /docs/ folder gets versioned). - Versioned content gets moved to a different branch and folder for each - release and therefore, a relative file path must be used. - -* `code="true"`: Use to include a file and add syntax highlighting to the content - (the file is not processed, just copied as is). - - * `lang="programming-language"`: The programming language syntax highlighting. - List of supported values: - https://gohugo.io/content-management/syntax-highlighting/#list-of-chroma-highlighting-languages - -*/}} - -{{/* Get the filepath */}} -{{/* If the first character is "/", the path is from the site's `baseURL`. */}} -{{ if eq (.Get "file" | printf "%.1s") "/" }} - -{{/* Use Hugo `readfile` behavior of path from site's `baseURL`. */}} -{{ $.Scratch.Set "filepath" ( .Get "file" ) }} - -{{ else }} - -{{/* Make relative: Fetch the current directory and then append it to the specified `file=""` value */}} -{{ $.Scratch.Set "filepath" $.Page.Dir }} -{{ $.Scratch.Add "filepath" ( .Get "file" ) }} - -{{ end }} - - -{{/* Check if the specified file exists */}} -{{ if fileExists ($.Scratch.Get "filepath") }} - -{{/* If Code, then highlight with the specified language. */}} -{{ if eq (.Get "code") "true" }} - -{{ highlight ($.Scratch.Get "filepath" | readFile | safeHTML ) (.Get "lang") "" }} - -{{ else }} - -{{/* If HTML or Markdown. For Markdown`{{%...%}}`, don't send content to processor again (use safeHTML). */}} -{{ $.Scratch.Get "filepath" | readFile | safeHTML }} - -{{ end }} - -{{/* Say something if the file is not found and display the path that was specified in the shortcode (`file=" "`). */}} -{{ else }} - -

Something's not right. The {{ .Get "file" }} file was not found.

- -{{ end }} \ No newline at end of file diff --git a/hugo/layouts/shortcodes/specSplash.html b/hugo/layouts/shortcodes/specSplash.html deleted file mode 100644 index 89a5841ce..000000000 --- a/hugo/layouts/shortcodes/specSplash.html +++ /dev/null @@ -1,30 +0,0 @@ - - -
-
Filecoin Specification
- -
- protocol version: {{ .Site.Data.version.filecoinVersion }}
- spec doc version: {{ .Site.Data.version.specVersion }}-{{ .Site.Data.version.shorthash }} -
- last published: {{ .Site.Data.version.date }} -
-
diff --git a/hugo/layouts/shortcodes/sref.html b/hugo/layouts/shortcodes/sref.html deleted file mode 100644 index 5df295207..000000000 --- a/hugo/layouts/shortcodes/sref.html +++ /dev/null @@ -1,42 +0,0 @@ -{{- $text := .Get 1 -}} -{{- $locs := $.Site.Data.sref_locations -}} -{{- $loc_titles := $.Site.Data.sref_titles -}} -{{- $k := .Get 0 }} - -{{- $numMatches := 0 -}} -{{- $matchPage := "" -}} -{{- range $.Site.Pages }} - {{- $pageName := partial "nameFromPagePath" .Path -}} - {{- if (eq $pageName $k) -}} - {{- $numMatches = add 1 $numMatches -}} - {{- $matchPage = . -}} - {{- end -}} -{{- end -}} - -{{- $v := slice -}} -{{- if (not (eq $numMatches 1)) }} - {{- $v = $k | index $locs -}} - {{- if (eq $v nil) -}} - {{- errorf "sref: Reference key not found: %v\n" $k -}} - {{- end -}} -{{- else -}} - {{- $pathBase := (index (split $matchPage.Path ".") 0) }} - {{- $v = (split $pathBase "/") }} - {{- $v = after 1 $v -}} -{{- end -}} - -{{- if not (eq $v nil) -}} - {{- $dstTag := print "/#" (delimit $v "__") -}} - - {{- $dstPagePath := print "/docs/" (delimit $v "/") -}} - {{- $dstPageObj := $.Site.GetPage $dstPagePath -}} - - {{- $text = default ($dstPageObj.Param "title") $text -}} - {{- $text = default (index $loc_titles $k) $text -}} - - {{- $text -}} -{{- else -}} - {{- $text -}} -{{- end -}} - -{{- $unused := 17 -}} diff --git a/hugo/layouts/shortcodes/todo.html b/hugo/layouts/shortcodes/todo.html deleted file mode 100644 index fcbbd75b9..000000000 --- a/hugo/layouts/shortcodes/todo.html +++ /dev/null @@ -1,3 +0,0 @@ -
- {{ "**TODO**: " | markdownify }} {{ .Inner }} -
diff --git a/hugo/layouts/shortcodes/todo_inline.html b/hugo/layouts/shortcodes/todo_inline.html deleted file mode 100644 index 7107eaa90..000000000 --- a/hugo/layouts/shortcodes/todo_inline.html +++ /dev/null @@ -1,3 +0,0 @@ -
- {{ "**TODO**: " | markdownify }} {{ .Inner }} -
diff --git a/hugo/static/MathJax.js b/hugo/static/MathJax.js deleted file mode 100644 index b77df9212..000000000 --- a/hugo/static/MathJax.js +++ /dev/null @@ -1,19 +0,0 @@ -/* - * /MathJax.js - * - * Copyright (c) 2009-2017 The MathJax Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -if(document.getElementById&&document.childNodes&&document.createElement){if(!(window.MathJax&&MathJax.Hub)){if(window.MathJax){window.MathJax={AuthorConfig:window.MathJax}}else{window.MathJax={}}MathJax.isPacked=true;MathJax.version="2.7.1";MathJax.fileversion="2.7.1";MathJax.cdnVersion="2.7.1";MathJax.cdnFileVersions={};(function(d){var b=window[d];if(!b){b=window[d]={}}var e=[];var c=function(f){var g=f.constructor;if(!g){g=function(){}}for(var h in f){if(h!=="constructor"&&f.hasOwnProperty(h)){g[h]=f[h]}}return g};var a=function(){return function(){return arguments.callee.Init.call(this,arguments)}};b.Object=c({constructor:a(),Subclass:function(f,h){var g=a();g.SUPER=this;g.Init=this.Init;g.Subclass=this.Subclass;g.Augment=this.Augment;g.protoFunction=this.protoFunction;g.can=this.can;g.has=this.has;g.isa=this.isa;g.prototype=new this(e);g.prototype.constructor=g;g.Augment(f,h);return g},Init:function(f){var g=this;if(f.length===1&&f[0]===e){return g}if(!(g instanceof f.callee)){g=new f.callee(e)}return g.Init.apply(g,f)||g},Augment:function(f,g){var h;if(f!=null){for(h in f){if(f.hasOwnProperty(h)){this.protoFunction(h,f[h])}}if(f.toString!==this.prototype.toString&&f.toString!=={}.toString){this.protoFunction("toString",f.toString)}}if(g!=null){for(h in g){if(g.hasOwnProperty(h)){this[h]=g[h]}}}return this},protoFunction:function(g,f){this.prototype[g]=f;if(typeof f==="function"){f.SUPER=this.SUPER.prototype}},prototype:{Init:function(){},SUPER:function(f){return f.callee.SUPER},can:function(f){return typeof(this[f])==="function"},has:function(f){return typeof(this[f])!=="undefined"},isa:function(f){return(f instanceof Object)&&(this instanceof f)}},can:function(f){return this.prototype.can.call(this,f)},has:function(f){return this.prototype.has.call(this,f)},isa:function(g){var f=this;while(f){if(f===g){return true}else{f=f.SUPER}}return false},SimpleSUPER:c({constructor:function(f){return this.SimpleSUPER.define(f)},define:function(f){var h={};if(f!=null){for(var g in f){if(f.hasOwnProperty(g)){h[g]=this.wrap(g,f[g])}}if(f.toString!==this.prototype.toString&&f.toString!=={}.toString){h.toString=this.wrap("toString",f.toString)}}return h},wrap:function(i,h){if(typeof(h)!=="function"||!h.toString().match(/\.\s*SUPER\s*\(/)){return h}var g=function(){this.SUPER=g.SUPER[i];try{var f=h.apply(this,arguments)}catch(j){delete this.SUPER;throw j}delete this.SUPER;return f};g.toString=function(){return h.toString.apply(h,arguments)};return g}})});b.Object.isArray=Array.isArray||function(f){return Object.prototype.toString.call(f)==="[object Array]"};b.Object.Array=Array})("MathJax");(function(BASENAME){var BASE=window[BASENAME];if(!BASE){BASE=window[BASENAME]={}}var isArray=BASE.Object.isArray;var CALLBACK=function(data){var cb=function(){return arguments.callee.execute.apply(arguments.callee,arguments)};for(var id in CALLBACK.prototype){if(CALLBACK.prototype.hasOwnProperty(id)){if(typeof(data[id])!=="undefined"){cb[id]=data[id]}else{cb[id]=CALLBACK.prototype[id]}}}cb.toString=CALLBACK.prototype.toString;return cb};CALLBACK.prototype={isCallback:true,hook:function(){},data:[],object:window,execute:function(){if(!this.called||this.autoReset){this.called=!this.autoReset;return this.hook.apply(this.object,this.data.concat([].slice.call(arguments,0)))}},reset:function(){delete this.called},toString:function(){return this.hook.toString.apply(this.hook,arguments)}};var ISCALLBACK=function(f){return(typeof(f)==="function"&&f.isCallback)};var EVAL=function(code){return eval.call(window,code)};var TESTEVAL=function(){EVAL("var __TeSt_VaR__ = 1");if(window.__TeSt_VaR__){try{delete window.__TeSt_VaR__}catch(error){window.__TeSt_VaR__=null}}else{if(window.execScript){EVAL=function(code){BASE.__code=code;code="try {"+BASENAME+".__result = eval("+BASENAME+".__code)} catch(err) {"+BASENAME+".__result = err}";window.execScript(code);var result=BASE.__result;delete BASE.__result;delete BASE.__code;if(result instanceof Error){throw result}return result}}else{EVAL=function(code){BASE.__code=code;code="try {"+BASENAME+".__result = eval("+BASENAME+".__code)} catch(err) {"+BASENAME+".__result = err}";var head=(document.getElementsByTagName("head"))[0];if(!head){head=document.body}var script=document.createElement("script");script.appendChild(document.createTextNode(code));head.appendChild(script);head.removeChild(script);var result=BASE.__result;delete BASE.__result;delete BASE.__code;if(result instanceof Error){throw result}return result}}}TESTEVAL=null};var USING=function(args,i){if(arguments.length>1){if(arguments.length===2&&!(typeof arguments[0]==="function")&&arguments[0] instanceof Object&&typeof arguments[1]==="number"){args=[].slice.call(args,i)}else{args=[].slice.call(arguments,0)}}if(isArray(args)&&args.length===1){args=args[0]}if(typeof args==="function"){if(args.execute===CALLBACK.prototype.execute){return args}return CALLBACK({hook:args})}else{if(isArray(args)){if(typeof(args[0])==="string"&&args[1] instanceof Object&&typeof args[1][args[0]]==="function"){return CALLBACK({hook:args[1][args[0]],object:args[1],data:args.slice(2)})}else{if(typeof args[0]==="function"){return CALLBACK({hook:args[0],data:args.slice(1)})}else{if(typeof args[1]==="function"){return CALLBACK({hook:args[1],object:args[0],data:args.slice(2)})}}}}else{if(typeof(args)==="string"){if(TESTEVAL){TESTEVAL()}return CALLBACK({hook:EVAL,data:[args]})}else{if(args instanceof Object){return CALLBACK(args)}else{if(typeof(args)==="undefined"){return CALLBACK({})}}}}}throw Error("Can't make callback from given data")};var DELAY=function(time,callback){callback=USING(callback);callback.timeout=setTimeout(callback,time);return callback};var WAITFOR=function(callback,signal){callback=USING(callback);if(!callback.called){WAITSIGNAL(callback,signal);signal.pending++}};var WAITEXECUTE=function(){var signals=this.signal;delete this.signal;this.execute=this.oldExecute;delete this.oldExecute;var result=this.execute.apply(this,arguments);if(ISCALLBACK(result)&&!result.called){WAITSIGNAL(result,signals)}else{for(var i=0,m=signals.length;i0&&priority=0;i--){this.hooks.splice(i,1)}this.remove=[]}});var EXECUTEHOOKS=function(hooks,data,reset){if(!hooks){return null}if(!isArray(hooks)){hooks=[hooks]}if(!isArray(data)){data=(data==null?[]:[data])}var handler=HOOKS(reset);for(var i=0,m=hooks.length;ig){g=document.styleSheets.length}if(!i){i=document.head||((document.getElementsByTagName("head"))[0]);if(!i){i=document.body}}return i};var f=[];var c=function(){for(var k=0,j=f.length;k=this.timeout){i(this.STATUS.ERROR);return 1}return 0},file:function(j,i){if(i<0){a.Ajax.loadTimeout(j)}else{a.Ajax.loadComplete(j)}},execute:function(){this.hook.call(this.object,this,this.data[0],this.data[1])},checkSafari2:function(i,j,k){if(i.time(k)){return}if(document.styleSheets.length>j&&document.styleSheets[j].cssRules&&document.styleSheets[j].cssRules.length){k(i.STATUS.OK)}else{setTimeout(i,i.delay)}},checkLength:function(i,l,n){if(i.time(n)){return}var m=0;var j=(l.sheet||l.styleSheet);try{if((j.cssRules||j.rules||[]).length>0){m=1}}catch(k){if(k.message.match(/protected variable|restricted URI/)){m=1}else{if(k.message.match(/Security error/)){m=1}}}if(m){setTimeout(a.Callback([n,i.STATUS.OK]),0)}else{setTimeout(i,i.delay)}}},loadComplete:function(i){i=this.fileURL(i);var j=this.loading[i];if(j&&!j.preloaded){a.Message.Clear(j.message);clearTimeout(j.timeout);if(j.script){if(f.length===0){setTimeout(c,0)}f.push(j.script)}this.loaded[i]=j.status;delete this.loading[i];this.addHook(i,j.callback)}else{if(j){delete this.loading[i]}this.loaded[i]=this.STATUS.OK;j={status:this.STATUS.OK}}if(!this.loadHooks[i]){return null}return this.loadHooks[i].Execute(j.status)},loadTimeout:function(i){if(this.loading[i].timeout){clearTimeout(this.loading[i].timeout)}this.loading[i].status=this.STATUS.ERROR;this.loadError(i);this.loadComplete(i)},loadError:function(i){a.Message.Set(["LoadFailed","File failed to load: %1",i],null,2000);a.Hub.signal.Post(["file load error",i])},Styles:function(k,l){var i=this.StyleString(k);if(i===""){l=a.Callback(l);l()}else{var j=document.createElement("style");j.type="text/css";this.head=h(this.head);this.head.appendChild(j);if(j.styleSheet&&typeof(j.styleSheet.cssText)!=="undefined"){j.styleSheet.cssText=i}else{j.appendChild(document.createTextNode(i))}l=this.timer.create.call(this,l,j)}return l},StyleString:function(n){if(typeof(n)==="string"){return n}var k="",o,m;for(o in n){if(n.hasOwnProperty(o)){if(typeof n[o]==="string"){k+=o+" {"+n[o]+"}\n"}else{if(a.Object.isArray(n[o])){for(var l=0;l="0"&&q<="9"){f[j]=p[f[j]-1];if(typeof f[j]==="number"){f[j]=this.number(f[j])}}else{if(q==="{"){q=f[j].substr(1);if(q>="0"&&q<="9"){f[j]=p[f[j].substr(1,f[j].length-2)-1];if(typeof f[j]==="number"){f[j]=this.number(f[j])}}else{var k=f[j].match(/^\{([a-z]+):%(\d+)\|(.*)\}$/);if(k){if(k[1]==="plural"){var d=p[k[2]-1];if(typeof d==="undefined"){f[j]="???"}else{d=this.plural(d)-1;var h=k[3].replace(/(^|[^%])(%%)*%\|/g,"$1$2%\uEFEF").split(/\|/);if(d>=0&&d=3){c.push([f[0],f[1],this.processSnippet(g,f[2])])}else{c.push(e[d])}}}}else{c.push(e[d])}}return c},markdownPattern:/(%.)|(\*{1,3})((?:%.|.)+?)\2|(`+)((?:%.|.)+?)\4|\[((?:%.|.)+?)\]\(([^\s\)]+)\)/,processMarkdown:function(b,h,d){var j=[],e;var c=b.split(this.markdownPattern);var g=c[0];for(var f=1,a=c.length;f1?d[1]:""));f=null}if(e&&(!b.preJax||d)){c.nodeValue=c.nodeValue.replace(b.postJax,(e.length>1?e[1]:""))}if(f&&!f.nodeValue.match(/\S/)){f=f.previousSibling}}if(b.preRemoveClass&&f&&f.className===b.preRemoveClass){a.MathJax.preview=f}a.MathJax.checked=1},processInput:function(a){var b,i=MathJax.ElementJax.STATE;var h,e,d=a.scripts.length;try{while(a.ithis.processUpdateTime&&a.i1){d.jax[a.outputJax].push(b)}b.MathJax.state=c.OUTPUT},prepareOutput:function(c,f){while(c.jthis.processUpdateTime&&h.i=0;q--){if((b[q].src||"").match(f)){s.script=b[q].innerHTML;if(RegExp.$2){var t=RegExp.$2.substr(1).split(/\&/);for(var p=0,l=t.length;p=parseInt(y[z])}}return true},Select:function(j){var i=j[d.Browser];if(i){return i(d.Browser)}return null}};var e=k.replace(/^Mozilla\/(\d+\.)+\d+ /,"").replace(/[a-z][-a-z0-9._: ]+\/\d+[^ ]*-[^ ]*\.([a-z][a-z])?\d+ /i,"").replace(/Gentoo |Ubuntu\/(\d+\.)*\d+ (\([^)]*\) )?/,"");d.Browser=d.Insert(d.Insert(new String("Unknown"),{version:"0.0"}),a);for(var v in a){if(a.hasOwnProperty(v)){if(a[v]&&v.substr(0,2)==="is"){v=v.slice(2);if(v==="Mac"||v==="PC"){continue}d.Browser=d.Insert(new String(v),a);var r=new RegExp(".*(Version/| Trident/.*; rv:)((?:\\d+\\.)+\\d+)|.*("+v+")"+(v=="MSIE"?" ":"/")+"((?:\\d+\\.)*\\d+)|(?:^|\\(| )([a-z][-a-z0-9._: ]+|(?:Apple)?WebKit)/((?:\\d+\\.)+\\d+)");var u=r.exec(e)||["","","","unknown","0.0"];d.Browser.name=(u[1]!=""?v:(u[3]||u[5]));d.Browser.version=u[2]||u[4]||u[6];break}}}try{d.Browser.Select({Safari:function(j){var i=parseInt((String(j.version).split("."))[0]);if(i>85){j.webkit=j.version}if(i>=538){j.version="8.0"}else{if(i>=537){j.version="7.0"}else{if(i>=536){j.version="6.0"}else{if(i>=534){j.version="5.1"}else{if(i>=533){j.version="5.0"}else{if(i>=526){j.version="4.0"}else{if(i>=525){j.version="3.1"}else{if(i>500){j.version="3.0"}else{if(i>400){j.version="2.0"}else{if(i>85){j.version="1.0"}}}}}}}}}}j.webkit=(navigator.appVersion.match(/WebKit\/(\d+)\./))[1];j.isMobile=(navigator.appVersion.match(/Mobile/i)!=null);j.noContextMenu=j.isMobile},Firefox:function(j){if((j.version==="0.0"||k.match(/Firefox/)==null)&&navigator.product==="Gecko"){var m=k.match(/[\/ ]rv:(\d+\.\d.*?)[\) ]/);if(m){j.version=m[1]}else{var i=(navigator.buildID||navigator.productSub||"0").substr(0,8);if(i>="20111220"){j.version="9.0"}else{if(i>="20111120"){j.version="8.0"}else{if(i>="20110927"){j.version="7.0"}else{if(i>="20110816"){j.version="6.0"}else{if(i>="20110621"){j.version="5.0"}else{if(i>="20110320"){j.version="4.0"}else{if(i>="20100121"){j.version="3.6"}else{if(i>="20090630"){j.version="3.5"}else{if(i>="20080617"){j.version="3.0"}else{if(i>="20061024"){j.version="2.0"}}}}}}}}}}}}j.isMobile=(navigator.appVersion.match(/Android/i)!=null||k.match(/ Fennec\//)!=null||k.match(/Mobile/)!=null)},Chrome:function(i){i.noContextMenu=i.isMobile=!!navigator.userAgent.match(/ Mobile[ \/]/)},Opera:function(i){i.version=opera.version()},Edge:function(i){i.isMobile=!!navigator.userAgent.match(/ Phone/)},MSIE:function(j){j.isMobile=!!navigator.userAgent.match(/ Phone/);j.isIE9=!!(document.documentMode&&(window.performance||window.msPerformance));MathJax.HTML.setScriptBug=!j.isIE9||document.documentMode<9;MathJax.Hub.msieHTMLCollectionBug=(document.documentMode<9);if(document.documentMode<10&&!s.params.NoMathPlayer){try{new ActiveXObject("MathPlayer.Factory.1");j.hasMathPlayer=true}catch(m){}try{if(j.hasMathPlayer){var i=document.createElement("object");i.id="mathplayer";i.classid="clsid:32F66A20-7614-11D4-BD11-00104BD3F987";g.appendChild(i);document.namespaces.add("m","http://www.w3.org/1998/Math/MathML");j.mpNamespace=true;if(document.readyState&&(document.readyState==="loading"||document.readyState==="interactive")){document.write('');j.mpImported=true}}else{document.namespaces.add("mjx_IE_fix","http://www.w3.org/1999/xlink")}}catch(m){}}}})}catch(c){console.error(c.message)}d.Browser.Select(MathJax.Message.browsers);if(h.AuthorConfig&&typeof h.AuthorConfig.AuthorInit==="function"){h.AuthorConfig.AuthorInit()}d.queue=h.Callback.Queue();d.queue.Push(["Post",s.signal,"Begin"],["Config",s],["Cookie",s],["Styles",s],["Message",s],function(){var i=h.Callback.Queue(s.Jax(),s.Extensions());return i.Push({})},["Menu",s],s.onLoad(),function(){MathJax.isReady=true},["Typeset",s],["Hash",s],["MenuZoom",s],["Post",s.signal,"End"])})("MathJax")}}; diff --git a/hugo/static/css/syntax.css b/hugo/static/css/syntax.css deleted file mode 100644 index 104dbddc5..000000000 --- a/hugo/static/css/syntax.css +++ /dev/null @@ -1,65 +0,0 @@ -/* Background */ .chroma { background-color: #ffffff } -/* Error */ .chroma .err { color: #ff0000; background-color: #ffaaaa } -/* LineTableTD */ .chroma .lntd { vertical-align: top; padding: 0; margin: 0; border: 0; } -/* LineTable */ .chroma .lntable { border-spacing: 0; padding: 0; margin: 0; border: 0; width: auto; overflow: auto; display: block; } -/* LineHighlight */ .chroma .hl { display: block; width: 100%;background-color: #ffffcc } -/* LineNumbersTable */ .chroma .lnt { margin-right: 0.4em; padding: 0 0.4em 0 0.4em;color: #7f7f7f } -/* LineNumbers */ .chroma .ln { margin-right: 0.4em; padding: 0 0.4em 0 0.4em;color: #7f7f7f } -/* Keyword */ .chroma .k { color: #0000aa } -/* KeywordConstant */ .chroma .kc { color: #0000aa } -/* KeywordDeclaration */ .chroma .kd { color: #0000aa } -/* KeywordNamespace */ .chroma .kn { color: #0000aa } -/* KeywordPseudo */ .chroma .kp { color: #0000aa } -/* KeywordReserved */ .chroma .kr { color: #0000aa } -/* KeywordType */ .chroma .kt { color: #00aaaa } -/* NameAttribute */ .chroma .na { color: #1e90ff } -/* NameBuiltin */ .chroma .nb { color: #00aaaa } -/* NameClass */ .chroma .nc { color: #00aa00; text-decoration: underline } -/* NameConstant */ .chroma .no { color: #aa0000 } -/* NameDecorator */ .chroma .nd { color: #888888 } -/* NameEntity */ .chroma .ni { color: #880000; font-weight: bold } -/* NameFunction */ .chroma .nf { color: #00aa00 } -/* NameNamespace */ .chroma .nn { color: #00aaaa; text-decoration: underline } -/* NameTag */ .chroma .nt { color: #1e90ff; font-weight: bold } -/* NameVariable */ .chroma .nv { color: #aa0000 } -/* LiteralString */ .chroma .s { color: #aa5500 } -/* LiteralStringAffix */ .chroma .sa { color: #aa5500 } -/* LiteralStringBacktick */ .chroma .sb { color: #aa5500 } -/* LiteralStringChar */ .chroma .sc { color: #aa5500 } -/* LiteralStringDelimiter */ .chroma .dl { color: #aa5500 } -/* LiteralStringDoc */ .chroma .sd { color: #aa5500 } -/* LiteralStringDouble */ .chroma .s2 { color: #aa5500 } -/* LiteralStringEscape */ .chroma .se { color: #aa5500 } -/* LiteralStringHeredoc */ .chroma .sh { color: #aa5500 } -/* LiteralStringInterpol */ .chroma .si { color: #aa5500 } -/* LiteralStringOther */ .chroma .sx { color: #aa5500 } -/* LiteralStringRegex */ .chroma .sr { color: #009999 } -/* LiteralStringSingle */ .chroma .s1 { color: #aa5500 } -/* LiteralStringSymbol */ .chroma .ss { color: #0000aa } -/* LiteralNumber */ .chroma .m { color: #009999 } -/* LiteralNumberBin */ .chroma .mb { color: #009999 } -/* LiteralNumberFloat */ .chroma .mf { color: #009999 } -/* LiteralNumberHex */ .chroma .mh { color: #009999 } -/* LiteralNumberInteger */ .chroma .mi { color: #009999 } -/* LiteralNumberIntegerLong */ .chroma .il { color: #009999 } -/* LiteralNumberOct */ .chroma .mo { color: #009999 } -/* OperatorWord */ .chroma .ow { color: #0000aa } -/* Comment */ .chroma .c { color: #aaaaaa; font-style: italic } -/* CommentHashbang */ .chroma .ch { color: #aaaaaa; font-style: italic } -/* CommentMultiline */ .chroma .cm { color: #aaaaaa; font-style: italic } -/* CommentSingle */ .chroma .c1 { color: #aaaaaa; font-style: italic } -/* CommentSpecial */ .chroma .cs { color: #0000aa; font-style: italic } -/* CommentPreproc */ .chroma .cp { color: #4c8317 } -/* CommentPreprocFile */ .chroma .cpf { color: #4c8317 } -/* GenericDeleted */ .chroma .gd { color: #aa0000 } -/* GenericEmph */ .chroma .ge { font-style: italic } -/* GenericError */ .chroma .gr { color: #aa0000 } -/* GenericHeading */ .chroma .gh { color: #000080; font-weight: bold } -/* GenericInserted */ .chroma .gi { color: #00aa00 } -/* GenericOutput */ .chroma .go { color: #888888 } -/* GenericPrompt */ .chroma .gp { color: #555555 } -/* GenericStrong */ .chroma .gs { font-weight: bold } -/* GenericSubheading */ .chroma .gu { color: #800080; font-weight: bold } -/* GenericTraceback */ .chroma .gt { color: #aa0000 } -/* GenericUnderline */ .chroma .gl { text-decoration: underline } -/* TextWhitespace */ .chroma .w { color: #bbbbbb } diff --git a/hugo/static/gumshoe.polyfills.min.js b/hugo/static/gumshoe.polyfills.min.js deleted file mode 100755 index 2ae80f0ab..000000000 --- a/hugo/static/gumshoe.polyfills.min.js +++ /dev/null @@ -1,2 +0,0 @@ -/*! gumshoejs v5.1.2 | (c) 2019 Chris Ferdinandi | MIT License | http://github.com/cferdinandi/gumshoe */ -Element.prototype.closest||(Element.prototype.matches||(Element.prototype.matches=Element.prototype.msMatchesSelector||Element.prototype.webkitMatchesSelector),Element.prototype.closest=function(t){var e=this;if(!document.documentElement.contains(this))return null;do{if(e.matches(t))return e;e=e.parentElement}while(null!==e);return null}),(function(){if("function"==typeof window.CustomEvent)return!1;function t(t,e){e=e||{bubbles:!1,cancelable:!1,detail:void 0};var n=document.createEvent("CustomEvent");return n.initCustomEvent(t,e.bubbles,e.cancelable,e.detail),n}t.prototype=window.Event.prototype,window.CustomEvent=t})(),(function(t,e){"function"==typeof define&&define.amd?define([],(function(){return e(t)})):"object"==typeof exports?module.exports=e(t):t.Gumshoe=e(t)})("undefined"!=typeof global?global:"undefined"!=typeof window?window:this,(function(t){"use strict";var e={navClass:"active",contentClass:"active",nested:!1,nestedClass:"active",offset:0,reflow:!1,events:!0},n=function(t,e,n){if(n.settings.events){var o=new CustomEvent(t,{bubbles:!0,cancelable:!0,detail:n});e.dispatchEvent(o)}},o=function(t){var e=0;if(t.offsetParent)for(;t;)e+=t.offsetTop,t=t.offsetParent;return e>=0?e:0},s=function(t){t&&t.sort((function(t,e){return o(t.content)=Math.max(document.body.scrollHeight,document.documentElement.scrollHeight,document.body.offsetHeight,document.documentElement.offsetHeight,document.body.clientHeight,document.documentElement.clientHeight)},i=function(t,e){var n=t[t.length-1];if(function(t,e){return!(!c()||!r(t.content,e,!0))}(n,e))return n;for(var o=t.length-1;o>=0;o--)if(r(t[o].content,e))return t[o]},l=function(t,e){if(e.nested&&t.parentNode){var n=t.parentNode.closest("li");n&&(n.classList.remove(e.nestedClass),l(n,e))}},a=function(t,e){if(t){var o=t.nav.closest("li");o&&(o.classList.remove(e.navClass),t.content.classList.remove(e.contentClass),l(o,e),n("gumshoeDeactivate",o,{link:t.nav,content:t.content,settings:e}))}},u=function(t,e){if(e.nested){var n=t.parentNode.closest("li");n&&(n.classList.add(e.nestedClass),u(n,e))}};return function(o,r){var c,l,f,d,m,v={};v.setup=function(){c=document.querySelectorAll(o),l=[],Array.prototype.forEach.call(c,(function(t){var e=document.getElementById(decodeURIComponent(t.hash.substr(1)));e&&l.push({nav:t,content:e})})),s(l)},v.detect=function(){var t=i(l,m);t?f&&t.content===f.content||(a(f,m),(function(t,e){if(t){var o=t.nav.closest("li");o&&(o.classList.add(e.navClass),t.content.classList.add(e.contentClass),u(o,e),n("gumshoeActivate",o,{link:t.nav,content:t.content,settings:e}))}})(t,m),f=t):f&&(a(f,m),f=null)};var p=function(e){d&&t.cancelAnimationFrame(d),d=t.requestAnimationFrame(v.detect)},h=function(e){d&&t.cancelAnimationFrame(d),d=t.requestAnimationFrame((function(){s(l),v.detect()}))};v.destroy=function(){f&&a(f,m),t.removeEventListener("scroll",p,!1),m.reflow&&t.removeEventListener("resize",h,!1),l=null,c=null,f=null,d=null,m=null};return m=(function(){var t={};return Array.prototype.forEach.call(arguments,(function(e){for(var n in e){if(!e.hasOwnProperty(n))return;t[n]=e[n]}})),t})(e,r||{}),v.setup(),v.detect(),t.addEventListener("scroll",p,!1),m.reflow&&t.addEventListener("resize",h,!1),v}})); \ No newline at end of file diff --git a/hugo/static/mermaid/mermaid.css b/hugo/static/mermaid/mermaid.css deleted file mode 100644 index 1ca8f3dd9..000000000 --- a/hugo/static/mermaid/mermaid.css +++ /dev/null @@ -1,277 +0,0 @@ -/* Flowchart variables */ -/* Sequence Diagram variables */ -/* Gantt chart variables */ -.mermaid .label { - color: #333; -} -.node rect, -.node circle, -.node ellipse, -.node polygon { - fill: #ECECFF; - stroke: #CCCCFF; - stroke-width: 1px; -} -.edgePath .path { - stroke: #333333; -} -.edgeLabel { - background-color: #e8e8e8; -} -.cluster rect { - fill: #ffffde !important; - rx: 4 !important; - stroke: #aaaa33 !important; - stroke-width: 1px !important; -} -.cluster text { - fill: #333; -} -.actor { - stroke: #CCCCFF; - fill: #ECECFF; -} -text.actor { - fill: black; - stroke: none; -} -.actor-line { - stroke: grey; -} -.messageLine0 { - stroke-width: 1.5; - stroke-dasharray: "2 2"; - marker-end: "url(#arrowhead)"; - stroke: #333; -} -.messageLine1 { - stroke-width: 1.5; - stroke-dasharray: "2 2"; - stroke: #333; -} -#arrowhead { - fill: #333; -} -#crosshead path { - fill: #333 !important; - stroke: #333 !important; -} -.messageText { - fill: #333; - stroke: none; -} -.labelBox { - stroke: #CCCCFF; - fill: #ECECFF; -} -.labelText { - fill: black; - stroke: none; -} -.loopText { - fill: black; - stroke: none; -} -.loopLine { - stroke-width: 2; - stroke-dasharray: "2 2"; - marker-end: "url(#arrowhead)"; - stroke: #CCCCFF; -} -.note { - stroke: #aaaa33; - fill: #fff5ad; -} -.noteText { - fill: black; - stroke: none; - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -/** Section styling */ -.section { - stroke: none; - opacity: 0.2; -} -.section0 { - fill: rgba(102, 102, 255, 0.49); -} -.section2 { - fill: #fff400; -} -.section1, -.section3 { - fill: white; - opacity: 0.2; -} -.sectionTitle0 { - fill: #333; -} -.sectionTitle1 { - fill: #333; -} -.sectionTitle2 { - fill: #333; -} -.sectionTitle3 { - fill: #333; -} -.sectionTitle { - text-anchor: start; - font-size: 11px; - text-height: 14px; -} -/* Grid and axis */ -.grid .tick { - stroke: lightgrey; - opacity: 0.3; - shape-rendering: crispEdges; -} -.grid path { - stroke-width: 0; -} -/* Today line */ -.today { - fill: none; - stroke: red; - stroke-width: 2px; -} -/* Task styling */ -/* Default task */ -.task { - stroke-width: 2; -} -.taskText { - text-anchor: middle; - font-size: 11px; -} -.taskTextOutsideRight { - fill: black; - text-anchor: start; - font-size: 11px; -} -.taskTextOutsideLeft { - fill: black; - text-anchor: end; - font-size: 11px; -} -/* Specific task settings for the sections*/ -.taskText0, -.taskText1, -.taskText2, -.taskText3 { - fill: white; -} -.task0, -.task1, -.task2, -.task3 { - fill: #8a90dd; - stroke: #534fbc; -} -.taskTextOutside0, -.taskTextOutside2 { - fill: black; -} -.taskTextOutside1, -.taskTextOutside3 { - fill: black; -} -/* Active task */ -.active0, -.active1, -.active2, -.active3 { - fill: #bfc7ff; - stroke: #534fbc; -} -.activeText0, -.activeText1, -.activeText2, -.activeText3 { - fill: black !important; -} -/* Completed task */ -.done0, -.done1, -.done2, -.done3 { - stroke: grey; - fill: lightgrey; - stroke-width: 2; -} -.doneText0, -.doneText1, -.doneText2, -.doneText3 { - fill: black !important; -} -/* Tasks on the critical line */ -.crit0, -.crit1, -.crit2, -.crit3 { - stroke: #ff8888; - fill: red; - stroke-width: 2; -} -.activeCrit0, -.activeCrit1, -.activeCrit2, -.activeCrit3 { - stroke: #ff8888; - fill: #bfc7ff; - stroke-width: 2; -} -.doneCrit0, -.doneCrit1, -.doneCrit2, -.doneCrit3 { - stroke: #ff8888; - fill: lightgrey; - stroke-width: 2; - cursor: pointer; - shape-rendering: crispEdges; -} -.doneCritText0, -.doneCritText1, -.doneCritText2, -.doneCritText3 { - fill: black !important; -} -.activeCritText0, -.activeCritText1, -.activeCritText2, -.activeCritText3 { - fill: black !important; -} -.titleText { - text-anchor: middle; - font-size: 18px; - fill: black; -} -/* - - -*/ -.node text { - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -.node.clickable { - cursor: pointer; -} -div.mermaidTooltip { - position: absolute; - text-align: center; - max-width: 200px; - padding: 2px; - font-family: 'trebuchet ms', verdana, arial; - font-size: 12px; - background: #ffffde; - border: 1px solid #aaaa33; - border-radius: 2px; - pointer-events: none; - z-index: 100; -} - diff --git a/hugo/static/mermaid/mermaid.dark.css b/hugo/static/mermaid/mermaid.dark.css deleted file mode 100644 index 507efb4ea..000000000 --- a/hugo/static/mermaid/mermaid.dark.css +++ /dev/null @@ -1,278 +0,0 @@ -/* Flowchart variables */ -/* Sequence Diagram variables */ -/* Gantt chart variables */ -.mermaid .label { - color: #323D47; -} -.node rect, -.node circle, -.node ellipse, -.node polygon { - fill: #BDD5EA; - stroke: #81B1DB; - stroke-width: 1px; -} -.edgePath .path { - stroke: lightgrey; -} -.edgeLabel { - background-color: #e8e8e8; -} -.cluster rect { - fill: #6D6D65 !important; - rx: 4 !important; - stroke: rgba(255, 255, 255, 0.25) !important; - stroke-width: 1px !important; -} -.cluster text { - fill: #F9FFFE; -} -.actor { - stroke: #81B1DB; - fill: #BDD5EA; -} -text.actor { - fill: black; - stroke: none; -} -.actor-line { - stroke: lightgrey; -} -.messageLine0 { - stroke-width: 1.5; - stroke-dasharray: "2 2"; - marker-end: "url(#arrowhead)"; - stroke: lightgrey; -} -.messageLine1 { - stroke-width: 1.5; - stroke-dasharray: "2 2"; - stroke: lightgrey; -} -#arrowhead { - fill: lightgrey !important; -} -#crosshead path { - fill: lightgrey !important; - stroke: lightgrey !important; -} -.messageText { - fill: lightgrey; - stroke: none; -} -.labelBox { - stroke: #81B1DB; - fill: #BDD5EA; -} -.labelText { - fill: #323D47; - stroke: none; -} -.loopText { - fill: lightgrey; - stroke: none; -} -.loopLine { - stroke-width: 2; - stroke-dasharray: "2 2"; - marker-end: "url(#arrowhead)"; - stroke: #81B1DB; -} -.note { - stroke: rgba(255, 255, 255, 0.25); - fill: #fff5ad; -} -.noteText { - fill: black; - stroke: none; - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -/** Section styling */ -.section { - stroke: none; - opacity: 0.2; -} -.section0 { - fill: rgba(255, 255, 255, 0.3); -} -.section2 { - fill: #EAE8B9; -} -.section1, -.section3 { - fill: white; - opacity: 0.2; -} -.sectionTitle0 { - fill: #F9FFFE; -} -.sectionTitle1 { - fill: #F9FFFE; -} -.sectionTitle2 { - fill: #F9FFFE; -} -.sectionTitle3 { - fill: #F9FFFE; -} -.sectionTitle { - text-anchor: start; - font-size: 11px; - text-height: 14px; -} -/* Grid and axis */ -.grid .tick { - stroke: rgba(255, 255, 255, 0.3); - opacity: 0.3; - shape-rendering: crispEdges; -} -.grid .tick text { - fill: lightgrey; - opacity: 0.5; -} -.grid path { - stroke-width: 0; -} -/* Today line */ -.today { - fill: none; - stroke: #DB5757; - stroke-width: 2px; -} -/* Task styling */ -/* Default task */ -.task { - stroke-width: 1; -} -.taskText { - text-anchor: middle; - font-size: 11px; -} -.taskTextOutsideRight { - fill: #323D47; - text-anchor: start; - font-size: 11px; -} -.taskTextOutsideLeft { - fill: #323D47; - text-anchor: end; - font-size: 11px; -} -/* Specific task settings for the sections*/ -.taskText0, -.taskText1, -.taskText2, -.taskText3 { - fill: #323D47; -} -.task0, -.task1, -.task2, -.task3 { - fill: #BDD5EA; - stroke: rgba(255, 255, 255, 0.5); -} -.taskTextOutside0, -.taskTextOutside2 { - fill: lightgrey; -} -.taskTextOutside1, -.taskTextOutside3 { - fill: lightgrey; -} -/* Active task */ -.active0, -.active1, -.active2, -.active3 { - fill: #81B1DB; - stroke: rgba(255, 255, 255, 0.5); -} -.activeText0, -.activeText1, -.activeText2, -.activeText3 { - fill: #323D47 !important; -} -/* Completed task */ -.done0, -.done1, -.done2, -.done3 { - fill: lightgrey; -} -.doneText0, -.doneText1, -.doneText2, -.doneText3 { - fill: #323D47 !important; -} -/* Tasks on the critical line */ -.crit0, -.crit1, -.crit2, -.crit3 { - stroke: #E83737; - fill: #E83737; - stroke-width: 2; -} -.activeCrit0, -.activeCrit1, -.activeCrit2, -.activeCrit3 { - stroke: #E83737; - fill: #81B1DB; - stroke-width: 2; -} -.doneCrit0, -.doneCrit1, -.doneCrit2, -.doneCrit3 { - stroke: #E83737; - fill: lightgrey; - stroke-width: 1; - cursor: pointer; - shape-rendering: crispEdges; -} -.doneCritText0, -.doneCritText1, -.doneCritText2, -.doneCritText3 { - fill: lightgrey !important; -} -.activeCritText0, -.activeCritText1, -.activeCritText2, -.activeCritText3 { - fill: #323D47 !important; -} -.titleText { - text-anchor: middle; - font-size: 18px; - fill: lightgrey; -} -/* - - -*/ -.node text { - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -.node.clickable { - cursor: pointer; -} -div.mermaidTooltip { - position: absolute; - text-align: center; - max-width: 200px; - padding: 2px; - font-family: 'trebuchet ms', verdana, arial; - font-size: 12px; - background: #6D6D65; - border: 1px solid rgba(255, 255, 255, 0.25); - border-radius: 2px; - pointer-events: none; - z-index: 100; -} diff --git a/hugo/static/mermaid/mermaid.forest.css b/hugo/static/mermaid/mermaid.forest.css deleted file mode 100644 index ad432d59d..000000000 --- a/hugo/static/mermaid/mermaid.forest.css +++ /dev/null @@ -1,356 +0,0 @@ -/* Flowchart variables */ -/* Sequence Diagram variables */ -/* Gantt chart variables */ -.mermaid .label { - font-family: 'trebuchet ms', verdana, arial; - color: #333; -} -.node rect, -.node circle, -.node ellipse, -.node polygon { - fill: #cde498; - stroke: #13540c; - stroke-width: 1px; -} -.edgePath .path { - stroke: green; - stroke-width: 1.5px; -} -.edgeLabel { - background-color: #e8e8e8; -} -.cluster rect { - fill: #cdffb2 !important; - rx: 4 !important; - stroke: #6eaa49 !important; - stroke-width: 1px !important; -} -.cluster text { - fill: #333; -} -.actor { - stroke: #13540c; - fill: #cde498; -} -text.actor { - fill: black; - stroke: none; -} -.actor-line { - stroke: grey; -} -.messageLine0 { - stroke-width: 1.5; - stroke-dasharray: "2 2"; - marker-end: "url(#arrowhead)"; - stroke: #333; -} -.messageLine1 { - stroke-width: 1.5; - stroke-dasharray: "2 2"; - stroke: #333; -} -#arrowhead { - fill: #333; -} -#crosshead path { - fill: #333 !important; - stroke: #333 !important; -} -.messageText { - fill: #333; - stroke: none; -} -.labelBox { - stroke: #326932; - fill: #cde498; -} -.labelText { - fill: black; - stroke: none; -} -.loopText { - fill: black; - stroke: none; -} -.loopLine { - stroke-width: 2; - stroke-dasharray: "2 2"; - marker-end: "url(#arrowhead)"; - stroke: #326932; -} -.note { - stroke: #6eaa49; - fill: #fff5ad; -} -.noteText { - fill: black; - stroke: none; - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -/** Section styling */ -.section { - stroke: none; - opacity: 0.2; -} -.section0 { - fill: #6eaa49; -} -.section2 { - fill: #6eaa49; -} -.section1, -.section3 { - fill: white; - opacity: 0.2; -} -.sectionTitle0 { - fill: #333; -} -.sectionTitle1 { - fill: #333; -} -.sectionTitle2 { - fill: #333; -} -.sectionTitle3 { - fill: #333; -} -.sectionTitle { - text-anchor: start; - font-size: 11px; - text-height: 14px; -} -/* Grid and axis */ -.grid .tick { - stroke: lightgrey; - opacity: 0.3; - shape-rendering: crispEdges; -} -.grid path { - stroke-width: 0; -} -/* Today line */ -.today { - fill: none; - stroke: red; - stroke-width: 2px; -} -/* Task styling */ -/* Default task */ -.task { - stroke-width: 2; -} -.taskText { - text-anchor: middle; - font-size: 11px; -} -.taskTextOutsideRight { - fill: black; - text-anchor: start; - font-size: 11px; -} -.taskTextOutsideLeft { - fill: black; - text-anchor: end; - font-size: 11px; -} -/* Specific task settings for the sections*/ -.taskText0, -.taskText1, -.taskText2, -.taskText3 { - fill: white; -} -.task0, -.task1, -.task2, -.task3 { - fill: #487e3a; - stroke: #13540c; -} -.taskTextOutside0, -.taskTextOutside2 { - fill: black; -} -.taskTextOutside1, -.taskTextOutside3 { - fill: black; -} -/* Active task */ -.active0, -.active1, -.active2, -.active3 { - fill: #cde498; - stroke: #13540c; -} -.activeText0, -.activeText1, -.activeText2, -.activeText3 { - fill: black !important; -} -/* Completed task */ -.done0, -.done1, -.done2, -.done3 { - stroke: grey; - fill: lightgrey; - stroke-width: 2; -} -.doneText0, -.doneText1, -.doneText2, -.doneText3 { - fill: black !important; -} -/* Tasks on the critical line */ -.crit0, -.crit1, -.crit2, -.crit3 { - stroke: #ff8888; - fill: red; - stroke-width: 2; -} -.activeCrit0, -.activeCrit1, -.activeCrit2, -.activeCrit3 { - stroke: #ff8888; - fill: #cde498; - stroke-width: 2; -} -.doneCrit0, -.doneCrit1, -.doneCrit2, -.doneCrit3 { - stroke: #ff8888; - fill: lightgrey; - stroke-width: 2; - cursor: pointer; - shape-rendering: crispEdges; -} -.doneCritText0, -.doneCritText1, -.doneCritText2, -.doneCritText3 { - fill: black !important; -} -.activeCritText0, -.activeCritText1, -.activeCritText2, -.activeCritText3 { - fill: black !important; -} -.titleText { - text-anchor: middle; - font-size: 18px; - fill: black; -} -/* - - -*/ -g.classGroup text { - fill: #13540c; - stroke: none; - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -g.classGroup rect { - fill: #cde498; - stroke: #13540c; -} -g.classGroup line { - stroke: #13540c; - stroke-width: 1; -} -svg .classLabel .box { - stroke: none; - stroke-width: 0; - fill: #cde498; - opacity: 0.5; -} -svg .classLabel .label { - fill: #13540c; -} -.relation { - stroke: #13540c; - stroke-width: 1; - fill: none; -} -.composition { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -#compositionStart { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -#compositionEnd { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -.aggregation { - fill: #cde498; - stroke: #13540c; - stroke-width: 1; -} -#aggregationStart { - fill: #cde498; - stroke: #13540c; - stroke-width: 1; -} -#aggregationEnd { - fill: #cde498; - stroke: #13540c; - stroke-width: 1; -} -#dependencyStart { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -#dependencyEnd { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -#extensionStart { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -#extensionEnd { - fill: #13540c; - stroke: #13540c; - stroke-width: 1; -} -.node text { - font-family: 'trebuchet ms', verdana, arial; - font-size: 14px; -} -.node.clickable { - cursor: pointer; -} -div.mermaidTooltip { - position: absolute; - text-align: center; - max-width: 200px; - padding: 2px; - font-family: 'trebuchet ms', verdana, arial; - font-size: 12px; - background: #cdffb2; - border: 1px solid #6eaa49; - border-radius: 2px; - pointer-events: none; - z-index: 100; -} diff --git a/hugo/static/mermaid/mermaid.js b/hugo/static/mermaid/mermaid.js deleted file mode 100644 index 93a34c20b..000000000 --- a/hugo/static/mermaid/mermaid.js +++ /dev/null @@ -1,59155 +0,0 @@ -(function webpackUniversalModuleDefinition(root, factory) { - if(typeof exports === 'object' && typeof module === 'object') - module.exports = factory(); - else if(typeof define === 'function' && define.amd) - define([], factory); - else if(typeof exports === 'object') - exports["mermaid"] = factory(); - else - root["mermaid"] = factory(); -})(window, function() { -return /******/ (function(modules) { // webpackBootstrap -/******/ // The module cache -/******/ var installedModules = {}; -/******/ -/******/ // The require function -/******/ function __webpack_require__(moduleId) { -/******/ -/******/ // Check if module is in cache -/******/ if(installedModules[moduleId]) { -/******/ return installedModules[moduleId].exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = installedModules[moduleId] = { -/******/ i: moduleId, -/******/ l: false, -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); -/******/ -/******/ // Flag the module as loaded -/******/ module.l = true; -/******/ -/******/ // Return the exports of the module -/******/ return module.exports; -/******/ } -/******/ -/******/ -/******/ // expose the modules object (__webpack_modules__) -/******/ __webpack_require__.m = modules; -/******/ -/******/ // expose the module cache -/******/ __webpack_require__.c = installedModules; -/******/ -/******/ // define getter function for harmony exports -/******/ __webpack_require__.d = function(exports, name, getter) { -/******/ if(!__webpack_require__.o(exports, name)) { -/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); -/******/ } -/******/ }; -/******/ -/******/ // define __esModule on exports -/******/ __webpack_require__.r = function(exports) { -/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { -/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); -/******/ } -/******/ Object.defineProperty(exports, '__esModule', { value: true }); -/******/ }; -/******/ -/******/ // create a fake namespace object -/******/ // mode & 1: value is a module id, require it -/******/ // mode & 2: merge all properties of value into the ns -/******/ // mode & 4: return value when already ns object -/******/ // mode & 8|1: behave like require -/******/ __webpack_require__.t = function(value, mode) { -/******/ if(mode & 1) value = __webpack_require__(value); -/******/ if(mode & 8) return value; -/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; -/******/ var ns = Object.create(null); -/******/ __webpack_require__.r(ns); -/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); -/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); -/******/ return ns; -/******/ }; -/******/ -/******/ // getDefaultExport function for compatibility with non-harmony modules -/******/ __webpack_require__.n = function(module) { -/******/ var getter = module && module.__esModule ? -/******/ function getDefault() { return module['default']; } : -/******/ function getModuleExports() { return module; }; -/******/ __webpack_require__.d(getter, 'a', getter); -/******/ return getter; -/******/ }; -/******/ -/******/ // Object.prototype.hasOwnProperty.call -/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; -/******/ -/******/ // __webpack_public_path__ -/******/ __webpack_require__.p = ""; -/******/ -/******/ -/******/ // Load entry module and return exports -/******/ return __webpack_require__(__webpack_require__.s = "./src/mermaid.js"); -/******/ }) -/************************************************************************/ -/******/ ({ - -/***/ "./node_modules/@braintree/sanitize-url/index.js": -/*!*******************************************************!*\ - !*** ./node_modules/@braintree/sanitize-url/index.js ***! - \*******************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -var invalidPrototcolRegex = /^(%20|\s)*(javascript|data)/im; -var ctrlCharactersRegex = /[^\x20-\x7E]/gmi; -var urlSchemeRegex = /^([^:]+):/gm; -var relativeFirstCharacters = ['.', '/'] - -function isRelativeUrl(url) { - return relativeFirstCharacters.indexOf(url[0]) > -1; -} - -function sanitizeUrl(url) { - if (!url) { - return 'about:blank'; - } - - var urlScheme, urlSchemeParseResults; - var sanitizedUrl = url.replace(ctrlCharactersRegex, '').trim(); - - if (isRelativeUrl(sanitizedUrl)) { - return sanitizedUrl; - } - - urlSchemeParseResults = sanitizedUrl.match(urlSchemeRegex); - - if (!urlSchemeParseResults) { - return 'about:blank'; - } - - urlScheme = urlSchemeParseResults[0]; - - if (invalidPrototcolRegex.test(urlScheme)) { - return 'about:blank'; - } - - return sanitizedUrl; -} - -module.exports = { - sanitizeUrl: sanitizeUrl -}; - - -/***/ }), - -/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/dark/index.scss": -/*!*******************************************************************************************************************!*\ - !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/dark/index.scss ***! - \*******************************************************************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -exports = module.exports = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js")(false); -// Module -exports.push([module.i, "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #BDD5EA;\n stroke: purple;\n stroke-width: 1px; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: lightgrey; }\n\n.edgePath .path {\n stroke: lightgrey;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: #e8e8e8; }\n\n.cluster rect {\n fill: #6D6D65;\n stroke: rgba(255, 255, 255, 0.25);\n stroke-width: 1px; }\n\n.cluster text {\n fill: #F9FFFE; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 12px;\n background: #6D6D65;\n border: 1px solid rgba(255, 255, 255, 0.25);\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #81B1DB;\n fill: #BDD5EA; }\n\ntext.actor {\n fill: black;\n stroke: none; }\n\n.actor-line {\n stroke: lightgrey; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: lightgrey; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: lightgrey; }\n\n#arrowhead {\n fill: lightgrey; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: lightgrey; }\n\n#crosshead path {\n fill: lightgrey !important;\n stroke: lightgrey !important; }\n\n.messageText {\n fill: lightgrey;\n stroke: none; }\n\n.labelBox {\n stroke: #81B1DB;\n fill: #BDD5EA; }\n\n.labelText {\n fill: #323D47;\n stroke: none; }\n\n.loopText {\n fill: lightgrey;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #81B1DB; }\n\n.note {\n stroke: rgba(255, 255, 255, 0.25);\n fill: #fff5ad; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: rgba(255, 255, 255, 0.3); }\n\n.section2 {\n fill: #EAE8B9; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #F9FFFE; }\n\n.sectionTitle1 {\n fill: #F9FFFE; }\n\n.sectionTitle2 {\n fill: #F9FFFE; }\n\n.sectionTitle3 {\n fill: #F9FFFE; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px; }\n\n/* Grid and axis */\n.grid .tick {\n stroke: lightgrey;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: #DB5757;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: #323D47;\n text-anchor: start;\n font-size: 11px; }\n\n.taskTextOutsideLeft {\n fill: #323D47;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: #323D47; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #BDD5EA;\n stroke: rgba(255, 255, 255, 0.5); }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: lightgrey; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: lightgrey; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #81B1DB;\n stroke: rgba(255, 255, 255, 0.5); }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: #323D47 !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: grey;\n fill: lightgrey;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: #323D47 !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #E83737;\n fill: #E83737;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #E83737;\n fill: #81B1DB;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #E83737;\n fill: lightgrey;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: #323D47 !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: #323D47 !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: #323D47; }\n\ng.classGroup text {\n fill: purple;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 10px; }\n\ng.classGroup rect {\n fill: #BDD5EA;\n stroke: purple; }\n\ng.classGroup line {\n stroke: purple;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #BDD5EA;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: purple;\n font-size: 10px; }\n\n.relation {\n stroke: purple;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #BDD5EA;\n stroke: purple;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #BDD5EA;\n stroke: purple;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#extensionStart {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: purple;\n stroke: purple;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey; }\n", ""]); - - - -/***/ }), - -/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/default/index.scss": -/*!**********************************************************************************************************************!*\ - !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/default/index.scss ***! - \**********************************************************************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -exports = module.exports = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js")(false); -// Module -exports.push([module.i, "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #ECECFF;\n stroke: #9370DB;\n stroke-width: 1px; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: #333333; }\n\n.edgePath .path {\n stroke: #333333;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: #e8e8e8; }\n\n.cluster rect {\n fill: #ffffde;\n stroke: #aaaa33;\n stroke-width: 1px; }\n\n.cluster text {\n fill: #333; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 12px;\n background: #ffffde;\n border: 1px solid #aaaa33;\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #CCCCFF;\n fill: #ECECFF; }\n\ntext.actor {\n fill: black;\n stroke: none; }\n\n.actor-line {\n stroke: grey; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n#arrowhead {\n fill: #333; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: #333; }\n\n#crosshead path {\n fill: #333 !important;\n stroke: #333 !important; }\n\n.messageText {\n fill: #333;\n stroke: none; }\n\n.labelBox {\n stroke: #CCCCFF;\n fill: #ECECFF; }\n\n.labelText {\n fill: black;\n stroke: none; }\n\n.loopText {\n fill: black;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #CCCCFF; }\n\n.note {\n stroke: #aaaa33;\n fill: #fff5ad; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: rgba(102, 102, 255, 0.49); }\n\n.section2 {\n fill: #fff400; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #333; }\n\n.sectionTitle1 {\n fill: #333; }\n\n.sectionTitle2 {\n fill: #333; }\n\n.sectionTitle3 {\n fill: #333; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px; }\n\n/* Grid and axis */\n.grid .tick {\n stroke: lightgrey;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: red;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: black;\n text-anchor: start;\n font-size: 11px; }\n\n.taskTextOutsideLeft {\n fill: black;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: white; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #8a90dd;\n stroke: #534fbc; }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: black; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: black; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #bfc7ff;\n stroke: #534fbc; }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: black !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: grey;\n fill: lightgrey;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: black !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #ff8888;\n fill: red;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #ff8888;\n fill: #bfc7ff;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #ff8888;\n fill: lightgrey;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: black !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: black !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: black; }\n\ng.classGroup text {\n fill: #9370DB;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 10px; }\n\ng.classGroup rect {\n fill: #ECECFF;\n stroke: #9370DB; }\n\ng.classGroup line {\n stroke: #9370DB;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #ECECFF;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: #9370DB;\n font-size: 10px; }\n\n.relation {\n stroke: #9370DB;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #ECECFF;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #ECECFF;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#extensionStart {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: #9370DB;\n stroke: #9370DB;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey; }\n", ""]); - - - -/***/ }), - -/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/forest/index.scss": -/*!*********************************************************************************************************************!*\ - !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/forest/index.scss ***! - \*********************************************************************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -exports = module.exports = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js")(false); -// Module -exports.push([module.i, "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #cde498;\n stroke: #13540c;\n stroke-width: 1px; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: green; }\n\n.edgePath .path {\n stroke: green;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: #e8e8e8; }\n\n.cluster rect {\n fill: #cdffb2;\n stroke: #6eaa49;\n stroke-width: 1px; }\n\n.cluster text {\n fill: #333; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 12px;\n background: #cdffb2;\n border: 1px solid #6eaa49;\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #13540c;\n fill: #cde498; }\n\ntext.actor {\n fill: black;\n stroke: none; }\n\n.actor-line {\n stroke: grey; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n#arrowhead {\n fill: #333; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: #333; }\n\n#crosshead path {\n fill: #333 !important;\n stroke: #333 !important; }\n\n.messageText {\n fill: #333;\n stroke: none; }\n\n.labelBox {\n stroke: #326932;\n fill: #cde498; }\n\n.labelText {\n fill: black;\n stroke: none; }\n\n.loopText {\n fill: black;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #326932; }\n\n.note {\n stroke: #6eaa49;\n fill: #fff5ad; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: #6eaa49; }\n\n.section2 {\n fill: #6eaa49; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #333; }\n\n.sectionTitle1 {\n fill: #333; }\n\n.sectionTitle2 {\n fill: #333; }\n\n.sectionTitle3 {\n fill: #333; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px; }\n\n/* Grid and axis */\n.grid .tick {\n stroke: lightgrey;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: red;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: black;\n text-anchor: start;\n font-size: 11px; }\n\n.taskTextOutsideLeft {\n fill: black;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: white; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #487e3a;\n stroke: #13540c; }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: black; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: black; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #cde498;\n stroke: #13540c; }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: black !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: grey;\n fill: lightgrey;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: black !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #ff8888;\n fill: red;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #ff8888;\n fill: #cde498;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #ff8888;\n fill: lightgrey;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: black !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: black !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: black; }\n\ng.classGroup text {\n fill: #13540c;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 10px; }\n\ng.classGroup rect {\n fill: #cde498;\n stroke: #13540c; }\n\ng.classGroup line {\n stroke: #13540c;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #cde498;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: #13540c;\n font-size: 10px; }\n\n.relation {\n stroke: #13540c;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #cde498;\n stroke: #13540c;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #cde498;\n stroke: #13540c;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#extensionStart {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: #13540c;\n stroke: #13540c;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey; }\n", ""]); - - - -/***/ }), - -/***/ "./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/neutral/index.scss": -/*!**********************************************************************************************************************!*\ - !*** ./node_modules/css-loader/dist/cjs.js!./node_modules/sass-loader/lib/loader.js!./src/themes/neutral/index.scss ***! - \**********************************************************************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -exports = module.exports = __webpack_require__(/*! ../../../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js")(false); -// Module -exports.push([module.i, "/* Flowchart variables */\n/* Sequence Diagram variables */\n/* Gantt chart variables */\n.label {\n font-family: 'trebuchet ms', verdana, arial;\n color: #333; }\n\n.label text {\n fill: #333; }\n\n.node rect,\n.node circle,\n.node ellipse,\n.node polygon {\n fill: #eee;\n stroke: #999;\n stroke-width: 1px; }\n\n.node.clickable {\n cursor: pointer; }\n\n.arrowheadPath {\n fill: #333333; }\n\n.edgePath .path {\n stroke: #666;\n stroke-width: 1.5px; }\n\n.edgeLabel {\n background-color: white; }\n\n.cluster rect {\n fill: #eaf2fb;\n stroke: #26a;\n stroke-width: 1px; }\n\n.cluster text {\n fill: #333; }\n\ndiv.mermaidTooltip {\n position: absolute;\n text-align: center;\n max-width: 200px;\n padding: 2px;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 12px;\n background: #eaf2fb;\n border: 1px solid #26a;\n border-radius: 2px;\n pointer-events: none;\n z-index: 100; }\n\n.actor {\n stroke: #999;\n fill: #eee; }\n\ntext.actor {\n fill: #333;\n stroke: none; }\n\n.actor-line {\n stroke: #666; }\n\n.messageLine0 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n.messageLine1 {\n stroke-width: 1.5;\n stroke-dasharray: '2 2';\n stroke: #333; }\n\n#arrowhead {\n fill: #333; }\n\n.sequenceNumber {\n fill: white; }\n\n#sequencenumber {\n fill: #333; }\n\n#crosshead path {\n fill: #333 !important;\n stroke: #333 !important; }\n\n.messageText {\n fill: #333;\n stroke: none; }\n\n.labelBox {\n stroke: #999;\n fill: #eee; }\n\n.labelText {\n fill: #333;\n stroke: none; }\n\n.loopText {\n fill: #333;\n stroke: none; }\n\n.loopLine {\n stroke-width: 2;\n stroke-dasharray: '2 2';\n stroke: #999; }\n\n.note {\n stroke: #777700;\n fill: #ffa; }\n\n.noteText {\n fill: black;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 14px; }\n\n.activation0 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation1 {\n fill: #f4f4f4;\n stroke: #666; }\n\n.activation2 {\n fill: #f4f4f4;\n stroke: #666; }\n\n/** Section styling */\n.section {\n stroke: none;\n opacity: 0.2; }\n\n.section0 {\n fill: #80b3e6; }\n\n.section2 {\n fill: #80b3e6; }\n\n.section1,\n.section3 {\n fill: white;\n opacity: 0.2; }\n\n.sectionTitle0 {\n fill: #333; }\n\n.sectionTitle1 {\n fill: #333; }\n\n.sectionTitle2 {\n fill: #333; }\n\n.sectionTitle3 {\n fill: #333; }\n\n.sectionTitle {\n text-anchor: start;\n font-size: 11px;\n text-height: 14px; }\n\n/* Grid and axis */\n.grid .tick {\n stroke: #e6e6e6;\n opacity: 0.3;\n shape-rendering: crispEdges; }\n\n.grid path {\n stroke-width: 0; }\n\n/* Today line */\n.today {\n fill: none;\n stroke: #d42;\n stroke-width: 2px; }\n\n/* Task styling */\n/* Default task */\n.task {\n stroke-width: 2; }\n\n.taskText {\n text-anchor: middle;\n font-size: 11px; }\n\n.taskTextOutsideRight {\n fill: #333;\n text-anchor: start;\n font-size: 11px; }\n\n.taskTextOutsideLeft {\n fill: #333;\n text-anchor: end;\n font-size: 11px; }\n\n/* Special case clickable */\n.task.clickable {\n cursor: pointer; }\n\n.taskText.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideLeft.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n.taskTextOutsideRight.clickable {\n cursor: pointer;\n fill: #003163 !important;\n font-weight: bold; }\n\n/* Specific task settings for the sections*/\n.taskText0,\n.taskText1,\n.taskText2,\n.taskText3 {\n fill: white; }\n\n.task0,\n.task1,\n.task2,\n.task3 {\n fill: #26a;\n stroke: #1a4d80; }\n\n.taskTextOutside0,\n.taskTextOutside2 {\n fill: #333; }\n\n.taskTextOutside1,\n.taskTextOutside3 {\n fill: #333; }\n\n/* Active task */\n.active0,\n.active1,\n.active2,\n.active3 {\n fill: #eee;\n stroke: #1a4d80; }\n\n.activeText0,\n.activeText1,\n.activeText2,\n.activeText3 {\n fill: #333 !important; }\n\n/* Completed task */\n.done0,\n.done1,\n.done2,\n.done3 {\n stroke: #666;\n fill: #bbb;\n stroke-width: 2; }\n\n.doneText0,\n.doneText1,\n.doneText2,\n.doneText3 {\n fill: #333 !important; }\n\n/* Tasks on the critical line */\n.crit0,\n.crit1,\n.crit2,\n.crit3 {\n stroke: #b1361b;\n fill: #d42;\n stroke-width: 2; }\n\n.activeCrit0,\n.activeCrit1,\n.activeCrit2,\n.activeCrit3 {\n stroke: #b1361b;\n fill: #eee;\n stroke-width: 2; }\n\n.doneCrit0,\n.doneCrit1,\n.doneCrit2,\n.doneCrit3 {\n stroke: #b1361b;\n fill: #bbb;\n stroke-width: 2;\n cursor: pointer;\n shape-rendering: crispEdges; }\n\n.milestone {\n transform: rotate(45deg) scale(0.8, 0.8); }\n\n.milestoneText {\n font-style: italic; }\n\n.doneCritText0,\n.doneCritText1,\n.doneCritText2,\n.doneCritText3 {\n fill: #333 !important; }\n\n.activeCritText0,\n.activeCritText1,\n.activeCritText2,\n.activeCritText3 {\n fill: #333 !important; }\n\n.titleText {\n text-anchor: middle;\n font-size: 18px;\n fill: #333; }\n\ng.classGroup text {\n fill: #999;\n stroke: none;\n font-family: 'trebuchet ms', verdana, arial;\n font-size: 10px; }\n\ng.classGroup rect {\n fill: #eee;\n stroke: #999; }\n\ng.classGroup line {\n stroke: #999;\n stroke-width: 1; }\n\n.classLabel .box {\n stroke: none;\n stroke-width: 0;\n fill: #eee;\n opacity: 0.5; }\n\n.classLabel .label {\n fill: #999;\n font-size: 10px; }\n\n.relation {\n stroke: #999;\n stroke-width: 1;\n fill: none; }\n\n#compositionStart {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#compositionEnd {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#aggregationStart {\n fill: #eee;\n stroke: #999;\n stroke-width: 1; }\n\n#aggregationEnd {\n fill: #eee;\n stroke: #999;\n stroke-width: 1; }\n\n#dependencyStart {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#dependencyEnd {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#extensionStart {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n#extensionEnd {\n fill: #999;\n stroke: #999;\n stroke-width: 1; }\n\n.commit-id,\n.commit-msg,\n.branch-label {\n fill: lightgrey;\n color: lightgrey; }\n", ""]); - - - -/***/ }), - -/***/ "./node_modules/css-loader/dist/runtime/api.js": -/*!*****************************************************!*\ - !*** ./node_modules/css-loader/dist/runtime/api.js ***! - \*****************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - - -/* - MIT License http://www.opensource.org/licenses/mit-license.php - Author Tobias Koppers @sokra -*/ -// css base code, injected by the css-loader -module.exports = function (useSourceMap) { - var list = []; // return the list of modules as css string - - list.toString = function toString() { - return this.map(function (item) { - var content = cssWithMappingToString(item, useSourceMap); - - if (item[2]) { - return '@media ' + item[2] + '{' + content + '}'; - } else { - return content; - } - }).join(''); - }; // import a list of modules into the list - - - list.i = function (modules, mediaQuery) { - if (typeof modules === 'string') { - modules = [[null, modules, '']]; - } - - var alreadyImportedModules = {}; - - for (var i = 0; i < this.length; i++) { - var id = this[i][0]; - - if (id != null) { - alreadyImportedModules[id] = true; - } - } - - for (i = 0; i < modules.length; i++) { - var item = modules[i]; // skip already imported module - // this implementation is not 100% perfect for weird media query combinations - // when a module is imported multiple times with different media queries. - // I hope this will never occur (Hey this way we have smaller bundles) - - if (item[0] == null || !alreadyImportedModules[item[0]]) { - if (mediaQuery && !item[2]) { - item[2] = mediaQuery; - } else if (mediaQuery) { - item[2] = '(' + item[2] + ') and (' + mediaQuery + ')'; - } - - list.push(item); - } - } - }; - - return list; -}; - -function cssWithMappingToString(item, useSourceMap) { - var content = item[1] || ''; - var cssMapping = item[3]; - - if (!cssMapping) { - return content; - } - - if (useSourceMap && typeof btoa === 'function') { - var sourceMapping = toComment(cssMapping); - var sourceURLs = cssMapping.sources.map(function (source) { - return '/*# sourceURL=' + cssMapping.sourceRoot + source + ' */'; - }); - return [content].concat(sourceURLs).concat([sourceMapping]).join('\n'); - } - - return [content].join('\n'); -} // Adapted from convert-source-map (MIT) - - -function toComment(sourceMap) { - // eslint-disable-next-line no-undef - var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))); - var data = 'sourceMappingURL=data:application/json;charset=utf-8;base64,' + base64; - return '/*# ' + data + ' */'; -} - -/***/ }), - -/***/ "./node_modules/d3-array/src/array.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/array.js ***! - \********************************************/ -/*! exports provided: slice, map */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "map", function() { return map; }); -var array = Array.prototype; - -var slice = array.slice; -var map = array.map; - - -/***/ }), - -/***/ "./node_modules/d3-array/src/ascending.js": -/*!************************************************!*\ - !*** ./node_modules/d3-array/src/ascending.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/bisect.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-array/src/bisect.js ***! - \*********************************************/ -/*! exports provided: bisectRight, bisectLeft, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bisectRight", function() { return bisectRight; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bisectLeft", function() { return bisectLeft; }); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-array/src/ascending.js"); -/* harmony import */ var _bisector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./bisector */ "./node_modules/d3-array/src/bisector.js"); - - - -var ascendingBisect = Object(_bisector__WEBPACK_IMPORTED_MODULE_1__["default"])(_ascending__WEBPACK_IMPORTED_MODULE_0__["default"]); -var bisectRight = ascendingBisect.right; -var bisectLeft = ascendingBisect.left; -/* harmony default export */ __webpack_exports__["default"] = (bisectRight); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/bisector.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-array/src/bisector.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-array/src/ascending.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(compare) { - if (compare.length === 1) compare = ascendingComparator(compare); - return { - left: function(a, x, lo, hi) { - if (lo == null) lo = 0; - if (hi == null) hi = a.length; - while (lo < hi) { - var mid = lo + hi >>> 1; - if (compare(a[mid], x) < 0) lo = mid + 1; - else hi = mid; - } - return lo; - }, - right: function(a, x, lo, hi) { - if (lo == null) lo = 0; - if (hi == null) hi = a.length; - while (lo < hi) { - var mid = lo + hi >>> 1; - if (compare(a[mid], x) > 0) hi = mid; - else lo = mid + 1; - } - return lo; - } - }; -}); - -function ascendingComparator(f) { - return function(d, x) { - return Object(_ascending__WEBPACK_IMPORTED_MODULE_0__["default"])(f(d), x); - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-array/src/constant.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-array/src/constant.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/cross.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/cross.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _pairs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./pairs */ "./node_modules/d3-array/src/pairs.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values0, values1, reduce) { - var n0 = values0.length, - n1 = values1.length, - values = new Array(n0 * n1), - i0, - i1, - i, - value0; - - if (reduce == null) reduce = _pairs__WEBPACK_IMPORTED_MODULE_0__["pair"]; - - for (i0 = i = 0; i0 < n0; ++i0) { - for (value0 = values0[i0], i1 = 0; i1 < n1; ++i1, ++i) { - values[i] = reduce(value0, values1[i1]); - } - } - - return values; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/descending.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-array/src/descending.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/deviation.js": -/*!************************************************!*\ - !*** ./node_modules/d3-array/src/deviation.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _variance__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./variance */ "./node_modules/d3-array/src/variance.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(array, f) { - var v = Object(_variance__WEBPACK_IMPORTED_MODULE_0__["default"])(array, f); - return v ? Math.sqrt(v) : v; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/extent.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-array/src/extent.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - i = -1, - value, - min, - max; - - if (valueof == null) { - while (++i < n) { // Find the first comparable value. - if ((value = values[i]) != null && value >= value) { - min = max = value; - while (++i < n) { // Compare the remaining values. - if ((value = values[i]) != null) { - if (min > value) min = value; - if (max < value) max = value; - } - } - } - } - } - - else { - while (++i < n) { // Find the first comparable value. - if ((value = valueof(values[i], i, values)) != null && value >= value) { - min = max = value; - while (++i < n) { // Compare the remaining values. - if ((value = valueof(values[i], i, values)) != null) { - if (min > value) min = value; - if (max < value) max = value; - } - } - } - } - } - - return [min, max]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/histogram.js": -/*!************************************************!*\ - !*** ./node_modules/d3-array/src/histogram.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./array */ "./node_modules/d3-array/src/array.js"); -/* harmony import */ var _bisect__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./bisect */ "./node_modules/d3-array/src/bisect.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-array/src/constant.js"); -/* harmony import */ var _extent__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./extent */ "./node_modules/d3-array/src/extent.js"); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./identity */ "./node_modules/d3-array/src/identity.js"); -/* harmony import */ var _range__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./range */ "./node_modules/d3-array/src/range.js"); -/* harmony import */ var _ticks__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ticks */ "./node_modules/d3-array/src/ticks.js"); -/* harmony import */ var _threshold_sturges__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./threshold/sturges */ "./node_modules/d3-array/src/threshold/sturges.js"); - - - - - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var value = _identity__WEBPACK_IMPORTED_MODULE_4__["default"], - domain = _extent__WEBPACK_IMPORTED_MODULE_3__["default"], - threshold = _threshold_sturges__WEBPACK_IMPORTED_MODULE_7__["default"]; - - function histogram(data) { - var i, - n = data.length, - x, - values = new Array(n); - - for (i = 0; i < n; ++i) { - values[i] = value(data[i], i, data); - } - - var xz = domain(values), - x0 = xz[0], - x1 = xz[1], - tz = threshold(values, x0, x1); - - // Convert number of thresholds into uniform thresholds. - if (!Array.isArray(tz)) { - tz = Object(_ticks__WEBPACK_IMPORTED_MODULE_6__["tickStep"])(x0, x1, tz); - tz = Object(_range__WEBPACK_IMPORTED_MODULE_5__["default"])(Math.ceil(x0 / tz) * tz, x1, tz); // exclusive - } - - // Remove any thresholds outside the domain. - var m = tz.length; - while (tz[0] <= x0) tz.shift(), --m; - while (tz[m - 1] > x1) tz.pop(), --m; - - var bins = new Array(m + 1), - bin; - - // Initialize bins. - for (i = 0; i <= m; ++i) { - bin = bins[i] = []; - bin.x0 = i > 0 ? tz[i - 1] : x0; - bin.x1 = i < m ? tz[i] : x1; - } - - // Assign data to bins by value, ignoring any outside the domain. - for (i = 0; i < n; ++i) { - x = values[i]; - if (x0 <= x && x <= x1) { - bins[Object(_bisect__WEBPACK_IMPORTED_MODULE_1__["default"])(tz, x, 0, m)].push(data[i]); - } - } - - return bins; - } - - histogram.value = function(_) { - return arguments.length ? (value = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(_), histogram) : value; - }; - - histogram.domain = function(_) { - return arguments.length ? (domain = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])([_[0], _[1]]), histogram) : domain; - }; - - histogram.thresholds = function(_) { - return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(_array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(_)) : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(_), histogram) : threshold; - }; - - return histogram; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/identity.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-array/src/identity.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/index.js ***! - \********************************************/ -/*! exports provided: bisect, bisectRight, bisectLeft, ascending, bisector, cross, descending, deviation, extent, histogram, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges, max, mean, median, merge, min, pairs, permute, quantile, range, scan, shuffle, sum, ticks, tickIncrement, tickStep, transpose, variance, zip */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _bisect__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./bisect */ "./node_modules/d3-array/src/bisect.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisect", function() { return _bisect__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisectRight", function() { return _bisect__WEBPACK_IMPORTED_MODULE_0__["bisectRight"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisectLeft", function() { return _bisect__WEBPACK_IMPORTED_MODULE_0__["bisectLeft"]; }); - -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-array/src/ascending.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ascending", function() { return _ascending__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _bisector__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./bisector */ "./node_modules/d3-array/src/bisector.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisector", function() { return _bisector__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _cross__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./cross */ "./node_modules/d3-array/src/cross.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cross", function() { return _cross__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _descending__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./descending */ "./node_modules/d3-array/src/descending.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "descending", function() { return _descending__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _deviation__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./deviation */ "./node_modules/d3-array/src/deviation.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "deviation", function() { return _deviation__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _extent__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./extent */ "./node_modules/d3-array/src/extent.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "extent", function() { return _extent__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _histogram__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./histogram */ "./node_modules/d3-array/src/histogram.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "histogram", function() { return _histogram__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _threshold_freedmanDiaconis__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./threshold/freedmanDiaconis */ "./node_modules/d3-array/src/threshold/freedmanDiaconis.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "thresholdFreedmanDiaconis", function() { return _threshold_freedmanDiaconis__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _threshold_scott__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./threshold/scott */ "./node_modules/d3-array/src/threshold/scott.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "thresholdScott", function() { return _threshold_scott__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _threshold_sturges__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./threshold/sturges */ "./node_modules/d3-array/src/threshold/sturges.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "thresholdSturges", function() { return _threshold_sturges__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony import */ var _max__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./max */ "./node_modules/d3-array/src/max.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "max", function() { return _max__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony import */ var _mean__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./mean */ "./node_modules/d3-array/src/mean.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "mean", function() { return _mean__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony import */ var _median__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./median */ "./node_modules/d3-array/src/median.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "median", function() { return _median__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony import */ var _merge__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./merge */ "./node_modules/d3-array/src/merge.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "merge", function() { return _merge__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony import */ var _min__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./min */ "./node_modules/d3-array/src/min.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "min", function() { return _min__WEBPACK_IMPORTED_MODULE_15__["default"]; }); - -/* harmony import */ var _pairs__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./pairs */ "./node_modules/d3-array/src/pairs.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pairs", function() { return _pairs__WEBPACK_IMPORTED_MODULE_16__["default"]; }); - -/* harmony import */ var _permute__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./permute */ "./node_modules/d3-array/src/permute.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "permute", function() { return _permute__WEBPACK_IMPORTED_MODULE_17__["default"]; }); - -/* harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./quantile */ "./node_modules/d3-array/src/quantile.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "quantile", function() { return _quantile__WEBPACK_IMPORTED_MODULE_18__["default"]; }); - -/* harmony import */ var _range__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./range */ "./node_modules/d3-array/src/range.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "range", function() { return _range__WEBPACK_IMPORTED_MODULE_19__["default"]; }); - -/* harmony import */ var _scan__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./scan */ "./node_modules/d3-array/src/scan.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scan", function() { return _scan__WEBPACK_IMPORTED_MODULE_20__["default"]; }); - -/* harmony import */ var _shuffle__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./shuffle */ "./node_modules/d3-array/src/shuffle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "shuffle", function() { return _shuffle__WEBPACK_IMPORTED_MODULE_21__["default"]; }); - -/* harmony import */ var _sum__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./sum */ "./node_modules/d3-array/src/sum.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "sum", function() { return _sum__WEBPACK_IMPORTED_MODULE_22__["default"]; }); - -/* harmony import */ var _ticks__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./ticks */ "./node_modules/d3-array/src/ticks.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ticks", function() { return _ticks__WEBPACK_IMPORTED_MODULE_23__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tickIncrement", function() { return _ticks__WEBPACK_IMPORTED_MODULE_23__["tickIncrement"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tickStep", function() { return _ticks__WEBPACK_IMPORTED_MODULE_23__["tickStep"]; }); - -/* harmony import */ var _transpose__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./transpose */ "./node_modules/d3-array/src/transpose.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "transpose", function() { return _transpose__WEBPACK_IMPORTED_MODULE_24__["default"]; }); - -/* harmony import */ var _variance__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./variance */ "./node_modules/d3-array/src/variance.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "variance", function() { return _variance__WEBPACK_IMPORTED_MODULE_25__["default"]; }); - -/* harmony import */ var _zip__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./zip */ "./node_modules/d3-array/src/zip.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zip", function() { return _zip__WEBPACK_IMPORTED_MODULE_26__["default"]; }); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-array/src/max.js": -/*!******************************************!*\ - !*** ./node_modules/d3-array/src/max.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - i = -1, - value, - max; - - if (valueof == null) { - while (++i < n) { // Find the first comparable value. - if ((value = values[i]) != null && value >= value) { - max = value; - while (++i < n) { // Compare the remaining values. - if ((value = values[i]) != null && value > max) { - max = value; - } - } - } - } - } - - else { - while (++i < n) { // Find the first comparable value. - if ((value = valueof(values[i], i, values)) != null && value >= value) { - max = value; - while (++i < n) { // Compare the remaining values. - if ((value = valueof(values[i], i, values)) != null && value > max) { - max = value; - } - } - } - } - } - - return max; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/mean.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-array/src/mean.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./number */ "./node_modules/d3-array/src/number.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - m = n, - i = -1, - value, - sum = 0; - - if (valueof == null) { - while (++i < n) { - if (!isNaN(value = Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(values[i]))) sum += value; - else --m; - } - } - - else { - while (++i < n) { - if (!isNaN(value = Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(valueof(values[i], i, values)))) sum += value; - else --m; - } - } - - if (m) return sum / m; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/median.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-array/src/median.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-array/src/ascending.js"); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./number */ "./node_modules/d3-array/src/number.js"); -/* harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./quantile */ "./node_modules/d3-array/src/quantile.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - i = -1, - value, - numbers = []; - - if (valueof == null) { - while (++i < n) { - if (!isNaN(value = Object(_number__WEBPACK_IMPORTED_MODULE_1__["default"])(values[i]))) { - numbers.push(value); - } - } - } - - else { - while (++i < n) { - if (!isNaN(value = Object(_number__WEBPACK_IMPORTED_MODULE_1__["default"])(valueof(values[i], i, values)))) { - numbers.push(value); - } - } - } - - return Object(_quantile__WEBPACK_IMPORTED_MODULE_2__["default"])(numbers.sort(_ascending__WEBPACK_IMPORTED_MODULE_0__["default"]), 0.5); -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/merge.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/merge.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(arrays) { - var n = arrays.length, - m, - i = -1, - j = 0, - merged, - array; - - while (++i < n) j += arrays[i].length; - merged = new Array(j); - - while (--n >= 0) { - array = arrays[n]; - m = array.length; - while (--m >= 0) { - merged[--j] = array[m]; - } - } - - return merged; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/min.js": -/*!******************************************!*\ - !*** ./node_modules/d3-array/src/min.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - i = -1, - value, - min; - - if (valueof == null) { - while (++i < n) { // Find the first comparable value. - if ((value = values[i]) != null && value >= value) { - min = value; - while (++i < n) { // Compare the remaining values. - if ((value = values[i]) != null && min > value) { - min = value; - } - } - } - } - } - - else { - while (++i < n) { // Find the first comparable value. - if ((value = valueof(values[i], i, values)) != null && value >= value) { - min = value; - while (++i < n) { // Compare the remaining values. - if ((value = valueof(values[i], i, values)) != null && min > value) { - min = value; - } - } - } - } - } - - return min; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/number.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-array/src/number.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return x === null ? NaN : +x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/pairs.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/pairs.js ***! - \********************************************/ -/*! exports provided: default, pair */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pair", function() { return pair; }); -/* harmony default export */ __webpack_exports__["default"] = (function(array, f) { - if (f == null) f = pair; - var i = 0, n = array.length - 1, p = array[0], pairs = new Array(n < 0 ? 0 : n); - while (i < n) pairs[i] = f(p, p = array[++i]); - return pairs; -}); - -function pair(a, b) { - return [a, b]; -} - - -/***/ }), - -/***/ "./node_modules/d3-array/src/permute.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-array/src/permute.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(array, indexes) { - var i = indexes.length, permutes = new Array(i); - while (i--) permutes[i] = array[indexes[i]]; - return permutes; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/quantile.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-array/src/quantile.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./number */ "./node_modules/d3-array/src/number.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, p, valueof) { - if (valueof == null) valueof = _number__WEBPACK_IMPORTED_MODULE_0__["default"]; - if (!(n = values.length)) return; - if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values); - if (p >= 1) return +valueof(values[n - 1], n - 1, values); - var n, - i = (n - 1) * p, - i0 = Math.floor(i), - value0 = +valueof(values[i0], i0, values), - value1 = +valueof(values[i0 + 1], i0 + 1, values); - return value0 + (value1 - value0) * (i - i0); -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/range.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/range.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(start, stop, step) { - start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step; - - var i = -1, - n = Math.max(0, Math.ceil((stop - start) / step)) | 0, - range = new Array(n); - - while (++i < n) { - range[i] = start + i * step; - } - - return range; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/scan.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-array/src/scan.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-array/src/ascending.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, compare) { - if (!(n = values.length)) return; - var n, - i = 0, - j = 0, - xi, - xj = values[j]; - - if (compare == null) compare = _ascending__WEBPACK_IMPORTED_MODULE_0__["default"]; - - while (++i < n) { - if (compare(xi = values[i], xj) < 0 || compare(xj, xj) !== 0) { - xj = xi, j = i; - } - } - - if (compare(xj, xj) === 0) return j; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/shuffle.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-array/src/shuffle.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(array, i0, i1) { - var m = (i1 == null ? array.length : i1) - (i0 = i0 == null ? 0 : +i0), - t, - i; - - while (m) { - i = Math.random() * m-- | 0; - t = array[m + i0]; - array[m + i0] = array[i + i0]; - array[i + i0] = t; - } - - return array; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/sum.js": -/*!******************************************!*\ - !*** ./node_modules/d3-array/src/sum.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - i = -1, - value, - sum = 0; - - if (valueof == null) { - while (++i < n) { - if (value = +values[i]) sum += value; // Note: zero and null are equivalent. - } - } - - else { - while (++i < n) { - if (value = +valueof(values[i], i, values)) sum += value; - } - } - - return sum; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/threshold/freedmanDiaconis.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-array/src/threshold/freedmanDiaconis.js ***! - \*****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../array */ "./node_modules/d3-array/src/array.js"); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ascending */ "./node_modules/d3-array/src/ascending.js"); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../number */ "./node_modules/d3-array/src/number.js"); -/* harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../quantile */ "./node_modules/d3-array/src/quantile.js"); - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, min, max) { - values = _array__WEBPACK_IMPORTED_MODULE_0__["map"].call(values, _number__WEBPACK_IMPORTED_MODULE_2__["default"]).sort(_ascending__WEBPACK_IMPORTED_MODULE_1__["default"]); - return Math.ceil((max - min) / (2 * (Object(_quantile__WEBPACK_IMPORTED_MODULE_3__["default"])(values, 0.75) - Object(_quantile__WEBPACK_IMPORTED_MODULE_3__["default"])(values, 0.25)) * Math.pow(values.length, -1 / 3))); -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/threshold/scott.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-array/src/threshold/scott.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _deviation__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../deviation */ "./node_modules/d3-array/src/deviation.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, min, max) { - return Math.ceil((max - min) / (3.5 * Object(_deviation__WEBPACK_IMPORTED_MODULE_0__["default"])(values) * Math.pow(values.length, -1 / 3))); -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/threshold/sturges.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-array/src/threshold/sturges.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(values) { - return Math.ceil(Math.log(values.length) / Math.LN2) + 1; -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/ticks.js": -/*!********************************************!*\ - !*** ./node_modules/d3-array/src/ticks.js ***! - \********************************************/ -/*! exports provided: default, tickIncrement, tickStep */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tickIncrement", function() { return tickIncrement; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tickStep", function() { return tickStep; }); -var e10 = Math.sqrt(50), - e5 = Math.sqrt(10), - e2 = Math.sqrt(2); - -/* harmony default export */ __webpack_exports__["default"] = (function(start, stop, count) { - var reverse, - i = -1, - n, - ticks, - step; - - stop = +stop, start = +start, count = +count; - if (start === stop && count > 0) return [start]; - if (reverse = stop < start) n = start, start = stop, stop = n; - if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return []; - - if (step > 0) { - start = Math.ceil(start / step); - stop = Math.floor(stop / step); - ticks = new Array(n = Math.ceil(stop - start + 1)); - while (++i < n) ticks[i] = (start + i) * step; - } else { - start = Math.floor(start * step); - stop = Math.ceil(stop * step); - ticks = new Array(n = Math.ceil(start - stop + 1)); - while (++i < n) ticks[i] = (start - i) / step; - } - - if (reverse) ticks.reverse(); - - return ticks; -}); - -function tickIncrement(start, stop, count) { - var step = (stop - start) / Math.max(0, count), - power = Math.floor(Math.log(step) / Math.LN10), - error = step / Math.pow(10, power); - return power >= 0 - ? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power) - : -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1); -} - -function tickStep(start, stop, count) { - var step0 = Math.abs(stop - start) / Math.max(0, count), - step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)), - error = step0 / step1; - if (error >= e10) step1 *= 10; - else if (error >= e5) step1 *= 5; - else if (error >= e2) step1 *= 2; - return stop < start ? -step1 : step1; -} - - -/***/ }), - -/***/ "./node_modules/d3-array/src/transpose.js": -/*!************************************************!*\ - !*** ./node_modules/d3-array/src/transpose.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _min__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./min */ "./node_modules/d3-array/src/min.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(matrix) { - if (!(n = matrix.length)) return []; - for (var i = -1, m = Object(_min__WEBPACK_IMPORTED_MODULE_0__["default"])(matrix, length), transpose = new Array(m); ++i < m;) { - for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) { - row[j] = matrix[j][i]; - } - } - return transpose; -}); - -function length(d) { - return d.length; -} - - -/***/ }), - -/***/ "./node_modules/d3-array/src/variance.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-array/src/variance.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./number */ "./node_modules/d3-array/src/number.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values, valueof) { - var n = values.length, - m = 0, - i = -1, - mean = 0, - value, - delta, - sum = 0; - - if (valueof == null) { - while (++i < n) { - if (!isNaN(value = Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(values[i]))) { - delta = value - mean; - mean += delta / ++m; - sum += delta * (value - mean); - } - } - } - - else { - while (++i < n) { - if (!isNaN(value = Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(valueof(values[i], i, values)))) { - delta = value - mean; - mean += delta / ++m; - sum += delta * (value - mean); - } - } - } - - if (m > 1) return sum / (m - 1); -}); - - -/***/ }), - -/***/ "./node_modules/d3-array/src/zip.js": -/*!******************************************!*\ - !*** ./node_modules/d3-array/src/zip.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _transpose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./transpose */ "./node_modules/d3-array/src/transpose.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_transpose__WEBPACK_IMPORTED_MODULE_0__["default"])(arguments); -}); - - -/***/ }), - -/***/ "./node_modules/d3-axis/src/array.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-axis/src/array.js ***! - \*******************************************/ -/*! exports provided: slice */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -var slice = Array.prototype.slice; - - -/***/ }), - -/***/ "./node_modules/d3-axis/src/axis.js": -/*!******************************************!*\ - !*** ./node_modules/d3-axis/src/axis.js ***! - \******************************************/ -/*! exports provided: axisTop, axisRight, axisBottom, axisLeft */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "axisTop", function() { return axisTop; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "axisRight", function() { return axisRight; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "axisBottom", function() { return axisBottom; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "axisLeft", function() { return axisLeft; }); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./array */ "./node_modules/d3-axis/src/array.js"); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./identity */ "./node_modules/d3-axis/src/identity.js"); - - - -var top = 1, - right = 2, - bottom = 3, - left = 4, - epsilon = 1e-6; - -function translateX(x) { - return "translate(" + (x + 0.5) + ",0)"; -} - -function translateY(y) { - return "translate(0," + (y + 0.5) + ")"; -} - -function number(scale) { - return function(d) { - return +scale(d); - }; -} - -function center(scale) { - var offset = Math.max(0, scale.bandwidth() - 1) / 2; // Adjust for 0.5px offset. - if (scale.round()) offset = Math.round(offset); - return function(d) { - return +scale(d) + offset; - }; -} - -function entering() { - return !this.__axis; -} - -function axis(orient, scale) { - var tickArguments = [], - tickValues = null, - tickFormat = null, - tickSizeInner = 6, - tickSizeOuter = 6, - tickPadding = 3, - k = orient === top || orient === left ? -1 : 1, - x = orient === left || orient === right ? "x" : "y", - transform = orient === top || orient === bottom ? translateX : translateY; - - function axis(context) { - var values = tickValues == null ? (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) : tickValues, - format = tickFormat == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : _identity__WEBPACK_IMPORTED_MODULE_1__["default"]) : tickFormat, - spacing = Math.max(tickSizeInner, 0) + tickPadding, - range = scale.range(), - range0 = +range[0] + 0.5, - range1 = +range[range.length - 1] + 0.5, - position = (scale.bandwidth ? center : number)(scale.copy()), - selection = context.selection ? context.selection() : context, - path = selection.selectAll(".domain").data([null]), - tick = selection.selectAll(".tick").data(values, scale).order(), - tickExit = tick.exit(), - tickEnter = tick.enter().append("g").attr("class", "tick"), - line = tick.select("line"), - text = tick.select("text"); - - path = path.merge(path.enter().insert("path", ".tick") - .attr("class", "domain") - .attr("stroke", "currentColor")); - - tick = tick.merge(tickEnter); - - line = line.merge(tickEnter.append("line") - .attr("stroke", "currentColor") - .attr(x + "2", k * tickSizeInner)); - - text = text.merge(tickEnter.append("text") - .attr("fill", "currentColor") - .attr(x, k * spacing) - .attr("dy", orient === top ? "0em" : orient === bottom ? "0.71em" : "0.32em")); - - if (context !== selection) { - path = path.transition(context); - tick = tick.transition(context); - line = line.transition(context); - text = text.transition(context); - - tickExit = tickExit.transition(context) - .attr("opacity", epsilon) - .attr("transform", function(d) { return isFinite(d = position(d)) ? transform(d) : this.getAttribute("transform"); }); - - tickEnter - .attr("opacity", epsilon) - .attr("transform", function(d) { var p = this.parentNode.__axis; return transform(p && isFinite(p = p(d)) ? p : position(d)); }); - } - - tickExit.remove(); - - path - .attr("d", orient === left || orient == right - ? (tickSizeOuter ? "M" + k * tickSizeOuter + "," + range0 + "H0.5V" + range1 + "H" + k * tickSizeOuter : "M0.5," + range0 + "V" + range1) - : (tickSizeOuter ? "M" + range0 + "," + k * tickSizeOuter + "V0.5H" + range1 + "V" + k * tickSizeOuter : "M" + range0 + ",0.5H" + range1)); - - tick - .attr("opacity", 1) - .attr("transform", function(d) { return transform(position(d)); }); - - line - .attr(x + "2", k * tickSizeInner); - - text - .attr(x, k * spacing) - .text(format); - - selection.filter(entering) - .attr("fill", "none") - .attr("font-size", 10) - .attr("font-family", "sans-serif") - .attr("text-anchor", orient === right ? "start" : orient === left ? "end" : "middle"); - - selection - .each(function() { this.__axis = position; }); - } - - axis.scale = function(_) { - return arguments.length ? (scale = _, axis) : scale; - }; - - axis.ticks = function() { - return tickArguments = _array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(arguments), axis; - }; - - axis.tickArguments = function(_) { - return arguments.length ? (tickArguments = _ == null ? [] : _array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(_), axis) : tickArguments.slice(); - }; - - axis.tickValues = function(_) { - return arguments.length ? (tickValues = _ == null ? null : _array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(_), axis) : tickValues && tickValues.slice(); - }; - - axis.tickFormat = function(_) { - return arguments.length ? (tickFormat = _, axis) : tickFormat; - }; - - axis.tickSize = function(_) { - return arguments.length ? (tickSizeInner = tickSizeOuter = +_, axis) : tickSizeInner; - }; - - axis.tickSizeInner = function(_) { - return arguments.length ? (tickSizeInner = +_, axis) : tickSizeInner; - }; - - axis.tickSizeOuter = function(_) { - return arguments.length ? (tickSizeOuter = +_, axis) : tickSizeOuter; - }; - - axis.tickPadding = function(_) { - return arguments.length ? (tickPadding = +_, axis) : tickPadding; - }; - - return axis; -} - -function axisTop(scale) { - return axis(top, scale); -} - -function axisRight(scale) { - return axis(right, scale); -} - -function axisBottom(scale) { - return axis(bottom, scale); -} - -function axisLeft(scale) { - return axis(left, scale); -} - - -/***/ }), - -/***/ "./node_modules/d3-axis/src/identity.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-axis/src/identity.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-axis/src/index.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-axis/src/index.js ***! - \*******************************************/ -/*! exports provided: axisTop, axisRight, axisBottom, axisLeft */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _axis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./axis */ "./node_modules/d3-axis/src/axis.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisTop", function() { return _axis__WEBPACK_IMPORTED_MODULE_0__["axisTop"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisRight", function() { return _axis__WEBPACK_IMPORTED_MODULE_0__["axisRight"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisBottom", function() { return _axis__WEBPACK_IMPORTED_MODULE_0__["axisBottom"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisLeft", function() { return _axis__WEBPACK_IMPORTED_MODULE_0__["axisLeft"]; }); - - - - -/***/ }), - -/***/ "./node_modules/d3-brush/src/brush.js": -/*!********************************************!*\ - !*** ./node_modules/d3-brush/src/brush.js ***! - \********************************************/ -/*! exports provided: brushSelection, brushX, brushY, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "brushSelection", function() { return brushSelection; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "brushX", function() { return brushX; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "brushY", function() { return brushY; }); -/* harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js"); -/* harmony import */ var d3_drag__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-drag */ "./node_modules/d3-drag/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var d3_transition__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! d3-transition */ "./node_modules/d3-transition/src/index.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-brush/src/constant.js"); -/* harmony import */ var _event__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./event */ "./node_modules/d3-brush/src/event.js"); -/* harmony import */ var _noevent__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./noevent */ "./node_modules/d3-brush/src/noevent.js"); - - - - - - - - - -var MODE_DRAG = {name: "drag"}, - MODE_SPACE = {name: "space"}, - MODE_HANDLE = {name: "handle"}, - MODE_CENTER = {name: "center"}; - -var X = { - name: "x", - handles: ["e", "w"].map(type), - input: function(x, e) { return x && [[x[0], e[0][1]], [x[1], e[1][1]]]; }, - output: function(xy) { return xy && [xy[0][0], xy[1][0]]; } -}; - -var Y = { - name: "y", - handles: ["n", "s"].map(type), - input: function(y, e) { return y && [[e[0][0], y[0]], [e[1][0], y[1]]]; }, - output: function(xy) { return xy && [xy[0][1], xy[1][1]]; } -}; - -var XY = { - name: "xy", - handles: ["n", "e", "s", "w", "nw", "ne", "se", "sw"].map(type), - input: function(xy) { return xy; }, - output: function(xy) { return xy; } -}; - -var cursors = { - overlay: "crosshair", - selection: "move", - n: "ns-resize", - e: "ew-resize", - s: "ns-resize", - w: "ew-resize", - nw: "nwse-resize", - ne: "nesw-resize", - se: "nwse-resize", - sw: "nesw-resize" -}; - -var flipX = { - e: "w", - w: "e", - nw: "ne", - ne: "nw", - se: "sw", - sw: "se" -}; - -var flipY = { - n: "s", - s: "n", - nw: "sw", - ne: "se", - se: "ne", - sw: "nw" -}; - -var signsX = { - overlay: +1, - selection: +1, - n: null, - e: +1, - s: null, - w: -1, - nw: -1, - ne: +1, - se: +1, - sw: -1 -}; - -var signsY = { - overlay: +1, - selection: +1, - n: -1, - e: null, - s: +1, - w: null, - nw: -1, - ne: -1, - se: +1, - sw: +1 -}; - -function type(t) { - return {type: t}; -} - -// Ignore right-click, since that should open the context menu. -function defaultFilter() { - return !d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].button; -} - -function defaultExtent() { - var svg = this.ownerSVGElement || this; - return [[0, 0], [svg.width.baseVal.value, svg.height.baseVal.value]]; -} - -// Like d3.local, but with the name “__brush” rather than auto-generated. -function local(node) { - while (!node.__brush) if (!(node = node.parentNode)) return; - return node.__brush; -} - -function empty(extent) { - return extent[0][0] === extent[1][0] - || extent[0][1] === extent[1][1]; -} - -function brushSelection(node) { - var state = node.__brush; - return state ? state.dim.output(state.selection) : null; -} - -function brushX() { - return brush(X); -} - -function brushY() { - return brush(Y); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return brush(XY); -}); - -function brush(dim) { - var extent = defaultExtent, - filter = defaultFilter, - listeners = Object(d3_dispatch__WEBPACK_IMPORTED_MODULE_0__["dispatch"])(brush, "start", "brush", "end"), - handleSize = 6, - touchending; - - function brush(group) { - var overlay = group - .property("__brush", initialize) - .selectAll(".overlay") - .data([type("overlay")]); - - overlay.enter().append("rect") - .attr("class", "overlay") - .attr("pointer-events", "all") - .attr("cursor", cursors.overlay) - .merge(overlay) - .each(function() { - var extent = local(this).extent; - Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(this) - .attr("x", extent[0][0]) - .attr("y", extent[0][1]) - .attr("width", extent[1][0] - extent[0][0]) - .attr("height", extent[1][1] - extent[0][1]); - }); - - group.selectAll(".selection") - .data([type("selection")]) - .enter().append("rect") - .attr("class", "selection") - .attr("cursor", cursors.selection) - .attr("fill", "#777") - .attr("fill-opacity", 0.3) - .attr("stroke", "#fff") - .attr("shape-rendering", "crispEdges"); - - var handle = group.selectAll(".handle") - .data(dim.handles, function(d) { return d.type; }); - - handle.exit().remove(); - - handle.enter().append("rect") - .attr("class", function(d) { return "handle handle--" + d.type; }) - .attr("cursor", function(d) { return cursors[d.type]; }); - - group - .each(redraw) - .attr("fill", "none") - .attr("pointer-events", "all") - .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)") - .on("mousedown.brush touchstart.brush", started); - } - - brush.move = function(group, selection) { - if (group.selection) { - group - .on("start.brush", function() { emitter(this, arguments).beforestart().start(); }) - .on("interrupt.brush end.brush", function() { emitter(this, arguments).end(); }) - .tween("brush", function() { - var that = this, - state = that.__brush, - emit = emitter(that, arguments), - selection0 = state.selection, - selection1 = dim.input(typeof selection === "function" ? selection.apply(this, arguments) : selection, state.extent), - i = Object(d3_interpolate__WEBPACK_IMPORTED_MODULE_2__["interpolate"])(selection0, selection1); - - function tween(t) { - state.selection = t === 1 && empty(selection1) ? null : i(t); - redraw.call(that); - emit.brush(); - } - - return selection0 && selection1 ? tween : tween(1); - }); - } else { - group - .each(function() { - var that = this, - args = arguments, - state = that.__brush, - selection1 = dim.input(typeof selection === "function" ? selection.apply(that, args) : selection, state.extent), - emit = emitter(that, args).beforestart(); - - Object(d3_transition__WEBPACK_IMPORTED_MODULE_4__["interrupt"])(that); - state.selection = selection1 == null || empty(selection1) ? null : selection1; - redraw.call(that); - emit.start().brush().end(); - }); - } - }; - - function redraw() { - var group = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(this), - selection = local(this).selection; - - if (selection) { - group.selectAll(".selection") - .style("display", null) - .attr("x", selection[0][0]) - .attr("y", selection[0][1]) - .attr("width", selection[1][0] - selection[0][0]) - .attr("height", selection[1][1] - selection[0][1]); - - group.selectAll(".handle") - .style("display", null) - .attr("x", function(d) { return d.type[d.type.length - 1] === "e" ? selection[1][0] - handleSize / 2 : selection[0][0] - handleSize / 2; }) - .attr("y", function(d) { return d.type[0] === "s" ? selection[1][1] - handleSize / 2 : selection[0][1] - handleSize / 2; }) - .attr("width", function(d) { return d.type === "n" || d.type === "s" ? selection[1][0] - selection[0][0] + handleSize : handleSize; }) - .attr("height", function(d) { return d.type === "e" || d.type === "w" ? selection[1][1] - selection[0][1] + handleSize : handleSize; }); - } - - else { - group.selectAll(".selection,.handle") - .style("display", "none") - .attr("x", null) - .attr("y", null) - .attr("width", null) - .attr("height", null); - } - } - - function emitter(that, args) { - return that.__brush.emitter || new Emitter(that, args); - } - - function Emitter(that, args) { - this.that = that; - this.args = args; - this.state = that.__brush; - this.active = 0; - } - - Emitter.prototype = { - beforestart: function() { - if (++this.active === 1) this.state.emitter = this, this.starting = true; - return this; - }, - start: function() { - if (this.starting) this.starting = false, this.emit("start"); - return this; - }, - brush: function() { - this.emit("brush"); - return this; - }, - end: function() { - if (--this.active === 0) delete this.state.emitter, this.emit("end"); - return this; - }, - emit: function(type) { - Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["customEvent"])(new _event__WEBPACK_IMPORTED_MODULE_6__["default"](brush, type, dim.output(this.state.selection)), listeners.apply, listeners, [type, this.that, this.args]); - } - }; - - function started() { - if (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].touches) { if (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].changedTouches.length < d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].touches.length) return Object(_noevent__WEBPACK_IMPORTED_MODULE_7__["default"])(); } - else if (touchending) return; - if (!filter.apply(this, arguments)) return; - - var that = this, - type = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].target.__data__.type, - mode = (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].metaKey ? type = "overlay" : type) === "selection" ? MODE_DRAG : (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].altKey ? MODE_CENTER : MODE_HANDLE), - signX = dim === Y ? null : signsX[type], - signY = dim === X ? null : signsY[type], - state = local(that), - extent = state.extent, - selection = state.selection, - W = extent[0][0], w0, w1, - N = extent[0][1], n0, n1, - E = extent[1][0], e0, e1, - S = extent[1][1], s0, s1, - dx, - dy, - moving, - shifting = signX && signY && d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].shiftKey, - lockX, - lockY, - point0 = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["mouse"])(that), - point = point0, - emit = emitter(that, arguments).beforestart(); - - if (type === "overlay") { - state.selection = selection = [ - [w0 = dim === Y ? W : point0[0], n0 = dim === X ? N : point0[1]], - [e0 = dim === Y ? E : w0, s0 = dim === X ? S : n0] - ]; - } else { - w0 = selection[0][0]; - n0 = selection[0][1]; - e0 = selection[1][0]; - s0 = selection[1][1]; - } - - w1 = w0; - n1 = n0; - e1 = e0; - s1 = s0; - - var group = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(that) - .attr("pointer-events", "none"); - - var overlay = group.selectAll(".overlay") - .attr("cursor", cursors[type]); - - if (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].touches) { - group - .on("touchmove.brush", moved, true) - .on("touchend.brush touchcancel.brush", ended, true); - } else { - var view = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].view) - .on("keydown.brush", keydowned, true) - .on("keyup.brush", keyupped, true) - .on("mousemove.brush", moved, true) - .on("mouseup.brush", ended, true); - - Object(d3_drag__WEBPACK_IMPORTED_MODULE_1__["dragDisable"])(d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].view); - } - - Object(_noevent__WEBPACK_IMPORTED_MODULE_7__["nopropagation"])(); - Object(d3_transition__WEBPACK_IMPORTED_MODULE_4__["interrupt"])(that); - redraw.call(that); - emit.start(); - - function moved() { - var point1 = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["mouse"])(that); - if (shifting && !lockX && !lockY) { - if (Math.abs(point1[0] - point[0]) > Math.abs(point1[1] - point[1])) lockY = true; - else lockX = true; - } - point = point1; - moving = true; - Object(_noevent__WEBPACK_IMPORTED_MODULE_7__["default"])(); - move(); - } - - function move() { - var t; - - dx = point[0] - point0[0]; - dy = point[1] - point0[1]; - - switch (mode) { - case MODE_SPACE: - case MODE_DRAG: { - if (signX) dx = Math.max(W - w0, Math.min(E - e0, dx)), w1 = w0 + dx, e1 = e0 + dx; - if (signY) dy = Math.max(N - n0, Math.min(S - s0, dy)), n1 = n0 + dy, s1 = s0 + dy; - break; - } - case MODE_HANDLE: { - if (signX < 0) dx = Math.max(W - w0, Math.min(E - w0, dx)), w1 = w0 + dx, e1 = e0; - else if (signX > 0) dx = Math.max(W - e0, Math.min(E - e0, dx)), w1 = w0, e1 = e0 + dx; - if (signY < 0) dy = Math.max(N - n0, Math.min(S - n0, dy)), n1 = n0 + dy, s1 = s0; - else if (signY > 0) dy = Math.max(N - s0, Math.min(S - s0, dy)), n1 = n0, s1 = s0 + dy; - break; - } - case MODE_CENTER: { - if (signX) w1 = Math.max(W, Math.min(E, w0 - dx * signX)), e1 = Math.max(W, Math.min(E, e0 + dx * signX)); - if (signY) n1 = Math.max(N, Math.min(S, n0 - dy * signY)), s1 = Math.max(N, Math.min(S, s0 + dy * signY)); - break; - } - } - - if (e1 < w1) { - signX *= -1; - t = w0, w0 = e0, e0 = t; - t = w1, w1 = e1, e1 = t; - if (type in flipX) overlay.attr("cursor", cursors[type = flipX[type]]); - } - - if (s1 < n1) { - signY *= -1; - t = n0, n0 = s0, s0 = t; - t = n1, n1 = s1, s1 = t; - if (type in flipY) overlay.attr("cursor", cursors[type = flipY[type]]); - } - - if (state.selection) selection = state.selection; // May be set by brush.move! - if (lockX) w1 = selection[0][0], e1 = selection[1][0]; - if (lockY) n1 = selection[0][1], s1 = selection[1][1]; - - if (selection[0][0] !== w1 - || selection[0][1] !== n1 - || selection[1][0] !== e1 - || selection[1][1] !== s1) { - state.selection = [[w1, n1], [e1, s1]]; - redraw.call(that); - emit.brush(); - } - } - - function ended() { - Object(_noevent__WEBPACK_IMPORTED_MODULE_7__["nopropagation"])(); - if (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].touches) { - if (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].touches.length) return; - if (touchending) clearTimeout(touchending); - touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! - group.on("touchmove.brush touchend.brush touchcancel.brush", null); - } else { - Object(d3_drag__WEBPACK_IMPORTED_MODULE_1__["dragEnable"])(d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].view, moving); - view.on("keydown.brush keyup.brush mousemove.brush mouseup.brush", null); - } - group.attr("pointer-events", "all"); - overlay.attr("cursor", cursors.overlay); - if (state.selection) selection = state.selection; // May be set by brush.move (on start)! - if (empty(selection)) state.selection = null, redraw.call(that); - emit.end(); - } - - function keydowned() { - switch (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].keyCode) { - case 16: { // SHIFT - shifting = signX && signY; - break; - } - case 18: { // ALT - if (mode === MODE_HANDLE) { - if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX; - if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY; - mode = MODE_CENTER; - move(); - } - break; - } - case 32: { // SPACE; takes priority over ALT - if (mode === MODE_HANDLE || mode === MODE_CENTER) { - if (signX < 0) e0 = e1 - dx; else if (signX > 0) w0 = w1 - dx; - if (signY < 0) s0 = s1 - dy; else if (signY > 0) n0 = n1 - dy; - mode = MODE_SPACE; - overlay.attr("cursor", cursors.selection); - move(); - } - break; - } - default: return; - } - Object(_noevent__WEBPACK_IMPORTED_MODULE_7__["default"])(); - } - - function keyupped() { - switch (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].keyCode) { - case 16: { // SHIFT - if (shifting) { - lockX = lockY = shifting = false; - move(); - } - break; - } - case 18: { // ALT - if (mode === MODE_CENTER) { - if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1; - if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1; - mode = MODE_HANDLE; - move(); - } - break; - } - case 32: { // SPACE - if (mode === MODE_SPACE) { - if (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].altKey) { - if (signX) e0 = e1 - dx * signX, w0 = w1 + dx * signX; - if (signY) s0 = s1 - dy * signY, n0 = n1 + dy * signY; - mode = MODE_CENTER; - } else { - if (signX < 0) e0 = e1; else if (signX > 0) w0 = w1; - if (signY < 0) s0 = s1; else if (signY > 0) n0 = n1; - mode = MODE_HANDLE; - } - overlay.attr("cursor", cursors[type]); - move(); - } - break; - } - default: return; - } - Object(_noevent__WEBPACK_IMPORTED_MODULE_7__["default"])(); - } - } - - function initialize() { - var state = this.__brush || {selection: null}; - state.extent = extent.apply(this, arguments); - state.dim = dim; - return state; - } - - brush.extent = function(_) { - return arguments.length ? (extent = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_5__["default"])([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), brush) : extent; - }; - - brush.filter = function(_) { - return arguments.length ? (filter = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_5__["default"])(!!_), brush) : filter; - }; - - brush.handleSize = function(_) { - return arguments.length ? (handleSize = +_, brush) : handleSize; - }; - - brush.on = function() { - var value = listeners.on.apply(listeners, arguments); - return value === listeners ? brush : value; - }; - - return brush; -} - - -/***/ }), - -/***/ "./node_modules/d3-brush/src/constant.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-brush/src/constant.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-brush/src/event.js": -/*!********************************************!*\ - !*** ./node_modules/d3-brush/src/event.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(target, type, selection) { - this.target = target; - this.type = type; - this.selection = selection; -}); - - -/***/ }), - -/***/ "./node_modules/d3-brush/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-brush/src/index.js ***! - \********************************************/ -/*! exports provided: brush, brushX, brushY, brushSelection */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _brush__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./brush */ "./node_modules/d3-brush/src/brush.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brush", function() { return _brush__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brushX", function() { return _brush__WEBPACK_IMPORTED_MODULE_0__["brushX"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brushY", function() { return _brush__WEBPACK_IMPORTED_MODULE_0__["brushY"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brushSelection", function() { return _brush__WEBPACK_IMPORTED_MODULE_0__["brushSelection"]; }); - - - - -/***/ }), - -/***/ "./node_modules/d3-brush/src/noevent.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-brush/src/noevent.js ***! - \**********************************************/ -/*! exports provided: nopropagation, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nopropagation", function() { return nopropagation; }); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); - - -function nopropagation() { - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].stopImmediatePropagation(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].preventDefault(); - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].stopImmediatePropagation(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-chord/src/array.js": -/*!********************************************!*\ - !*** ./node_modules/d3-chord/src/array.js ***! - \********************************************/ -/*! exports provided: slice */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -var slice = Array.prototype.slice; - - -/***/ }), - -/***/ "./node_modules/d3-chord/src/chord.js": -/*!********************************************!*\ - !*** ./node_modules/d3-chord/src/chord.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./math */ "./node_modules/d3-chord/src/math.js"); - - - -function compareValue(compare) { - return function(a, b) { - return compare( - a.source.value + a.target.value, - b.source.value + b.target.value - ); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var padAngle = 0, - sortGroups = null, - sortSubgroups = null, - sortChords = null; - - function chord(matrix) { - var n = matrix.length, - groupSums = [], - groupIndex = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(n), - subgroupIndex = [], - chords = [], - groups = chords.groups = new Array(n), - subgroups = new Array(n * n), - k, - x, - x0, - dx, - i, - j; - - // Compute the sum. - k = 0, i = -1; while (++i < n) { - x = 0, j = -1; while (++j < n) { - x += matrix[i][j]; - } - groupSums.push(x); - subgroupIndex.push(Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(n)); - k += x; - } - - // Sort groups… - if (sortGroups) groupIndex.sort(function(a, b) { - return sortGroups(groupSums[a], groupSums[b]); - }); - - // Sort subgroups… - if (sortSubgroups) subgroupIndex.forEach(function(d, i) { - d.sort(function(a, b) { - return sortSubgroups(matrix[i][a], matrix[i][b]); - }); - }); - - // Convert the sum to scaling factor for [0, 2pi]. - // TODO Allow start and end angle to be specified? - // TODO Allow padding to be specified as percentage? - k = Object(_math__WEBPACK_IMPORTED_MODULE_1__["max"])(0, _math__WEBPACK_IMPORTED_MODULE_1__["tau"] - padAngle * n) / k; - dx = k ? padAngle : _math__WEBPACK_IMPORTED_MODULE_1__["tau"] / n; - - // Compute the start and end angle for each group and subgroup. - // Note: Opera has a bug reordering object literal properties! - x = 0, i = -1; while (++i < n) { - x0 = x, j = -1; while (++j < n) { - var di = groupIndex[i], - dj = subgroupIndex[di][j], - v = matrix[di][dj], - a0 = x, - a1 = x += v * k; - subgroups[dj * n + di] = { - index: di, - subindex: dj, - startAngle: a0, - endAngle: a1, - value: v - }; - } - groups[di] = { - index: di, - startAngle: x0, - endAngle: x, - value: groupSums[di] - }; - x += dx; - } - - // Generate chords for each (non-empty) subgroup-subgroup link. - i = -1; while (++i < n) { - j = i - 1; while (++j < n) { - var source = subgroups[j * n + i], - target = subgroups[i * n + j]; - if (source.value || target.value) { - chords.push(source.value < target.value - ? {source: target, target: source} - : {source: source, target: target}); - } - } - } - - return sortChords ? chords.sort(sortChords) : chords; - } - - chord.padAngle = function(_) { - return arguments.length ? (padAngle = Object(_math__WEBPACK_IMPORTED_MODULE_1__["max"])(0, _), chord) : padAngle; - }; - - chord.sortGroups = function(_) { - return arguments.length ? (sortGroups = _, chord) : sortGroups; - }; - - chord.sortSubgroups = function(_) { - return arguments.length ? (sortSubgroups = _, chord) : sortSubgroups; - }; - - chord.sortChords = function(_) { - return arguments.length ? (_ == null ? sortChords = null : (sortChords = compareValue(_))._ = _, chord) : sortChords && sortChords._; - }; - - return chord; -}); - - -/***/ }), - -/***/ "./node_modules/d3-chord/src/constant.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-chord/src/constant.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-chord/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-chord/src/index.js ***! - \********************************************/ -/*! exports provided: chord, ribbon */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _chord__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./chord */ "./node_modules/d3-chord/src/chord.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "chord", function() { return _chord__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _ribbon__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ribbon */ "./node_modules/d3-chord/src/ribbon.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ribbon", function() { return _ribbon__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - - - - - -/***/ }), - -/***/ "./node_modules/d3-chord/src/math.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-chord/src/math.js ***! - \*******************************************/ -/*! exports provided: cos, sin, pi, halfPi, tau, max */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cos", function() { return cos; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sin", function() { return sin; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pi", function() { return pi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "halfPi", function() { return halfPi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tau", function() { return tau; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "max", function() { return max; }); -var cos = Math.cos; -var sin = Math.sin; -var pi = Math.PI; -var halfPi = pi / 2; -var tau = pi * 2; -var max = Math.max; - - -/***/ }), - -/***/ "./node_modules/d3-chord/src/ribbon.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-chord/src/ribbon.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./array */ "./node_modules/d3-chord/src/array.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-chord/src/constant.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-chord/src/math.js"); -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); - - - - - -function defaultSource(d) { - return d.source; -} - -function defaultTarget(d) { - return d.target; -} - -function defaultRadius(d) { - return d.radius; -} - -function defaultStartAngle(d) { - return d.startAngle; -} - -function defaultEndAngle(d) { - return d.endAngle; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var source = defaultSource, - target = defaultTarget, - radius = defaultRadius, - startAngle = defaultStartAngle, - endAngle = defaultEndAngle, - context = null; - - function ribbon() { - var buffer, - argv = _array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(arguments), - s = source.apply(this, argv), - t = target.apply(this, argv), - sr = +radius.apply(this, (argv[0] = s, argv)), - sa0 = startAngle.apply(this, argv) - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"], - sa1 = endAngle.apply(this, argv) - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"], - sx0 = sr * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(sa0), - sy0 = sr * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(sa0), - tr = +radius.apply(this, (argv[0] = t, argv)), - ta0 = startAngle.apply(this, argv) - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"], - ta1 = endAngle.apply(this, argv) - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"]; - - if (!context) context = buffer = Object(d3_path__WEBPACK_IMPORTED_MODULE_3__["path"])(); - - context.moveTo(sx0, sy0); - context.arc(0, 0, sr, sa0, sa1); - if (sa0 !== ta0 || sa1 !== ta1) { // TODO sr !== tr? - context.quadraticCurveTo(0, 0, tr * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(ta0), tr * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(ta0)); - context.arc(0, 0, tr, ta0, ta1); - } - context.quadraticCurveTo(0, 0, sx0, sy0); - context.closePath(); - - if (buffer) return context = null, buffer + "" || null; - } - - ribbon.radius = function(_) { - return arguments.length ? (radius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), ribbon) : radius; - }; - - ribbon.startAngle = function(_) { - return arguments.length ? (startAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), ribbon) : startAngle; - }; - - ribbon.endAngle = function(_) { - return arguments.length ? (endAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), ribbon) : endAngle; - }; - - ribbon.source = function(_) { - return arguments.length ? (source = _, ribbon) : source; - }; - - ribbon.target = function(_) { - return arguments.length ? (target = _, ribbon) : target; - }; - - ribbon.context = function(_) { - return arguments.length ? ((context = _ == null ? null : _), ribbon) : context; - }; - - return ribbon; -}); - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/entries.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-collection/src/entries.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(map) { - var entries = []; - for (var key in map) entries.push({key: key, value: map[key]}); - return entries; -}); - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/index.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-collection/src/index.js ***! - \*************************************************/ -/*! exports provided: nest, set, map, keys, values, entries */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _nest__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./nest */ "./node_modules/d3-collection/src/nest.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "nest", function() { return _nest__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _set__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./set */ "./node_modules/d3-collection/src/set.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "set", function() { return _set__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _map__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./map */ "./node_modules/d3-collection/src/map.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "map", function() { return _map__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _keys__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./keys */ "./node_modules/d3-collection/src/keys.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "keys", function() { return _keys__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _values__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./values */ "./node_modules/d3-collection/src/values.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "values", function() { return _values__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _entries__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./entries */ "./node_modules/d3-collection/src/entries.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "entries", function() { return _entries__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/keys.js": -/*!************************************************!*\ - !*** ./node_modules/d3-collection/src/keys.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(map) { - var keys = []; - for (var key in map) keys.push(key); - return keys; -}); - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/map.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-collection/src/map.js ***! - \***********************************************/ -/*! exports provided: prefix, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "prefix", function() { return prefix; }); -var prefix = "$"; - -function Map() {} - -Map.prototype = map.prototype = { - constructor: Map, - has: function(key) { - return (prefix + key) in this; - }, - get: function(key) { - return this[prefix + key]; - }, - set: function(key, value) { - this[prefix + key] = value; - return this; - }, - remove: function(key) { - var property = prefix + key; - return property in this && delete this[property]; - }, - clear: function() { - for (var property in this) if (property[0] === prefix) delete this[property]; - }, - keys: function() { - var keys = []; - for (var property in this) if (property[0] === prefix) keys.push(property.slice(1)); - return keys; - }, - values: function() { - var values = []; - for (var property in this) if (property[0] === prefix) values.push(this[property]); - return values; - }, - entries: function() { - var entries = []; - for (var property in this) if (property[0] === prefix) entries.push({key: property.slice(1), value: this[property]}); - return entries; - }, - size: function() { - var size = 0; - for (var property in this) if (property[0] === prefix) ++size; - return size; - }, - empty: function() { - for (var property in this) if (property[0] === prefix) return false; - return true; - }, - each: function(f) { - for (var property in this) if (property[0] === prefix) f(this[property], property.slice(1), this); - } -}; - -function map(object, f) { - var map = new Map; - - // Copy constructor. - if (object instanceof Map) object.each(function(value, key) { map.set(key, value); }); - - // Index array by numeric index or specified key function. - else if (Array.isArray(object)) { - var i = -1, - n = object.length, - o; - - if (f == null) while (++i < n) map.set(i, object[i]); - else while (++i < n) map.set(f(o = object[i], i, object), o); - } - - // Convert object to map. - else if (object) for (var key in object) map.set(key, object[key]); - - return map; -} - -/* harmony default export */ __webpack_exports__["default"] = (map); - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/nest.js": -/*!************************************************!*\ - !*** ./node_modules/d3-collection/src/nest.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _map__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./map */ "./node_modules/d3-collection/src/map.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var keys = [], - sortKeys = [], - sortValues, - rollup, - nest; - - function apply(array, depth, createResult, setResult) { - if (depth >= keys.length) { - if (sortValues != null) array.sort(sortValues); - return rollup != null ? rollup(array) : array; - } - - var i = -1, - n = array.length, - key = keys[depth++], - keyValue, - value, - valuesByKey = Object(_map__WEBPACK_IMPORTED_MODULE_0__["default"])(), - values, - result = createResult(); - - while (++i < n) { - if (values = valuesByKey.get(keyValue = key(value = array[i]) + "")) { - values.push(value); - } else { - valuesByKey.set(keyValue, [value]); - } - } - - valuesByKey.each(function(values, key) { - setResult(result, key, apply(values, depth, createResult, setResult)); - }); - - return result; - } - - function entries(map, depth) { - if (++depth > keys.length) return map; - var array, sortKey = sortKeys[depth - 1]; - if (rollup != null && depth >= keys.length) array = map.entries(); - else array = [], map.each(function(v, k) { array.push({key: k, values: entries(v, depth)}); }); - return sortKey != null ? array.sort(function(a, b) { return sortKey(a.key, b.key); }) : array; - } - - return nest = { - object: function(array) { return apply(array, 0, createObject, setObject); }, - map: function(array) { return apply(array, 0, createMap, setMap); }, - entries: function(array) { return entries(apply(array, 0, createMap, setMap), 0); }, - key: function(d) { keys.push(d); return nest; }, - sortKeys: function(order) { sortKeys[keys.length - 1] = order; return nest; }, - sortValues: function(order) { sortValues = order; return nest; }, - rollup: function(f) { rollup = f; return nest; } - }; -}); - -function createObject() { - return {}; -} - -function setObject(object, key, value) { - object[key] = value; -} - -function createMap() { - return Object(_map__WEBPACK_IMPORTED_MODULE_0__["default"])(); -} - -function setMap(map, key, value) { - map.set(key, value); -} - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/set.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-collection/src/set.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _map__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./map */ "./node_modules/d3-collection/src/map.js"); - - -function Set() {} - -var proto = _map__WEBPACK_IMPORTED_MODULE_0__["default"].prototype; - -Set.prototype = set.prototype = { - constructor: Set, - has: proto.has, - add: function(value) { - value += ""; - this[_map__WEBPACK_IMPORTED_MODULE_0__["prefix"] + value] = value; - return this; - }, - remove: proto.remove, - clear: proto.clear, - values: proto.keys, - size: proto.size, - empty: proto.empty, - each: proto.each -}; - -function set(object, f) { - var set = new Set; - - // Copy constructor. - if (object instanceof Set) object.each(function(value) { set.add(value); }); - - // Otherwise, assume it’s an array. - else if (object) { - var i = -1, n = object.length; - if (f == null) while (++i < n) set.add(object[i]); - else while (++i < n) set.add(f(object[i], i, object)); - } - - return set; -} - -/* harmony default export */ __webpack_exports__["default"] = (set); - - -/***/ }), - -/***/ "./node_modules/d3-collection/src/values.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-collection/src/values.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(map) { - var values = []; - for (var key in map) values.push(map[key]); - return values; -}); - - -/***/ }), - -/***/ "./node_modules/d3-color/src/color.js": -/*!********************************************!*\ - !*** ./node_modules/d3-color/src/color.js ***! - \********************************************/ -/*! exports provided: Color, darker, brighter, default, rgbConvert, rgb, Rgb, hslConvert, hsl */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Color", function() { return Color; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "darker", function() { return darker; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "brighter", function() { return brighter; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return color; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rgbConvert", function() { return rgbConvert; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rgb", function() { return rgb; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Rgb", function() { return Rgb; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hslConvert", function() { return hslConvert; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hsl", function() { return hsl; }); -/* harmony import */ var _define__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./define */ "./node_modules/d3-color/src/define.js"); - - -function Color() {} - -var darker = 0.7; -var brighter = 1 / darker; - -var reI = "\\s*([+-]?\\d+)\\s*", - reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*", - reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*", - reHex3 = /^#([0-9a-f]{3})$/, - reHex6 = /^#([0-9a-f]{6})$/, - reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"), - reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"), - reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"), - reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"), - reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"), - reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$"); - -var named = { - aliceblue: 0xf0f8ff, - antiquewhite: 0xfaebd7, - aqua: 0x00ffff, - aquamarine: 0x7fffd4, - azure: 0xf0ffff, - beige: 0xf5f5dc, - bisque: 0xffe4c4, - black: 0x000000, - blanchedalmond: 0xffebcd, - blue: 0x0000ff, - blueviolet: 0x8a2be2, - brown: 0xa52a2a, - burlywood: 0xdeb887, - cadetblue: 0x5f9ea0, - chartreuse: 0x7fff00, - chocolate: 0xd2691e, - coral: 0xff7f50, - cornflowerblue: 0x6495ed, - cornsilk: 0xfff8dc, - crimson: 0xdc143c, - cyan: 0x00ffff, - darkblue: 0x00008b, - darkcyan: 0x008b8b, - darkgoldenrod: 0xb8860b, - darkgray: 0xa9a9a9, - darkgreen: 0x006400, - darkgrey: 0xa9a9a9, - darkkhaki: 0xbdb76b, - darkmagenta: 0x8b008b, - darkolivegreen: 0x556b2f, - darkorange: 0xff8c00, - darkorchid: 0x9932cc, - darkred: 0x8b0000, - darksalmon: 0xe9967a, - darkseagreen: 0x8fbc8f, - darkslateblue: 0x483d8b, - darkslategray: 0x2f4f4f, - darkslategrey: 0x2f4f4f, - darkturquoise: 0x00ced1, - darkviolet: 0x9400d3, - deeppink: 0xff1493, - deepskyblue: 0x00bfff, - dimgray: 0x696969, - dimgrey: 0x696969, - dodgerblue: 0x1e90ff, - firebrick: 0xb22222, - floralwhite: 0xfffaf0, - forestgreen: 0x228b22, - fuchsia: 0xff00ff, - gainsboro: 0xdcdcdc, - ghostwhite: 0xf8f8ff, - gold: 0xffd700, - goldenrod: 0xdaa520, - gray: 0x808080, - green: 0x008000, - greenyellow: 0xadff2f, - grey: 0x808080, - honeydew: 0xf0fff0, - hotpink: 0xff69b4, - indianred: 0xcd5c5c, - indigo: 0x4b0082, - ivory: 0xfffff0, - khaki: 0xf0e68c, - lavender: 0xe6e6fa, - lavenderblush: 0xfff0f5, - lawngreen: 0x7cfc00, - lemonchiffon: 0xfffacd, - lightblue: 0xadd8e6, - lightcoral: 0xf08080, - lightcyan: 0xe0ffff, - lightgoldenrodyellow: 0xfafad2, - lightgray: 0xd3d3d3, - lightgreen: 0x90ee90, - lightgrey: 0xd3d3d3, - lightpink: 0xffb6c1, - lightsalmon: 0xffa07a, - lightseagreen: 0x20b2aa, - lightskyblue: 0x87cefa, - lightslategray: 0x778899, - lightslategrey: 0x778899, - lightsteelblue: 0xb0c4de, - lightyellow: 0xffffe0, - lime: 0x00ff00, - limegreen: 0x32cd32, - linen: 0xfaf0e6, - magenta: 0xff00ff, - maroon: 0x800000, - mediumaquamarine: 0x66cdaa, - mediumblue: 0x0000cd, - mediumorchid: 0xba55d3, - mediumpurple: 0x9370db, - mediumseagreen: 0x3cb371, - mediumslateblue: 0x7b68ee, - mediumspringgreen: 0x00fa9a, - mediumturquoise: 0x48d1cc, - mediumvioletred: 0xc71585, - midnightblue: 0x191970, - mintcream: 0xf5fffa, - mistyrose: 0xffe4e1, - moccasin: 0xffe4b5, - navajowhite: 0xffdead, - navy: 0x000080, - oldlace: 0xfdf5e6, - olive: 0x808000, - olivedrab: 0x6b8e23, - orange: 0xffa500, - orangered: 0xff4500, - orchid: 0xda70d6, - palegoldenrod: 0xeee8aa, - palegreen: 0x98fb98, - paleturquoise: 0xafeeee, - palevioletred: 0xdb7093, - papayawhip: 0xffefd5, - peachpuff: 0xffdab9, - peru: 0xcd853f, - pink: 0xffc0cb, - plum: 0xdda0dd, - powderblue: 0xb0e0e6, - purple: 0x800080, - rebeccapurple: 0x663399, - red: 0xff0000, - rosybrown: 0xbc8f8f, - royalblue: 0x4169e1, - saddlebrown: 0x8b4513, - salmon: 0xfa8072, - sandybrown: 0xf4a460, - seagreen: 0x2e8b57, - seashell: 0xfff5ee, - sienna: 0xa0522d, - silver: 0xc0c0c0, - skyblue: 0x87ceeb, - slateblue: 0x6a5acd, - slategray: 0x708090, - slategrey: 0x708090, - snow: 0xfffafa, - springgreen: 0x00ff7f, - steelblue: 0x4682b4, - tan: 0xd2b48c, - teal: 0x008080, - thistle: 0xd8bfd8, - tomato: 0xff6347, - turquoise: 0x40e0d0, - violet: 0xee82ee, - wheat: 0xf5deb3, - white: 0xffffff, - whitesmoke: 0xf5f5f5, - yellow: 0xffff00, - yellowgreen: 0x9acd32 -}; - -Object(_define__WEBPACK_IMPORTED_MODULE_0__["default"])(Color, color, { - displayable: function() { - return this.rgb().displayable(); - }, - hex: function() { - return this.rgb().hex(); - }, - toString: function() { - return this.rgb() + ""; - } -}); - -function color(format) { - var m; - format = (format + "").trim().toLowerCase(); - return (m = reHex3.exec(format)) ? (m = parseInt(m[1], 16), new Rgb((m >> 8 & 0xf) | (m >> 4 & 0x0f0), (m >> 4 & 0xf) | (m & 0xf0), ((m & 0xf) << 4) | (m & 0xf), 1)) // #f00 - : (m = reHex6.exec(format)) ? rgbn(parseInt(m[1], 16)) // #ff0000 - : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0) - : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%) - : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1) - : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1) - : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%) - : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1) - : named.hasOwnProperty(format) ? rgbn(named[format]) - : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) - : null; -} - -function rgbn(n) { - return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1); -} - -function rgba(r, g, b, a) { - if (a <= 0) r = g = b = NaN; - return new Rgb(r, g, b, a); -} - -function rgbConvert(o) { - if (!(o instanceof Color)) o = color(o); - if (!o) return new Rgb; - o = o.rgb(); - return new Rgb(o.r, o.g, o.b, o.opacity); -} - -function rgb(r, g, b, opacity) { - return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity); -} - -function Rgb(r, g, b, opacity) { - this.r = +r; - this.g = +g; - this.b = +b; - this.opacity = +opacity; -} - -Object(_define__WEBPACK_IMPORTED_MODULE_0__["default"])(Rgb, rgb, Object(_define__WEBPACK_IMPORTED_MODULE_0__["extend"])(Color, { - brighter: function(k) { - k = k == null ? brighter : Math.pow(brighter, k); - return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); - }, - darker: function(k) { - k = k == null ? darker : Math.pow(darker, k); - return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity); - }, - rgb: function() { - return this; - }, - displayable: function() { - return (0 <= this.r && this.r <= 255) - && (0 <= this.g && this.g <= 255) - && (0 <= this.b && this.b <= 255) - && (0 <= this.opacity && this.opacity <= 1); - }, - hex: function() { - return "#" + hex(this.r) + hex(this.g) + hex(this.b); - }, - toString: function() { - var a = this.opacity; a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a)); - return (a === 1 ? "rgb(" : "rgba(") - + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " - + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " - + Math.max(0, Math.min(255, Math.round(this.b) || 0)) - + (a === 1 ? ")" : ", " + a + ")"); - } -})); - -function hex(value) { - value = Math.max(0, Math.min(255, Math.round(value) || 0)); - return (value < 16 ? "0" : "") + value.toString(16); -} - -function hsla(h, s, l, a) { - if (a <= 0) h = s = l = NaN; - else if (l <= 0 || l >= 1) h = s = NaN; - else if (s <= 0) h = NaN; - return new Hsl(h, s, l, a); -} - -function hslConvert(o) { - if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity); - if (!(o instanceof Color)) o = color(o); - if (!o) return new Hsl; - if (o instanceof Hsl) return o; - o = o.rgb(); - var r = o.r / 255, - g = o.g / 255, - b = o.b / 255, - min = Math.min(r, g, b), - max = Math.max(r, g, b), - h = NaN, - s = max - min, - l = (max + min) / 2; - if (s) { - if (r === max) h = (g - b) / s + (g < b) * 6; - else if (g === max) h = (b - r) / s + 2; - else h = (r - g) / s + 4; - s /= l < 0.5 ? max + min : 2 - max - min; - h *= 60; - } else { - s = l > 0 && l < 1 ? 0 : h; - } - return new Hsl(h, s, l, o.opacity); -} - -function hsl(h, s, l, opacity) { - return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity); -} - -function Hsl(h, s, l, opacity) { - this.h = +h; - this.s = +s; - this.l = +l; - this.opacity = +opacity; -} - -Object(_define__WEBPACK_IMPORTED_MODULE_0__["default"])(Hsl, hsl, Object(_define__WEBPACK_IMPORTED_MODULE_0__["extend"])(Color, { - brighter: function(k) { - k = k == null ? brighter : Math.pow(brighter, k); - return new Hsl(this.h, this.s, this.l * k, this.opacity); - }, - darker: function(k) { - k = k == null ? darker : Math.pow(darker, k); - return new Hsl(this.h, this.s, this.l * k, this.opacity); - }, - rgb: function() { - var h = this.h % 360 + (this.h < 0) * 360, - s = isNaN(h) || isNaN(this.s) ? 0 : this.s, - l = this.l, - m2 = l + (l < 0.5 ? l : 1 - l) * s, - m1 = 2 * l - m2; - return new Rgb( - hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), - hsl2rgb(h, m1, m2), - hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), - this.opacity - ); - }, - displayable: function() { - return (0 <= this.s && this.s <= 1 || isNaN(this.s)) - && (0 <= this.l && this.l <= 1) - && (0 <= this.opacity && this.opacity <= 1); - } -})); - -/* From FvD 13.37, CSS Color Module Level 3 */ -function hsl2rgb(h, m1, m2) { - return (h < 60 ? m1 + (m2 - m1) * h / 60 - : h < 180 ? m2 - : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 - : m1) * 255; -} - - -/***/ }), - -/***/ "./node_modules/d3-color/src/cubehelix.js": -/*!************************************************!*\ - !*** ./node_modules/d3-color/src/cubehelix.js ***! - \************************************************/ -/*! exports provided: default, Cubehelix */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return cubehelix; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Cubehelix", function() { return Cubehelix; }); -/* harmony import */ var _define__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./define */ "./node_modules/d3-color/src/define.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./color */ "./node_modules/d3-color/src/color.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-color/src/math.js"); - - - - -var A = -0.14861, - B = +1.78277, - C = -0.29227, - D = -0.90649, - E = +1.97294, - ED = E * D, - EB = E * B, - BC_DA = B * C - D * A; - -function cubehelixConvert(o) { - if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity); - if (!(o instanceof _color__WEBPACK_IMPORTED_MODULE_1__["Rgb"])) o = Object(_color__WEBPACK_IMPORTED_MODULE_1__["rgbConvert"])(o); - var r = o.r / 255, - g = o.g / 255, - b = o.b / 255, - l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB), - bl = b - l, - k = (E * (g - l) - C * bl) / D, - s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)), // NaN if l=0 or l=1 - h = s ? Math.atan2(k, bl) * _math__WEBPACK_IMPORTED_MODULE_2__["rad2deg"] - 120 : NaN; - return new Cubehelix(h < 0 ? h + 360 : h, s, l, o.opacity); -} - -function cubehelix(h, s, l, opacity) { - return arguments.length === 1 ? cubehelixConvert(h) : new Cubehelix(h, s, l, opacity == null ? 1 : opacity); -} - -function Cubehelix(h, s, l, opacity) { - this.h = +h; - this.s = +s; - this.l = +l; - this.opacity = +opacity; -} - -Object(_define__WEBPACK_IMPORTED_MODULE_0__["default"])(Cubehelix, cubehelix, Object(_define__WEBPACK_IMPORTED_MODULE_0__["extend"])(_color__WEBPACK_IMPORTED_MODULE_1__["Color"], { - brighter: function(k) { - k = k == null ? _color__WEBPACK_IMPORTED_MODULE_1__["brighter"] : Math.pow(_color__WEBPACK_IMPORTED_MODULE_1__["brighter"], k); - return new Cubehelix(this.h, this.s, this.l * k, this.opacity); - }, - darker: function(k) { - k = k == null ? _color__WEBPACK_IMPORTED_MODULE_1__["darker"] : Math.pow(_color__WEBPACK_IMPORTED_MODULE_1__["darker"], k); - return new Cubehelix(this.h, this.s, this.l * k, this.opacity); - }, - rgb: function() { - var h = isNaN(this.h) ? 0 : (this.h + 120) * _math__WEBPACK_IMPORTED_MODULE_2__["deg2rad"], - l = +this.l, - a = isNaN(this.s) ? 0 : this.s * l * (1 - l), - cosh = Math.cos(h), - sinh = Math.sin(h); - return new _color__WEBPACK_IMPORTED_MODULE_1__["Rgb"]( - 255 * (l + a * (A * cosh + B * sinh)), - 255 * (l + a * (C * cosh + D * sinh)), - 255 * (l + a * (E * cosh)), - this.opacity - ); - } -})); - - -/***/ }), - -/***/ "./node_modules/d3-color/src/define.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-color/src/define.js ***! - \*********************************************/ -/*! exports provided: default, extend */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extend", function() { return extend; }); -/* harmony default export */ __webpack_exports__["default"] = (function(constructor, factory, prototype) { - constructor.prototype = factory.prototype = prototype; - prototype.constructor = constructor; -}); - -function extend(parent, definition) { - var prototype = Object.create(parent.prototype); - for (var key in definition) prototype[key] = definition[key]; - return prototype; -} - - -/***/ }), - -/***/ "./node_modules/d3-color/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-color/src/index.js ***! - \********************************************/ -/*! exports provided: color, rgb, hsl, lab, hcl, lch, gray, cubehelix */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./color */ "./node_modules/d3-color/src/color.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "color", function() { return _color__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "rgb", function() { return _color__WEBPACK_IMPORTED_MODULE_0__["rgb"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hsl", function() { return _color__WEBPACK_IMPORTED_MODULE_0__["hsl"]; }); - -/* harmony import */ var _lab__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./lab */ "./node_modules/d3-color/src/lab.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "lab", function() { return _lab__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hcl", function() { return _lab__WEBPACK_IMPORTED_MODULE_1__["hcl"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "lch", function() { return _lab__WEBPACK_IMPORTED_MODULE_1__["lch"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "gray", function() { return _lab__WEBPACK_IMPORTED_MODULE_1__["gray"]; }); - -/* harmony import */ var _cubehelix__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./cubehelix */ "./node_modules/d3-color/src/cubehelix.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cubehelix", function() { return _cubehelix__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - - - - - - -/***/ }), - -/***/ "./node_modules/d3-color/src/lab.js": -/*!******************************************!*\ - !*** ./node_modules/d3-color/src/lab.js ***! - \******************************************/ -/*! exports provided: gray, default, Lab, lch, hcl, Hcl */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "gray", function() { return gray; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return lab; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Lab", function() { return Lab; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lch", function() { return lch; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hcl", function() { return hcl; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Hcl", function() { return Hcl; }); -/* harmony import */ var _define__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./define */ "./node_modules/d3-color/src/define.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./color */ "./node_modules/d3-color/src/color.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-color/src/math.js"); - - - - -// https://beta.observablehq.com/@mbostock/lab-and-rgb -var K = 18, - Xn = 0.96422, - Yn = 1, - Zn = 0.82521, - t0 = 4 / 29, - t1 = 6 / 29, - t2 = 3 * t1 * t1, - t3 = t1 * t1 * t1; - -function labConvert(o) { - if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity); - if (o instanceof Hcl) { - if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity); - var h = o.h * _math__WEBPACK_IMPORTED_MODULE_2__["deg2rad"]; - return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity); - } - if (!(o instanceof _color__WEBPACK_IMPORTED_MODULE_1__["Rgb"])) o = Object(_color__WEBPACK_IMPORTED_MODULE_1__["rgbConvert"])(o); - var r = rgb2lrgb(o.r), - g = rgb2lrgb(o.g), - b = rgb2lrgb(o.b), - y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn), x, z; - if (r === g && g === b) x = z = y; else { - x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn); - z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn); - } - return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity); -} - -function gray(l, opacity) { - return new Lab(l, 0, 0, opacity == null ? 1 : opacity); -} - -function lab(l, a, b, opacity) { - return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity); -} - -function Lab(l, a, b, opacity) { - this.l = +l; - this.a = +a; - this.b = +b; - this.opacity = +opacity; -} - -Object(_define__WEBPACK_IMPORTED_MODULE_0__["default"])(Lab, lab, Object(_define__WEBPACK_IMPORTED_MODULE_0__["extend"])(_color__WEBPACK_IMPORTED_MODULE_1__["Color"], { - brighter: function(k) { - return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity); - }, - darker: function(k) { - return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity); - }, - rgb: function() { - var y = (this.l + 16) / 116, - x = isNaN(this.a) ? y : y + this.a / 500, - z = isNaN(this.b) ? y : y - this.b / 200; - x = Xn * lab2xyz(x); - y = Yn * lab2xyz(y); - z = Zn * lab2xyz(z); - return new _color__WEBPACK_IMPORTED_MODULE_1__["Rgb"]( - lrgb2rgb( 3.1338561 * x - 1.6168667 * y - 0.4906146 * z), - lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z), - lrgb2rgb( 0.0719453 * x - 0.2289914 * y + 1.4052427 * z), - this.opacity - ); - } -})); - -function xyz2lab(t) { - return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0; -} - -function lab2xyz(t) { - return t > t1 ? t * t * t : t2 * (t - t0); -} - -function lrgb2rgb(x) { - return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055); -} - -function rgb2lrgb(x) { - return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4); -} - -function hclConvert(o) { - if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity); - if (!(o instanceof Lab)) o = labConvert(o); - if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0, o.l, o.opacity); - var h = Math.atan2(o.b, o.a) * _math__WEBPACK_IMPORTED_MODULE_2__["rad2deg"]; - return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity); -} - -function lch(l, c, h, opacity) { - return arguments.length === 1 ? hclConvert(l) : new Hcl(h, c, l, opacity == null ? 1 : opacity); -} - -function hcl(h, c, l, opacity) { - return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity); -} - -function Hcl(h, c, l, opacity) { - this.h = +h; - this.c = +c; - this.l = +l; - this.opacity = +opacity; -} - -Object(_define__WEBPACK_IMPORTED_MODULE_0__["default"])(Hcl, hcl, Object(_define__WEBPACK_IMPORTED_MODULE_0__["extend"])(_color__WEBPACK_IMPORTED_MODULE_1__["Color"], { - brighter: function(k) { - return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity); - }, - darker: function(k) { - return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity); - }, - rgb: function() { - return labConvert(this).rgb(); - } -})); - - -/***/ }), - -/***/ "./node_modules/d3-color/src/math.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-color/src/math.js ***! - \*******************************************/ -/*! exports provided: deg2rad, rad2deg */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "deg2rad", function() { return deg2rad; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rad2deg", function() { return rad2deg; }); -var deg2rad = Math.PI / 180; -var rad2deg = 180 / Math.PI; - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/area.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-contour/src/area.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(ring) { - var i = 0, n = ring.length, area = ring[n - 1][1] * ring[0][0] - ring[n - 1][0] * ring[0][1]; - while (++i < n) area += ring[i - 1][1] * ring[i][0] - ring[i - 1][0] * ring[i][1]; - return area; -}); - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/array.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-contour/src/array.js ***! - \**********************************************/ -/*! exports provided: slice */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -var array = Array.prototype; - -var slice = array.slice; - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/ascending.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-contour/src/ascending.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return a - b; -}); - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/blur.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-contour/src/blur.js ***! - \*********************************************/ -/*! exports provided: blurX, blurY */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "blurX", function() { return blurX; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "blurY", function() { return blurY; }); -// TODO Optimize edge cases. -// TODO Optimize index calculation. -// TODO Optimize arguments. -function blurX(source, target, r) { - var n = source.width, - m = source.height, - w = (r << 1) + 1; - for (var j = 0; j < m; ++j) { - for (var i = 0, sr = 0; i < n + r; ++i) { - if (i < n) { - sr += source.data[i + j * n]; - } - if (i >= r) { - if (i >= w) { - sr -= source.data[i - w + j * n]; - } - target.data[i - r + j * n] = sr / Math.min(i + 1, n - 1 + w - i, w); - } - } - } -} - -// TODO Optimize edge cases. -// TODO Optimize index calculation. -// TODO Optimize arguments. -function blurY(source, target, r) { - var n = source.width, - m = source.height, - w = (r << 1) + 1; - for (var i = 0; i < n; ++i) { - for (var j = 0, sr = 0; j < m + r; ++j) { - if (j < m) { - sr += source.data[i + j * n]; - } - if (j >= r) { - if (j >= w) { - sr -= source.data[i + (j - w) * n]; - } - target.data[i + (j - r) * n] = sr / Math.min(j + 1, m - 1 + w - j, w); - } - } - } -} - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/constant.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-contour/src/constant.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/contains.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-contour/src/contains.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(ring, hole) { - var i = -1, n = hole.length, c; - while (++i < n) if (c = ringContains(ring, hole[i])) return c; - return 0; -}); - -function ringContains(ring, point) { - var x = point[0], y = point[1], contains = -1; - for (var i = 0, n = ring.length, j = n - 1; i < n; j = i++) { - var pi = ring[i], xi = pi[0], yi = pi[1], pj = ring[j], xj = pj[0], yj = pj[1]; - if (segmentContains(pi, pj, point)) return 0; - if (((yi > y) !== (yj > y)) && ((x < (xj - xi) * (y - yi) / (yj - yi) + xi))) contains = -contains; - } - return contains; -} - -function segmentContains(a, b, c) { - var i; return collinear(a, b, c) && within(a[i = +(a[0] === b[0])], c[i], b[i]); -} - -function collinear(a, b, c) { - return (b[0] - a[0]) * (c[1] - a[1]) === (c[0] - a[0]) * (b[1] - a[1]); -} - -function within(p, q, r) { - return p <= q && q <= r || r <= q && q <= p; -} - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/contours.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-contour/src/contours.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-contour/src/array.js"); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-contour/src/ascending.js"); -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./area */ "./node_modules/d3-contour/src/area.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-contour/src/constant.js"); -/* harmony import */ var _contains__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./contains */ "./node_modules/d3-contour/src/contains.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./noop */ "./node_modules/d3-contour/src/noop.js"); - - - - - - - - -var cases = [ - [], - [[[1.0, 1.5], [0.5, 1.0]]], - [[[1.5, 1.0], [1.0, 1.5]]], - [[[1.5, 1.0], [0.5, 1.0]]], - [[[1.0, 0.5], [1.5, 1.0]]], - [[[1.0, 1.5], [0.5, 1.0]], [[1.0, 0.5], [1.5, 1.0]]], - [[[1.0, 0.5], [1.0, 1.5]]], - [[[1.0, 0.5], [0.5, 1.0]]], - [[[0.5, 1.0], [1.0, 0.5]]], - [[[1.0, 1.5], [1.0, 0.5]]], - [[[0.5, 1.0], [1.0, 0.5]], [[1.5, 1.0], [1.0, 1.5]]], - [[[1.5, 1.0], [1.0, 0.5]]], - [[[0.5, 1.0], [1.5, 1.0]]], - [[[1.0, 1.5], [1.5, 1.0]]], - [[[0.5, 1.0], [1.0, 1.5]]], - [] -]; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var dx = 1, - dy = 1, - threshold = d3_array__WEBPACK_IMPORTED_MODULE_0__["thresholdSturges"], - smooth = smoothLinear; - - function contours(values) { - var tz = threshold(values); - - // Convert number of thresholds into uniform thresholds. - if (!Array.isArray(tz)) { - var domain = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["extent"])(values), start = domain[0], stop = domain[1]; - tz = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickStep"])(start, stop, tz); - tz = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(Math.floor(start / tz) * tz, Math.floor(stop / tz) * tz, tz); - } else { - tz = tz.slice().sort(_ascending__WEBPACK_IMPORTED_MODULE_2__["default"]); - } - - return tz.map(function(value) { - return contour(values, value); - }); - } - - // Accumulate, smooth contour rings, assign holes to exterior rings. - // Based on https://github.com/mbostock/shapefile/blob/v0.6.2/shp/polygon.js - function contour(values, value) { - var polygons = [], - holes = []; - - isorings(values, value, function(ring) { - smooth(ring, values, value); - if (Object(_area__WEBPACK_IMPORTED_MODULE_3__["default"])(ring) > 0) polygons.push([ring]); - else holes.push(ring); - }); - - holes.forEach(function(hole) { - for (var i = 0, n = polygons.length, polygon; i < n; ++i) { - if (Object(_contains__WEBPACK_IMPORTED_MODULE_5__["default"])((polygon = polygons[i])[0], hole) !== -1) { - polygon.push(hole); - return; - } - } - }); - - return { - type: "MultiPolygon", - value: value, - coordinates: polygons - }; - } - - // Marching squares with isolines stitched into rings. - // Based on https://github.com/topojson/topojson-client/blob/v3.0.0/src/stitch.js - function isorings(values, value, callback) { - var fragmentByStart = new Array, - fragmentByEnd = new Array, - x, y, t0, t1, t2, t3; - - // Special case for the first row (y = -1, t2 = t3 = 0). - x = y = -1; - t1 = values[0] >= value; - cases[t1 << 1].forEach(stitch); - while (++x < dx - 1) { - t0 = t1, t1 = values[x + 1] >= value; - cases[t0 | t1 << 1].forEach(stitch); - } - cases[t1 << 0].forEach(stitch); - - // General case for the intermediate rows. - while (++y < dy - 1) { - x = -1; - t1 = values[y * dx + dx] >= value; - t2 = values[y * dx] >= value; - cases[t1 << 1 | t2 << 2].forEach(stitch); - while (++x < dx - 1) { - t0 = t1, t1 = values[y * dx + dx + x + 1] >= value; - t3 = t2, t2 = values[y * dx + x + 1] >= value; - cases[t0 | t1 << 1 | t2 << 2 | t3 << 3].forEach(stitch); - } - cases[t1 | t2 << 3].forEach(stitch); - } - - // Special case for the last row (y = dy - 1, t0 = t1 = 0). - x = -1; - t2 = values[y * dx] >= value; - cases[t2 << 2].forEach(stitch); - while (++x < dx - 1) { - t3 = t2, t2 = values[y * dx + x + 1] >= value; - cases[t2 << 2 | t3 << 3].forEach(stitch); - } - cases[t2 << 3].forEach(stitch); - - function stitch(line) { - var start = [line[0][0] + x, line[0][1] + y], - end = [line[1][0] + x, line[1][1] + y], - startIndex = index(start), - endIndex = index(end), - f, g; - if (f = fragmentByEnd[startIndex]) { - if (g = fragmentByStart[endIndex]) { - delete fragmentByEnd[f.end]; - delete fragmentByStart[g.start]; - if (f === g) { - f.ring.push(end); - callback(f.ring); - } else { - fragmentByStart[f.start] = fragmentByEnd[g.end] = {start: f.start, end: g.end, ring: f.ring.concat(g.ring)}; - } - } else { - delete fragmentByEnd[f.end]; - f.ring.push(end); - fragmentByEnd[f.end = endIndex] = f; - } - } else if (f = fragmentByStart[endIndex]) { - if (g = fragmentByEnd[startIndex]) { - delete fragmentByStart[f.start]; - delete fragmentByEnd[g.end]; - if (f === g) { - f.ring.push(end); - callback(f.ring); - } else { - fragmentByStart[g.start] = fragmentByEnd[f.end] = {start: g.start, end: f.end, ring: g.ring.concat(f.ring)}; - } - } else { - delete fragmentByStart[f.start]; - f.ring.unshift(start); - fragmentByStart[f.start = startIndex] = f; - } - } else { - fragmentByStart[startIndex] = fragmentByEnd[endIndex] = {start: startIndex, end: endIndex, ring: [start, end]}; - } - } - } - - function index(point) { - return point[0] * 2 + point[1] * (dx + 1) * 4; - } - - function smoothLinear(ring, values, value) { - ring.forEach(function(point) { - var x = point[0], - y = point[1], - xt = x | 0, - yt = y | 0, - v0, - v1 = values[yt * dx + xt]; - if (x > 0 && x < dx && xt === x) { - v0 = values[yt * dx + xt - 1]; - point[0] = x + (value - v0) / (v1 - v0) - 0.5; - } - if (y > 0 && y < dy && yt === y) { - v0 = values[(yt - 1) * dx + xt]; - point[1] = y + (value - v0) / (v1 - v0) - 0.5; - } - }); - } - - contours.contour = contour; - - contours.size = function(_) { - if (!arguments.length) return [dx, dy]; - var _0 = Math.ceil(_[0]), _1 = Math.ceil(_[1]); - if (!(_0 > 0) || !(_1 > 0)) throw new Error("invalid size"); - return dx = _0, dy = _1, contours; - }; - - contours.thresholds = function(_) { - return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? Object(_constant__WEBPACK_IMPORTED_MODULE_4__["default"])(_array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_)) : Object(_constant__WEBPACK_IMPORTED_MODULE_4__["default"])(_), contours) : threshold; - }; - - contours.smooth = function(_) { - return arguments.length ? (smooth = _ ? smoothLinear : _noop__WEBPACK_IMPORTED_MODULE_6__["default"], contours) : smooth === smoothLinear; - }; - - return contours; -}); - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/density.js": -/*!************************************************!*\ - !*** ./node_modules/d3-contour/src/density.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-contour/src/array.js"); -/* harmony import */ var _blur__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./blur */ "./node_modules/d3-contour/src/blur.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-contour/src/constant.js"); -/* harmony import */ var _contours__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./contours */ "./node_modules/d3-contour/src/contours.js"); - - - - - - -function defaultX(d) { - return d[0]; -} - -function defaultY(d) { - return d[1]; -} - -function defaultWeight() { - return 1; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var x = defaultX, - y = defaultY, - weight = defaultWeight, - dx = 960, - dy = 500, - r = 20, // blur radius - k = 2, // log2(grid cell size) - o = r * 3, // grid offset, to pad for blur - n = (dx + o * 2) >> k, // grid width - m = (dy + o * 2) >> k, // grid height - threshold = Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(20); - - function density(data) { - var values0 = new Float32Array(n * m), - values1 = new Float32Array(n * m); - - data.forEach(function(d, i, data) { - var xi = (+x(d, i, data) + o) >> k, - yi = (+y(d, i, data) + o) >> k, - wi = +weight(d, i, data); - if (xi >= 0 && xi < n && yi >= 0 && yi < m) { - values0[xi + yi * n] += wi; - } - }); - - // TODO Optimize. - Object(_blur__WEBPACK_IMPORTED_MODULE_2__["blurX"])({width: n, height: m, data: values0}, {width: n, height: m, data: values1}, r >> k); - Object(_blur__WEBPACK_IMPORTED_MODULE_2__["blurY"])({width: n, height: m, data: values1}, {width: n, height: m, data: values0}, r >> k); - Object(_blur__WEBPACK_IMPORTED_MODULE_2__["blurX"])({width: n, height: m, data: values0}, {width: n, height: m, data: values1}, r >> k); - Object(_blur__WEBPACK_IMPORTED_MODULE_2__["blurY"])({width: n, height: m, data: values1}, {width: n, height: m, data: values0}, r >> k); - Object(_blur__WEBPACK_IMPORTED_MODULE_2__["blurX"])({width: n, height: m, data: values0}, {width: n, height: m, data: values1}, r >> k); - Object(_blur__WEBPACK_IMPORTED_MODULE_2__["blurY"])({width: n, height: m, data: values1}, {width: n, height: m, data: values0}, r >> k); - - var tz = threshold(values0); - - // Convert number of thresholds into uniform thresholds. - if (!Array.isArray(tz)) { - var stop = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["max"])(values0); - tz = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickStep"])(0, stop, tz); - tz = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(0, Math.floor(stop / tz) * tz, tz); - tz.shift(); - } - - return Object(_contours__WEBPACK_IMPORTED_MODULE_4__["default"])() - .thresholds(tz) - .size([n, m]) - (values0) - .map(transform); - } - - function transform(geometry) { - geometry.value *= Math.pow(2, -2 * k); // Density in points per square pixel. - geometry.coordinates.forEach(transformPolygon); - return geometry; - } - - function transformPolygon(coordinates) { - coordinates.forEach(transformRing); - } - - function transformRing(coordinates) { - coordinates.forEach(transformPoint); - } - - // TODO Optimize. - function transformPoint(coordinates) { - coordinates[0] = coordinates[0] * Math.pow(2, k) - o; - coordinates[1] = coordinates[1] * Math.pow(2, k) - o; - } - - function resize() { - o = r * 3; - n = (dx + o * 2) >> k; - m = (dy + o * 2) >> k; - return density; - } - - density.x = function(_) { - return arguments.length ? (x = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+_), density) : x; - }; - - density.y = function(_) { - return arguments.length ? (y = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+_), density) : y; - }; - - density.weight = function(_) { - return arguments.length ? (weight = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+_), density) : weight; - }; - - density.size = function(_) { - if (!arguments.length) return [dx, dy]; - var _0 = Math.ceil(_[0]), _1 = Math.ceil(_[1]); - if (!(_0 >= 0) && !(_0 >= 0)) throw new Error("invalid size"); - return dx = _0, dy = _1, resize(); - }; - - density.cellSize = function(_) { - if (!arguments.length) return 1 << k; - if (!((_ = +_) >= 1)) throw new Error("invalid cell size"); - return k = Math.floor(Math.log(_) / Math.LN2), resize(); - }; - - density.thresholds = function(_) { - return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(_array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_)) : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(_), density) : threshold; - }; - - density.bandwidth = function(_) { - if (!arguments.length) return Math.sqrt(r * (r + 1)); - if (!((_ = +_) >= 0)) throw new Error("invalid bandwidth"); - return r = Math.round((Math.sqrt(4 * _ * _ + 1) - 1) / 2), resize(); - }; - - return density; -}); - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/index.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-contour/src/index.js ***! - \**********************************************/ -/*! exports provided: contours, contourDensity */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _contours__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./contours */ "./node_modules/d3-contour/src/contours.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "contours", function() { return _contours__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _density__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./density */ "./node_modules/d3-contour/src/density.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "contourDensity", function() { return _density__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - - - - - -/***/ }), - -/***/ "./node_modules/d3-contour/src/noop.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-contour/src/noop.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() {}); - - -/***/ }), - -/***/ "./node_modules/d3-dispatch/src/dispatch.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-dispatch/src/dispatch.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var noop = {value: function() {}}; - -function dispatch() { - for (var i = 0, n = arguments.length, _ = {}, t; i < n; ++i) { - if (!(t = arguments[i] + "") || (t in _)) throw new Error("illegal type: " + t); - _[t] = []; - } - return new Dispatch(_); -} - -function Dispatch(_) { - this._ = _; -} - -function parseTypenames(typenames, types) { - return typenames.trim().split(/^|\s+/).map(function(t) { - var name = "", i = t.indexOf("."); - if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); - if (t && !types.hasOwnProperty(t)) throw new Error("unknown type: " + t); - return {type: t, name: name}; - }); -} - -Dispatch.prototype = dispatch.prototype = { - constructor: Dispatch, - on: function(typename, callback) { - var _ = this._, - T = parseTypenames(typename + "", _), - t, - i = -1, - n = T.length; - - // If no callback was specified, return the callback of the given type and name. - if (arguments.length < 2) { - while (++i < n) if ((t = (typename = T[i]).type) && (t = get(_[t], typename.name))) return t; - return; - } - - // If a type was specified, set the callback for the given type and name. - // Otherwise, if a null callback was specified, remove callbacks of the given name. - if (callback != null && typeof callback !== "function") throw new Error("invalid callback: " + callback); - while (++i < n) { - if (t = (typename = T[i]).type) _[t] = set(_[t], typename.name, callback); - else if (callback == null) for (t in _) _[t] = set(_[t], typename.name, null); - } - - return this; - }, - copy: function() { - var copy = {}, _ = this._; - for (var t in _) copy[t] = _[t].slice(); - return new Dispatch(copy); - }, - call: function(type, that) { - if ((n = arguments.length - 2) > 0) for (var args = new Array(n), i = 0, n, t; i < n; ++i) args[i] = arguments[i + 2]; - if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); - for (t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); - }, - apply: function(type, that, args) { - if (!this._.hasOwnProperty(type)) throw new Error("unknown type: " + type); - for (var t = this._[type], i = 0, n = t.length; i < n; ++i) t[i].value.apply(that, args); - } -}; - -function get(type, name) { - for (var i = 0, n = type.length, c; i < n; ++i) { - if ((c = type[i]).name === name) { - return c.value; - } - } -} - -function set(type, name, callback) { - for (var i = 0, n = type.length; i < n; ++i) { - if (type[i].name === name) { - type[i] = noop, type = type.slice(0, i).concat(type.slice(i + 1)); - break; - } - } - if (callback != null) type.push({name: name, value: callback}); - return type; -} - -/* harmony default export */ __webpack_exports__["default"] = (dispatch); - - -/***/ }), - -/***/ "./node_modules/d3-dispatch/src/index.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-dispatch/src/index.js ***! - \***********************************************/ -/*! exports provided: dispatch */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dispatch */ "./node_modules/d3-dispatch/src/dispatch.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dispatch", function() { return _dispatch__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - - - - -/***/ }), - -/***/ "./node_modules/d3-drag/src/constant.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-drag/src/constant.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-drag/src/drag.js": -/*!******************************************!*\ - !*** ./node_modules/d3-drag/src/drag.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js"); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _nodrag__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./nodrag */ "./node_modules/d3-drag/src/nodrag.js"); -/* harmony import */ var _noevent__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./noevent */ "./node_modules/d3-drag/src/noevent.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-drag/src/constant.js"); -/* harmony import */ var _event__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./event */ "./node_modules/d3-drag/src/event.js"); - - - - - - - -// Ignore right-click, since that should open the context menu. -function defaultFilter() { - return !d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].button; -} - -function defaultContainer() { - return this.parentNode; -} - -function defaultSubject(d) { - return d == null ? {x: d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].x, y: d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].y} : d; -} - -function defaultTouchable() { - return "ontouchstart" in this; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var filter = defaultFilter, - container = defaultContainer, - subject = defaultSubject, - touchable = defaultTouchable, - gestures = {}, - listeners = Object(d3_dispatch__WEBPACK_IMPORTED_MODULE_0__["dispatch"])("start", "drag", "end"), - active = 0, - mousedownx, - mousedowny, - mousemoving, - touchending, - clickDistance2 = 0; - - function drag(selection) { - selection - .on("mousedown.drag", mousedowned) - .filter(touchable) - .on("touchstart.drag", touchstarted) - .on("touchmove.drag", touchmoved) - .on("touchend.drag touchcancel.drag", touchended) - .style("touch-action", "none") - .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); - } - - function mousedowned() { - if (touchending || !filter.apply(this, arguments)) return; - var gesture = beforestart("mouse", container.apply(this, arguments), d3_selection__WEBPACK_IMPORTED_MODULE_1__["mouse"], this, arguments); - if (!gesture) return; - Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["select"])(d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].view).on("mousemove.drag", mousemoved, true).on("mouseup.drag", mouseupped, true); - Object(_nodrag__WEBPACK_IMPORTED_MODULE_2__["default"])(d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].view); - Object(_noevent__WEBPACK_IMPORTED_MODULE_3__["nopropagation"])(); - mousemoving = false; - mousedownx = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].clientX; - mousedowny = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].clientY; - gesture("start"); - } - - function mousemoved() { - Object(_noevent__WEBPACK_IMPORTED_MODULE_3__["default"])(); - if (!mousemoving) { - var dx = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].clientX - mousedownx, dy = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].clientY - mousedowny; - mousemoving = dx * dx + dy * dy > clickDistance2; - } - gestures.mouse("drag"); - } - - function mouseupped() { - Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["select"])(d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].view).on("mousemove.drag mouseup.drag", null); - Object(_nodrag__WEBPACK_IMPORTED_MODULE_2__["yesdrag"])(d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].view, mousemoving); - Object(_noevent__WEBPACK_IMPORTED_MODULE_3__["default"])(); - gestures.mouse("end"); - } - - function touchstarted() { - if (!filter.apply(this, arguments)) return; - var touches = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].changedTouches, - c = container.apply(this, arguments), - n = touches.length, i, gesture; - - for (i = 0; i < n; ++i) { - if (gesture = beforestart(touches[i].identifier, c, d3_selection__WEBPACK_IMPORTED_MODULE_1__["touch"], this, arguments)) { - Object(_noevent__WEBPACK_IMPORTED_MODULE_3__["nopropagation"])(); - gesture("start"); - } - } - } - - function touchmoved() { - var touches = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].changedTouches, - n = touches.length, i, gesture; - - for (i = 0; i < n; ++i) { - if (gesture = gestures[touches[i].identifier]) { - Object(_noevent__WEBPACK_IMPORTED_MODULE_3__["default"])(); - gesture("drag"); - } - } - } - - function touchended() { - var touches = d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].changedTouches, - n = touches.length, i, gesture; - - if (touchending) clearTimeout(touchending); - touchending = setTimeout(function() { touchending = null; }, 500); // Ghost clicks are delayed! - for (i = 0; i < n; ++i) { - if (gesture = gestures[touches[i].identifier]) { - Object(_noevent__WEBPACK_IMPORTED_MODULE_3__["nopropagation"])(); - gesture("end"); - } - } - } - - function beforestart(id, container, point, that, args) { - var p = point(container, id), s, dx, dy, - sublisteners = listeners.copy(); - - if (!Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["customEvent"])(new _event__WEBPACK_IMPORTED_MODULE_5__["default"](drag, "beforestart", s, id, active, p[0], p[1], 0, 0, sublisteners), function() { - if ((d3_selection__WEBPACK_IMPORTED_MODULE_1__["event"].subject = s = subject.apply(that, args)) == null) return false; - dx = s.x - p[0] || 0; - dy = s.y - p[1] || 0; - return true; - })) return; - - return function gesture(type) { - var p0 = p, n; - switch (type) { - case "start": gestures[id] = gesture, n = active++; break; - case "end": delete gestures[id], --active; // nobreak - case "drag": p = point(container, id), n = active; break; - } - Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["customEvent"])(new _event__WEBPACK_IMPORTED_MODULE_5__["default"](drag, type, s, id, n, p[0] + dx, p[1] + dy, p[0] - p0[0], p[1] - p0[1], sublisteners), sublisteners.apply, sublisteners, [type, that, args]); - }; - } - - drag.filter = function(_) { - return arguments.length ? (filter = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_4__["default"])(!!_), drag) : filter; - }; - - drag.container = function(_) { - return arguments.length ? (container = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_4__["default"])(_), drag) : container; - }; - - drag.subject = function(_) { - return arguments.length ? (subject = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_4__["default"])(_), drag) : subject; - }; - - drag.touchable = function(_) { - return arguments.length ? (touchable = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_4__["default"])(!!_), drag) : touchable; - }; - - drag.on = function() { - var value = listeners.on.apply(listeners, arguments); - return value === listeners ? drag : value; - }; - - drag.clickDistance = function(_) { - return arguments.length ? (clickDistance2 = (_ = +_) * _, drag) : Math.sqrt(clickDistance2); - }; - - return drag; -}); - - -/***/ }), - -/***/ "./node_modules/d3-drag/src/event.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-drag/src/event.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return DragEvent; }); -function DragEvent(target, type, subject, id, active, x, y, dx, dy, dispatch) { - this.target = target; - this.type = type; - this.subject = subject; - this.identifier = id; - this.active = active; - this.x = x; - this.y = y; - this.dx = dx; - this.dy = dy; - this._ = dispatch; -} - -DragEvent.prototype.on = function() { - var value = this._.on.apply(this._, arguments); - return value === this._ ? this : value; -}; - - -/***/ }), - -/***/ "./node_modules/d3-drag/src/index.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-drag/src/index.js ***! - \*******************************************/ -/*! exports provided: drag, dragDisable, dragEnable */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _drag__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./drag */ "./node_modules/d3-drag/src/drag.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "drag", function() { return _drag__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _nodrag__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./nodrag */ "./node_modules/d3-drag/src/nodrag.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dragDisable", function() { return _nodrag__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dragEnable", function() { return _nodrag__WEBPACK_IMPORTED_MODULE_1__["yesdrag"]; }); - - - - - -/***/ }), - -/***/ "./node_modules/d3-drag/src/nodrag.js": -/*!********************************************!*\ - !*** ./node_modules/d3-drag/src/nodrag.js ***! - \********************************************/ -/*! exports provided: default, yesdrag */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "yesdrag", function() { return yesdrag; }); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _noevent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./noevent */ "./node_modules/d3-drag/src/noevent.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(view) { - var root = view.document.documentElement, - selection = Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["select"])(view).on("dragstart.drag", _noevent__WEBPACK_IMPORTED_MODULE_1__["default"], true); - if ("onselectstart" in root) { - selection.on("selectstart.drag", _noevent__WEBPACK_IMPORTED_MODULE_1__["default"], true); - } else { - root.__noselect = root.style.MozUserSelect; - root.style.MozUserSelect = "none"; - } -}); - -function yesdrag(view, noclick) { - var root = view.document.documentElement, - selection = Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["select"])(view).on("dragstart.drag", null); - if (noclick) { - selection.on("click.drag", _noevent__WEBPACK_IMPORTED_MODULE_1__["default"], true); - setTimeout(function() { selection.on("click.drag", null); }, 0); - } - if ("onselectstart" in root) { - selection.on("selectstart.drag", null); - } else { - root.style.MozUserSelect = root.__noselect; - delete root.__noselect; - } -} - - -/***/ }), - -/***/ "./node_modules/d3-drag/src/noevent.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-drag/src/noevent.js ***! - \*********************************************/ -/*! exports provided: nopropagation, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nopropagation", function() { return nopropagation; }); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); - - -function nopropagation() { - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].stopImmediatePropagation(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].preventDefault(); - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].stopImmediatePropagation(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-dsv/src/csv.js": -/*!****************************************!*\ - !*** ./node_modules/d3-dsv/src/csv.js ***! - \****************************************/ -/*! exports provided: csvParse, csvParseRows, csvFormat, csvFormatRows */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "csvParse", function() { return csvParse; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "csvParseRows", function() { return csvParseRows; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "csvFormat", function() { return csvFormat; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "csvFormatRows", function() { return csvFormatRows; }); -/* harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dsv */ "./node_modules/d3-dsv/src/dsv.js"); - - -var csv = Object(_dsv__WEBPACK_IMPORTED_MODULE_0__["default"])(","); - -var csvParse = csv.parse; -var csvParseRows = csv.parseRows; -var csvFormat = csv.format; -var csvFormatRows = csv.formatRows; - - -/***/ }), - -/***/ "./node_modules/d3-dsv/src/dsv.js": -/*!****************************************!*\ - !*** ./node_modules/d3-dsv/src/dsv.js ***! - \****************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var EOL = {}, - EOF = {}, - QUOTE = 34, - NEWLINE = 10, - RETURN = 13; - -function objectConverter(columns) { - return new Function("d", "return {" + columns.map(function(name, i) { - return JSON.stringify(name) + ": d[" + i + "]"; - }).join(",") + "}"); -} - -function customConverter(columns, f) { - var object = objectConverter(columns); - return function(row, i) { - return f(object(row), i, columns); - }; -} - -// Compute unique columns in order of discovery. -function inferColumns(rows) { - var columnSet = Object.create(null), - columns = []; - - rows.forEach(function(row) { - for (var column in row) { - if (!(column in columnSet)) { - columns.push(columnSet[column] = column); - } - } - }); - - return columns; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(delimiter) { - var reFormat = new RegExp("[\"" + delimiter + "\n\r]"), - DELIMITER = delimiter.charCodeAt(0); - - function parse(text, f) { - var convert, columns, rows = parseRows(text, function(row, i) { - if (convert) return convert(row, i - 1); - columns = row, convert = f ? customConverter(row, f) : objectConverter(row); - }); - rows.columns = columns || []; - return rows; - } - - function parseRows(text, f) { - var rows = [], // output rows - N = text.length, - I = 0, // current character index - n = 0, // current line number - t, // current token - eof = N <= 0, // current token followed by EOF? - eol = false; // current token followed by EOL? - - // Strip the trailing newline. - if (text.charCodeAt(N - 1) === NEWLINE) --N; - if (text.charCodeAt(N - 1) === RETURN) --N; - - function token() { - if (eof) return EOF; - if (eol) return eol = false, EOL; - - // Unescape quotes. - var i, j = I, c; - if (text.charCodeAt(j) === QUOTE) { - while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE); - if ((i = I) >= N) eof = true; - else if ((c = text.charCodeAt(I++)) === NEWLINE) eol = true; - else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; } - return text.slice(j + 1, i - 1).replace(/""/g, "\""); - } - - // Find next delimiter or newline. - while (I < N) { - if ((c = text.charCodeAt(i = I++)) === NEWLINE) eol = true; - else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; } - else if (c !== DELIMITER) continue; - return text.slice(j, i); - } - - // Return last token before EOF. - return eof = true, text.slice(j, N); - } - - while ((t = token()) !== EOF) { - var row = []; - while (t !== EOL && t !== EOF) row.push(t), t = token(); - if (f && (row = f(row, n++)) == null) continue; - rows.push(row); - } - - return rows; - } - - function format(rows, columns) { - if (columns == null) columns = inferColumns(rows); - return [columns.map(formatValue).join(delimiter)].concat(rows.map(function(row) { - return columns.map(function(column) { - return formatValue(row[column]); - }).join(delimiter); - })).join("\n"); - } - - function formatRows(rows) { - return rows.map(formatRow).join("\n"); - } - - function formatRow(row) { - return row.map(formatValue).join(delimiter); - } - - function formatValue(text) { - return text == null ? "" - : reFormat.test(text += "") ? "\"" + text.replace(/"/g, "\"\"") + "\"" - : text; - } - - return { - parse: parse, - parseRows: parseRows, - format: format, - formatRows: formatRows - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-dsv/src/index.js": -/*!******************************************!*\ - !*** ./node_modules/d3-dsv/src/index.js ***! - \******************************************/ -/*! exports provided: dsvFormat, csvParse, csvParseRows, csvFormat, csvFormatRows, tsvParse, tsvParseRows, tsvFormat, tsvFormatRows */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dsv */ "./node_modules/d3-dsv/src/dsv.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dsvFormat", function() { return _dsv__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _csv__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./csv */ "./node_modules/d3-dsv/src/csv.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvParse", function() { return _csv__WEBPACK_IMPORTED_MODULE_1__["csvParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvParseRows", function() { return _csv__WEBPACK_IMPORTED_MODULE_1__["csvParseRows"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvFormat", function() { return _csv__WEBPACK_IMPORTED_MODULE_1__["csvFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvFormatRows", function() { return _csv__WEBPACK_IMPORTED_MODULE_1__["csvFormatRows"]; }); - -/* harmony import */ var _tsv__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./tsv */ "./node_modules/d3-dsv/src/tsv.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvParse", function() { return _tsv__WEBPACK_IMPORTED_MODULE_2__["tsvParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvParseRows", function() { return _tsv__WEBPACK_IMPORTED_MODULE_2__["tsvParseRows"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvFormat", function() { return _tsv__WEBPACK_IMPORTED_MODULE_2__["tsvFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvFormatRows", function() { return _tsv__WEBPACK_IMPORTED_MODULE_2__["tsvFormatRows"]; }); - - - - - - -/***/ }), - -/***/ "./node_modules/d3-dsv/src/tsv.js": -/*!****************************************!*\ - !*** ./node_modules/d3-dsv/src/tsv.js ***! - \****************************************/ -/*! exports provided: tsvParse, tsvParseRows, tsvFormat, tsvFormatRows */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tsvParse", function() { return tsvParse; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tsvParseRows", function() { return tsvParseRows; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tsvFormat", function() { return tsvFormat; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tsvFormatRows", function() { return tsvFormatRows; }); -/* harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dsv */ "./node_modules/d3-dsv/src/dsv.js"); - - -var tsv = Object(_dsv__WEBPACK_IMPORTED_MODULE_0__["default"])("\t"); - -var tsvParse = tsv.parse; -var tsvParseRows = tsv.parseRows; -var tsvFormat = tsv.format; -var tsvFormatRows = tsv.formatRows; - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/back.js": -/*!******************************************!*\ - !*** ./node_modules/d3-ease/src/back.js ***! - \******************************************/ -/*! exports provided: backIn, backOut, backInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "backIn", function() { return backIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "backOut", function() { return backOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "backInOut", function() { return backInOut; }); -var overshoot = 1.70158; - -var backIn = (function custom(s) { - s = +s; - - function backIn(t) { - return t * t * ((s + 1) * t - s); - } - - backIn.overshoot = custom; - - return backIn; -})(overshoot); - -var backOut = (function custom(s) { - s = +s; - - function backOut(t) { - return --t * t * ((s + 1) * t + s) + 1; - } - - backOut.overshoot = custom; - - return backOut; -})(overshoot); - -var backInOut = (function custom(s) { - s = +s; - - function backInOut(t) { - return ((t *= 2) < 1 ? t * t * ((s + 1) * t - s) : (t -= 2) * t * ((s + 1) * t + s) + 2) / 2; - } - - backInOut.overshoot = custom; - - return backInOut; -})(overshoot); - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/bounce.js": -/*!********************************************!*\ - !*** ./node_modules/d3-ease/src/bounce.js ***! - \********************************************/ -/*! exports provided: bounceIn, bounceOut, bounceInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bounceIn", function() { return bounceIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bounceOut", function() { return bounceOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bounceInOut", function() { return bounceInOut; }); -var b1 = 4 / 11, - b2 = 6 / 11, - b3 = 8 / 11, - b4 = 3 / 4, - b5 = 9 / 11, - b6 = 10 / 11, - b7 = 15 / 16, - b8 = 21 / 22, - b9 = 63 / 64, - b0 = 1 / b1 / b1; - -function bounceIn(t) { - return 1 - bounceOut(1 - t); -} - -function bounceOut(t) { - return (t = +t) < b1 ? b0 * t * t : t < b3 ? b0 * (t -= b2) * t + b4 : t < b6 ? b0 * (t -= b5) * t + b7 : b0 * (t -= b8) * t + b9; -} - -function bounceInOut(t) { - return ((t *= 2) <= 1 ? 1 - bounceOut(1 - t) : bounceOut(t - 1) + 1) / 2; -} - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/circle.js": -/*!********************************************!*\ - !*** ./node_modules/d3-ease/src/circle.js ***! - \********************************************/ -/*! exports provided: circleIn, circleOut, circleInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "circleIn", function() { return circleIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "circleOut", function() { return circleOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "circleInOut", function() { return circleInOut; }); -function circleIn(t) { - return 1 - Math.sqrt(1 - t * t); -} - -function circleOut(t) { - return Math.sqrt(1 - --t * t); -} - -function circleInOut(t) { - return ((t *= 2) <= 1 ? 1 - Math.sqrt(1 - t * t) : Math.sqrt(1 - (t -= 2) * t) + 1) / 2; -} - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/cubic.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-ease/src/cubic.js ***! - \*******************************************/ -/*! exports provided: cubicIn, cubicOut, cubicInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cubicIn", function() { return cubicIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cubicOut", function() { return cubicOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cubicInOut", function() { return cubicInOut; }); -function cubicIn(t) { - return t * t * t; -} - -function cubicOut(t) { - return --t * t * t + 1; -} - -function cubicInOut(t) { - return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2; -} - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/elastic.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-ease/src/elastic.js ***! - \*********************************************/ -/*! exports provided: elasticIn, elasticOut, elasticInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "elasticIn", function() { return elasticIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "elasticOut", function() { return elasticOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "elasticInOut", function() { return elasticInOut; }); -var tau = 2 * Math.PI, - amplitude = 1, - period = 0.3; - -var elasticIn = (function custom(a, p) { - var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); - - function elasticIn(t) { - return a * Math.pow(2, 10 * --t) * Math.sin((s - t) / p); - } - - elasticIn.amplitude = function(a) { return custom(a, p * tau); }; - elasticIn.period = function(p) { return custom(a, p); }; - - return elasticIn; -})(amplitude, period); - -var elasticOut = (function custom(a, p) { - var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); - - function elasticOut(t) { - return 1 - a * Math.pow(2, -10 * (t = +t)) * Math.sin((t + s) / p); - } - - elasticOut.amplitude = function(a) { return custom(a, p * tau); }; - elasticOut.period = function(p) { return custom(a, p); }; - - return elasticOut; -})(amplitude, period); - -var elasticInOut = (function custom(a, p) { - var s = Math.asin(1 / (a = Math.max(1, a))) * (p /= tau); - - function elasticInOut(t) { - return ((t = t * 2 - 1) < 0 - ? a * Math.pow(2, 10 * t) * Math.sin((s - t) / p) - : 2 - a * Math.pow(2, -10 * t) * Math.sin((s + t) / p)) / 2; - } - - elasticInOut.amplitude = function(a) { return custom(a, p * tau); }; - elasticInOut.period = function(p) { return custom(a, p); }; - - return elasticInOut; -})(amplitude, period); - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/exp.js": -/*!*****************************************!*\ - !*** ./node_modules/d3-ease/src/exp.js ***! - \*****************************************/ -/*! exports provided: expIn, expOut, expInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "expIn", function() { return expIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "expOut", function() { return expOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "expInOut", function() { return expInOut; }); -function expIn(t) { - return Math.pow(2, 10 * t - 10); -} - -function expOut(t) { - return 1 - Math.pow(2, -10 * t); -} - -function expInOut(t) { - return ((t *= 2) <= 1 ? Math.pow(2, 10 * t - 10) : 2 - Math.pow(2, 10 - 10 * t)) / 2; -} - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/index.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-ease/src/index.js ***! - \*******************************************/ -/*! exports provided: easeLinear, easeQuad, easeQuadIn, easeQuadOut, easeQuadInOut, easeCubic, easeCubicIn, easeCubicOut, easeCubicInOut, easePoly, easePolyIn, easePolyOut, easePolyInOut, easeSin, easeSinIn, easeSinOut, easeSinInOut, easeExp, easeExpIn, easeExpOut, easeExpInOut, easeCircle, easeCircleIn, easeCircleOut, easeCircleInOut, easeBounce, easeBounceIn, easeBounceOut, easeBounceInOut, easeBack, easeBackIn, easeBackOut, easeBackInOut, easeElastic, easeElasticIn, easeElasticOut, easeElasticInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-ease/src/linear.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeLinear", function() { return _linear__WEBPACK_IMPORTED_MODULE_0__["linear"]; }); - -/* harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./quad */ "./node_modules/d3-ease/src/quad.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuad", function() { return _quad__WEBPACK_IMPORTED_MODULE_1__["quadInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuadIn", function() { return _quad__WEBPACK_IMPORTED_MODULE_1__["quadIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuadOut", function() { return _quad__WEBPACK_IMPORTED_MODULE_1__["quadOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuadInOut", function() { return _quad__WEBPACK_IMPORTED_MODULE_1__["quadInOut"]; }); - -/* harmony import */ var _cubic__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./cubic */ "./node_modules/d3-ease/src/cubic.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubic", function() { return _cubic__WEBPACK_IMPORTED_MODULE_2__["cubicInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubicIn", function() { return _cubic__WEBPACK_IMPORTED_MODULE_2__["cubicIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubicOut", function() { return _cubic__WEBPACK_IMPORTED_MODULE_2__["cubicOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubicInOut", function() { return _cubic__WEBPACK_IMPORTED_MODULE_2__["cubicInOut"]; }); - -/* harmony import */ var _poly__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./poly */ "./node_modules/d3-ease/src/poly.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePoly", function() { return _poly__WEBPACK_IMPORTED_MODULE_3__["polyInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePolyIn", function() { return _poly__WEBPACK_IMPORTED_MODULE_3__["polyIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePolyOut", function() { return _poly__WEBPACK_IMPORTED_MODULE_3__["polyOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePolyInOut", function() { return _poly__WEBPACK_IMPORTED_MODULE_3__["polyInOut"]; }); - -/* harmony import */ var _sin__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./sin */ "./node_modules/d3-ease/src/sin.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSin", function() { return _sin__WEBPACK_IMPORTED_MODULE_4__["sinInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSinIn", function() { return _sin__WEBPACK_IMPORTED_MODULE_4__["sinIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSinOut", function() { return _sin__WEBPACK_IMPORTED_MODULE_4__["sinOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSinInOut", function() { return _sin__WEBPACK_IMPORTED_MODULE_4__["sinInOut"]; }); - -/* harmony import */ var _exp__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./exp */ "./node_modules/d3-ease/src/exp.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExp", function() { return _exp__WEBPACK_IMPORTED_MODULE_5__["expInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExpIn", function() { return _exp__WEBPACK_IMPORTED_MODULE_5__["expIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExpOut", function() { return _exp__WEBPACK_IMPORTED_MODULE_5__["expOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExpInOut", function() { return _exp__WEBPACK_IMPORTED_MODULE_5__["expInOut"]; }); - -/* harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./circle */ "./node_modules/d3-ease/src/circle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircle", function() { return _circle__WEBPACK_IMPORTED_MODULE_6__["circleInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircleIn", function() { return _circle__WEBPACK_IMPORTED_MODULE_6__["circleIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircleOut", function() { return _circle__WEBPACK_IMPORTED_MODULE_6__["circleOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircleInOut", function() { return _circle__WEBPACK_IMPORTED_MODULE_6__["circleInOut"]; }); - -/* harmony import */ var _bounce__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./bounce */ "./node_modules/d3-ease/src/bounce.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounce", function() { return _bounce__WEBPACK_IMPORTED_MODULE_7__["bounceOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounceIn", function() { return _bounce__WEBPACK_IMPORTED_MODULE_7__["bounceIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounceOut", function() { return _bounce__WEBPACK_IMPORTED_MODULE_7__["bounceOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounceInOut", function() { return _bounce__WEBPACK_IMPORTED_MODULE_7__["bounceInOut"]; }); - -/* harmony import */ var _back__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./back */ "./node_modules/d3-ease/src/back.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBack", function() { return _back__WEBPACK_IMPORTED_MODULE_8__["backInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBackIn", function() { return _back__WEBPACK_IMPORTED_MODULE_8__["backIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBackOut", function() { return _back__WEBPACK_IMPORTED_MODULE_8__["backOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBackInOut", function() { return _back__WEBPACK_IMPORTED_MODULE_8__["backInOut"]; }); - -/* harmony import */ var _elastic__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./elastic */ "./node_modules/d3-ease/src/elastic.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElastic", function() { return _elastic__WEBPACK_IMPORTED_MODULE_9__["elasticOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElasticIn", function() { return _elastic__WEBPACK_IMPORTED_MODULE_9__["elasticIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElasticOut", function() { return _elastic__WEBPACK_IMPORTED_MODULE_9__["elasticOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElasticInOut", function() { return _elastic__WEBPACK_IMPORTED_MODULE_9__["elasticInOut"]; }); - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/linear.js": -/*!********************************************!*\ - !*** ./node_modules/d3-ease/src/linear.js ***! - \********************************************/ -/*! exports provided: linear */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linear", function() { return linear; }); -function linear(t) { - return +t; -} - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/poly.js": -/*!******************************************!*\ - !*** ./node_modules/d3-ease/src/poly.js ***! - \******************************************/ -/*! exports provided: polyIn, polyOut, polyInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polyIn", function() { return polyIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polyOut", function() { return polyOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "polyInOut", function() { return polyInOut; }); -var exponent = 3; - -var polyIn = (function custom(e) { - e = +e; - - function polyIn(t) { - return Math.pow(t, e); - } - - polyIn.exponent = custom; - - return polyIn; -})(exponent); - -var polyOut = (function custom(e) { - e = +e; - - function polyOut(t) { - return 1 - Math.pow(1 - t, e); - } - - polyOut.exponent = custom; - - return polyOut; -})(exponent); - -var polyInOut = (function custom(e) { - e = +e; - - function polyInOut(t) { - return ((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2; - } - - polyInOut.exponent = custom; - - return polyInOut; -})(exponent); - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/quad.js": -/*!******************************************!*\ - !*** ./node_modules/d3-ease/src/quad.js ***! - \******************************************/ -/*! exports provided: quadIn, quadOut, quadInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "quadIn", function() { return quadIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "quadOut", function() { return quadOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "quadInOut", function() { return quadInOut; }); -function quadIn(t) { - return t * t; -} - -function quadOut(t) { - return t * (2 - t); -} - -function quadInOut(t) { - return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2; -} - - -/***/ }), - -/***/ "./node_modules/d3-ease/src/sin.js": -/*!*****************************************!*\ - !*** ./node_modules/d3-ease/src/sin.js ***! - \*****************************************/ -/*! exports provided: sinIn, sinOut, sinInOut */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sinIn", function() { return sinIn; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sinOut", function() { return sinOut; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sinInOut", function() { return sinInOut; }); -var pi = Math.PI, - halfPi = pi / 2; - -function sinIn(t) { - return 1 - Math.cos(t * halfPi); -} - -function sinOut(t) { - return Math.sin(t * halfPi); -} - -function sinInOut(t) { - return (1 - Math.cos(pi * t)) / 2; -} - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/blob.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-fetch/src/blob.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function responseBlob(response) { - if (!response.ok) throw new Error(response.status + " " + response.statusText); - return response.blob(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(input, init) { - return fetch(input, init).then(responseBlob); -}); - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/buffer.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-fetch/src/buffer.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function responseArrayBuffer(response) { - if (!response.ok) throw new Error(response.status + " " + response.statusText); - return response.arrayBuffer(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(input, init) { - return fetch(input, init).then(responseArrayBuffer); -}); - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/dsv.js": -/*!******************************************!*\ - !*** ./node_modules/d3-fetch/src/dsv.js ***! - \******************************************/ -/*! exports provided: default, csv, tsv */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return dsv; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "csv", function() { return csv; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tsv", function() { return tsv; }); -/* harmony import */ var d3_dsv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-dsv */ "./node_modules/d3-dsv/src/index.js"); -/* harmony import */ var _text__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./text */ "./node_modules/d3-fetch/src/text.js"); - - - -function dsvParse(parse) { - return function(input, init, row) { - if (arguments.length === 2 && typeof init === "function") row = init, init = undefined; - return Object(_text__WEBPACK_IMPORTED_MODULE_1__["default"])(input, init).then(function(response) { - return parse(response, row); - }); - }; -} - -function dsv(delimiter, input, init, row) { - if (arguments.length === 3 && typeof init === "function") row = init, init = undefined; - var format = Object(d3_dsv__WEBPACK_IMPORTED_MODULE_0__["dsvFormat"])(delimiter); - return Object(_text__WEBPACK_IMPORTED_MODULE_1__["default"])(input, init).then(function(response) { - return format.parse(response, row); - }); -} - -var csv = dsvParse(d3_dsv__WEBPACK_IMPORTED_MODULE_0__["csvParse"]); -var tsv = dsvParse(d3_dsv__WEBPACK_IMPORTED_MODULE_0__["tsvParse"]); - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/image.js": -/*!********************************************!*\ - !*** ./node_modules/d3-fetch/src/image.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(input, init) { - return new Promise(function(resolve, reject) { - var image = new Image; - for (var key in init) image[key] = init[key]; - image.onerror = reject; - image.onload = function() { resolve(image); }; - image.src = input; - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-fetch/src/index.js ***! - \********************************************/ -/*! exports provided: blob, buffer, dsv, csv, tsv, image, json, text, xml, html, svg */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _blob__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./blob */ "./node_modules/d3-fetch/src/blob.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "blob", function() { return _blob__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _buffer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./buffer */ "./node_modules/d3-fetch/src/buffer.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buffer", function() { return _buffer__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _dsv__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./dsv */ "./node_modules/d3-fetch/src/dsv.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dsv", function() { return _dsv__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csv", function() { return _dsv__WEBPACK_IMPORTED_MODULE_2__["csv"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsv", function() { return _dsv__WEBPACK_IMPORTED_MODULE_2__["tsv"]; }); - -/* harmony import */ var _image__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./image */ "./node_modules/d3-fetch/src/image.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "image", function() { return _image__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _json__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./json */ "./node_modules/d3-fetch/src/json.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "json", function() { return _json__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _text__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./text */ "./node_modules/d3-fetch/src/text.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "text", function() { return _text__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _xml__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./xml */ "./node_modules/d3-fetch/src/xml.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "xml", function() { return _xml__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "html", function() { return _xml__WEBPACK_IMPORTED_MODULE_6__["html"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "svg", function() { return _xml__WEBPACK_IMPORTED_MODULE_6__["svg"]; }); - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/json.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-fetch/src/json.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function responseJson(response) { - if (!response.ok) throw new Error(response.status + " " + response.statusText); - return response.json(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(input, init) { - return fetch(input, init).then(responseJson); -}); - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/text.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-fetch/src/text.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function responseText(response) { - if (!response.ok) throw new Error(response.status + " " + response.statusText); - return response.text(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(input, init) { - return fetch(input, init).then(responseText); -}); - - -/***/ }), - -/***/ "./node_modules/d3-fetch/src/xml.js": -/*!******************************************!*\ - !*** ./node_modules/d3-fetch/src/xml.js ***! - \******************************************/ -/*! exports provided: default, html, svg */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "html", function() { return html; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "svg", function() { return svg; }); -/* harmony import */ var _text__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./text */ "./node_modules/d3-fetch/src/text.js"); - - -function parser(type) { - return function(input, init) { - return Object(_text__WEBPACK_IMPORTED_MODULE_0__["default"])(input, init).then(function(text) { - return (new DOMParser).parseFromString(text, type); - }); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (parser("application/xml")); - -var html = parser("text/html"); - -var svg = parser("image/svg+xml"); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/center.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-force/src/center.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x, y) { - var nodes; - - if (x == null) x = 0; - if (y == null) y = 0; - - function force() { - var i, - n = nodes.length, - node, - sx = 0, - sy = 0; - - for (i = 0; i < n; ++i) { - node = nodes[i], sx += node.x, sy += node.y; - } - - for (sx = sx / n - x, sy = sy / n - y, i = 0; i < n; ++i) { - node = nodes[i], node.x -= sx, node.y -= sy; - } - } - - force.initialize = function(_) { - nodes = _; - }; - - force.x = function(_) { - return arguments.length ? (x = +_, force) : x; - }; - - force.y = function(_) { - return arguments.length ? (y = +_, force) : y; - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/collide.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-force/src/collide.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-force/src/constant.js"); -/* harmony import */ var _jiggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./jiggle */ "./node_modules/d3-force/src/jiggle.js"); -/* harmony import */ var d3_quadtree__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-quadtree */ "./node_modules/d3-quadtree/src/index.js"); - - - - -function x(d) { - return d.x + d.vx; -} - -function y(d) { - return d.y + d.vy; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(radius) { - var nodes, - radii, - strength = 1, - iterations = 1; - - if (typeof radius !== "function") radius = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(radius == null ? 1 : +radius); - - function force() { - var i, n = nodes.length, - tree, - node, - xi, - yi, - ri, - ri2; - - for (var k = 0; k < iterations; ++k) { - tree = Object(d3_quadtree__WEBPACK_IMPORTED_MODULE_2__["quadtree"])(nodes, x, y).visitAfter(prepare); - for (i = 0; i < n; ++i) { - node = nodes[i]; - ri = radii[node.index], ri2 = ri * ri; - xi = node.x + node.vx; - yi = node.y + node.vy; - tree.visit(apply); - } - } - - function apply(quad, x0, y0, x1, y1) { - var data = quad.data, rj = quad.r, r = ri + rj; - if (data) { - if (data.index > node.index) { - var x = xi - data.x - data.vx, - y = yi - data.y - data.vy, - l = x * x + y * y; - if (l < r * r) { - if (x === 0) x = Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(), l += x * x; - if (y === 0) y = Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(), l += y * y; - l = (r - (l = Math.sqrt(l))) / l * strength; - node.vx += (x *= l) * (r = (rj *= rj) / (ri2 + rj)); - node.vy += (y *= l) * r; - data.vx -= x * (r = 1 - r); - data.vy -= y * r; - } - } - return; - } - return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r; - } - } - - function prepare(quad) { - if (quad.data) return quad.r = radii[quad.data.index]; - for (var i = quad.r = 0; i < 4; ++i) { - if (quad[i] && quad[i].r > quad.r) { - quad.r = quad[i].r; - } - } - } - - function initialize() { - if (!nodes) return; - var i, n = nodes.length, node; - radii = new Array(n); - for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes); - } - - force.initialize = function(_) { - nodes = _; - initialize(); - }; - - force.iterations = function(_) { - return arguments.length ? (iterations = +_, force) : iterations; - }; - - force.strength = function(_) { - return arguments.length ? (strength = +_, force) : strength; - }; - - force.radius = function(_) { - return arguments.length ? (radius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : radius; - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/constant.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-force/src/constant.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-force/src/index.js ***! - \********************************************/ -/*! exports provided: forceCenter, forceCollide, forceLink, forceManyBody, forceRadial, forceSimulation, forceX, forceY */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _center__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./center */ "./node_modules/d3-force/src/center.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceCenter", function() { return _center__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _collide__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./collide */ "./node_modules/d3-force/src/collide.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceCollide", function() { return _collide__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _link__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./link */ "./node_modules/d3-force/src/link.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceLink", function() { return _link__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _manyBody__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./manyBody */ "./node_modules/d3-force/src/manyBody.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceManyBody", function() { return _manyBody__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _radial__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./radial */ "./node_modules/d3-force/src/radial.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceRadial", function() { return _radial__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _simulation__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./simulation */ "./node_modules/d3-force/src/simulation.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceSimulation", function() { return _simulation__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _x__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./x */ "./node_modules/d3-force/src/x.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceX", function() { return _x__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _y__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./y */ "./node_modules/d3-force/src/y.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceY", function() { return _y__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-force/src/jiggle.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-force/src/jiggle.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - return (Math.random() - 0.5) * 1e-6; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/link.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-force/src/link.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-force/src/constant.js"); -/* harmony import */ var _jiggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./jiggle */ "./node_modules/d3-force/src/jiggle.js"); -/* harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-collection */ "./node_modules/d3-collection/src/index.js"); - - - - -function index(d) { - return d.index; -} - -function find(nodeById, nodeId) { - var node = nodeById.get(nodeId); - if (!node) throw new Error("missing: " + nodeId); - return node; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(links) { - var id = index, - strength = defaultStrength, - strengths, - distance = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(30), - distances, - nodes, - count, - bias, - iterations = 1; - - if (links == null) links = []; - - function defaultStrength(link) { - return 1 / Math.min(count[link.source.index], count[link.target.index]); - } - - function force(alpha) { - for (var k = 0, n = links.length; k < iterations; ++k) { - for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) { - link = links[i], source = link.source, target = link.target; - x = target.x + target.vx - source.x - source.vx || Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(); - y = target.y + target.vy - source.y - source.vy || Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(); - l = Math.sqrt(x * x + y * y); - l = (l - distances[i]) / l * alpha * strengths[i]; - x *= l, y *= l; - target.vx -= x * (b = bias[i]); - target.vy -= y * b; - source.vx += x * (b = 1 - b); - source.vy += y * b; - } - } - } - - function initialize() { - if (!nodes) return; - - var i, - n = nodes.length, - m = links.length, - nodeById = Object(d3_collection__WEBPACK_IMPORTED_MODULE_2__["map"])(nodes, id), - link; - - for (i = 0, count = new Array(n); i < m; ++i) { - link = links[i], link.index = i; - if (typeof link.source !== "object") link.source = find(nodeById, link.source); - if (typeof link.target !== "object") link.target = find(nodeById, link.target); - count[link.source.index] = (count[link.source.index] || 0) + 1; - count[link.target.index] = (count[link.target.index] || 0) + 1; - } - - for (i = 0, bias = new Array(m); i < m; ++i) { - link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]); - } - - strengths = new Array(m), initializeStrength(); - distances = new Array(m), initializeDistance(); - } - - function initializeStrength() { - if (!nodes) return; - - for (var i = 0, n = links.length; i < n; ++i) { - strengths[i] = +strength(links[i], i, links); - } - } - - function initializeDistance() { - if (!nodes) return; - - for (var i = 0, n = links.length; i < n; ++i) { - distances[i] = +distance(links[i], i, links); - } - } - - force.initialize = function(_) { - nodes = _; - initialize(); - }; - - force.links = function(_) { - return arguments.length ? (links = _, initialize(), force) : links; - }; - - force.id = function(_) { - return arguments.length ? (id = _, force) : id; - }; - - force.iterations = function(_) { - return arguments.length ? (iterations = +_, force) : iterations; - }; - - force.strength = function(_) { - return arguments.length ? (strength = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initializeStrength(), force) : strength; - }; - - force.distance = function(_) { - return arguments.length ? (distance = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initializeDistance(), force) : distance; - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/manyBody.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-force/src/manyBody.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-force/src/constant.js"); -/* harmony import */ var _jiggle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./jiggle */ "./node_modules/d3-force/src/jiggle.js"); -/* harmony import */ var d3_quadtree__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-quadtree */ "./node_modules/d3-quadtree/src/index.js"); -/* harmony import */ var _simulation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./simulation */ "./node_modules/d3-force/src/simulation.js"); - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var nodes, - node, - alpha, - strength = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(-30), - strengths, - distanceMin2 = 1, - distanceMax2 = Infinity, - theta2 = 0.81; - - function force(_) { - var i, n = nodes.length, tree = Object(d3_quadtree__WEBPACK_IMPORTED_MODULE_2__["quadtree"])(nodes, _simulation__WEBPACK_IMPORTED_MODULE_3__["x"], _simulation__WEBPACK_IMPORTED_MODULE_3__["y"]).visitAfter(accumulate); - for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply); - } - - function initialize() { - if (!nodes) return; - var i, n = nodes.length, node; - strengths = new Array(n); - for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes); - } - - function accumulate(quad) { - var strength = 0, q, c, weight = 0, x, y, i; - - // For internal nodes, accumulate forces from child quadrants. - if (quad.length) { - for (x = y = i = 0; i < 4; ++i) { - if ((q = quad[i]) && (c = Math.abs(q.value))) { - strength += q.value, weight += c, x += c * q.x, y += c * q.y; - } - } - quad.x = x / weight; - quad.y = y / weight; - } - - // For leaf nodes, accumulate forces from coincident quadrants. - else { - q = quad; - q.x = q.data.x; - q.y = q.data.y; - do strength += strengths[q.data.index]; - while (q = q.next); - } - - quad.value = strength; - } - - function apply(quad, x1, _, x2) { - if (!quad.value) return true; - - var x = quad.x - node.x, - y = quad.y - node.y, - w = x2 - x1, - l = x * x + y * y; - - // Apply the Barnes-Hut approximation if possible. - // Limit forces for very close nodes; randomize direction if coincident. - if (w * w / theta2 < l) { - if (l < distanceMax2) { - if (x === 0) x = Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(), l += x * x; - if (y === 0) y = Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(), l += y * y; - if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); - node.vx += x * quad.value * alpha / l; - node.vy += y * quad.value * alpha / l; - } - return true; - } - - // Otherwise, process points directly. - else if (quad.length || l >= distanceMax2) return; - - // Limit forces for very close nodes; randomize direction if coincident. - if (quad.data !== node || quad.next) { - if (x === 0) x = Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(), l += x * x; - if (y === 0) y = Object(_jiggle__WEBPACK_IMPORTED_MODULE_1__["default"])(), l += y * y; - if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l); - } - - do if (quad.data !== node) { - w = strengths[quad.data.index] * alpha / l; - node.vx += x * w; - node.vy += y * w; - } while (quad = quad.next); - } - - force.initialize = function(_) { - nodes = _; - initialize(); - }; - - force.strength = function(_) { - return arguments.length ? (strength = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : strength; - }; - - force.distanceMin = function(_) { - return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2); - }; - - force.distanceMax = function(_) { - return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2); - }; - - force.theta = function(_) { - return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2); - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/radial.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-force/src/radial.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-force/src/constant.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(radius, x, y) { - var nodes, - strength = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(0.1), - strengths, - radiuses; - - if (typeof radius !== "function") radius = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+radius); - if (x == null) x = 0; - if (y == null) y = 0; - - function force(alpha) { - for (var i = 0, n = nodes.length; i < n; ++i) { - var node = nodes[i], - dx = node.x - x || 1e-6, - dy = node.y - y || 1e-6, - r = Math.sqrt(dx * dx + dy * dy), - k = (radiuses[i] - r) * strengths[i] * alpha / r; - node.vx += dx * k; - node.vy += dy * k; - } - } - - function initialize() { - if (!nodes) return; - var i, n = nodes.length; - strengths = new Array(n); - radiuses = new Array(n); - for (i = 0; i < n; ++i) { - radiuses[i] = +radius(nodes[i], i, nodes); - strengths[i] = isNaN(radiuses[i]) ? 0 : +strength(nodes[i], i, nodes); - } - } - - force.initialize = function(_) { - nodes = _, initialize(); - }; - - force.strength = function(_) { - return arguments.length ? (strength = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : strength; - }; - - force.radius = function(_) { - return arguments.length ? (radius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : radius; - }; - - force.x = function(_) { - return arguments.length ? (x = +_, force) : x; - }; - - force.y = function(_) { - return arguments.length ? (y = +_, force) : y; - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/simulation.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-force/src/simulation.js ***! - \*************************************************/ -/*! exports provided: x, y, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return x; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return y; }); -/* harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js"); -/* harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-collection */ "./node_modules/d3-collection/src/index.js"); -/* harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-timer */ "./node_modules/d3-timer/src/index.js"); - - - - -function x(d) { - return d.x; -} - -function y(d) { - return d.y; -} - -var initialRadius = 10, - initialAngle = Math.PI * (3 - Math.sqrt(5)); - -/* harmony default export */ __webpack_exports__["default"] = (function(nodes) { - var simulation, - alpha = 1, - alphaMin = 0.001, - alphaDecay = 1 - Math.pow(alphaMin, 1 / 300), - alphaTarget = 0, - velocityDecay = 0.6, - forces = Object(d3_collection__WEBPACK_IMPORTED_MODULE_1__["map"])(), - stepper = Object(d3_timer__WEBPACK_IMPORTED_MODULE_2__["timer"])(step), - event = Object(d3_dispatch__WEBPACK_IMPORTED_MODULE_0__["dispatch"])("tick", "end"); - - if (nodes == null) nodes = []; - - function step() { - tick(); - event.call("tick", simulation); - if (alpha < alphaMin) { - stepper.stop(); - event.call("end", simulation); - } - } - - function tick() { - var i, n = nodes.length, node; - - alpha += (alphaTarget - alpha) * alphaDecay; - - forces.each(function(force) { - force(alpha); - }); - - for (i = 0; i < n; ++i) { - node = nodes[i]; - if (node.fx == null) node.x += node.vx *= velocityDecay; - else node.x = node.fx, node.vx = 0; - if (node.fy == null) node.y += node.vy *= velocityDecay; - else node.y = node.fy, node.vy = 0; - } - } - - function initializeNodes() { - for (var i = 0, n = nodes.length, node; i < n; ++i) { - node = nodes[i], node.index = i; - if (isNaN(node.x) || isNaN(node.y)) { - var radius = initialRadius * Math.sqrt(i), angle = i * initialAngle; - node.x = radius * Math.cos(angle); - node.y = radius * Math.sin(angle); - } - if (isNaN(node.vx) || isNaN(node.vy)) { - node.vx = node.vy = 0; - } - } - } - - function initializeForce(force) { - if (force.initialize) force.initialize(nodes); - return force; - } - - initializeNodes(); - - return simulation = { - tick: tick, - - restart: function() { - return stepper.restart(step), simulation; - }, - - stop: function() { - return stepper.stop(), simulation; - }, - - nodes: function(_) { - return arguments.length ? (nodes = _, initializeNodes(), forces.each(initializeForce), simulation) : nodes; - }, - - alpha: function(_) { - return arguments.length ? (alpha = +_, simulation) : alpha; - }, - - alphaMin: function(_) { - return arguments.length ? (alphaMin = +_, simulation) : alphaMin; - }, - - alphaDecay: function(_) { - return arguments.length ? (alphaDecay = +_, simulation) : +alphaDecay; - }, - - alphaTarget: function(_) { - return arguments.length ? (alphaTarget = +_, simulation) : alphaTarget; - }, - - velocityDecay: function(_) { - return arguments.length ? (velocityDecay = 1 - _, simulation) : 1 - velocityDecay; - }, - - force: function(name, _) { - return arguments.length > 1 ? ((_ == null ? forces.remove(name) : forces.set(name, initializeForce(_))), simulation) : forces.get(name); - }, - - find: function(x, y, radius) { - var i = 0, - n = nodes.length, - dx, - dy, - d2, - node, - closest; - - if (radius == null) radius = Infinity; - else radius *= radius; - - for (i = 0; i < n; ++i) { - node = nodes[i]; - dx = x - node.x; - dy = y - node.y; - d2 = dx * dx + dy * dy; - if (d2 < radius) closest = node, radius = d2; - } - - return closest; - }, - - on: function(name, _) { - return arguments.length > 1 ? (event.on(name, _), simulation) : event.on(name); - } - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/x.js": -/*!****************************************!*\ - !*** ./node_modules/d3-force/src/x.js ***! - \****************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-force/src/constant.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - var strength = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(0.1), - nodes, - strengths, - xz; - - if (typeof x !== "function") x = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(x == null ? 0 : +x); - - function force(alpha) { - for (var i = 0, n = nodes.length, node; i < n; ++i) { - node = nodes[i], node.vx += (xz[i] - node.x) * strengths[i] * alpha; - } - } - - function initialize() { - if (!nodes) return; - var i, n = nodes.length; - strengths = new Array(n); - xz = new Array(n); - for (i = 0; i < n; ++i) { - strengths[i] = isNaN(xz[i] = +x(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); - } - } - - force.initialize = function(_) { - nodes = _; - initialize(); - }; - - force.strength = function(_) { - return arguments.length ? (strength = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : strength; - }; - - force.x = function(_) { - return arguments.length ? (x = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : x; - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-force/src/y.js": -/*!****************************************!*\ - !*** ./node_modules/d3-force/src/y.js ***! - \****************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-force/src/constant.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(y) { - var strength = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(0.1), - nodes, - strengths, - yz; - - if (typeof y !== "function") y = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(y == null ? 0 : +y); - - function force(alpha) { - for (var i = 0, n = nodes.length, node; i < n; ++i) { - node = nodes[i], node.vy += (yz[i] - node.y) * strengths[i] * alpha; - } - } - - function initialize() { - if (!nodes) return; - var i, n = nodes.length; - strengths = new Array(n); - yz = new Array(n); - for (i = 0; i < n; ++i) { - strengths[i] = isNaN(yz[i] = +y(nodes[i], i, nodes)) ? 0 : +strength(nodes[i], i, nodes); - } - } - - force.initialize = function(_) { - nodes = _; - initialize(); - }; - - force.strength = function(_) { - return arguments.length ? (strength = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : strength; - }; - - force.y = function(_) { - return arguments.length ? (y = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), initialize(), force) : y; - }; - - return force; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/defaultLocale.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-format/src/defaultLocale.js ***! - \*****************************************************/ -/*! exports provided: format, formatPrefix, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "format", function() { return format; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "formatPrefix", function() { return formatPrefix; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return defaultLocale; }); -/* harmony import */ var _locale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./locale */ "./node_modules/d3-format/src/locale.js"); - - -var locale; -var format; -var formatPrefix; - -defaultLocale({ - decimal: ".", - thousands: ",", - grouping: [3], - currency: ["$", ""] -}); - -function defaultLocale(definition) { - locale = Object(_locale__WEBPACK_IMPORTED_MODULE_0__["default"])(definition); - format = locale.format; - formatPrefix = locale.formatPrefix; - return locale; -} - - -/***/ }), - -/***/ "./node_modules/d3-format/src/exponent.js": -/*!************************************************!*\ - !*** ./node_modules/d3-format/src/exponent.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _formatDecimal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./formatDecimal */ "./node_modules/d3-format/src/formatDecimal.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return x = Object(_formatDecimal__WEBPACK_IMPORTED_MODULE_0__["default"])(Math.abs(x)), x ? x[1] : NaN; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatDecimal.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-format/src/formatDecimal.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -// Computes the decimal coefficient and exponent of the specified number x with -// significant digits p, where x is positive and p is in [1, 21] or undefined. -// For example, formatDecimal(1.23) returns ["123", 0]. -/* harmony default export */ __webpack_exports__["default"] = (function(x, p) { - if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity - var i, coefficient = x.slice(0, i); - - // The string returned by toExponential either has the form \d\.\d+e[-+]\d+ - // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3). - return [ - coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient, - +x.slice(i + 1) - ]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatGroup.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-format/src/formatGroup.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(grouping, thousands) { - return function(value, width) { - var i = value.length, - t = [], - j = 0, - g = grouping[0], - length = 0; - - while (i > 0 && g > 0) { - if (length + g + 1 > width) g = Math.max(1, width - length); - t.push(value.substring(i -= g, i + g)); - if ((length += g + 1) > width) break; - g = grouping[j = (j + 1) % grouping.length]; - } - - return t.reverse().join(thousands); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatNumerals.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-format/src/formatNumerals.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(numerals) { - return function(value) { - return value.replace(/[0-9]/g, function(i) { - return numerals[+i]; - }); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatPrefixAuto.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-format/src/formatPrefixAuto.js ***! - \********************************************************/ -/*! exports provided: prefixExponent, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "prefixExponent", function() { return prefixExponent; }); -/* harmony import */ var _formatDecimal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./formatDecimal */ "./node_modules/d3-format/src/formatDecimal.js"); - - -var prefixExponent; - -/* harmony default export */ __webpack_exports__["default"] = (function(x, p) { - var d = Object(_formatDecimal__WEBPACK_IMPORTED_MODULE_0__["default"])(x, p); - if (!d) return x + ""; - var coefficient = d[0], - exponent = d[1], - i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1, - n = coefficient.length; - return i === n ? coefficient - : i > n ? coefficient + new Array(i - n + 1).join("0") - : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i) - : "0." + new Array(1 - i).join("0") + Object(_formatDecimal__WEBPACK_IMPORTED_MODULE_0__["default"])(x, Math.max(0, p + i - 1))[0]; // less than 1y! -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatRounded.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-format/src/formatRounded.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _formatDecimal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./formatDecimal */ "./node_modules/d3-format/src/formatDecimal.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(x, p) { - var d = Object(_formatDecimal__WEBPACK_IMPORTED_MODULE_0__["default"])(x, p); - if (!d) return x + ""; - var coefficient = d[0], - exponent = d[1]; - return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient - : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1) - : coefficient + new Array(exponent - coefficient.length + 2).join("0"); -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatSpecifier.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-format/src/formatSpecifier.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return formatSpecifier; }); -// [[fill]align][sign][symbol][0][width][,][.precision][~][type] -var re = /^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i; - -function formatSpecifier(specifier) { - return new FormatSpecifier(specifier); -} - -formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof - -function FormatSpecifier(specifier) { - if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier); - var match; - this.fill = match[1] || " "; - this.align = match[2] || ">"; - this.sign = match[3] || "-"; - this.symbol = match[4] || ""; - this.zero = !!match[5]; - this.width = match[6] && +match[6]; - this.comma = !!match[7]; - this.precision = match[8] && +match[8].slice(1); - this.trim = !!match[9]; - this.type = match[10] || ""; -} - -FormatSpecifier.prototype.toString = function() { - return this.fill - + this.align - + this.sign - + this.symbol - + (this.zero ? "0" : "") - + (this.width == null ? "" : Math.max(1, this.width | 0)) - + (this.comma ? "," : "") - + (this.precision == null ? "" : "." + Math.max(0, this.precision | 0)) - + (this.trim ? "~" : "") - + this.type; -}; - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatTrim.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-format/src/formatTrim.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -// Trims insignificant zeros, e.g., replaces 1.2000k with 1.2k. -/* harmony default export */ __webpack_exports__["default"] = (function(s) { - out: for (var n = s.length, i = 1, i0 = -1, i1; i < n; ++i) { - switch (s[i]) { - case ".": i0 = i1 = i; break; - case "0": if (i0 === 0) i0 = i; i1 = i; break; - default: if (i0 > 0) { if (!+s[i]) break out; i0 = 0; } break; - } - } - return i0 > 0 ? s.slice(0, i0) + s.slice(i1 + 1) : s; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/formatTypes.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-format/src/formatTypes.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _formatPrefixAuto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./formatPrefixAuto */ "./node_modules/d3-format/src/formatPrefixAuto.js"); -/* harmony import */ var _formatRounded__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./formatRounded */ "./node_modules/d3-format/src/formatRounded.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = ({ - "%": function(x, p) { return (x * 100).toFixed(p); }, - "b": function(x) { return Math.round(x).toString(2); }, - "c": function(x) { return x + ""; }, - "d": function(x) { return Math.round(x).toString(10); }, - "e": function(x, p) { return x.toExponential(p); }, - "f": function(x, p) { return x.toFixed(p); }, - "g": function(x, p) { return x.toPrecision(p); }, - "o": function(x) { return Math.round(x).toString(8); }, - "p": function(x, p) { return Object(_formatRounded__WEBPACK_IMPORTED_MODULE_1__["default"])(x * 100, p); }, - "r": _formatRounded__WEBPACK_IMPORTED_MODULE_1__["default"], - "s": _formatPrefixAuto__WEBPACK_IMPORTED_MODULE_0__["default"], - "X": function(x) { return Math.round(x).toString(16).toUpperCase(); }, - "x": function(x) { return Math.round(x).toString(16); } -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/identity.js": -/*!************************************************!*\ - !*** ./node_modules/d3-format/src/identity.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/index.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-format/src/index.js ***! - \*********************************************/ -/*! exports provided: formatDefaultLocale, format, formatPrefix, formatLocale, formatSpecifier, precisionFixed, precisionPrefix, precisionRound */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultLocale */ "./node_modules/d3-format/src/defaultLocale.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatDefaultLocale", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "format", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["format"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatPrefix", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["formatPrefix"]; }); - -/* harmony import */ var _locale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./locale */ "./node_modules/d3-format/src/locale.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatLocale", function() { return _locale__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _formatSpecifier__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./formatSpecifier */ "./node_modules/d3-format/src/formatSpecifier.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatSpecifier", function() { return _formatSpecifier__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _precisionFixed__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./precisionFixed */ "./node_modules/d3-format/src/precisionFixed.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "precisionFixed", function() { return _precisionFixed__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _precisionPrefix__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./precisionPrefix */ "./node_modules/d3-format/src/precisionPrefix.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "precisionPrefix", function() { return _precisionPrefix__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _precisionRound__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./precisionRound */ "./node_modules/d3-format/src/precisionRound.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "precisionRound", function() { return _precisionRound__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-format/src/locale.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-format/src/locale.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _exponent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./exponent */ "./node_modules/d3-format/src/exponent.js"); -/* harmony import */ var _formatGroup__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./formatGroup */ "./node_modules/d3-format/src/formatGroup.js"); -/* harmony import */ var _formatNumerals__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./formatNumerals */ "./node_modules/d3-format/src/formatNumerals.js"); -/* harmony import */ var _formatSpecifier__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./formatSpecifier */ "./node_modules/d3-format/src/formatSpecifier.js"); -/* harmony import */ var _formatTrim__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./formatTrim */ "./node_modules/d3-format/src/formatTrim.js"); -/* harmony import */ var _formatTypes__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./formatTypes */ "./node_modules/d3-format/src/formatTypes.js"); -/* harmony import */ var _formatPrefixAuto__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./formatPrefixAuto */ "./node_modules/d3-format/src/formatPrefixAuto.js"); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./identity */ "./node_modules/d3-format/src/identity.js"); - - - - - - - - - -var prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"]; - -/* harmony default export */ __webpack_exports__["default"] = (function(locale) { - var group = locale.grouping && locale.thousands ? Object(_formatGroup__WEBPACK_IMPORTED_MODULE_1__["default"])(locale.grouping, locale.thousands) : _identity__WEBPACK_IMPORTED_MODULE_7__["default"], - currency = locale.currency, - decimal = locale.decimal, - numerals = locale.numerals ? Object(_formatNumerals__WEBPACK_IMPORTED_MODULE_2__["default"])(locale.numerals) : _identity__WEBPACK_IMPORTED_MODULE_7__["default"], - percent = locale.percent || "%"; - - function newFormat(specifier) { - specifier = Object(_formatSpecifier__WEBPACK_IMPORTED_MODULE_3__["default"])(specifier); - - var fill = specifier.fill, - align = specifier.align, - sign = specifier.sign, - symbol = specifier.symbol, - zero = specifier.zero, - width = specifier.width, - comma = specifier.comma, - precision = specifier.precision, - trim = specifier.trim, - type = specifier.type; - - // The "n" type is an alias for ",g". - if (type === "n") comma = true, type = "g"; - - // The "" type, and any invalid type, is an alias for ".12~g". - else if (!_formatTypes__WEBPACK_IMPORTED_MODULE_5__["default"][type]) precision == null && (precision = 12), trim = true, type = "g"; - - // If zero fill is specified, padding goes after sign and before digits. - if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "="; - - // Compute the prefix and suffix. - // For SI-prefix, the suffix is lazily computed. - var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "", - suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? percent : ""; - - // What format function should we use? - // Is this an integer type? - // Can this type generate exponential notation? - var formatType = _formatTypes__WEBPACK_IMPORTED_MODULE_5__["default"][type], - maybeSuffix = /[defgprs%]/.test(type); - - // Set the default precision if not specified, - // or clamp the specified precision to the supported range. - // For significant precision, it must be in [1, 21]. - // For fixed precision, it must be in [0, 20]. - precision = precision == null ? 6 - : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision)) - : Math.max(0, Math.min(20, precision)); - - function format(value) { - var valuePrefix = prefix, - valueSuffix = suffix, - i, n, c; - - if (type === "c") { - valueSuffix = formatType(value) + valueSuffix; - value = ""; - } else { - value = +value; - - // Perform the initial formatting. - var valueNegative = value < 0; - value = formatType(Math.abs(value), precision); - - // Trim insignificant zeros. - if (trim) value = Object(_formatTrim__WEBPACK_IMPORTED_MODULE_4__["default"])(value); - - // If a negative value rounds to zero during formatting, treat as positive. - if (valueNegative && +value === 0) valueNegative = false; - - // Compute the prefix and suffix. - valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix; - valueSuffix = (type === "s" ? prefixes[8 + _formatPrefixAuto__WEBPACK_IMPORTED_MODULE_6__["prefixExponent"] / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : ""); - - // Break the formatted value into the integer “value” part that can be - // grouped, and fractional or exponential “suffix” part that is not. - if (maybeSuffix) { - i = -1, n = value.length; - while (++i < n) { - if (c = value.charCodeAt(i), 48 > c || c > 57) { - valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix; - value = value.slice(0, i); - break; - } - } - } - } - - // If the fill character is not "0", grouping is applied before padding. - if (comma && !zero) value = group(value, Infinity); - - // Compute the padding. - var length = valuePrefix.length + value.length + valueSuffix.length, - padding = length < width ? new Array(width - length + 1).join(fill) : ""; - - // If the fill character is "0", grouping is applied after padding. - if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = ""; - - // Reconstruct the final output based on the desired alignment. - switch (align) { - case "<": value = valuePrefix + value + valueSuffix + padding; break; - case "=": value = valuePrefix + padding + value + valueSuffix; break; - case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break; - default: value = padding + valuePrefix + value + valueSuffix; break; - } - - return numerals(value); - } - - format.toString = function() { - return specifier + ""; - }; - - return format; - } - - function formatPrefix(specifier, value) { - var f = newFormat((specifier = Object(_formatSpecifier__WEBPACK_IMPORTED_MODULE_3__["default"])(specifier), specifier.type = "f", specifier)), - e = Math.max(-8, Math.min(8, Math.floor(Object(_exponent__WEBPACK_IMPORTED_MODULE_0__["default"])(value) / 3))) * 3, - k = Math.pow(10, -e), - prefix = prefixes[8 + e / 3]; - return function(value) { - return f(k * value) + prefix; - }; - } - - return { - format: newFormat, - formatPrefix: formatPrefix - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/precisionFixed.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-format/src/precisionFixed.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _exponent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./exponent */ "./node_modules/d3-format/src/exponent.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(step) { - return Math.max(0, -Object(_exponent__WEBPACK_IMPORTED_MODULE_0__["default"])(Math.abs(step))); -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/precisionPrefix.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-format/src/precisionPrefix.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _exponent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./exponent */ "./node_modules/d3-format/src/exponent.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(step, value) { - return Math.max(0, Math.max(-8, Math.min(8, Math.floor(Object(_exponent__WEBPACK_IMPORTED_MODULE_0__["default"])(value) / 3))) * 3 - Object(_exponent__WEBPACK_IMPORTED_MODULE_0__["default"])(Math.abs(step))); -}); - - -/***/ }), - -/***/ "./node_modules/d3-format/src/precisionRound.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-format/src/precisionRound.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _exponent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./exponent */ "./node_modules/d3-format/src/exponent.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(step, max) { - step = Math.abs(step), max = Math.abs(max) - step; - return Math.max(0, Object(_exponent__WEBPACK_IMPORTED_MODULE_0__["default"])(max) - Object(_exponent__WEBPACK_IMPORTED_MODULE_0__["default"])(step)) + 1; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/adder.js": -/*!******************************************!*\ - !*** ./node_modules/d3-geo/src/adder.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -// Adds floating point numbers with twice the normal precision. -// Reference: J. R. Shewchuk, Adaptive Precision Floating-Point Arithmetic and -// Fast Robust Geometric Predicates, Discrete & Computational Geometry 18(3) -// 305–363 (1997). -// Code adapted from GeographicLib by Charles F. F. Karney, -// http://geographiclib.sourceforge.net/ - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return new Adder; -}); - -function Adder() { - this.reset(); -} - -Adder.prototype = { - constructor: Adder, - reset: function() { - this.s = // rounded value - this.t = 0; // exact error - }, - add: function(y) { - add(temp, y, this.t); - add(this, temp.s, this.s); - if (this.s) this.t += temp.t; - else this.s = temp.t; - }, - valueOf: function() { - return this.s; - } -}; - -var temp = new Adder; - -function add(adder, a, b) { - var x = adder.s = a + b, - bv = x - a, - av = x - bv; - adder.t = (a - av) + (b - bv); -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/area.js": -/*!*****************************************!*\ - !*** ./node_modules/d3-geo/src/area.js ***! - \*****************************************/ -/*! exports provided: areaRingSum, areaStream, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "areaRingSum", function() { return areaRingSum; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "areaStream", function() { return areaStream; }); -/* harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./adder */ "./node_modules/d3-geo/src/adder.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./noop */ "./node_modules/d3-geo/src/noop.js"); -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./stream */ "./node_modules/d3-geo/src/stream.js"); - - - - - -var areaRingSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(); - -var areaSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(), - lambda00, - phi00, - lambda0, - cosPhi0, - sinPhi0; - -var areaStream = { - point: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - lineStart: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - lineEnd: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - polygonStart: function() { - areaRingSum.reset(); - areaStream.lineStart = areaRingStart; - areaStream.lineEnd = areaRingEnd; - }, - polygonEnd: function() { - var areaRing = +areaRingSum; - areaSum.add(areaRing < 0 ? _math__WEBPACK_IMPORTED_MODULE_1__["tau"] + areaRing : areaRing); - this.lineStart = this.lineEnd = this.point = _noop__WEBPACK_IMPORTED_MODULE_2__["default"]; - }, - sphere: function() { - areaSum.add(_math__WEBPACK_IMPORTED_MODULE_1__["tau"]); - } -}; - -function areaRingStart() { - areaStream.point = areaPointFirst; -} - -function areaRingEnd() { - areaPoint(lambda00, phi00); -} - -function areaPointFirst(lambda, phi) { - areaStream.point = areaPoint; - lambda00 = lambda, phi00 = phi; - lambda *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"]; - lambda0 = lambda, cosPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi = phi / 2 + _math__WEBPACK_IMPORTED_MODULE_1__["quarterPi"]), sinPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi); -} - -function areaPoint(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"]; - phi = phi / 2 + _math__WEBPACK_IMPORTED_MODULE_1__["quarterPi"]; // half the angular distance from south pole - - // Spherical excess E for a spherical triangle with vertices: south pole, - // previous point, current point. Uses a formula derived from Cagnoli’s - // theorem. See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2). - var dLambda = lambda - lambda0, - sdLambda = dLambda >= 0 ? 1 : -1, - adLambda = sdLambda * dLambda, - cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi), - sinPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi), - k = sinPhi0 * sinPhi, - u = cosPhi0 * cosPhi + k * Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(adLambda), - v = k * sdLambda * Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(adLambda); - areaRingSum.add(Object(_math__WEBPACK_IMPORTED_MODULE_1__["atan2"])(v, u)); - - // Advance the previous points. - lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(object) { - areaSum.reset(); - Object(_stream__WEBPACK_IMPORTED_MODULE_3__["default"])(object, areaStream); - return areaSum * 2; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/bounds.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-geo/src/bounds.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./adder */ "./node_modules/d3-geo/src/adder.js"); -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./area */ "./node_modules/d3-geo/src/area.js"); -/* harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./cartesian */ "./node_modules/d3-geo/src/cartesian.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./stream */ "./node_modules/d3-geo/src/stream.js"); - - - - - - -var lambda0, phi0, lambda1, phi1, // bounds - lambda2, // previous lambda-coordinate - lambda00, phi00, // first point - p0, // previous 3D point - deltaSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(), - ranges, - range; - -var boundsStream = { - point: boundsPoint, - lineStart: boundsLineStart, - lineEnd: boundsLineEnd, - polygonStart: function() { - boundsStream.point = boundsRingPoint; - boundsStream.lineStart = boundsRingStart; - boundsStream.lineEnd = boundsRingEnd; - deltaSum.reset(); - _area__WEBPACK_IMPORTED_MODULE_1__["areaStream"].polygonStart(); - }, - polygonEnd: function() { - _area__WEBPACK_IMPORTED_MODULE_1__["areaStream"].polygonEnd(); - boundsStream.point = boundsPoint; - boundsStream.lineStart = boundsLineStart; - boundsStream.lineEnd = boundsLineEnd; - if (_area__WEBPACK_IMPORTED_MODULE_1__["areaRingSum"] < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90); - else if (deltaSum > _math__WEBPACK_IMPORTED_MODULE_3__["epsilon"]) phi1 = 90; - else if (deltaSum < -_math__WEBPACK_IMPORTED_MODULE_3__["epsilon"]) phi0 = -90; - range[0] = lambda0, range[1] = lambda1; - } -}; - -function boundsPoint(lambda, phi) { - ranges.push(range = [lambda0 = lambda, lambda1 = lambda]); - if (phi < phi0) phi0 = phi; - if (phi > phi1) phi1 = phi; -} - -function linePoint(lambda, phi) { - var p = Object(_cartesian__WEBPACK_IMPORTED_MODULE_2__["cartesian"])([lambda * _math__WEBPACK_IMPORTED_MODULE_3__["radians"], phi * _math__WEBPACK_IMPORTED_MODULE_3__["radians"]]); - if (p0) { - var normal = Object(_cartesian__WEBPACK_IMPORTED_MODULE_2__["cartesianCross"])(p0, p), - equatorial = [normal[1], -normal[0], 0], - inflection = Object(_cartesian__WEBPACK_IMPORTED_MODULE_2__["cartesianCross"])(equatorial, normal); - Object(_cartesian__WEBPACK_IMPORTED_MODULE_2__["cartesianNormalizeInPlace"])(inflection); - inflection = Object(_cartesian__WEBPACK_IMPORTED_MODULE_2__["spherical"])(inflection); - var delta = lambda - lambda2, - sign = delta > 0 ? 1 : -1, - lambdai = inflection[0] * _math__WEBPACK_IMPORTED_MODULE_3__["degrees"] * sign, - phii, - antimeridian = Object(_math__WEBPACK_IMPORTED_MODULE_3__["abs"])(delta) > 180; - if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) { - phii = inflection[1] * _math__WEBPACK_IMPORTED_MODULE_3__["degrees"]; - if (phii > phi1) phi1 = phii; - } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) { - phii = -inflection[1] * _math__WEBPACK_IMPORTED_MODULE_3__["degrees"]; - if (phii < phi0) phi0 = phii; - } else { - if (phi < phi0) phi0 = phi; - if (phi > phi1) phi1 = phi; - } - if (antimeridian) { - if (lambda < lambda2) { - if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda; - } else { - if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda; - } - } else { - if (lambda1 >= lambda0) { - if (lambda < lambda0) lambda0 = lambda; - if (lambda > lambda1) lambda1 = lambda; - } else { - if (lambda > lambda2) { - if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda; - } else { - if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda; - } - } - } - } else { - ranges.push(range = [lambda0 = lambda, lambda1 = lambda]); - } - if (phi < phi0) phi0 = phi; - if (phi > phi1) phi1 = phi; - p0 = p, lambda2 = lambda; -} - -function boundsLineStart() { - boundsStream.point = linePoint; -} - -function boundsLineEnd() { - range[0] = lambda0, range[1] = lambda1; - boundsStream.point = boundsPoint; - p0 = null; -} - -function boundsRingPoint(lambda, phi) { - if (p0) { - var delta = lambda - lambda2; - deltaSum.add(Object(_math__WEBPACK_IMPORTED_MODULE_3__["abs"])(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta); - } else { - lambda00 = lambda, phi00 = phi; - } - _area__WEBPACK_IMPORTED_MODULE_1__["areaStream"].point(lambda, phi); - linePoint(lambda, phi); -} - -function boundsRingStart() { - _area__WEBPACK_IMPORTED_MODULE_1__["areaStream"].lineStart(); -} - -function boundsRingEnd() { - boundsRingPoint(lambda00, phi00); - _area__WEBPACK_IMPORTED_MODULE_1__["areaStream"].lineEnd(); - if (Object(_math__WEBPACK_IMPORTED_MODULE_3__["abs"])(deltaSum) > _math__WEBPACK_IMPORTED_MODULE_3__["epsilon"]) lambda0 = -(lambda1 = 180); - range[0] = lambda0, range[1] = lambda1; - p0 = null; -} - -// Finds the left-right distance between two longitudes. -// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want -// the distance between ±180° to be 360°. -function angle(lambda0, lambda1) { - return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1; -} - -function rangeCompare(a, b) { - return a[0] - b[0]; -} - -function rangeContains(range, x) { - return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(feature) { - var i, n, a, b, merged, deltaMax, delta; - - phi1 = lambda1 = -(lambda0 = phi0 = Infinity); - ranges = []; - Object(_stream__WEBPACK_IMPORTED_MODULE_4__["default"])(feature, boundsStream); - - // First, sort ranges by their minimum longitudes. - if (n = ranges.length) { - ranges.sort(rangeCompare); - - // Then, merge any ranges that overlap. - for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) { - b = ranges[i]; - if (rangeContains(a, b[0]) || rangeContains(a, b[1])) { - if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1]; - if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0]; - } else { - merged.push(a = b); - } - } - - // Finally, find the largest gap between the merged ranges. - // The final bounding box will be the inverse of this gap. - for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) { - b = merged[i]; - if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0 = b[0], lambda1 = a[1]; - } - } - - ranges = range = null; - - return lambda0 === Infinity || phi0 === Infinity - ? [[NaN, NaN], [NaN, NaN]] - : [[lambda0, phi0], [lambda1, phi1]]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/cartesian.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-geo/src/cartesian.js ***! - \**********************************************/ -/*! exports provided: spherical, cartesian, cartesianDot, cartesianCross, cartesianAddInPlace, cartesianScale, cartesianNormalizeInPlace */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "spherical", function() { return spherical; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cartesian", function() { return cartesian; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cartesianDot", function() { return cartesianDot; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cartesianCross", function() { return cartesianCross; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cartesianAddInPlace", function() { return cartesianAddInPlace; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cartesianScale", function() { return cartesianScale; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cartesianNormalizeInPlace", function() { return cartesianNormalizeInPlace; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - -function spherical(cartesian) { - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(cartesian[1], cartesian[0]), Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(cartesian[2])]; -} - -function cartesian(spherical) { - var lambda = spherical[0], phi = spherical[1], cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi); - return [cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(lambda), cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(lambda), Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi)]; -} - -function cartesianDot(a, b) { - return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; -} - -function cartesianCross(a, b) { - return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; -} - -// TODO return a -function cartesianAddInPlace(a, b) { - a[0] += b[0], a[1] += b[1], a[2] += b[2]; -} - -function cartesianScale(vector, k) { - return [vector[0] * k, vector[1] * k, vector[2] * k]; -} - -// TODO return d -function cartesianNormalizeInPlace(d) { - var l = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]); - d[0] /= l, d[1] /= l, d[2] /= l; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/centroid.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-geo/src/centroid.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./noop */ "./node_modules/d3-geo/src/noop.js"); -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./stream */ "./node_modules/d3-geo/src/stream.js"); - - - - -var W0, W1, - X0, Y0, Z0, - X1, Y1, Z1, - X2, Y2, Z2, - lambda00, phi00, // first point - x0, y0, z0; // previous point - -var centroidStream = { - sphere: _noop__WEBPACK_IMPORTED_MODULE_1__["default"], - point: centroidPoint, - lineStart: centroidLineStart, - lineEnd: centroidLineEnd, - polygonStart: function() { - centroidStream.lineStart = centroidRingStart; - centroidStream.lineEnd = centroidRingEnd; - }, - polygonEnd: function() { - centroidStream.lineStart = centroidLineStart; - centroidStream.lineEnd = centroidLineEnd; - } -}; - -// Arithmetic mean of Cartesian vectors. -function centroidPoint(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"]; - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi); - centroidPointCartesian(cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(lambda), cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(lambda), Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi)); -} - -function centroidPointCartesian(x, y, z) { - ++W0; - X0 += (x - X0) / W0; - Y0 += (y - Y0) / W0; - Z0 += (z - Z0) / W0; -} - -function centroidLineStart() { - centroidStream.point = centroidLinePointFirst; -} - -function centroidLinePointFirst(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"]; - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi); - x0 = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(lambda); - y0 = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(lambda); - z0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi); - centroidStream.point = centroidLinePoint; - centroidPointCartesian(x0, y0, z0); -} - -function centroidLinePoint(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"]; - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi), - x = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(lambda), - y = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(lambda), - z = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi), - w = Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z); - W1 += w; - X1 += w * (x0 + (x0 = x)); - Y1 += w * (y0 + (y0 = y)); - Z1 += w * (z0 + (z0 = z)); - centroidPointCartesian(x0, y0, z0); -} - -function centroidLineEnd() { - centroidStream.point = centroidPoint; -} - -// See J. E. Brock, The Inertia Tensor for a Spherical Triangle, -// J. Applied Mechanics 42, 239 (1975). -function centroidRingStart() { - centroidStream.point = centroidRingPointFirst; -} - -function centroidRingEnd() { - centroidRingPoint(lambda00, phi00); - centroidStream.point = centroidPoint; -} - -function centroidRingPointFirst(lambda, phi) { - lambda00 = lambda, phi00 = phi; - lambda *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"]; - centroidStream.point = centroidRingPoint; - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi); - x0 = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(lambda); - y0 = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(lambda); - z0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi); - centroidPointCartesian(x0, y0, z0); -} - -function centroidRingPoint(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_0__["radians"]; - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi), - x = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(lambda), - y = cosPhi * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(lambda), - z = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi), - cx = y0 * z - z0 * y, - cy = z0 * x - x0 * z, - cz = x0 * y - y0 * x, - m = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(cx * cx + cy * cy + cz * cz), - w = Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(m), // line weight = angle - v = m && -w / m; // area weight multiplier - X2 += v * cx; - Y2 += v * cy; - Z2 += v * cz; - W1 += w; - X1 += w * (x0 + (x0 = x)); - Y1 += w * (y0 + (y0 = y)); - Z1 += w * (z0 + (z0 = z)); - centroidPointCartesian(x0, y0, z0); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(object) { - W0 = W1 = - X0 = Y0 = Z0 = - X1 = Y1 = Z1 = - X2 = Y2 = Z2 = 0; - Object(_stream__WEBPACK_IMPORTED_MODULE_2__["default"])(object, centroidStream); - - var x = X2, - y = Y2, - z = Z2, - m = x * x + y * y + z * z; - - // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid. - if (m < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon2"]) { - x = X1, y = Y1, z = Z1; - // If the feature has zero length, fall back to arithmetic mean of point vectors. - if (W1 < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) x = X0, y = Y0, z = Z0; - m = x * x + y * y + z * z; - // If the feature still has an undefined ccentroid, then return. - if (m < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon2"]) return [NaN, NaN]; - } - - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(y, x) * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"], Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(z / Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(m)) * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"]]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/circle.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-geo/src/circle.js ***! - \*******************************************/ -/*! exports provided: circleStream, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "circleStream", function() { return circleStream; }); -/* harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cartesian */ "./node_modules/d3-geo/src/cartesian.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-geo/src/constant.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./rotation */ "./node_modules/d3-geo/src/rotation.js"); - - - - - -// Generates a circle centered at [0°, 0°], with a given radius and precision. -function circleStream(stream, radius, delta, direction, t0, t1) { - if (!delta) return; - var cosRadius = Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(radius), - sinRadius = Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(radius), - step = direction * delta; - if (t0 == null) { - t0 = radius + direction * _math__WEBPACK_IMPORTED_MODULE_2__["tau"]; - t1 = radius - step / 2; - } else { - t0 = circleRadius(cosRadius, t0); - t1 = circleRadius(cosRadius, t1); - if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * _math__WEBPACK_IMPORTED_MODULE_2__["tau"]; - } - for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) { - point = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["spherical"])([cosRadius, -sinRadius * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(t), -sinRadius * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(t)]); - stream.point(point[0], point[1]); - } -} - -// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0]. -function circleRadius(cosRadius, point) { - point = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesian"])(point), point[0] -= cosRadius; - Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianNormalizeInPlace"])(point); - var radius = Object(_math__WEBPACK_IMPORTED_MODULE_2__["acos"])(-point[1]); - return ((-point[2] < 0 ? -radius : radius) + _math__WEBPACK_IMPORTED_MODULE_2__["tau"] - _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) % _math__WEBPACK_IMPORTED_MODULE_2__["tau"]; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var center = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])([0, 0]), - radius = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(90), - precision = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(6), - ring, - rotate, - stream = {point: point}; - - function point(x, y) { - ring.push(x = rotate(x, y)); - x[0] *= _math__WEBPACK_IMPORTED_MODULE_2__["degrees"], x[1] *= _math__WEBPACK_IMPORTED_MODULE_2__["degrees"]; - } - - function circle() { - var c = center.apply(this, arguments), - r = radius.apply(this, arguments) * _math__WEBPACK_IMPORTED_MODULE_2__["radians"], - p = precision.apply(this, arguments) * _math__WEBPACK_IMPORTED_MODULE_2__["radians"]; - ring = []; - rotate = Object(_rotation__WEBPACK_IMPORTED_MODULE_3__["rotateRadians"])(-c[0] * _math__WEBPACK_IMPORTED_MODULE_2__["radians"], -c[1] * _math__WEBPACK_IMPORTED_MODULE_2__["radians"], 0).invert; - circleStream(stream, r, p, 1); - c = {type: "Polygon", coordinates: [ring]}; - ring = rotate = null; - return c; - } - - circle.center = function(_) { - return arguments.length ? (center = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])([+_[0], +_[1]]), circle) : center; - }; - - circle.radius = function(_) { - return arguments.length ? (radius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), circle) : radius; - }; - - circle.precision = function(_) { - return arguments.length ? (precision = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), circle) : precision; - }; - - return circle; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/antimeridian.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-geo/src/clip/antimeridian.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/clip/index.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_index__WEBPACK_IMPORTED_MODULE_0__["default"])( - function() { return true; }, - clipAntimeridianLine, - clipAntimeridianInterpolate, - [-_math__WEBPACK_IMPORTED_MODULE_1__["pi"], -_math__WEBPACK_IMPORTED_MODULE_1__["halfPi"]] -)); - -// Takes a line and cuts into visible segments. Return values: 0 - there were -// intersections or the line was empty; 1 - no intersections; 2 - there were -// intersections, and the first and last segments should be rejoined. -function clipAntimeridianLine(stream) { - var lambda0 = NaN, - phi0 = NaN, - sign0 = NaN, - clean; // no intersections - - return { - lineStart: function() { - stream.lineStart(); - clean = 1; - }, - point: function(lambda1, phi1) { - var sign1 = lambda1 > 0 ? _math__WEBPACK_IMPORTED_MODULE_1__["pi"] : -_math__WEBPACK_IMPORTED_MODULE_1__["pi"], - delta = Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(lambda1 - lambda0); - if (Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(delta - _math__WEBPACK_IMPORTED_MODULE_1__["pi"]) < _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]) { // line crosses a pole - stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? _math__WEBPACK_IMPORTED_MODULE_1__["halfPi"] : -_math__WEBPACK_IMPORTED_MODULE_1__["halfPi"]); - stream.point(sign0, phi0); - stream.lineEnd(); - stream.lineStart(); - stream.point(sign1, phi0); - stream.point(lambda1, phi0); - clean = 0; - } else if (sign0 !== sign1 && delta >= _math__WEBPACK_IMPORTED_MODULE_1__["pi"]) { // line crosses antimeridian - if (Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(lambda0 - sign0) < _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]) lambda0 -= sign0 * _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]; // handle degeneracies - if (Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(lambda1 - sign1) < _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]) lambda1 -= sign1 * _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]; - phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1); - stream.point(sign0, phi0); - stream.lineEnd(); - stream.lineStart(); - stream.point(sign1, phi0); - clean = 0; - } - stream.point(lambda0 = lambda1, phi0 = phi1); - sign0 = sign1; - }, - lineEnd: function() { - stream.lineEnd(); - lambda0 = phi0 = NaN; - }, - clean: function() { - return 2 - clean; // if intersections, rejoin first and last segments - } - }; -} - -function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) { - var cosPhi0, - cosPhi1, - sinLambda0Lambda1 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(lambda0 - lambda1); - return Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(sinLambda0Lambda1) > _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"] - ? Object(_math__WEBPACK_IMPORTED_MODULE_1__["atan"])((Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi0) * (cosPhi1 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi1)) * Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(lambda1) - - Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi1) * (cosPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi0)) * Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(lambda0)) - / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) - : (phi0 + phi1) / 2; -} - -function clipAntimeridianInterpolate(from, to, direction, stream) { - var phi; - if (from == null) { - phi = direction * _math__WEBPACK_IMPORTED_MODULE_1__["halfPi"]; - stream.point(-_math__WEBPACK_IMPORTED_MODULE_1__["pi"], phi); - stream.point(0, phi); - stream.point(_math__WEBPACK_IMPORTED_MODULE_1__["pi"], phi); - stream.point(_math__WEBPACK_IMPORTED_MODULE_1__["pi"], 0); - stream.point(_math__WEBPACK_IMPORTED_MODULE_1__["pi"], -phi); - stream.point(0, -phi); - stream.point(-_math__WEBPACK_IMPORTED_MODULE_1__["pi"], -phi); - stream.point(-_math__WEBPACK_IMPORTED_MODULE_1__["pi"], 0); - stream.point(-_math__WEBPACK_IMPORTED_MODULE_1__["pi"], phi); - } else if (Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(from[0] - to[0]) > _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]) { - var lambda = from[0] < to[0] ? _math__WEBPACK_IMPORTED_MODULE_1__["pi"] : -_math__WEBPACK_IMPORTED_MODULE_1__["pi"]; - phi = direction * lambda / 2; - stream.point(-lambda, phi); - stream.point(0, phi); - stream.point(lambda, phi); - } else { - stream.point(to[0], to[1]); - } -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/buffer.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/clip/buffer.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-geo/src/noop.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var lines = [], - line; - return { - point: function(x, y) { - line.push([x, y]); - }, - lineStart: function() { - lines.push(line = []); - }, - lineEnd: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - rejoin: function() { - if (lines.length > 1) lines.push(lines.pop().concat(lines.shift())); - }, - result: function() { - var result = lines; - lines = []; - line = null; - return result; - } - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/circle.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/clip/circle.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../cartesian */ "./node_modules/d3-geo/src/cartesian.js"); -/* harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../circle */ "./node_modules/d3-geo/src/circle.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _pointEqual__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../pointEqual */ "./node_modules/d3-geo/src/pointEqual.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/clip/index.js"); - - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(radius) { - var cr = Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(radius), - delta = 6 * _math__WEBPACK_IMPORTED_MODULE_2__["radians"], - smallRadius = cr > 0, - notHemisphere = Object(_math__WEBPACK_IMPORTED_MODULE_2__["abs"])(cr) > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; // TODO optimise for this common case - - function interpolate(from, to, direction, stream) { - Object(_circle__WEBPACK_IMPORTED_MODULE_1__["circleStream"])(stream, radius, delta, direction, from, to); - } - - function visible(lambda, phi) { - return Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(lambda) * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(phi) > cr; - } - - // Takes a line and cuts into visible segments. Return values used for polygon - // clipping: 0 - there were intersections or the line was empty; 1 - no - // intersections 2 - there were intersections, and the first and last segments - // should be rejoined. - function clipLine(stream) { - var point0, // previous point - c0, // code for previous point - v0, // visibility of previous point - v00, // visibility of first point - clean; // no intersections - return { - lineStart: function() { - v00 = v0 = false; - clean = 1; - }, - point: function(lambda, phi) { - var point1 = [lambda, phi], - point2, - v = visible(lambda, phi), - c = smallRadius - ? v ? 0 : code(lambda, phi) - : v ? code(lambda + (lambda < 0 ? _math__WEBPACK_IMPORTED_MODULE_2__["pi"] : -_math__WEBPACK_IMPORTED_MODULE_2__["pi"]), phi) : 0; - if (!point0 && (v00 = v0 = v)) stream.lineStart(); - // Handle degeneracies. - // TODO ignore if not clipping polygons. - if (v !== v0) { - point2 = intersect(point0, point1); - if (!point2 || Object(_pointEqual__WEBPACK_IMPORTED_MODULE_3__["default"])(point0, point2) || Object(_pointEqual__WEBPACK_IMPORTED_MODULE_3__["default"])(point1, point2)) { - point1[0] += _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; - point1[1] += _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; - v = visible(point1[0], point1[1]); - } - } - if (v !== v0) { - clean = 0; - if (v) { - // outside going in - stream.lineStart(); - point2 = intersect(point1, point0); - stream.point(point2[0], point2[1]); - } else { - // inside going out - point2 = intersect(point0, point1); - stream.point(point2[0], point2[1]); - stream.lineEnd(); - } - point0 = point2; - } else if (notHemisphere && point0 && smallRadius ^ v) { - var t; - // If the codes for two points are different, or are both zero, - // and there this segment intersects with the small circle. - if (!(c & c0) && (t = intersect(point1, point0, true))) { - clean = 0; - if (smallRadius) { - stream.lineStart(); - stream.point(t[0][0], t[0][1]); - stream.point(t[1][0], t[1][1]); - stream.lineEnd(); - } else { - stream.point(t[1][0], t[1][1]); - stream.lineEnd(); - stream.lineStart(); - stream.point(t[0][0], t[0][1]); - } - } - } - if (v && (!point0 || !Object(_pointEqual__WEBPACK_IMPORTED_MODULE_3__["default"])(point0, point1))) { - stream.point(point1[0], point1[1]); - } - point0 = point1, v0 = v, c0 = c; - }, - lineEnd: function() { - if (v0) stream.lineEnd(); - point0 = null; - }, - // Rejoin first and last segments if there were intersections and the first - // and last points were visible. - clean: function() { - return clean | ((v00 && v0) << 1); - } - }; - } - - // Intersects the great circle between a and b with the clip circle. - function intersect(a, b, two) { - var pa = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesian"])(a), - pb = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesian"])(b); - - // We have two planes, n1.p = d1 and n2.p = d2. - // Find intersection line p(t) = c1 n1 + c2 n2 + t (n1 ⨯ n2). - var n1 = [1, 0, 0], // normal - n2 = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianCross"])(pa, pb), - n2n2 = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianDot"])(n2, n2), - n1n2 = n2[0], // cartesianDot(n1, n2), - determinant = n2n2 - n1n2 * n1n2; - - // Two polar points. - if (!determinant) return !two && a; - - var c1 = cr * n2n2 / determinant, - c2 = -cr * n1n2 / determinant, - n1xn2 = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianCross"])(n1, n2), - A = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianScale"])(n1, c1), - B = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianScale"])(n2, c2); - Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianAddInPlace"])(A, B); - - // Solve |p(t)|^2 = 1. - var u = n1xn2, - w = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianDot"])(A, u), - uu = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianDot"])(u, u), - t2 = w * w - uu * (Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianDot"])(A, A) - 1); - - if (t2 < 0) return; - - var t = Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(t2), - q = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianScale"])(u, (-w - t) / uu); - Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianAddInPlace"])(q, A); - q = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["spherical"])(q); - - if (!two) return q; - - // Two intersection points. - var lambda0 = a[0], - lambda1 = b[0], - phi0 = a[1], - phi1 = b[1], - z; - - if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z; - - var delta = lambda1 - lambda0, - polar = Object(_math__WEBPACK_IMPORTED_MODULE_2__["abs"])(delta - _math__WEBPACK_IMPORTED_MODULE_2__["pi"]) < _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"], - meridian = polar || delta < _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; - - if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z; - - // Check that the first point is between a and b. - if (meridian - ? polar - ? phi0 + phi1 > 0 ^ q[1] < (Object(_math__WEBPACK_IMPORTED_MODULE_2__["abs"])(q[0] - lambda0) < _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"] ? phi0 : phi1) - : phi0 <= q[1] && q[1] <= phi1 - : delta > _math__WEBPACK_IMPORTED_MODULE_2__["pi"] ^ (lambda0 <= q[0] && q[0] <= lambda1)) { - var q1 = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianScale"])(u, (-w + t) / uu); - Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesianAddInPlace"])(q1, A); - return [q, Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["spherical"])(q1)]; - } - } - - // Generates a 4-bit vector representing the location of a point relative to - // the small circle's bounding box. - function code(lambda, phi) { - var r = smallRadius ? radius : _math__WEBPACK_IMPORTED_MODULE_2__["pi"] - radius, - code = 0; - if (lambda < -r) code |= 1; // left - else if (lambda > r) code |= 2; // right - if (phi < -r) code |= 4; // below - else if (phi > r) code |= 8; // above - return code; - } - - return Object(_index__WEBPACK_IMPORTED_MODULE_4__["default"])(visible, clipLine, interpolate, smallRadius ? [0, -radius] : [-_math__WEBPACK_IMPORTED_MODULE_2__["pi"], radius - _math__WEBPACK_IMPORTED_MODULE_2__["pi"]]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/extent.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/clip/extent.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _rectangle__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var x0 = 0, - y0 = 0, - x1 = 960, - y1 = 500, - cache, - cacheStream, - clip; - - return clip = { - stream: function(stream) { - return cache && cacheStream === stream ? cache : cache = Object(_rectangle__WEBPACK_IMPORTED_MODULE_0__["default"])(x0, y0, x1, y1)(cacheStream = stream); - }, - extent: function(_) { - return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]]; - } - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/index.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-geo/src/clip/index.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _buffer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./buffer */ "./node_modules/d3-geo/src/clip/buffer.js"); -/* harmony import */ var _rejoin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./rejoin */ "./node_modules/d3-geo/src/clip/rejoin.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _polygonContains__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../polygonContains */ "./node_modules/d3-geo/src/polygonContains.js"); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); - - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(pointVisible, clipLine, interpolate, start) { - return function(sink) { - var line = clipLine(sink), - ringBuffer = Object(_buffer__WEBPACK_IMPORTED_MODULE_0__["default"])(), - ringSink = clipLine(ringBuffer), - polygonStarted = false, - polygon, - segments, - ring; - - var clip = { - point: point, - lineStart: lineStart, - lineEnd: lineEnd, - polygonStart: function() { - clip.point = pointRing; - clip.lineStart = ringStart; - clip.lineEnd = ringEnd; - segments = []; - polygon = []; - }, - polygonEnd: function() { - clip.point = point; - clip.lineStart = lineStart; - clip.lineEnd = lineEnd; - segments = Object(d3_array__WEBPACK_IMPORTED_MODULE_4__["merge"])(segments); - var startInside = Object(_polygonContains__WEBPACK_IMPORTED_MODULE_3__["default"])(polygon, start); - if (segments.length) { - if (!polygonStarted) sink.polygonStart(), polygonStarted = true; - Object(_rejoin__WEBPACK_IMPORTED_MODULE_1__["default"])(segments, compareIntersection, startInside, interpolate, sink); - } else if (startInside) { - if (!polygonStarted) sink.polygonStart(), polygonStarted = true; - sink.lineStart(); - interpolate(null, null, 1, sink); - sink.lineEnd(); - } - if (polygonStarted) sink.polygonEnd(), polygonStarted = false; - segments = polygon = null; - }, - sphere: function() { - sink.polygonStart(); - sink.lineStart(); - interpolate(null, null, 1, sink); - sink.lineEnd(); - sink.polygonEnd(); - } - }; - - function point(lambda, phi) { - if (pointVisible(lambda, phi)) sink.point(lambda, phi); - } - - function pointLine(lambda, phi) { - line.point(lambda, phi); - } - - function lineStart() { - clip.point = pointLine; - line.lineStart(); - } - - function lineEnd() { - clip.point = point; - line.lineEnd(); - } - - function pointRing(lambda, phi) { - ring.push([lambda, phi]); - ringSink.point(lambda, phi); - } - - function ringStart() { - ringSink.lineStart(); - ring = []; - } - - function ringEnd() { - pointRing(ring[0][0], ring[0][1]); - ringSink.lineEnd(); - - var clean = ringSink.clean(), - ringSegments = ringBuffer.result(), - i, n = ringSegments.length, m, - segment, - point; - - ring.pop(); - polygon.push(ring); - ring = null; - - if (!n) return; - - // No intersections. - if (clean & 1) { - segment = ringSegments[0]; - if ((m = segment.length - 1) > 0) { - if (!polygonStarted) sink.polygonStart(), polygonStarted = true; - sink.lineStart(); - for (i = 0; i < m; ++i) sink.point((point = segment[i])[0], point[1]); - sink.lineEnd(); - } - return; - } - - // Rejoin connected segments. - // TODO reuse ringBuffer.rejoin()? - if (n > 1 && clean & 2) ringSegments.push(ringSegments.pop().concat(ringSegments.shift())); - - segments.push(ringSegments.filter(validSegment)); - } - - return clip; - }; -}); - -function validSegment(segment) { - return segment.length > 1; -} - -// Intersections are sorted along the clip edge. For both antimeridian cutting -// and circle clipping, the same comparison is used. -function compareIntersection(a, b) { - return ((a = a.x)[0] < 0 ? a[1] - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"] - _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"] : _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"] - a[1]) - - ((b = b.x)[0] < 0 ? b[1] - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"] - _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"] : _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"] - b[1]); -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/line.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-geo/src/clip/line.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b, x0, y0, x1, y1) { - var ax = a[0], - ay = a[1], - bx = b[0], - by = b[1], - t0 = 0, - t1 = 1, - dx = bx - ax, - dy = by - ay, - r; - - r = x0 - ax; - if (!dx && r > 0) return; - r /= dx; - if (dx < 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } else if (dx > 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } - - r = x1 - ax; - if (!dx && r < 0) return; - r /= dx; - if (dx < 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } else if (dx > 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } - - r = y0 - ay; - if (!dy && r > 0) return; - r /= dy; - if (dy < 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } else if (dy > 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } - - r = y1 - ay; - if (!dy && r < 0) return; - r /= dy; - if (dy < 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } else if (dy > 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } - - if (t0 > 0) a[0] = ax + t0 * dx, a[1] = ay + t0 * dy; - if (t1 < 1) b[0] = ax + t1 * dx, b[1] = ay + t1 * dy; - return true; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/rectangle.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-geo/src/clip/rectangle.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return clipRectangle; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _buffer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./buffer */ "./node_modules/d3-geo/src/clip/buffer.js"); -/* harmony import */ var _line__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./line */ "./node_modules/d3-geo/src/clip/line.js"); -/* harmony import */ var _rejoin__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./rejoin */ "./node_modules/d3-geo/src/clip/rejoin.js"); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); - - - - - - -var clipMax = 1e9, clipMin = -clipMax; - -// TODO Use d3-polygon’s polygonContains here for the ring check? -// TODO Eliminate duplicate buffering in clipBuffer and polygon.push? - -function clipRectangle(x0, y0, x1, y1) { - - function visible(x, y) { - return x0 <= x && x <= x1 && y0 <= y && y <= y1; - } - - function interpolate(from, to, direction, stream) { - var a = 0, a1 = 0; - if (from == null - || (a = corner(from, direction)) !== (a1 = corner(to, direction)) - || comparePoint(from, to) < 0 ^ direction > 0) { - do stream.point(a === 0 || a === 3 ? x0 : x1, a > 1 ? y1 : y0); - while ((a = (a + direction + 4) % 4) !== a1); - } else { - stream.point(to[0], to[1]); - } - } - - function corner(p, direction) { - return Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(p[0] - x0) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"] ? direction > 0 ? 0 : 3 - : Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(p[0] - x1) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"] ? direction > 0 ? 2 : 1 - : Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(p[1] - y0) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"] ? direction > 0 ? 1 : 0 - : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon - } - - function compareIntersection(a, b) { - return comparePoint(a.x, b.x); - } - - function comparePoint(a, b) { - var ca = corner(a, 1), - cb = corner(b, 1); - return ca !== cb ? ca - cb - : ca === 0 ? b[1] - a[1] - : ca === 1 ? a[0] - b[0] - : ca === 2 ? a[1] - b[1] - : b[0] - a[0]; - } - - return function(stream) { - var activeStream = stream, - bufferStream = Object(_buffer__WEBPACK_IMPORTED_MODULE_1__["default"])(), - segments, - polygon, - ring, - x__, y__, v__, // first point - x_, y_, v_, // previous point - first, - clean; - - var clipStream = { - point: point, - lineStart: lineStart, - lineEnd: lineEnd, - polygonStart: polygonStart, - polygonEnd: polygonEnd - }; - - function point(x, y) { - if (visible(x, y)) activeStream.point(x, y); - } - - function polygonInside() { - var winding = 0; - - for (var i = 0, n = polygon.length; i < n; ++i) { - for (var ring = polygon[i], j = 1, m = ring.length, point = ring[0], a0, a1, b0 = point[0], b1 = point[1]; j < m; ++j) { - a0 = b0, a1 = b1, point = ring[j], b0 = point[0], b1 = point[1]; - if (a1 <= y1) { if (b1 > y1 && (b0 - a0) * (y1 - a1) > (b1 - a1) * (x0 - a0)) ++winding; } - else { if (b1 <= y1 && (b0 - a0) * (y1 - a1) < (b1 - a1) * (x0 - a0)) --winding; } - } - } - - return winding; - } - - // Buffer geometry within a polygon and then clip it en masse. - function polygonStart() { - activeStream = bufferStream, segments = [], polygon = [], clean = true; - } - - function polygonEnd() { - var startInside = polygonInside(), - cleanInside = clean && startInside, - visible = (segments = Object(d3_array__WEBPACK_IMPORTED_MODULE_4__["merge"])(segments)).length; - if (cleanInside || visible) { - stream.polygonStart(); - if (cleanInside) { - stream.lineStart(); - interpolate(null, null, 1, stream); - stream.lineEnd(); - } - if (visible) { - Object(_rejoin__WEBPACK_IMPORTED_MODULE_3__["default"])(segments, compareIntersection, startInside, interpolate, stream); - } - stream.polygonEnd(); - } - activeStream = stream, segments = polygon = ring = null; - } - - function lineStart() { - clipStream.point = linePoint; - if (polygon) polygon.push(ring = []); - first = true; - v_ = false; - x_ = y_ = NaN; - } - - // TODO rather than special-case polygons, simply handle them separately. - // Ideally, coincident intersection points should be jittered to avoid - // clipping issues. - function lineEnd() { - if (segments) { - linePoint(x__, y__); - if (v__ && v_) bufferStream.rejoin(); - segments.push(bufferStream.result()); - } - clipStream.point = point; - if (v_) activeStream.lineEnd(); - } - - function linePoint(x, y) { - var v = visible(x, y); - if (polygon) ring.push([x, y]); - if (first) { - x__ = x, y__ = y, v__ = v; - first = false; - if (v) { - activeStream.lineStart(); - activeStream.point(x, y); - } - } else { - if (v && v_) activeStream.point(x, y); - else { - var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))], - b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))]; - if (Object(_line__WEBPACK_IMPORTED_MODULE_2__["default"])(a, b, x0, y0, x1, y1)) { - if (!v_) { - activeStream.lineStart(); - activeStream.point(a[0], a[1]); - } - activeStream.point(b[0], b[1]); - if (!v) activeStream.lineEnd(); - clean = false; - } else if (v) { - activeStream.lineStart(); - activeStream.point(x, y); - clean = false; - } - } - } - x_ = x, y_ = y, v_ = v; - } - - return clipStream; - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/clip/rejoin.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/clip/rejoin.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _pointEqual__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../pointEqual */ "./node_modules/d3-geo/src/pointEqual.js"); - - -function Intersection(point, points, other, entry) { - this.x = point; - this.z = points; - this.o = other; // another intersection - this.e = entry; // is an entry? - this.v = false; // visited - this.n = this.p = null; // next & previous -} - -// A generalized polygon clipping algorithm: given a polygon that has been cut -// into its visible line segments, and rejoins the segments by interpolating -// along the clip edge. -/* harmony default export */ __webpack_exports__["default"] = (function(segments, compareIntersection, startInside, interpolate, stream) { - var subject = [], - clip = [], - i, - n; - - segments.forEach(function(segment) { - if ((n = segment.length - 1) <= 0) return; - var n, p0 = segment[0], p1 = segment[n], x; - - // If the first and last points of a segment are coincident, then treat as a - // closed ring. TODO if all rings are closed, then the winding order of the - // exterior ring should be checked. - if (Object(_pointEqual__WEBPACK_IMPORTED_MODULE_0__["default"])(p0, p1)) { - stream.lineStart(); - for (i = 0; i < n; ++i) stream.point((p0 = segment[i])[0], p0[1]); - stream.lineEnd(); - return; - } - - subject.push(x = new Intersection(p0, segment, null, true)); - clip.push(x.o = new Intersection(p0, null, x, false)); - subject.push(x = new Intersection(p1, segment, null, false)); - clip.push(x.o = new Intersection(p1, null, x, true)); - }); - - if (!subject.length) return; - - clip.sort(compareIntersection); - link(subject); - link(clip); - - for (i = 0, n = clip.length; i < n; ++i) { - clip[i].e = startInside = !startInside; - } - - var start = subject[0], - points, - point; - - while (1) { - // Find first unvisited intersection. - var current = start, - isSubject = true; - while (current.v) if ((current = current.n) === start) return; - points = current.z; - stream.lineStart(); - do { - current.v = current.o.v = true; - if (current.e) { - if (isSubject) { - for (i = 0, n = points.length; i < n; ++i) stream.point((point = points[i])[0], point[1]); - } else { - interpolate(current.x, current.n.x, 1, stream); - } - current = current.n; - } else { - if (isSubject) { - points = current.p.z; - for (i = points.length - 1; i >= 0; --i) stream.point((point = points[i])[0], point[1]); - } else { - interpolate(current.x, current.p.x, -1, stream); - } - current = current.p; - } - current = current.o; - points = current.z; - isSubject = !isSubject; - } while (!current.v); - stream.lineEnd(); - } -}); - -function link(array) { - if (!(n = array.length)) return; - var n, - i = 0, - a = array[0], - b; - while (++i < n) { - a.n = b = array[i]; - b.p = a; - a = b; - } - a.n = b = array[0]; - b.p = a; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/compose.js": -/*!********************************************!*\ - !*** ./node_modules/d3-geo/src/compose.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - - function compose(x, y) { - return x = a(x, y), b(x[0], x[1]); - } - - if (a.invert && b.invert) compose.invert = function(x, y) { - return x = b.invert(x, y), x && a.invert(x[0], x[1]); - }; - - return compose; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/constant.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-geo/src/constant.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/contains.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-geo/src/contains.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _polygonContains__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./polygonContains */ "./node_modules/d3-geo/src/polygonContains.js"); -/* harmony import */ var _distance__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./distance */ "./node_modules/d3-geo/src/distance.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - - - -var containsObjectType = { - Feature: function(object, point) { - return containsGeometry(object.geometry, point); - }, - FeatureCollection: function(object, point) { - var features = object.features, i = -1, n = features.length; - while (++i < n) if (containsGeometry(features[i].geometry, point)) return true; - return false; - } -}; - -var containsGeometryType = { - Sphere: function() { - return true; - }, - Point: function(object, point) { - return containsPoint(object.coordinates, point); - }, - MultiPoint: function(object, point) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) if (containsPoint(coordinates[i], point)) return true; - return false; - }, - LineString: function(object, point) { - return containsLine(object.coordinates, point); - }, - MultiLineString: function(object, point) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) if (containsLine(coordinates[i], point)) return true; - return false; - }, - Polygon: function(object, point) { - return containsPolygon(object.coordinates, point); - }, - MultiPolygon: function(object, point) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) if (containsPolygon(coordinates[i], point)) return true; - return false; - }, - GeometryCollection: function(object, point) { - var geometries = object.geometries, i = -1, n = geometries.length; - while (++i < n) if (containsGeometry(geometries[i], point)) return true; - return false; - } -}; - -function containsGeometry(geometry, point) { - return geometry && containsGeometryType.hasOwnProperty(geometry.type) - ? containsGeometryType[geometry.type](geometry, point) - : false; -} - -function containsPoint(coordinates, point) { - return Object(_distance__WEBPACK_IMPORTED_MODULE_1__["default"])(coordinates, point) === 0; -} - -function containsLine(coordinates, point) { - var ab = Object(_distance__WEBPACK_IMPORTED_MODULE_1__["default"])(coordinates[0], coordinates[1]), - ao = Object(_distance__WEBPACK_IMPORTED_MODULE_1__["default"])(coordinates[0], point), - ob = Object(_distance__WEBPACK_IMPORTED_MODULE_1__["default"])(point, coordinates[1]); - return ao + ob <= ab + _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; -} - -function containsPolygon(coordinates, point) { - return !!Object(_polygonContains__WEBPACK_IMPORTED_MODULE_0__["default"])(coordinates.map(ringRadians), pointRadians(point)); -} - -function ringRadians(ring) { - return ring = ring.map(pointRadians), ring.pop(), ring; -} - -function pointRadians(point) { - return [point[0] * _math__WEBPACK_IMPORTED_MODULE_2__["radians"], point[1] * _math__WEBPACK_IMPORTED_MODULE_2__["radians"]]; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(object, point) { - return (object && containsObjectType.hasOwnProperty(object.type) - ? containsObjectType[object.type] - : containsGeometry)(object, point); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/distance.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-geo/src/distance.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _length__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./length */ "./node_modules/d3-geo/src/length.js"); - - -var coordinates = [null, null], - object = {type: "LineString", coordinates: coordinates}; - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - coordinates[0] = a; - coordinates[1] = b; - return Object(_length__WEBPACK_IMPORTED_MODULE_0__["default"])(object); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/graticule.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-geo/src/graticule.js ***! - \**********************************************/ -/*! exports provided: default, graticule10 */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return graticule; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "graticule10", function() { return graticule10; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - - -function graticuleX(y0, y1, dy) { - var y = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(y0, y1 - _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"], dy).concat(y1); - return function(x) { return y.map(function(y) { return [x, y]; }); }; -} - -function graticuleY(x0, x1, dx) { - var x = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(x0, x1 - _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"], dx).concat(x1); - return function(y) { return x.map(function(x) { return [x, y]; }); }; -} - -function graticule() { - var x1, x0, X1, X0, - y1, y0, Y1, Y0, - dx = 10, dy = dx, DX = 90, DY = 360, - x, y, X, Y, - precision = 2.5; - - function graticule() { - return {type: "MultiLineString", coordinates: lines()}; - } - - function lines() { - return Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(Object(_math__WEBPACK_IMPORTED_MODULE_1__["ceil"])(X0 / DX) * DX, X1, DX).map(X) - .concat(Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(Object(_math__WEBPACK_IMPORTED_MODULE_1__["ceil"])(Y0 / DY) * DY, Y1, DY).map(Y)) - .concat(Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(Object(_math__WEBPACK_IMPORTED_MODULE_1__["ceil"])(x0 / dx) * dx, x1, dx).filter(function(x) { return Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(x % DX) > _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]; }).map(x)) - .concat(Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(Object(_math__WEBPACK_IMPORTED_MODULE_1__["ceil"])(y0 / dy) * dy, y1, dy).filter(function(y) { return Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(y % DY) > _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]; }).map(y)); - } - - graticule.lines = function() { - return lines().map(function(coordinates) { return {type: "LineString", coordinates: coordinates}; }); - }; - - graticule.outline = function() { - return { - type: "Polygon", - coordinates: [ - X(X0).concat( - Y(Y1).slice(1), - X(X1).reverse().slice(1), - Y(Y0).reverse().slice(1)) - ] - }; - }; - - graticule.extent = function(_) { - if (!arguments.length) return graticule.extentMinor(); - return graticule.extentMajor(_).extentMinor(_); - }; - - graticule.extentMajor = function(_) { - if (!arguments.length) return [[X0, Y0], [X1, Y1]]; - X0 = +_[0][0], X1 = +_[1][0]; - Y0 = +_[0][1], Y1 = +_[1][1]; - if (X0 > X1) _ = X0, X0 = X1, X1 = _; - if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _; - return graticule.precision(precision); - }; - - graticule.extentMinor = function(_) { - if (!arguments.length) return [[x0, y0], [x1, y1]]; - x0 = +_[0][0], x1 = +_[1][0]; - y0 = +_[0][1], y1 = +_[1][1]; - if (x0 > x1) _ = x0, x0 = x1, x1 = _; - if (y0 > y1) _ = y0, y0 = y1, y1 = _; - return graticule.precision(precision); - }; - - graticule.step = function(_) { - if (!arguments.length) return graticule.stepMinor(); - return graticule.stepMajor(_).stepMinor(_); - }; - - graticule.stepMajor = function(_) { - if (!arguments.length) return [DX, DY]; - DX = +_[0], DY = +_[1]; - return graticule; - }; - - graticule.stepMinor = function(_) { - if (!arguments.length) return [dx, dy]; - dx = +_[0], dy = +_[1]; - return graticule; - }; - - graticule.precision = function(_) { - if (!arguments.length) return precision; - precision = +_; - x = graticuleX(y0, y1, 90); - y = graticuleY(x0, x1, precision); - X = graticuleX(Y0, Y1, 90); - Y = graticuleY(X0, X1, precision); - return graticule; - }; - - return graticule - .extentMajor([[-180, -90 + _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]], [180, 90 - _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]]]) - .extentMinor([[-180, -80 - _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]], [180, 80 + _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"]]]); -} - -function graticule10() { - return graticule()(); -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/identity.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-geo/src/identity.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/index.js": -/*!******************************************!*\ - !*** ./node_modules/d3-geo/src/index.js ***! - \******************************************/ -/*! exports provided: geoArea, geoBounds, geoCentroid, geoCircle, geoClipAntimeridian, geoClipCircle, geoClipExtent, geoClipRectangle, geoContains, geoDistance, geoGraticule, geoGraticule10, geoInterpolate, geoLength, geoPath, geoAlbers, geoAlbersUsa, geoAzimuthalEqualArea, geoAzimuthalEqualAreaRaw, geoAzimuthalEquidistant, geoAzimuthalEquidistantRaw, geoConicConformal, geoConicConformalRaw, geoConicEqualArea, geoConicEqualAreaRaw, geoConicEquidistant, geoConicEquidistantRaw, geoEqualEarth, geoEqualEarthRaw, geoEquirectangular, geoEquirectangularRaw, geoGnomonic, geoGnomonicRaw, geoIdentity, geoProjection, geoProjectionMutator, geoMercator, geoMercatorRaw, geoNaturalEarth1, geoNaturalEarth1Raw, geoOrthographic, geoOrthographicRaw, geoStereographic, geoStereographicRaw, geoTransverseMercator, geoTransverseMercatorRaw, geoRotation, geoStream, geoTransform */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./area */ "./node_modules/d3-geo/src/area.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoArea", function() { return _area__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _bounds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./bounds */ "./node_modules/d3-geo/src/bounds.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoBounds", function() { return _bounds__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _centroid__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./centroid */ "./node_modules/d3-geo/src/centroid.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoCentroid", function() { return _centroid__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./circle */ "./node_modules/d3-geo/src/circle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoCircle", function() { return _circle__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _clip_antimeridian__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./clip/antimeridian */ "./node_modules/d3-geo/src/clip/antimeridian.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipAntimeridian", function() { return _clip_antimeridian__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _clip_circle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./clip/circle */ "./node_modules/d3-geo/src/clip/circle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipCircle", function() { return _clip_circle__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _clip_extent__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./clip/extent */ "./node_modules/d3-geo/src/clip/extent.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipExtent", function() { return _clip_extent__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _clip_rectangle__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./clip/rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipRectangle", function() { return _clip_rectangle__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _contains__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./contains */ "./node_modules/d3-geo/src/contains.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoContains", function() { return _contains__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _distance__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./distance */ "./node_modules/d3-geo/src/distance.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoDistance", function() { return _distance__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _graticule__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./graticule */ "./node_modules/d3-geo/src/graticule.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGraticule", function() { return _graticule__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGraticule10", function() { return _graticule__WEBPACK_IMPORTED_MODULE_10__["graticule10"]; }); - -/* harmony import */ var _interpolate__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./interpolate */ "./node_modules/d3-geo/src/interpolate.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoInterpolate", function() { return _interpolate__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony import */ var _length__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./length */ "./node_modules/d3-geo/src/length.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoLength", function() { return _length__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony import */ var _path_index__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./path/index */ "./node_modules/d3-geo/src/path/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoPath", function() { return _path_index__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony import */ var _projection_albers__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./projection/albers */ "./node_modules/d3-geo/src/projection/albers.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAlbers", function() { return _projection_albers__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony import */ var _projection_albersUsa__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./projection/albersUsa */ "./node_modules/d3-geo/src/projection/albersUsa.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAlbersUsa", function() { return _projection_albersUsa__WEBPACK_IMPORTED_MODULE_15__["default"]; }); - -/* harmony import */ var _projection_azimuthalEqualArea__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./projection/azimuthalEqualArea */ "./node_modules/d3-geo/src/projection/azimuthalEqualArea.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEqualArea", function() { return _projection_azimuthalEqualArea__WEBPACK_IMPORTED_MODULE_16__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEqualAreaRaw", function() { return _projection_azimuthalEqualArea__WEBPACK_IMPORTED_MODULE_16__["azimuthalEqualAreaRaw"]; }); - -/* harmony import */ var _projection_azimuthalEquidistant__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./projection/azimuthalEquidistant */ "./node_modules/d3-geo/src/projection/azimuthalEquidistant.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEquidistant", function() { return _projection_azimuthalEquidistant__WEBPACK_IMPORTED_MODULE_17__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEquidistantRaw", function() { return _projection_azimuthalEquidistant__WEBPACK_IMPORTED_MODULE_17__["azimuthalEquidistantRaw"]; }); - -/* harmony import */ var _projection_conicConformal__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./projection/conicConformal */ "./node_modules/d3-geo/src/projection/conicConformal.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicConformal", function() { return _projection_conicConformal__WEBPACK_IMPORTED_MODULE_18__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicConformalRaw", function() { return _projection_conicConformal__WEBPACK_IMPORTED_MODULE_18__["conicConformalRaw"]; }); - -/* harmony import */ var _projection_conicEqualArea__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./projection/conicEqualArea */ "./node_modules/d3-geo/src/projection/conicEqualArea.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEqualArea", function() { return _projection_conicEqualArea__WEBPACK_IMPORTED_MODULE_19__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEqualAreaRaw", function() { return _projection_conicEqualArea__WEBPACK_IMPORTED_MODULE_19__["conicEqualAreaRaw"]; }); - -/* harmony import */ var _projection_conicEquidistant__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./projection/conicEquidistant */ "./node_modules/d3-geo/src/projection/conicEquidistant.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEquidistant", function() { return _projection_conicEquidistant__WEBPACK_IMPORTED_MODULE_20__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEquidistantRaw", function() { return _projection_conicEquidistant__WEBPACK_IMPORTED_MODULE_20__["conicEquidistantRaw"]; }); - -/* harmony import */ var _projection_equalEarth__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./projection/equalEarth */ "./node_modules/d3-geo/src/projection/equalEarth.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEqualEarth", function() { return _projection_equalEarth__WEBPACK_IMPORTED_MODULE_21__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEqualEarthRaw", function() { return _projection_equalEarth__WEBPACK_IMPORTED_MODULE_21__["equalEarthRaw"]; }); - -/* harmony import */ var _projection_equirectangular__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./projection/equirectangular */ "./node_modules/d3-geo/src/projection/equirectangular.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEquirectangular", function() { return _projection_equirectangular__WEBPACK_IMPORTED_MODULE_22__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEquirectangularRaw", function() { return _projection_equirectangular__WEBPACK_IMPORTED_MODULE_22__["equirectangularRaw"]; }); - -/* harmony import */ var _projection_gnomonic__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./projection/gnomonic */ "./node_modules/d3-geo/src/projection/gnomonic.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGnomonic", function() { return _projection_gnomonic__WEBPACK_IMPORTED_MODULE_23__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGnomonicRaw", function() { return _projection_gnomonic__WEBPACK_IMPORTED_MODULE_23__["gnomonicRaw"]; }); - -/* harmony import */ var _projection_identity__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./projection/identity */ "./node_modules/d3-geo/src/projection/identity.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoIdentity", function() { return _projection_identity__WEBPACK_IMPORTED_MODULE_24__["default"]; }); - -/* harmony import */ var _projection_index__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./projection/index */ "./node_modules/d3-geo/src/projection/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoProjection", function() { return _projection_index__WEBPACK_IMPORTED_MODULE_25__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoProjectionMutator", function() { return _projection_index__WEBPACK_IMPORTED_MODULE_25__["projectionMutator"]; }); - -/* harmony import */ var _projection_mercator__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./projection/mercator */ "./node_modules/d3-geo/src/projection/mercator.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoMercator", function() { return _projection_mercator__WEBPACK_IMPORTED_MODULE_26__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoMercatorRaw", function() { return _projection_mercator__WEBPACK_IMPORTED_MODULE_26__["mercatorRaw"]; }); - -/* harmony import */ var _projection_naturalEarth1__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./projection/naturalEarth1 */ "./node_modules/d3-geo/src/projection/naturalEarth1.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoNaturalEarth1", function() { return _projection_naturalEarth1__WEBPACK_IMPORTED_MODULE_27__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoNaturalEarth1Raw", function() { return _projection_naturalEarth1__WEBPACK_IMPORTED_MODULE_27__["naturalEarth1Raw"]; }); - -/* harmony import */ var _projection_orthographic__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./projection/orthographic */ "./node_modules/d3-geo/src/projection/orthographic.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoOrthographic", function() { return _projection_orthographic__WEBPACK_IMPORTED_MODULE_28__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoOrthographicRaw", function() { return _projection_orthographic__WEBPACK_IMPORTED_MODULE_28__["orthographicRaw"]; }); - -/* harmony import */ var _projection_stereographic__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./projection/stereographic */ "./node_modules/d3-geo/src/projection/stereographic.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoStereographic", function() { return _projection_stereographic__WEBPACK_IMPORTED_MODULE_29__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoStereographicRaw", function() { return _projection_stereographic__WEBPACK_IMPORTED_MODULE_29__["stereographicRaw"]; }); - -/* harmony import */ var _projection_transverseMercator__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./projection/transverseMercator */ "./node_modules/d3-geo/src/projection/transverseMercator.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoTransverseMercator", function() { return _projection_transverseMercator__WEBPACK_IMPORTED_MODULE_30__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoTransverseMercatorRaw", function() { return _projection_transverseMercator__WEBPACK_IMPORTED_MODULE_30__["transverseMercatorRaw"]; }); - -/* harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./rotation */ "./node_modules/d3-geo/src/rotation.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoRotation", function() { return _rotation__WEBPACK_IMPORTED_MODULE_31__["default"]; }); - -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(/*! ./stream */ "./node_modules/d3-geo/src/stream.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoStream", function() { return _stream__WEBPACK_IMPORTED_MODULE_32__["default"]; }); - -/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(/*! ./transform */ "./node_modules/d3-geo/src/transform.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoTransform", function() { return _transform__WEBPACK_IMPORTED_MODULE_33__["default"]; }); - - - - - - - - // DEPRECATED! Use d3.geoIdentity().clipExtent(…). - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/interpolate.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/interpolate.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var x0 = a[0] * _math__WEBPACK_IMPORTED_MODULE_0__["radians"], - y0 = a[1] * _math__WEBPACK_IMPORTED_MODULE_0__["radians"], - x1 = b[0] * _math__WEBPACK_IMPORTED_MODULE_0__["radians"], - y1 = b[1] * _math__WEBPACK_IMPORTED_MODULE_0__["radians"], - cy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y0), - sy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y0), - cy1 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y1), - sy1 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y1), - kx0 = cy0 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(x0), - ky0 = cy0 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x0), - kx1 = cy1 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(x1), - ky1 = cy1 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x1), - d = 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["haversin"])(y1 - y0) + cy0 * cy1 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["haversin"])(x1 - x0))), - k = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(d); - - var interpolate = d ? function(t) { - var B = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(t *= d) / k, - A = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(d - t) / k, - x = A * kx0 + B * kx1, - y = A * ky0 + B * ky1, - z = A * sy0 + B * sy1; - return [ - Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(y, x) * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"], - Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(z, Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(x * x + y * y)) * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"] - ]; - } : function() { - return [x0 * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"], y0 * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"]]; - }; - - interpolate.distance = d; - - return interpolate; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/length.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-geo/src/length.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./adder */ "./node_modules/d3-geo/src/adder.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./noop */ "./node_modules/d3-geo/src/noop.js"); -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./stream */ "./node_modules/d3-geo/src/stream.js"); - - - - - -var lengthSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(), - lambda0, - sinPhi0, - cosPhi0; - -var lengthStream = { - sphere: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - point: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - lineStart: lengthLineStart, - lineEnd: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - polygonStart: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - polygonEnd: _noop__WEBPACK_IMPORTED_MODULE_2__["default"] -}; - -function lengthLineStart() { - lengthStream.point = lengthPointFirst; - lengthStream.lineEnd = lengthLineEnd; -} - -function lengthLineEnd() { - lengthStream.point = lengthStream.lineEnd = _noop__WEBPACK_IMPORTED_MODULE_2__["default"]; -} - -function lengthPointFirst(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"]; - lambda0 = lambda, sinPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi), cosPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi); - lengthStream.point = lengthPoint; -} - -function lengthPoint(lambda, phi) { - lambda *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"], phi *= _math__WEBPACK_IMPORTED_MODULE_1__["radians"]; - var sinPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi), - cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi), - delta = Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(lambda - lambda0), - cosDelta = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(delta), - sinDelta = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(delta), - x = cosPhi * sinDelta, - y = cosPhi0 * sinPhi - sinPhi0 * cosPhi * cosDelta, - z = sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosDelta; - lengthSum.add(Object(_math__WEBPACK_IMPORTED_MODULE_1__["atan2"])(Object(_math__WEBPACK_IMPORTED_MODULE_1__["sqrt"])(x * x + y * y), z)); - lambda0 = lambda, sinPhi0 = sinPhi, cosPhi0 = cosPhi; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(object) { - lengthSum.reset(); - Object(_stream__WEBPACK_IMPORTED_MODULE_3__["default"])(object, lengthStream); - return +lengthSum; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/math.js": -/*!*****************************************!*\ - !*** ./node_modules/d3-geo/src/math.js ***! - \*****************************************/ -/*! exports provided: epsilon, epsilon2, pi, halfPi, quarterPi, tau, degrees, radians, abs, atan, atan2, cos, ceil, exp, floor, log, pow, sin, sign, sqrt, tan, acos, asin, haversin */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "epsilon", function() { return epsilon; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "epsilon2", function() { return epsilon2; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pi", function() { return pi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "halfPi", function() { return halfPi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "quarterPi", function() { return quarterPi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tau", function() { return tau; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "degrees", function() { return degrees; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "radians", function() { return radians; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "abs", function() { return abs; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "atan", function() { return atan; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "atan2", function() { return atan2; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cos", function() { return cos; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ceil", function() { return ceil; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exp", function() { return exp; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "floor", function() { return floor; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "log", function() { return log; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pow", function() { return pow; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sin", function() { return sin; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sign", function() { return sign; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrt", function() { return sqrt; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tan", function() { return tan; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "acos", function() { return acos; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "asin", function() { return asin; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "haversin", function() { return haversin; }); -var epsilon = 1e-6; -var epsilon2 = 1e-12; -var pi = Math.PI; -var halfPi = pi / 2; -var quarterPi = pi / 4; -var tau = pi * 2; - -var degrees = 180 / pi; -var radians = pi / 180; - -var abs = Math.abs; -var atan = Math.atan; -var atan2 = Math.atan2; -var cos = Math.cos; -var ceil = Math.ceil; -var exp = Math.exp; -var floor = Math.floor; -var log = Math.log; -var pow = Math.pow; -var sin = Math.sin; -var sign = Math.sign || function(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }; -var sqrt = Math.sqrt; -var tan = Math.tan; - -function acos(x) { - return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); -} - -function asin(x) { - return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x); -} - -function haversin(x) { - return (x = sin(x / 2)) * x; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/noop.js": -/*!*****************************************!*\ - !*** ./node_modules/d3-geo/src/noop.js ***! - \*****************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return noop; }); -function noop() {} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/area.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-geo/src/path/area.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../adder */ "./node_modules/d3-geo/src/adder.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-geo/src/noop.js"); - - - - -var areaSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(), - areaRingSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(), - x00, - y00, - x0, - y0; - -var areaStream = { - point: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - lineStart: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - lineEnd: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - polygonStart: function() { - areaStream.lineStart = areaRingStart; - areaStream.lineEnd = areaRingEnd; - }, - polygonEnd: function() { - areaStream.lineStart = areaStream.lineEnd = areaStream.point = _noop__WEBPACK_IMPORTED_MODULE_2__["default"]; - areaSum.add(Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(areaRingSum)); - areaRingSum.reset(); - }, - result: function() { - var area = areaSum / 2; - areaSum.reset(); - return area; - } -}; - -function areaRingStart() { - areaStream.point = areaPointFirst; -} - -function areaPointFirst(x, y) { - areaStream.point = areaPoint; - x00 = x0 = x, y00 = y0 = y; -} - -function areaPoint(x, y) { - areaRingSum.add(y0 * x - x0 * y); - x0 = x, y0 = y; -} - -function areaRingEnd() { - areaPoint(x00, y00); -} - -/* harmony default export */ __webpack_exports__["default"] = (areaStream); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/bounds.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/path/bounds.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-geo/src/noop.js"); - - -var x0 = Infinity, - y0 = x0, - x1 = -x0, - y1 = x1; - -var boundsStream = { - point: boundsPoint, - lineStart: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - lineEnd: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - polygonStart: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - polygonEnd: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - result: function() { - var bounds = [[x0, y0], [x1, y1]]; - x1 = y1 = -(y0 = x0 = Infinity); - return bounds; - } -}; - -function boundsPoint(x, y) { - if (x < x0) x0 = x; - if (x > x1) x1 = x; - if (y < y0) y0 = y; - if (y > y1) y1 = y; -} - -/* harmony default export */ __webpack_exports__["default"] = (boundsStream); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/centroid.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-geo/src/path/centroid.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); - - -// TODO Enforce positive area for exterior, negative area for interior? - -var X0 = 0, - Y0 = 0, - Z0 = 0, - X1 = 0, - Y1 = 0, - Z1 = 0, - X2 = 0, - Y2 = 0, - Z2 = 0, - x00, - y00, - x0, - y0; - -var centroidStream = { - point: centroidPoint, - lineStart: centroidLineStart, - lineEnd: centroidLineEnd, - polygonStart: function() { - centroidStream.lineStart = centroidRingStart; - centroidStream.lineEnd = centroidRingEnd; - }, - polygonEnd: function() { - centroidStream.point = centroidPoint; - centroidStream.lineStart = centroidLineStart; - centroidStream.lineEnd = centroidLineEnd; - }, - result: function() { - var centroid = Z2 ? [X2 / Z2, Y2 / Z2] - : Z1 ? [X1 / Z1, Y1 / Z1] - : Z0 ? [X0 / Z0, Y0 / Z0] - : [NaN, NaN]; - X0 = Y0 = Z0 = - X1 = Y1 = Z1 = - X2 = Y2 = Z2 = 0; - return centroid; - } -}; - -function centroidPoint(x, y) { - X0 += x; - Y0 += y; - ++Z0; -} - -function centroidLineStart() { - centroidStream.point = centroidPointFirstLine; -} - -function centroidPointFirstLine(x, y) { - centroidStream.point = centroidPointLine; - centroidPoint(x0 = x, y0 = y); -} - -function centroidPointLine(x, y) { - var dx = x - x0, dy = y - y0, z = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(dx * dx + dy * dy); - X1 += z * (x0 + x) / 2; - Y1 += z * (y0 + y) / 2; - Z1 += z; - centroidPoint(x0 = x, y0 = y); -} - -function centroidLineEnd() { - centroidStream.point = centroidPoint; -} - -function centroidRingStart() { - centroidStream.point = centroidPointFirstRing; -} - -function centroidRingEnd() { - centroidPointRing(x00, y00); -} - -function centroidPointFirstRing(x, y) { - centroidStream.point = centroidPointRing; - centroidPoint(x00 = x0 = x, y00 = y0 = y); -} - -function centroidPointRing(x, y) { - var dx = x - x0, - dy = y - y0, - z = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(dx * dx + dy * dy); - - X1 += z * (x0 + x) / 2; - Y1 += z * (y0 + y) / 2; - Z1 += z; - - z = y0 * x - x0 * y; - X2 += z * (x0 + x); - Y2 += z * (y0 + y); - Z2 += z * 3; - centroidPoint(x0 = x, y0 = y); -} - -/* harmony default export */ __webpack_exports__["default"] = (centroidStream); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/context.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-geo/src/path/context.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return PathContext; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-geo/src/noop.js"); - - - -function PathContext(context) { - this._context = context; -} - -PathContext.prototype = { - _radius: 4.5, - pointRadius: function(_) { - return this._radius = _, this; - }, - polygonStart: function() { - this._line = 0; - }, - polygonEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._point = 0; - }, - lineEnd: function() { - if (this._line === 0) this._context.closePath(); - this._point = NaN; - }, - point: function(x, y) { - switch (this._point) { - case 0: { - this._context.moveTo(x, y); - this._point = 1; - break; - } - case 1: { - this._context.lineTo(x, y); - break; - } - default: { - this._context.moveTo(x + this._radius, y); - this._context.arc(x, y, this._radius, 0, _math__WEBPACK_IMPORTED_MODULE_0__["tau"]); - break; - } - } - }, - result: _noop__WEBPACK_IMPORTED_MODULE_1__["default"] -}; - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/index.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-geo/src/path/index.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../identity */ "./node_modules/d3-geo/src/identity.js"); -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../stream */ "./node_modules/d3-geo/src/stream.js"); -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./area */ "./node_modules/d3-geo/src/path/area.js"); -/* harmony import */ var _bounds__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./bounds */ "./node_modules/d3-geo/src/path/bounds.js"); -/* harmony import */ var _centroid__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./centroid */ "./node_modules/d3-geo/src/path/centroid.js"); -/* harmony import */ var _context__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./context */ "./node_modules/d3-geo/src/path/context.js"); -/* harmony import */ var _measure__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./measure */ "./node_modules/d3-geo/src/path/measure.js"); -/* harmony import */ var _string__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./string */ "./node_modules/d3-geo/src/path/string.js"); - - - - - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(projection, context) { - var pointRadius = 4.5, - projectionStream, - contextStream; - - function path(object) { - if (object) { - if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments)); - Object(_stream__WEBPACK_IMPORTED_MODULE_1__["default"])(object, projectionStream(contextStream)); - } - return contextStream.result(); - } - - path.area = function(object) { - Object(_stream__WEBPACK_IMPORTED_MODULE_1__["default"])(object, projectionStream(_area__WEBPACK_IMPORTED_MODULE_2__["default"])); - return _area__WEBPACK_IMPORTED_MODULE_2__["default"].result(); - }; - - path.measure = function(object) { - Object(_stream__WEBPACK_IMPORTED_MODULE_1__["default"])(object, projectionStream(_measure__WEBPACK_IMPORTED_MODULE_6__["default"])); - return _measure__WEBPACK_IMPORTED_MODULE_6__["default"].result(); - }; - - path.bounds = function(object) { - Object(_stream__WEBPACK_IMPORTED_MODULE_1__["default"])(object, projectionStream(_bounds__WEBPACK_IMPORTED_MODULE_3__["default"])); - return _bounds__WEBPACK_IMPORTED_MODULE_3__["default"].result(); - }; - - path.centroid = function(object) { - Object(_stream__WEBPACK_IMPORTED_MODULE_1__["default"])(object, projectionStream(_centroid__WEBPACK_IMPORTED_MODULE_4__["default"])); - return _centroid__WEBPACK_IMPORTED_MODULE_4__["default"].result(); - }; - - path.projection = function(_) { - return arguments.length ? (projectionStream = _ == null ? (projection = null, _identity__WEBPACK_IMPORTED_MODULE_0__["default"]) : (projection = _).stream, path) : projection; - }; - - path.context = function(_) { - if (!arguments.length) return context; - contextStream = _ == null ? (context = null, new _string__WEBPACK_IMPORTED_MODULE_7__["default"]) : new _context__WEBPACK_IMPORTED_MODULE_5__["default"](context = _); - if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius); - return path; - }; - - path.pointRadius = function(_) { - if (!arguments.length) return pointRadius; - pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_); - return path; - }; - - return path.projection(projection).context(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/measure.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-geo/src/path/measure.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../adder */ "./node_modules/d3-geo/src/adder.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-geo/src/noop.js"); - - - - -var lengthSum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(), - lengthRing, - x00, - y00, - x0, - y0; - -var lengthStream = { - point: _noop__WEBPACK_IMPORTED_MODULE_2__["default"], - lineStart: function() { - lengthStream.point = lengthPointFirst; - }, - lineEnd: function() { - if (lengthRing) lengthPoint(x00, y00); - lengthStream.point = _noop__WEBPACK_IMPORTED_MODULE_2__["default"]; - }, - polygonStart: function() { - lengthRing = true; - }, - polygonEnd: function() { - lengthRing = null; - }, - result: function() { - var length = +lengthSum; - lengthSum.reset(); - return length; - } -}; - -function lengthPointFirst(x, y) { - lengthStream.point = lengthPoint; - x00 = x0 = x, y00 = y0 = y; -} - -function lengthPoint(x, y) { - x0 -= x, y0 -= y; - lengthSum.add(Object(_math__WEBPACK_IMPORTED_MODULE_1__["sqrt"])(x0 * x0 + y0 * y0)); - x0 = x, y0 = y; -} - -/* harmony default export */ __webpack_exports__["default"] = (lengthStream); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/path/string.js": -/*!************************************************!*\ - !*** ./node_modules/d3-geo/src/path/string.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return PathString; }); -function PathString() { - this._string = []; -} - -PathString.prototype = { - _radius: 4.5, - _circle: circle(4.5), - pointRadius: function(_) { - if ((_ = +_) !== this._radius) this._radius = _, this._circle = null; - return this; - }, - polygonStart: function() { - this._line = 0; - }, - polygonEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._point = 0; - }, - lineEnd: function() { - if (this._line === 0) this._string.push("Z"); - this._point = NaN; - }, - point: function(x, y) { - switch (this._point) { - case 0: { - this._string.push("M", x, ",", y); - this._point = 1; - break; - } - case 1: { - this._string.push("L", x, ",", y); - break; - } - default: { - if (this._circle == null) this._circle = circle(this._radius); - this._string.push("M", x, ",", y, this._circle); - break; - } - } - }, - result: function() { - if (this._string.length) { - var result = this._string.join(""); - this._string = []; - return result; - } else { - return null; - } - } -}; - -function circle(radius) { - return "m0," + radius - + "a" + radius + "," + radius + " 0 1,1 0," + -2 * radius - + "a" + radius + "," + radius + " 0 1,1 0," + 2 * radius - + "z"; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/pointEqual.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-geo/src/pointEqual.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(a[0] - b[0]) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"] && Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(a[1] - b[1]) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/polygonContains.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-geo/src/polygonContains.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _adder__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./adder */ "./node_modules/d3-geo/src/adder.js"); -/* harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./cartesian */ "./node_modules/d3-geo/src/cartesian.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - - - -var sum = Object(_adder__WEBPACK_IMPORTED_MODULE_0__["default"])(); - -/* harmony default export */ __webpack_exports__["default"] = (function(polygon, point) { - var lambda = point[0], - phi = point[1], - sinPhi = Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(phi), - normal = [Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(lambda), -Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(lambda), 0], - angle = 0, - winding = 0; - - sum.reset(); - - if (sinPhi === 1) phi = _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"] + _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; - else if (sinPhi === -1) phi = -_math__WEBPACK_IMPORTED_MODULE_2__["halfPi"] - _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]; - - for (var i = 0, n = polygon.length; i < n; ++i) { - if (!(m = (ring = polygon[i]).length)) continue; - var ring, - m, - point0 = ring[m - 1], - lambda0 = point0[0], - phi0 = point0[1] / 2 + _math__WEBPACK_IMPORTED_MODULE_2__["quarterPi"], - sinPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(phi0), - cosPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(phi0); - - for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) { - var point1 = ring[j], - lambda1 = point1[0], - phi1 = point1[1] / 2 + _math__WEBPACK_IMPORTED_MODULE_2__["quarterPi"], - sinPhi1 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(phi1), - cosPhi1 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(phi1), - delta = lambda1 - lambda0, - sign = delta >= 0 ? 1 : -1, - absDelta = sign * delta, - antimeridian = absDelta > _math__WEBPACK_IMPORTED_MODULE_2__["pi"], - k = sinPhi0 * sinPhi1; - - sum.add(Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(k * sign * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(absDelta), cosPhi0 * cosPhi1 + k * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(absDelta))); - angle += antimeridian ? delta + sign * _math__WEBPACK_IMPORTED_MODULE_2__["tau"] : delta; - - // Are the longitudes either side of the point’s meridian (lambda), - // and are the latitudes smaller than the parallel (phi)? - if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) { - var arc = Object(_cartesian__WEBPACK_IMPORTED_MODULE_1__["cartesianCross"])(Object(_cartesian__WEBPACK_IMPORTED_MODULE_1__["cartesian"])(point0), Object(_cartesian__WEBPACK_IMPORTED_MODULE_1__["cartesian"])(point1)); - Object(_cartesian__WEBPACK_IMPORTED_MODULE_1__["cartesianNormalizeInPlace"])(arc); - var intersection = Object(_cartesian__WEBPACK_IMPORTED_MODULE_1__["cartesianCross"])(normal, arc); - Object(_cartesian__WEBPACK_IMPORTED_MODULE_1__["cartesianNormalizeInPlace"])(intersection); - var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * Object(_math__WEBPACK_IMPORTED_MODULE_2__["asin"])(intersection[2]); - if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) { - winding += antimeridian ^ delta >= 0 ? 1 : -1; - } - } - } - } - - // First, determine whether the South pole is inside or outside: - // - // It is inside if: - // * the polygon winds around it in a clockwise direction. - // * the polygon does not (cumulatively) wind around it, but has a negative - // (counter-clockwise) area. - // - // Second, count the (signed) number of times a segment crosses a lambda - // from the point to the South pole. If it is zero, then the point is the - // same side as the South pole. - - return (angle < -_math__WEBPACK_IMPORTED_MODULE_2__["epsilon"] || angle < _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"] && sum < -_math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) ^ (winding & 1); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/albers.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/albers.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _conicEqualArea__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./conicEqualArea */ "./node_modules/d3-geo/src/projection/conicEqualArea.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_conicEqualArea__WEBPACK_IMPORTED_MODULE_0__["default"])() - .parallels([29.5, 45.5]) - .scale(1070) - .translate([480, 250]) - .rotate([96, 0]) - .center([-0.6, 38.7]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/albersUsa.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/albersUsa.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _albers__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./albers */ "./node_modules/d3-geo/src/projection/albers.js"); -/* harmony import */ var _conicEqualArea__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./conicEqualArea */ "./node_modules/d3-geo/src/projection/conicEqualArea.js"); -/* harmony import */ var _fit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./fit */ "./node_modules/d3-geo/src/projection/fit.js"); - - - - - -// The projections must have mutually exclusive clip regions on the sphere, -// as this will avoid emitting interleaving lines and polygons. -function multiplex(streams) { - var n = streams.length; - return { - point: function(x, y) { var i = -1; while (++i < n) streams[i].point(x, y); }, - sphere: function() { var i = -1; while (++i < n) streams[i].sphere(); }, - lineStart: function() { var i = -1; while (++i < n) streams[i].lineStart(); }, - lineEnd: function() { var i = -1; while (++i < n) streams[i].lineEnd(); }, - polygonStart: function() { var i = -1; while (++i < n) streams[i].polygonStart(); }, - polygonEnd: function() { var i = -1; while (++i < n) streams[i].polygonEnd(); } - }; -} - -// A composite projection for the United States, configured by default for -// 960×500. The projection also works quite well at 960×600 if you change the -// scale to 1285 and adjust the translate accordingly. The set of standard -// parallels for each region comes from USGS, which is published here: -// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers -/* harmony default export */ __webpack_exports__["default"] = (function() { - var cache, - cacheStream, - lower48 = Object(_albers__WEBPACK_IMPORTED_MODULE_1__["default"])(), lower48Point, - alaska = Object(_conicEqualArea__WEBPACK_IMPORTED_MODULE_2__["default"])().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), alaskaPoint, // EPSG:3338 - hawaii = Object(_conicEqualArea__WEBPACK_IMPORTED_MODULE_2__["default"])().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), hawaiiPoint, // ESRI:102007 - point, pointStream = {point: function(x, y) { point = [x, y]; }}; - - function albersUsa(coordinates) { - var x = coordinates[0], y = coordinates[1]; - return point = null, - (lower48Point.point(x, y), point) - || (alaskaPoint.point(x, y), point) - || (hawaiiPoint.point(x, y), point); - } - - albersUsa.invert = function(coordinates) { - var k = lower48.scale(), - t = lower48.translate(), - x = (coordinates[0] - t[0]) / k, - y = (coordinates[1] - t[1]) / k; - return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska - : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii - : lower48).invert(coordinates); - }; - - albersUsa.stream = function(stream) { - return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]); - }; - - albersUsa.precision = function(_) { - if (!arguments.length) return lower48.precision(); - lower48.precision(_), alaska.precision(_), hawaii.precision(_); - return reset(); - }; - - albersUsa.scale = function(_) { - if (!arguments.length) return lower48.scale(); - lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_); - return albersUsa.translate(lower48.translate()); - }; - - albersUsa.translate = function(_) { - if (!arguments.length) return lower48.translate(); - var k = lower48.scale(), x = +_[0], y = +_[1]; - - lower48Point = lower48 - .translate(_) - .clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]) - .stream(pointStream); - - alaskaPoint = alaska - .translate([x - 0.307 * k, y + 0.201 * k]) - .clipExtent([[x - 0.425 * k + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"], y + 0.120 * k + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]], [x - 0.214 * k - _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"], y + 0.234 * k - _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]]]) - .stream(pointStream); - - hawaiiPoint = hawaii - .translate([x - 0.205 * k, y + 0.212 * k]) - .clipExtent([[x - 0.214 * k + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"], y + 0.166 * k + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]], [x - 0.115 * k - _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"], y + 0.234 * k - _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]]]) - .stream(pointStream); - - return reset(); - }; - - albersUsa.fitExtent = function(extent, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitExtent"])(albersUsa, extent, object); - }; - - albersUsa.fitSize = function(size, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitSize"])(albersUsa, size, object); - }; - - albersUsa.fitWidth = function(width, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitWidth"])(albersUsa, width, object); - }; - - albersUsa.fitHeight = function(height, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitHeight"])(albersUsa, height, object); - }; - - function reset() { - cache = cacheStream = null; - return albersUsa; - } - - return albersUsa.scale(1070); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/azimuthal.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/azimuthal.js ***! - \*********************************************************/ -/*! exports provided: azimuthalRaw, azimuthalInvert */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "azimuthalRaw", function() { return azimuthalRaw; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "azimuthalInvert", function() { return azimuthalInvert; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); - - -function azimuthalRaw(scale) { - return function(x, y) { - var cx = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(x), - cy = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y), - k = scale(cx * cy); - return [ - k * cy * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x), - k * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y) - ]; - } -} - -function azimuthalInvert(angle) { - return function(x, y) { - var z = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(x * x + y * y), - c = angle(z), - sc = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(c), - cc = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(c); - return [ - Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(x * sc, z * cc), - Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(z && y * sc / z) - ]; - } -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/azimuthalEqualArea.js": -/*!******************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/azimuthalEqualArea.js ***! - \******************************************************************/ -/*! exports provided: azimuthalEqualAreaRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "azimuthalEqualAreaRaw", function() { return azimuthalEqualAreaRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - - -var azimuthalEqualAreaRaw = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalRaw"])(function(cxcy) { - return Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(2 / (1 + cxcy)); -}); - -azimuthalEqualAreaRaw.invert = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalInvert"])(function(z) { - return 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(z / 2); -}); - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_2__["default"])(azimuthalEqualAreaRaw) - .scale(124.75) - .clipAngle(180 - 1e-3); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/azimuthalEquidistant.js": -/*!********************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/azimuthalEquidistant.js ***! - \********************************************************************/ -/*! exports provided: azimuthalEquidistantRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "azimuthalEquidistantRaw", function() { return azimuthalEquidistantRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - - -var azimuthalEquidistantRaw = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalRaw"])(function(c) { - return (c = Object(_math__WEBPACK_IMPORTED_MODULE_0__["acos"])(c)) && c / Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(c); -}); - -azimuthalEquidistantRaw.invert = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalInvert"])(function(z) { - return z; -}); - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_2__["default"])(azimuthalEquidistantRaw) - .scale(79.4188) - .clipAngle(180 - 1e-3); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/conic.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/conic.js ***! - \*****************************************************/ -/*! exports provided: conicProjection */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conicProjection", function() { return conicProjection; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - -function conicProjection(projectAt) { - var phi0 = 0, - phi1 = _math__WEBPACK_IMPORTED_MODULE_0__["pi"] / 3, - m = Object(_index__WEBPACK_IMPORTED_MODULE_1__["projectionMutator"])(projectAt), - p = m(phi0, phi1); - - p.parallels = function(_) { - return arguments.length ? m(phi0 = _[0] * _math__WEBPACK_IMPORTED_MODULE_0__["radians"], phi1 = _[1] * _math__WEBPACK_IMPORTED_MODULE_0__["radians"]) : [phi0 * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"], phi1 * _math__WEBPACK_IMPORTED_MODULE_0__["degrees"]]; - }; - - return p; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/conicConformal.js": -/*!**************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/conicConformal.js ***! - \**************************************************************/ -/*! exports provided: conicConformalRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conicConformalRaw", function() { return conicConformalRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _conic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./conic */ "./node_modules/d3-geo/src/projection/conic.js"); -/* harmony import */ var _mercator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./mercator */ "./node_modules/d3-geo/src/projection/mercator.js"); - - - - -function tany(y) { - return Object(_math__WEBPACK_IMPORTED_MODULE_0__["tan"])((_math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] + y) / 2); -} - -function conicConformalRaw(y0, y1) { - var cy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y0), - n = y0 === y1 ? Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y0) : Object(_math__WEBPACK_IMPORTED_MODULE_0__["log"])(cy0 / Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y1)) / Object(_math__WEBPACK_IMPORTED_MODULE_0__["log"])(tany(y1) / tany(y0)), - f = cy0 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["pow"])(tany(y0), n) / n; - - if (!n) return _mercator__WEBPACK_IMPORTED_MODULE_2__["mercatorRaw"]; - - function project(x, y) { - if (f > 0) { if (y < -_math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) y = -_math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]; } - else { if (y > _math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] - _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) y = _math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] - _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]; } - var r = f / Object(_math__WEBPACK_IMPORTED_MODULE_0__["pow"])(tany(y), n); - return [r * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(n * x), f - r * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(n * x)]; - } - - project.invert = function(x, y) { - var fy = f - y, r = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sign"])(n) * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(x * x + fy * fy); - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(x, Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(fy)) / n * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sign"])(fy), 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["pow"])(f / r, 1 / n)) - _math__WEBPACK_IMPORTED_MODULE_0__["halfPi"]]; - }; - - return project; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_conic__WEBPACK_IMPORTED_MODULE_1__["conicProjection"])(conicConformalRaw) - .scale(109.5) - .parallels([30, 30]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/conicEqualArea.js": -/*!**************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/conicEqualArea.js ***! - \**************************************************************/ -/*! exports provided: conicEqualAreaRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conicEqualAreaRaw", function() { return conicEqualAreaRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _conic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./conic */ "./node_modules/d3-geo/src/projection/conic.js"); -/* harmony import */ var _cylindricalEqualArea__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./cylindricalEqualArea */ "./node_modules/d3-geo/src/projection/cylindricalEqualArea.js"); - - - - -function conicEqualAreaRaw(y0, y1) { - var sy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y0), n = (sy0 + Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y1)) / 2; - - // Are the parallels symmetrical around the Equator? - if (Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(n) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) return Object(_cylindricalEqualArea__WEBPACK_IMPORTED_MODULE_2__["cylindricalEqualAreaRaw"])(y0); - - var c = 1 + sy0 * (2 * n - sy0), r0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(c) / n; - - function project(x, y) { - var r = Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(c - 2 * n * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y)) / n; - return [r * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x *= n), r0 - r * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(x)]; - } - - project.invert = function(x, y) { - var r0y = r0 - y; - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(x, Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(r0y)) / n * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sign"])(r0y), Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])((c - (x * x + r0y * r0y) * n * n) / (2 * n))]; - }; - - return project; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_conic__WEBPACK_IMPORTED_MODULE_1__["conicProjection"])(conicEqualAreaRaw) - .scale(155.424) - .center([0, 33.6442]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/conicEquidistant.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/conicEquidistant.js ***! - \****************************************************************/ -/*! exports provided: conicEquidistantRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conicEquidistantRaw", function() { return conicEquidistantRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _conic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./conic */ "./node_modules/d3-geo/src/projection/conic.js"); -/* harmony import */ var _equirectangular__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./equirectangular */ "./node_modules/d3-geo/src/projection/equirectangular.js"); - - - - -function conicEquidistantRaw(y0, y1) { - var cy0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y0), - n = y0 === y1 ? Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y0) : (cy0 - Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y1)) / (y1 - y0), - g = cy0 / n + y0; - - if (Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(n) < _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) return _equirectangular__WEBPACK_IMPORTED_MODULE_2__["equirectangularRaw"]; - - function project(x, y) { - var gy = g - y, nx = n * x; - return [gy * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(nx), g - gy * Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(nx)]; - } - - project.invert = function(x, y) { - var gy = g - y; - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan2"])(x, Object(_math__WEBPACK_IMPORTED_MODULE_0__["abs"])(gy)) / n * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sign"])(gy), g - Object(_math__WEBPACK_IMPORTED_MODULE_0__["sign"])(n) * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sqrt"])(x * x + gy * gy)]; - }; - - return project; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_conic__WEBPACK_IMPORTED_MODULE_1__["conicProjection"])(conicEquidistantRaw) - .scale(131.154) - .center([0, 13.9389]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/cylindricalEqualArea.js": -/*!********************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/cylindricalEqualArea.js ***! - \********************************************************************/ -/*! exports provided: cylindricalEqualAreaRaw */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cylindricalEqualAreaRaw", function() { return cylindricalEqualAreaRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); - - -function cylindricalEqualAreaRaw(phi0) { - var cosPhi0 = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(phi0); - - function forward(lambda, phi) { - return [lambda * cosPhi0, Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(phi) / cosPhi0]; - } - - forward.invert = function(x, y) { - return [x / cosPhi0, Object(_math__WEBPACK_IMPORTED_MODULE_0__["asin"])(y * cosPhi0)]; - }; - - return forward; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/equalEarth.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/equalEarth.js ***! - \**********************************************************/ -/*! exports provided: equalEarthRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equalEarthRaw", function() { return equalEarthRaw; }); -/* harmony import */ var _index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index.js */ "./node_modules/d3-geo/src/projection/index.js"); -/* harmony import */ var _math_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../math.js */ "./node_modules/d3-geo/src/math.js"); - - - -var A1 = 1.340264, - A2 = -0.081106, - A3 = 0.000893, - A4 = 0.003796, - M = Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["sqrt"])(3) / 2, - iterations = 12; - -function equalEarthRaw(lambda, phi) { - var l = Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["asin"])(M * Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi)), l2 = l * l, l6 = l2 * l2 * l2; - return [ - lambda * Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["cos"])(l) / (M * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))), - l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - ]; -} - -equalEarthRaw.invert = function(x, y) { - var l = y, l2 = l * l, l6 = l2 * l2 * l2; - for (var i = 0, delta, fy, fpy; i < iterations; ++i) { - fy = l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - y; - fpy = A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2); - l -= delta = fy / fpy, l2 = l * l, l6 = l2 * l2 * l2; - if (Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["abs"])(delta) < _math_js__WEBPACK_IMPORTED_MODULE_1__["epsilon2"]) break; - } - return [ - M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2)) / Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["cos"])(l), - Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["asin"])(Object(_math_js__WEBPACK_IMPORTED_MODULE_1__["sin"])(l) / M) - ]; -}; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index_js__WEBPACK_IMPORTED_MODULE_0__["default"])(equalEarthRaw) - .scale(177.158); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/equirectangular.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/equirectangular.js ***! - \***************************************************************/ -/*! exports provided: equirectangularRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equirectangularRaw", function() { return equirectangularRaw; }); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - -function equirectangularRaw(lambda, phi) { - return [lambda, phi]; -} - -equirectangularRaw.invert = equirectangularRaw; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_0__["default"])(equirectangularRaw) - .scale(152.63); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/fit.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/fit.js ***! - \***************************************************/ -/*! exports provided: fitExtent, fitSize, fitWidth, fitHeight */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fitExtent", function() { return fitExtent; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fitSize", function() { return fitSize; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fitWidth", function() { return fitWidth; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fitHeight", function() { return fitHeight; }); -/* harmony import */ var _stream__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../stream */ "./node_modules/d3-geo/src/stream.js"); -/* harmony import */ var _path_bounds__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../path/bounds */ "./node_modules/d3-geo/src/path/bounds.js"); - - - -function fit(projection, fitBounds, object) { - var clip = projection.clipExtent && projection.clipExtent(); - projection.scale(150).translate([0, 0]); - if (clip != null) projection.clipExtent(null); - Object(_stream__WEBPACK_IMPORTED_MODULE_0__["default"])(object, projection.stream(_path_bounds__WEBPACK_IMPORTED_MODULE_1__["default"])); - fitBounds(_path_bounds__WEBPACK_IMPORTED_MODULE_1__["default"].result()); - if (clip != null) projection.clipExtent(clip); - return projection; -} - -function fitExtent(projection, extent, object) { - return fit(projection, function(b) { - var w = extent[1][0] - extent[0][0], - h = extent[1][1] - extent[0][1], - k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])), - x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2, - y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2; - projection.scale(150 * k).translate([x, y]); - }, object); -} - -function fitSize(projection, size, object) { - return fitExtent(projection, [[0, 0], size], object); -} - -function fitWidth(projection, width, object) { - return fit(projection, function(b) { - var w = +width, - k = w / (b[1][0] - b[0][0]), - x = (w - k * (b[1][0] + b[0][0])) / 2, - y = -k * b[0][1]; - projection.scale(150 * k).translate([x, y]); - }, object); -} - -function fitHeight(projection, height, object) { - return fit(projection, function(b) { - var h = +height, - k = h / (b[1][1] - b[0][1]), - x = -k * b[0][0], - y = (h - k * (b[1][1] + b[0][1])) / 2; - projection.scale(150 * k).translate([x, y]); - }, object); -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/gnomonic.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/gnomonic.js ***! - \********************************************************/ -/*! exports provided: gnomonicRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "gnomonicRaw", function() { return gnomonicRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - - -function gnomonicRaw(x, y) { - var cy = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y), k = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(x) * cy; - return [cy * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x) / k, Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y) / k]; -} - -gnomonicRaw.invert = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalInvert"])(_math__WEBPACK_IMPORTED_MODULE_0__["atan"]); - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_2__["default"])(gnomonicRaw) - .scale(144.049) - .clipAngle(60); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/identity.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/identity.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _clip_rectangle__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../clip/rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js"); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../identity */ "./node_modules/d3-geo/src/identity.js"); -/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../transform */ "./node_modules/d3-geo/src/transform.js"); -/* harmony import */ var _fit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./fit */ "./node_modules/d3-geo/src/projection/fit.js"); - - - - - -function scaleTranslate(kx, ky, tx, ty) { - return kx === 1 && ky === 1 && tx === 0 && ty === 0 ? _identity__WEBPACK_IMPORTED_MODULE_1__["default"] : Object(_transform__WEBPACK_IMPORTED_MODULE_2__["transformer"])({ - point: function(x, y) { - this.stream.point(x * kx + tx, y * ky + ty); - } - }); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var k = 1, tx = 0, ty = 0, sx = 1, sy = 1, transform = _identity__WEBPACK_IMPORTED_MODULE_1__["default"], // scale, translate and reflect - x0 = null, y0, x1, y1, // clip extent - postclip = _identity__WEBPACK_IMPORTED_MODULE_1__["default"], - cache, - cacheStream, - projection; - - function reset() { - cache = cacheStream = null; - return projection; - } - - return projection = { - stream: function(stream) { - return cache && cacheStream === stream ? cache : cache = transform(postclip(cacheStream = stream)); - }, - postclip: function(_) { - return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip; - }, - clipExtent: function(_) { - return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, _identity__WEBPACK_IMPORTED_MODULE_1__["default"]) : Object(_clip_rectangle__WEBPACK_IMPORTED_MODULE_0__["default"])(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]]; - }, - scale: function(_) { - return arguments.length ? (transform = scaleTranslate((k = +_) * sx, k * sy, tx, ty), reset()) : k; - }, - translate: function(_) { - return arguments.length ? (transform = scaleTranslate(k * sx, k * sy, tx = +_[0], ty = +_[1]), reset()) : [tx, ty]; - }, - reflectX: function(_) { - return arguments.length ? (transform = scaleTranslate(k * (sx = _ ? -1 : 1), k * sy, tx, ty), reset()) : sx < 0; - }, - reflectY: function(_) { - return arguments.length ? (transform = scaleTranslate(k * sx, k * (sy = _ ? -1 : 1), tx, ty), reset()) : sy < 0; - }, - fitExtent: function(extent, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitExtent"])(projection, extent, object); - }, - fitSize: function(size, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitSize"])(projection, size, object); - }, - fitWidth: function(width, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitWidth"])(projection, width, object); - }, - fitHeight: function(height, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_3__["fitHeight"])(projection, height, object); - } - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/index.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/index.js ***! - \*****************************************************/ -/*! exports provided: default, projectionMutator */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return projection; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "projectionMutator", function() { return projectionMutator; }); -/* harmony import */ var _clip_antimeridian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../clip/antimeridian */ "./node_modules/d3-geo/src/clip/antimeridian.js"); -/* harmony import */ var _clip_circle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../clip/circle */ "./node_modules/d3-geo/src/clip/circle.js"); -/* harmony import */ var _clip_rectangle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../clip/rectangle */ "./node_modules/d3-geo/src/clip/rectangle.js"); -/* harmony import */ var _compose__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../compose */ "./node_modules/d3-geo/src/compose.js"); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../identity */ "./node_modules/d3-geo/src/identity.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../rotation */ "./node_modules/d3-geo/src/rotation.js"); -/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../transform */ "./node_modules/d3-geo/src/transform.js"); -/* harmony import */ var _fit__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./fit */ "./node_modules/d3-geo/src/projection/fit.js"); -/* harmony import */ var _resample__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./resample */ "./node_modules/d3-geo/src/projection/resample.js"); - - - - - - - - - - - -var transformRadians = Object(_transform__WEBPACK_IMPORTED_MODULE_7__["transformer"])({ - point: function(x, y) { - this.stream.point(x * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], y * _math__WEBPACK_IMPORTED_MODULE_5__["radians"]); - } -}); - -function transformRotate(rotate) { - return Object(_transform__WEBPACK_IMPORTED_MODULE_7__["transformer"])({ - point: function(x, y) { - var r = rotate(x, y); - return this.stream.point(r[0], r[1]); - } - }); -} - -function scaleTranslate(k, dx, dy) { - function transform(x, y) { - return [dx + k * x, dy - k * y]; - } - transform.invert = function(x, y) { - return [(x - dx) / k, (dy - y) / k]; - }; - return transform; -} - -function scaleTranslateRotate(k, dx, dy, alpha) { - var cosAlpha = Object(_math__WEBPACK_IMPORTED_MODULE_5__["cos"])(alpha), - sinAlpha = Object(_math__WEBPACK_IMPORTED_MODULE_5__["sin"])(alpha), - a = cosAlpha * k, - b = sinAlpha * k, - ai = cosAlpha / k, - bi = sinAlpha / k, - ci = (sinAlpha * dy - cosAlpha * dx) / k, - fi = (sinAlpha * dx + cosAlpha * dy) / k; - function transform(x, y) { - return [a * x - b * y + dx, dy - b * x - a * y]; - } - transform.invert = function(x, y) { - return [ai * x - bi * y + ci, fi - bi * x - ai * y]; - }; - return transform; -} - -function projection(project) { - return projectionMutator(function() { return project; })(); -} - -function projectionMutator(projectAt) { - var project, - k = 150, // scale - x = 480, y = 250, // translate - lambda = 0, phi = 0, // center - deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, // pre-rotate - alpha = 0, // post-rotate - theta = null, preclip = _clip_antimeridian__WEBPACK_IMPORTED_MODULE_0__["default"], // pre-clip angle - x0 = null, y0, x1, y1, postclip = _identity__WEBPACK_IMPORTED_MODULE_4__["default"], // post-clip extent - delta2 = 0.5, // precision - projectResample, - projectTransform, - projectRotateTransform, - cache, - cacheStream; - - function projection(point) { - return projectRotateTransform(point[0] * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], point[1] * _math__WEBPACK_IMPORTED_MODULE_5__["radians"]); - } - - function invert(point) { - point = projectRotateTransform.invert(point[0], point[1]); - return point && [point[0] * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"], point[1] * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"]]; - } - - projection.stream = function(stream) { - return cache && cacheStream === stream ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream))))); - }; - - projection.preclip = function(_) { - return arguments.length ? (preclip = _, theta = undefined, reset()) : preclip; - }; - - projection.postclip = function(_) { - return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip; - }; - - projection.clipAngle = function(_) { - return arguments.length ? (preclip = +_ ? Object(_clip_circle__WEBPACK_IMPORTED_MODULE_1__["default"])(theta = _ * _math__WEBPACK_IMPORTED_MODULE_5__["radians"]) : (theta = null, _clip_antimeridian__WEBPACK_IMPORTED_MODULE_0__["default"]), reset()) : theta * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"]; - }; - - projection.clipExtent = function(_) { - return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, _identity__WEBPACK_IMPORTED_MODULE_4__["default"]) : Object(_clip_rectangle__WEBPACK_IMPORTED_MODULE_2__["default"])(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]]; - }; - - projection.scale = function(_) { - return arguments.length ? (k = +_, recenter()) : k; - }; - - projection.translate = function(_) { - return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y]; - }; - - projection.center = function(_) { - return arguments.length ? (lambda = _[0] % 360 * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], phi = _[1] % 360 * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], recenter()) : [lambda * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"], phi * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"]]; - }; - - projection.rotate = function(_) { - return arguments.length ? (deltaLambda = _[0] % 360 * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], deltaPhi = _[1] % 360 * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], deltaGamma = _.length > 2 ? _[2] % 360 * _math__WEBPACK_IMPORTED_MODULE_5__["radians"] : 0, recenter()) : [deltaLambda * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"], deltaPhi * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"], deltaGamma * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"]]; - }; - - projection.angle = function(_) { - return arguments.length ? (alpha = _ % 360 * _math__WEBPACK_IMPORTED_MODULE_5__["radians"], recenter()) : alpha * _math__WEBPACK_IMPORTED_MODULE_5__["degrees"]; - }; - - projection.precision = function(_) { - return arguments.length ? (projectResample = Object(_resample__WEBPACK_IMPORTED_MODULE_9__["default"])(projectTransform, delta2 = _ * _), reset()) : Object(_math__WEBPACK_IMPORTED_MODULE_5__["sqrt"])(delta2); - }; - - projection.fitExtent = function(extent, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_8__["fitExtent"])(projection, extent, object); - }; - - projection.fitSize = function(size, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_8__["fitSize"])(projection, size, object); - }; - - projection.fitWidth = function(width, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_8__["fitWidth"])(projection, width, object); - }; - - projection.fitHeight = function(height, object) { - return Object(_fit__WEBPACK_IMPORTED_MODULE_8__["fitHeight"])(projection, height, object); - }; - - function recenter() { - var center = scaleTranslateRotate(k, 0, 0, alpha).apply(null, project(lambda, phi)), - transform = (alpha ? scaleTranslateRotate : scaleTranslate)(k, x - center[0], y - center[1], alpha); - rotate = Object(_rotation__WEBPACK_IMPORTED_MODULE_6__["rotateRadians"])(deltaLambda, deltaPhi, deltaGamma); - projectTransform = Object(_compose__WEBPACK_IMPORTED_MODULE_3__["default"])(project, transform); - projectRotateTransform = Object(_compose__WEBPACK_IMPORTED_MODULE_3__["default"])(rotate, projectTransform); - projectResample = Object(_resample__WEBPACK_IMPORTED_MODULE_9__["default"])(projectTransform, delta2); - return reset(); - } - - function reset() { - cache = cacheStream = null; - return projection; - } - - return function() { - project = projectAt.apply(this, arguments); - projection.invert = project.invert && invert; - return recenter(); - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/mercator.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/mercator.js ***! - \********************************************************/ -/*! exports provided: mercatorRaw, default, mercatorProjection */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mercatorRaw", function() { return mercatorRaw; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mercatorProjection", function() { return mercatorProjection; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _rotation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../rotation */ "./node_modules/d3-geo/src/rotation.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - - -function mercatorRaw(lambda, phi) { - return [lambda, Object(_math__WEBPACK_IMPORTED_MODULE_0__["log"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["tan"])((_math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] + phi) / 2))]; -} - -mercatorRaw.invert = function(x, y) { - return [x, 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["exp"])(y)) - _math__WEBPACK_IMPORTED_MODULE_0__["halfPi"]]; -}; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return mercatorProjection(mercatorRaw) - .scale(961 / _math__WEBPACK_IMPORTED_MODULE_0__["tau"]); -}); - -function mercatorProjection(project) { - var m = Object(_index__WEBPACK_IMPORTED_MODULE_2__["default"])(project), - center = m.center, - scale = m.scale, - translate = m.translate, - clipExtent = m.clipExtent, - x0 = null, y0, x1, y1; // clip extent - - m.scale = function(_) { - return arguments.length ? (scale(_), reclip()) : scale(); - }; - - m.translate = function(_) { - return arguments.length ? (translate(_), reclip()) : translate(); - }; - - m.center = function(_) { - return arguments.length ? (center(_), reclip()) : center(); - }; - - m.clipExtent = function(_) { - return arguments.length ? ((_ == null ? x0 = y0 = x1 = y1 = null : (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1])), reclip()) : x0 == null ? null : [[x0, y0], [x1, y1]]; - }; - - function reclip() { - var k = _math__WEBPACK_IMPORTED_MODULE_0__["pi"] * scale(), - t = m(Object(_rotation__WEBPACK_IMPORTED_MODULE_1__["default"])(m.rotate()).invert([0, 0])); - return clipExtent(x0 == null - ? [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]] : project === mercatorRaw - ? [[Math.max(t[0] - k, x0), y0], [Math.min(t[0] + k, x1), y1]] - : [[x0, Math.max(t[1] - k, y0)], [x1, Math.min(t[1] + k, y1)]]); - } - - return reclip(); -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/naturalEarth1.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/naturalEarth1.js ***! - \*************************************************************/ -/*! exports provided: naturalEarth1Raw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "naturalEarth1Raw", function() { return naturalEarth1Raw; }); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); - - - -function naturalEarth1Raw(lambda, phi) { - var phi2 = phi * phi, phi4 = phi2 * phi2; - return [ - lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (0.003971 * phi2 - 0.001529 * phi4))), - phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - ]; -} - -naturalEarth1Raw.invert = function(x, y) { - var phi = y, i = 25, delta; - do { - var phi2 = phi * phi, phi4 = phi2 * phi2; - phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - y) / - (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 0.005916 * 11 * phi4))); - } while (Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(delta) > _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"] && --i > 0); - return [ - x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (0.003971 - 0.001529 * phi2)))), - phi - ]; -}; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_0__["default"])(naturalEarth1Raw) - .scale(175.295); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/orthographic.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/orthographic.js ***! - \************************************************************/ -/*! exports provided: orthographicRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "orthographicRaw", function() { return orthographicRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - - -function orthographicRaw(x, y) { - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y) * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x), Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y)]; -} - -orthographicRaw.invert = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalInvert"])(_math__WEBPACK_IMPORTED_MODULE_0__["asin"]); - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_2__["default"])(orthographicRaw) - .scale(249.5) - .clipAngle(90 + _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/resample.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/resample.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _cartesian__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../cartesian */ "./node_modules/d3-geo/src/cartesian.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../transform */ "./node_modules/d3-geo/src/transform.js"); - - - - -var maxDepth = 16, // maximum depth of subdivision - cosMinDistance = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(30 * _math__WEBPACK_IMPORTED_MODULE_1__["radians"]); // cos(minimum angular distance) - -/* harmony default export */ __webpack_exports__["default"] = (function(project, delta2) { - return +delta2 ? resample(project, delta2) : resampleNone(project); -}); - -function resampleNone(project) { - return Object(_transform__WEBPACK_IMPORTED_MODULE_2__["transformer"])({ - point: function(x, y) { - x = project(x, y); - this.stream.point(x[0], x[1]); - } - }); -} - -function resample(project, delta2) { - - function resampleLineTo(x0, y0, lambda0, a0, b0, c0, x1, y1, lambda1, a1, b1, c1, depth, stream) { - var dx = x1 - x0, - dy = y1 - y0, - d2 = dx * dx + dy * dy; - if (d2 > 4 * delta2 && depth--) { - var a = a0 + a1, - b = b0 + b1, - c = c0 + c1, - m = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sqrt"])(a * a + b * b + c * c), - phi2 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["asin"])(c /= m), - lambda2 = Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(c) - 1) < _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"] || Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(lambda0 - lambda1) < _math__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? (lambda0 + lambda1) / 2 : Object(_math__WEBPACK_IMPORTED_MODULE_1__["atan2"])(b, a), - p = project(lambda2, phi2), - x2 = p[0], - y2 = p[1], - dx2 = x2 - x0, - dy2 = y2 - y0, - dz = dy * dx2 - dx * dy2; - if (dz * dz / d2 > delta2 // perpendicular projected distance - || Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 // midpoint close to an end - || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) { // angular distance - resampleLineTo(x0, y0, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream); - stream.point(x2, y2); - resampleLineTo(x2, y2, lambda2, a, b, c, x1, y1, lambda1, a1, b1, c1, depth, stream); - } - } - } - return function(stream) { - var lambda00, x00, y00, a00, b00, c00, // first point - lambda0, x0, y0, a0, b0, c0; // previous point - - var resampleStream = { - point: point, - lineStart: lineStart, - lineEnd: lineEnd, - polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; }, - polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; } - }; - - function point(x, y) { - x = project(x, y); - stream.point(x[0], x[1]); - } - - function lineStart() { - x0 = NaN; - resampleStream.point = linePoint; - stream.lineStart(); - } - - function linePoint(lambda, phi) { - var c = Object(_cartesian__WEBPACK_IMPORTED_MODULE_0__["cartesian"])([lambda, phi]), p = project(lambda, phi); - resampleLineTo(x0, y0, lambda0, a0, b0, c0, x0 = p[0], y0 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream); - stream.point(x0, y0); - } - - function lineEnd() { - resampleStream.point = point; - stream.lineEnd(); - } - - function ringStart() { - lineStart(); - resampleStream.point = ringPoint; - resampleStream.lineEnd = ringEnd; - } - - function ringPoint(lambda, phi) { - linePoint(lambda00 = lambda, phi), x00 = x0, y00 = y0, a00 = a0, b00 = b0, c00 = c0; - resampleStream.point = linePoint; - } - - function ringEnd() { - resampleLineTo(x0, y0, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream); - resampleStream.lineEnd = lineEnd; - lineEnd(); - } - - return resampleStream; - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/stereographic.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/stereographic.js ***! - \*************************************************************/ -/*! exports provided: stereographicRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stereographicRaw", function() { return stereographicRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _azimuthal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./azimuthal */ "./node_modules/d3-geo/src/projection/azimuthal.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./index */ "./node_modules/d3-geo/src/projection/index.js"); - - - - -function stereographicRaw(x, y) { - var cy = Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(y), k = 1 + Object(_math__WEBPACK_IMPORTED_MODULE_0__["cos"])(x) * cy; - return [cy * Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(x) / k, Object(_math__WEBPACK_IMPORTED_MODULE_0__["sin"])(y) / k]; -} - -stereographicRaw.invert = Object(_azimuthal__WEBPACK_IMPORTED_MODULE_1__["azimuthalInvert"])(function(z) { - return 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan"])(z); -}); - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_index__WEBPACK_IMPORTED_MODULE_2__["default"])(stereographicRaw) - .scale(250) - .clipAngle(142); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/projection/transverseMercator.js": -/*!******************************************************************!*\ - !*** ./node_modules/d3-geo/src/projection/transverseMercator.js ***! - \******************************************************************/ -/*! exports provided: transverseMercatorRaw, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transverseMercatorRaw", function() { return transverseMercatorRaw; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-geo/src/math.js"); -/* harmony import */ var _mercator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./mercator */ "./node_modules/d3-geo/src/projection/mercator.js"); - - - -function transverseMercatorRaw(lambda, phi) { - return [Object(_math__WEBPACK_IMPORTED_MODULE_0__["log"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["tan"])((_math__WEBPACK_IMPORTED_MODULE_0__["halfPi"] + phi) / 2)), -lambda]; -} - -transverseMercatorRaw.invert = function(x, y) { - return [-y, 2 * Object(_math__WEBPACK_IMPORTED_MODULE_0__["atan"])(Object(_math__WEBPACK_IMPORTED_MODULE_0__["exp"])(x)) - _math__WEBPACK_IMPORTED_MODULE_0__["halfPi"]]; -}; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var m = Object(_mercator__WEBPACK_IMPORTED_MODULE_1__["mercatorProjection"])(transverseMercatorRaw), - center = m.center, - rotate = m.rotate; - - m.center = function(_) { - return arguments.length ? center([-_[1], _[0]]) : (_ = center(), [_[1], -_[0]]); - }; - - m.rotate = function(_) { - return arguments.length ? rotate([_[0], _[1], _.length > 2 ? _[2] + 90 : 90]) : (_ = rotate(), [_[0], _[1], _[2] - 90]); - }; - - return rotate([0, 0, 90]) - .scale(159.155); -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/rotation.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-geo/src/rotation.js ***! - \*********************************************/ -/*! exports provided: rotateRadians, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateRadians", function() { return rotateRadians; }); -/* harmony import */ var _compose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./compose */ "./node_modules/d3-geo/src/compose.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./math */ "./node_modules/d3-geo/src/math.js"); - - - -function rotationIdentity(lambda, phi) { - return [Object(_math__WEBPACK_IMPORTED_MODULE_1__["abs"])(lambda) > _math__WEBPACK_IMPORTED_MODULE_1__["pi"] ? lambda + Math.round(-lambda / _math__WEBPACK_IMPORTED_MODULE_1__["tau"]) * _math__WEBPACK_IMPORTED_MODULE_1__["tau"] : lambda, phi]; -} - -rotationIdentity.invert = rotationIdentity; - -function rotateRadians(deltaLambda, deltaPhi, deltaGamma) { - return (deltaLambda %= _math__WEBPACK_IMPORTED_MODULE_1__["tau"]) ? (deltaPhi || deltaGamma ? Object(_compose__WEBPACK_IMPORTED_MODULE_0__["default"])(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) - : rotationLambda(deltaLambda)) - : (deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) - : rotationIdentity); -} - -function forwardRotationLambda(deltaLambda) { - return function(lambda, phi) { - return lambda += deltaLambda, [lambda > _math__WEBPACK_IMPORTED_MODULE_1__["pi"] ? lambda - _math__WEBPACK_IMPORTED_MODULE_1__["tau"] : lambda < -_math__WEBPACK_IMPORTED_MODULE_1__["pi"] ? lambda + _math__WEBPACK_IMPORTED_MODULE_1__["tau"] : lambda, phi]; - }; -} - -function rotationLambda(deltaLambda) { - var rotation = forwardRotationLambda(deltaLambda); - rotation.invert = forwardRotationLambda(-deltaLambda); - return rotation; -} - -function rotationPhiGamma(deltaPhi, deltaGamma) { - var cosDeltaPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(deltaPhi), - sinDeltaPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(deltaPhi), - cosDeltaGamma = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(deltaGamma), - sinDeltaGamma = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(deltaGamma); - - function rotation(lambda, phi) { - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi), - x = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(lambda) * cosPhi, - y = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(lambda) * cosPhi, - z = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi), - k = z * cosDeltaPhi + x * sinDeltaPhi; - return [ - Object(_math__WEBPACK_IMPORTED_MODULE_1__["atan2"])(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi), - Object(_math__WEBPACK_IMPORTED_MODULE_1__["asin"])(k * cosDeltaGamma + y * sinDeltaGamma) - ]; - } - - rotation.invert = function(lambda, phi) { - var cosPhi = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(phi), - x = Object(_math__WEBPACK_IMPORTED_MODULE_1__["cos"])(lambda) * cosPhi, - y = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(lambda) * cosPhi, - z = Object(_math__WEBPACK_IMPORTED_MODULE_1__["sin"])(phi), - k = z * cosDeltaGamma - y * sinDeltaGamma; - return [ - Object(_math__WEBPACK_IMPORTED_MODULE_1__["atan2"])(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi), - Object(_math__WEBPACK_IMPORTED_MODULE_1__["asin"])(k * cosDeltaPhi - x * sinDeltaPhi) - ]; - }; - - return rotation; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(rotate) { - rotate = rotateRadians(rotate[0] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"], rotate[1] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"], rotate.length > 2 ? rotate[2] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"] : 0); - - function forward(coordinates) { - coordinates = rotate(coordinates[0] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"], coordinates[1] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"]); - return coordinates[0] *= _math__WEBPACK_IMPORTED_MODULE_1__["degrees"], coordinates[1] *= _math__WEBPACK_IMPORTED_MODULE_1__["degrees"], coordinates; - } - - forward.invert = function(coordinates) { - coordinates = rotate.invert(coordinates[0] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"], coordinates[1] * _math__WEBPACK_IMPORTED_MODULE_1__["radians"]); - return coordinates[0] *= _math__WEBPACK_IMPORTED_MODULE_1__["degrees"], coordinates[1] *= _math__WEBPACK_IMPORTED_MODULE_1__["degrees"], coordinates; - }; - - return forward; -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/stream.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-geo/src/stream.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function streamGeometry(geometry, stream) { - if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) { - streamGeometryType[geometry.type](geometry, stream); - } -} - -var streamObjectType = { - Feature: function(object, stream) { - streamGeometry(object.geometry, stream); - }, - FeatureCollection: function(object, stream) { - var features = object.features, i = -1, n = features.length; - while (++i < n) streamGeometry(features[i].geometry, stream); - } -}; - -var streamGeometryType = { - Sphere: function(object, stream) { - stream.sphere(); - }, - Point: function(object, stream) { - object = object.coordinates; - stream.point(object[0], object[1], object[2]); - }, - MultiPoint: function(object, stream) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]); - }, - LineString: function(object, stream) { - streamLine(object.coordinates, stream, 0); - }, - MultiLineString: function(object, stream) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) streamLine(coordinates[i], stream, 0); - }, - Polygon: function(object, stream) { - streamPolygon(object.coordinates, stream); - }, - MultiPolygon: function(object, stream) { - var coordinates = object.coordinates, i = -1, n = coordinates.length; - while (++i < n) streamPolygon(coordinates[i], stream); - }, - GeometryCollection: function(object, stream) { - var geometries = object.geometries, i = -1, n = geometries.length; - while (++i < n) streamGeometry(geometries[i], stream); - } -}; - -function streamLine(coordinates, stream, closed) { - var i = -1, n = coordinates.length - closed, coordinate; - stream.lineStart(); - while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]); - stream.lineEnd(); -} - -function streamPolygon(coordinates, stream) { - var i = -1, n = coordinates.length; - stream.polygonStart(); - while (++i < n) streamLine(coordinates[i], stream, 1); - stream.polygonEnd(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(object, stream) { - if (object && streamObjectType.hasOwnProperty(object.type)) { - streamObjectType[object.type](object, stream); - } else { - streamGeometry(object, stream); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-geo/src/transform.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-geo/src/transform.js ***! - \**********************************************/ -/*! exports provided: default, transformer */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformer", function() { return transformer; }); -/* harmony default export */ __webpack_exports__["default"] = (function(methods) { - return { - stream: transformer(methods) - }; -}); - -function transformer(methods) { - return function(stream) { - var s = new TransformStream; - for (var key in methods) s[key] = methods[key]; - s.stream = stream; - return s; - }; -} - -function TransformStream() {} - -TransformStream.prototype = { - constructor: TransformStream, - point: function(x, y) { this.stream.point(x, y); }, - sphere: function() { this.stream.sphere(); }, - lineStart: function() { this.stream.lineStart(); }, - lineEnd: function() { this.stream.lineEnd(); }, - polygonStart: function() { this.stream.polygonStart(); }, - polygonEnd: function() { this.stream.polygonEnd(); } -}; - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/accessors.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/accessors.js ***! - \****************************************************/ -/*! exports provided: optional, required */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "optional", function() { return optional; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "required", function() { return required; }); -function optional(f) { - return f == null ? null : required(f); -} - -function required(f) { - if (typeof f !== "function") throw new Error; - return f; -} - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/array.js": -/*!************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/array.js ***! - \************************************************/ -/*! exports provided: slice, shuffle */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "shuffle", function() { return shuffle; }); -var slice = Array.prototype.slice; - -function shuffle(array) { - var m = array.length, - t, - i; - - while (m) { - i = Math.random() * m-- | 0; - t = array[m]; - array[m] = array[i]; - array[i] = t; - } - - return array; -} - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/cluster.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/cluster.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function defaultSeparation(a, b) { - return a.parent === b.parent ? 1 : 2; -} - -function meanX(children) { - return children.reduce(meanXReduce, 0) / children.length; -} - -function meanXReduce(x, c) { - return x + c.x; -} - -function maxY(children) { - return 1 + children.reduce(maxYReduce, 0); -} - -function maxYReduce(y, c) { - return Math.max(y, c.y); -} - -function leafLeft(node) { - var children; - while (children = node.children) node = children[0]; - return node; -} - -function leafRight(node) { - var children; - while (children = node.children) node = children[children.length - 1]; - return node; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var separation = defaultSeparation, - dx = 1, - dy = 1, - nodeSize = false; - - function cluster(root) { - var previousNode, - x = 0; - - // First walk, computing the initial x & y values. - root.eachAfter(function(node) { - var children = node.children; - if (children) { - node.x = meanX(children); - node.y = maxY(children); - } else { - node.x = previousNode ? x += separation(node, previousNode) : 0; - node.y = 0; - previousNode = node; - } - }); - - var left = leafLeft(root), - right = leafRight(root), - x0 = left.x - separation(left, right) / 2, - x1 = right.x + separation(right, left) / 2; - - // Second walk, normalizing x & y to the desired size. - return root.eachAfter(nodeSize ? function(node) { - node.x = (node.x - root.x) * dx; - node.y = (root.y - node.y) * dy; - } : function(node) { - node.x = (node.x - x0) / (x1 - x0) * dx; - node.y = (1 - (root.y ? node.y / root.y : 1)) * dy; - }); - } - - cluster.separation = function(x) { - return arguments.length ? (separation = x, cluster) : separation; - }; - - cluster.size = function(x) { - return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? null : [dx, dy]); - }; - - cluster.nodeSize = function(x) { - return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], cluster) : (nodeSize ? [dx, dy] : null); - }; - - return cluster; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/constant.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/constant.js ***! - \***************************************************/ -/*! exports provided: constantZero, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "constantZero", function() { return constantZero; }); -function constantZero() { - return 0; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/ancestors.js": -/*!**************************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/ancestors.js ***! - \**************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var node = this, nodes = [node]; - while (node = node.parent) { - nodes.push(node); - } - return nodes; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/count.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/count.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function count(node) { - var sum = 0, - children = node.children, - i = children && children.length; - if (!i) sum = 1; - else while (--i >= 0) sum += children[i].value; - node.value = sum; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return this.eachAfter(count); -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/descendants.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/descendants.js ***! - \****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var nodes = []; - this.each(function(node) { - nodes.push(node); - }); - return nodes; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/each.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/each.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(callback) { - var node = this, current, next = [node], children, i, n; - do { - current = next.reverse(), next = []; - while (node = current.pop()) { - callback(node), children = node.children; - if (children) for (i = 0, n = children.length; i < n; ++i) { - next.push(children[i]); - } - } - } while (next.length); - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/eachAfter.js": -/*!**************************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/eachAfter.js ***! - \**************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(callback) { - var node = this, nodes = [node], next = [], children, i, n; - while (node = nodes.pop()) { - next.push(node), children = node.children; - if (children) for (i = 0, n = children.length; i < n; ++i) { - nodes.push(children[i]); - } - } - while (node = next.pop()) { - callback(node); - } - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/eachBefore.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/eachBefore.js ***! - \***************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(callback) { - var node = this, nodes = [node], children, i; - while (node = nodes.pop()) { - callback(node), children = node.children; - if (children) for (i = children.length - 1; i >= 0; --i) { - nodes.push(children[i]); - } - } - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/index.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/index.js ***! - \**********************************************************/ -/*! exports provided: default, computeHeight, Node */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return hierarchy; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeHeight", function() { return computeHeight; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Node", function() { return Node; }); -/* harmony import */ var _count__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./count */ "./node_modules/d3-hierarchy/src/hierarchy/count.js"); -/* harmony import */ var _each__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./each */ "./node_modules/d3-hierarchy/src/hierarchy/each.js"); -/* harmony import */ var _eachBefore__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./eachBefore */ "./node_modules/d3-hierarchy/src/hierarchy/eachBefore.js"); -/* harmony import */ var _eachAfter__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./eachAfter */ "./node_modules/d3-hierarchy/src/hierarchy/eachAfter.js"); -/* harmony import */ var _sum__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./sum */ "./node_modules/d3-hierarchy/src/hierarchy/sum.js"); -/* harmony import */ var _sort__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./sort */ "./node_modules/d3-hierarchy/src/hierarchy/sort.js"); -/* harmony import */ var _path__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./path */ "./node_modules/d3-hierarchy/src/hierarchy/path.js"); -/* harmony import */ var _ancestors__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./ancestors */ "./node_modules/d3-hierarchy/src/hierarchy/ancestors.js"); -/* harmony import */ var _descendants__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./descendants */ "./node_modules/d3-hierarchy/src/hierarchy/descendants.js"); -/* harmony import */ var _leaves__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./leaves */ "./node_modules/d3-hierarchy/src/hierarchy/leaves.js"); -/* harmony import */ var _links__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./links */ "./node_modules/d3-hierarchy/src/hierarchy/links.js"); - - - - - - - - - - - - -function hierarchy(data, children) { - var root = new Node(data), - valued = +data.value && (root.value = data.value), - node, - nodes = [root], - child, - childs, - i, - n; - - if (children == null) children = defaultChildren; - - while (node = nodes.pop()) { - if (valued) node.value = +node.data.value; - if ((childs = children(node.data)) && (n = childs.length)) { - node.children = new Array(n); - for (i = n - 1; i >= 0; --i) { - nodes.push(child = node.children[i] = new Node(childs[i])); - child.parent = node; - child.depth = node.depth + 1; - } - } - } - - return root.eachBefore(computeHeight); -} - -function node_copy() { - return hierarchy(this).eachBefore(copyData); -} - -function defaultChildren(d) { - return d.children; -} - -function copyData(node) { - node.data = node.data.data; -} - -function computeHeight(node) { - var height = 0; - do node.height = height; - while ((node = node.parent) && (node.height < ++height)); -} - -function Node(data) { - this.data = data; - this.depth = - this.height = 0; - this.parent = null; -} - -Node.prototype = hierarchy.prototype = { - constructor: Node, - count: _count__WEBPACK_IMPORTED_MODULE_0__["default"], - each: _each__WEBPACK_IMPORTED_MODULE_1__["default"], - eachAfter: _eachAfter__WEBPACK_IMPORTED_MODULE_3__["default"], - eachBefore: _eachBefore__WEBPACK_IMPORTED_MODULE_2__["default"], - sum: _sum__WEBPACK_IMPORTED_MODULE_4__["default"], - sort: _sort__WEBPACK_IMPORTED_MODULE_5__["default"], - path: _path__WEBPACK_IMPORTED_MODULE_6__["default"], - ancestors: _ancestors__WEBPACK_IMPORTED_MODULE_7__["default"], - descendants: _descendants__WEBPACK_IMPORTED_MODULE_8__["default"], - leaves: _leaves__WEBPACK_IMPORTED_MODULE_9__["default"], - links: _links__WEBPACK_IMPORTED_MODULE_10__["default"], - copy: node_copy -}; - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/leaves.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/leaves.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var leaves = []; - this.eachBefore(function(node) { - if (!node.children) { - leaves.push(node); - } - }); - return leaves; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/links.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/links.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var root = this, links = []; - root.each(function(node) { - if (node !== root) { // Don’t include the root’s parent, if any. - links.push({source: node.parent, target: node}); - } - }); - return links; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/path.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/path.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(end) { - var start = this, - ancestor = leastCommonAncestor(start, end), - nodes = [start]; - while (start !== ancestor) { - start = start.parent; - nodes.push(start); - } - var k = nodes.length; - while (end !== ancestor) { - nodes.splice(k, 0, end); - end = end.parent; - } - return nodes; -}); - -function leastCommonAncestor(a, b) { - if (a === b) return a; - var aNodes = a.ancestors(), - bNodes = b.ancestors(), - c = null; - a = aNodes.pop(); - b = bNodes.pop(); - while (a === b) { - c = a; - a = aNodes.pop(); - b = bNodes.pop(); - } - return c; -} - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/sort.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/sort.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(compare) { - return this.eachBefore(function(node) { - if (node.children) { - node.children.sort(compare); - } - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/hierarchy/sum.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/hierarchy/sum.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - return this.eachAfter(function(node) { - var sum = +value(node.data) || 0, - children = node.children, - i = children && children.length; - while (--i >= 0) sum += children[i].value; - node.value = sum; - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/index.js": -/*!************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/index.js ***! - \************************************************/ -/*! exports provided: cluster, hierarchy, pack, packSiblings, packEnclose, partition, stratify, tree, treemap, treemapBinary, treemapDice, treemapSlice, treemapSliceDice, treemapSquarify, treemapResquarify */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _cluster__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cluster */ "./node_modules/d3-hierarchy/src/cluster.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cluster", function() { return _cluster__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hierarchy/index */ "./node_modules/d3-hierarchy/src/hierarchy/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hierarchy", function() { return _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _pack_index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./pack/index */ "./node_modules/d3-hierarchy/src/pack/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pack", function() { return _pack_index__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _pack_siblings__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./pack/siblings */ "./node_modules/d3-hierarchy/src/pack/siblings.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "packSiblings", function() { return _pack_siblings__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _pack_enclose__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./pack/enclose */ "./node_modules/d3-hierarchy/src/pack/enclose.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "packEnclose", function() { return _pack_enclose__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _partition__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./partition */ "./node_modules/d3-hierarchy/src/partition.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "partition", function() { return _partition__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _stratify__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./stratify */ "./node_modules/d3-hierarchy/src/stratify.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stratify", function() { return _stratify__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _tree__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./tree */ "./node_modules/d3-hierarchy/src/tree.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tree", function() { return _tree__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _treemap_index__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./treemap/index */ "./node_modules/d3-hierarchy/src/treemap/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemap", function() { return _treemap_index__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _treemap_binary__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./treemap/binary */ "./node_modules/d3-hierarchy/src/treemap/binary.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapBinary", function() { return _treemap_binary__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _treemap_dice__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./treemap/dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapDice", function() { return _treemap_dice__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony import */ var _treemap_slice__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./treemap/slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSlice", function() { return _treemap_slice__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony import */ var _treemap_sliceDice__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./treemap/sliceDice */ "./node_modules/d3-hierarchy/src/treemap/sliceDice.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSliceDice", function() { return _treemap_sliceDice__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony import */ var _treemap_squarify__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./treemap/squarify */ "./node_modules/d3-hierarchy/src/treemap/squarify.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSquarify", function() { return _treemap_squarify__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony import */ var _treemap_resquarify__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./treemap/resquarify */ "./node_modules/d3-hierarchy/src/treemap/resquarify.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapResquarify", function() { return _treemap_resquarify__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/pack/enclose.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/pack/enclose.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../array */ "./node_modules/d3-hierarchy/src/array.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(circles) { - var i = 0, n = (circles = Object(_array__WEBPACK_IMPORTED_MODULE_0__["shuffle"])(_array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(circles))).length, B = [], p, e; - - while (i < n) { - p = circles[i]; - if (e && enclosesWeak(e, p)) ++i; - else e = encloseBasis(B = extendBasis(B, p)), i = 0; - } - - return e; -}); - -function extendBasis(B, p) { - var i, j; - - if (enclosesWeakAll(p, B)) return [p]; - - // If we get here then B must have at least one element. - for (i = 0; i < B.length; ++i) { - if (enclosesNot(p, B[i]) - && enclosesWeakAll(encloseBasis2(B[i], p), B)) { - return [B[i], p]; - } - } - - // If we get here then B must have at least two elements. - for (i = 0; i < B.length - 1; ++i) { - for (j = i + 1; j < B.length; ++j) { - if (enclosesNot(encloseBasis2(B[i], B[j]), p) - && enclosesNot(encloseBasis2(B[i], p), B[j]) - && enclosesNot(encloseBasis2(B[j], p), B[i]) - && enclosesWeakAll(encloseBasis3(B[i], B[j], p), B)) { - return [B[i], B[j], p]; - } - } - } - - // If we get here then something is very wrong. - throw new Error; -} - -function enclosesNot(a, b) { - var dr = a.r - b.r, dx = b.x - a.x, dy = b.y - a.y; - return dr < 0 || dr * dr < dx * dx + dy * dy; -} - -function enclosesWeak(a, b) { - var dr = a.r - b.r + 1e-6, dx = b.x - a.x, dy = b.y - a.y; - return dr > 0 && dr * dr > dx * dx + dy * dy; -} - -function enclosesWeakAll(a, B) { - for (var i = 0; i < B.length; ++i) { - if (!enclosesWeak(a, B[i])) { - return false; - } - } - return true; -} - -function encloseBasis(B) { - switch (B.length) { - case 1: return encloseBasis1(B[0]); - case 2: return encloseBasis2(B[0], B[1]); - case 3: return encloseBasis3(B[0], B[1], B[2]); - } -} - -function encloseBasis1(a) { - return { - x: a.x, - y: a.y, - r: a.r - }; -} - -function encloseBasis2(a, b) { - var x1 = a.x, y1 = a.y, r1 = a.r, - x2 = b.x, y2 = b.y, r2 = b.r, - x21 = x2 - x1, y21 = y2 - y1, r21 = r2 - r1, - l = Math.sqrt(x21 * x21 + y21 * y21); - return { - x: (x1 + x2 + x21 / l * r21) / 2, - y: (y1 + y2 + y21 / l * r21) / 2, - r: (l + r1 + r2) / 2 - }; -} - -function encloseBasis3(a, b, c) { - var x1 = a.x, y1 = a.y, r1 = a.r, - x2 = b.x, y2 = b.y, r2 = b.r, - x3 = c.x, y3 = c.y, r3 = c.r, - a2 = x1 - x2, - a3 = x1 - x3, - b2 = y1 - y2, - b3 = y1 - y3, - c2 = r2 - r1, - c3 = r3 - r1, - d1 = x1 * x1 + y1 * y1 - r1 * r1, - d2 = d1 - x2 * x2 - y2 * y2 + r2 * r2, - d3 = d1 - x3 * x3 - y3 * y3 + r3 * r3, - ab = a3 * b2 - a2 * b3, - xa = (b2 * d3 - b3 * d2) / (ab * 2) - x1, - xb = (b3 * c2 - b2 * c3) / ab, - ya = (a3 * d2 - a2 * d3) / (ab * 2) - y1, - yb = (a2 * c3 - a3 * c2) / ab, - A = xb * xb + yb * yb - 1, - B = 2 * (r1 + xa * xb + ya * yb), - C = xa * xa + ya * ya - r1 * r1, - r = -(A ? (B + Math.sqrt(B * B - 4 * A * C)) / (2 * A) : C / B); - return { - x: x1 + xa + xb * r, - y: y1 + ya + yb * r, - r: r - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/pack/index.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/pack/index.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _siblings__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./siblings */ "./node_modules/d3-hierarchy/src/pack/siblings.js"); -/* harmony import */ var _accessors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../accessors */ "./node_modules/d3-hierarchy/src/accessors.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../constant */ "./node_modules/d3-hierarchy/src/constant.js"); - - - - -function defaultRadius(d) { - return Math.sqrt(d.value); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var radius = null, - dx = 1, - dy = 1, - padding = _constant__WEBPACK_IMPORTED_MODULE_2__["constantZero"]; - - function pack(root) { - root.x = dx / 2, root.y = dy / 2; - if (radius) { - root.eachBefore(radiusLeaf(radius)) - .eachAfter(packChildren(padding, 0.5)) - .eachBefore(translateChild(1)); - } else { - root.eachBefore(radiusLeaf(defaultRadius)) - .eachAfter(packChildren(_constant__WEBPACK_IMPORTED_MODULE_2__["constantZero"], 1)) - .eachAfter(packChildren(padding, root.r / Math.min(dx, dy))) - .eachBefore(translateChild(Math.min(dx, dy) / (2 * root.r))); - } - return root; - } - - pack.radius = function(x) { - return arguments.length ? (radius = Object(_accessors__WEBPACK_IMPORTED_MODULE_1__["optional"])(x), pack) : radius; - }; - - pack.size = function(x) { - return arguments.length ? (dx = +x[0], dy = +x[1], pack) : [dx, dy]; - }; - - pack.padding = function(x) { - return arguments.length ? (padding = typeof x === "function" ? x : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(+x), pack) : padding; - }; - - return pack; -}); - -function radiusLeaf(radius) { - return function(node) { - if (!node.children) { - node.r = Math.max(0, +radius(node) || 0); - } - }; -} - -function packChildren(padding, k) { - return function(node) { - if (children = node.children) { - var children, - i, - n = children.length, - r = padding(node) * k || 0, - e; - - if (r) for (i = 0; i < n; ++i) children[i].r += r; - e = Object(_siblings__WEBPACK_IMPORTED_MODULE_0__["packEnclose"])(children); - if (r) for (i = 0; i < n; ++i) children[i].r -= r; - node.r = e + r; - } - }; -} - -function translateChild(k) { - return function(node) { - var parent = node.parent; - node.r *= k; - if (parent) { - node.x = parent.x + k * node.x; - node.y = parent.y + k * node.y; - } - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/pack/siblings.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/pack/siblings.js ***! - \********************************************************/ -/*! exports provided: packEnclose, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "packEnclose", function() { return packEnclose; }); -/* harmony import */ var _enclose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./enclose */ "./node_modules/d3-hierarchy/src/pack/enclose.js"); - - -function place(b, a, c) { - var dx = b.x - a.x, x, a2, - dy = b.y - a.y, y, b2, - d2 = dx * dx + dy * dy; - if (d2) { - a2 = a.r + c.r, a2 *= a2; - b2 = b.r + c.r, b2 *= b2; - if (a2 > b2) { - x = (d2 + b2 - a2) / (2 * d2); - y = Math.sqrt(Math.max(0, b2 / d2 - x * x)); - c.x = b.x - x * dx - y * dy; - c.y = b.y - x * dy + y * dx; - } else { - x = (d2 + a2 - b2) / (2 * d2); - y = Math.sqrt(Math.max(0, a2 / d2 - x * x)); - c.x = a.x + x * dx - y * dy; - c.y = a.y + x * dy + y * dx; - } - } else { - c.x = a.x + c.r; - c.y = a.y; - } -} - -function intersects(a, b) { - var dr = a.r + b.r - 1e-6, dx = b.x - a.x, dy = b.y - a.y; - return dr > 0 && dr * dr > dx * dx + dy * dy; -} - -function score(node) { - var a = node._, - b = node.next._, - ab = a.r + b.r, - dx = (a.x * b.r + b.x * a.r) / ab, - dy = (a.y * b.r + b.y * a.r) / ab; - return dx * dx + dy * dy; -} - -function Node(circle) { - this._ = circle; - this.next = null; - this.previous = null; -} - -function packEnclose(circles) { - if (!(n = circles.length)) return 0; - - var a, b, c, n, aa, ca, i, j, k, sj, sk; - - // Place the first circle. - a = circles[0], a.x = 0, a.y = 0; - if (!(n > 1)) return a.r; - - // Place the second circle. - b = circles[1], a.x = -b.r, b.x = a.r, b.y = 0; - if (!(n > 2)) return a.r + b.r; - - // Place the third circle. - place(b, a, c = circles[2]); - - // Initialize the front-chain using the first three circles a, b and c. - a = new Node(a), b = new Node(b), c = new Node(c); - a.next = c.previous = b; - b.next = a.previous = c; - c.next = b.previous = a; - - // Attempt to place each remaining circle… - pack: for (i = 3; i < n; ++i) { - place(a._, b._, c = circles[i]), c = new Node(c); - - // Find the closest intersecting circle on the front-chain, if any. - // “Closeness” is determined by linear distance along the front-chain. - // “Ahead” or “behind” is likewise determined by linear distance. - j = b.next, k = a.previous, sj = b._.r, sk = a._.r; - do { - if (sj <= sk) { - if (intersects(j._, c._)) { - b = j, a.next = b, b.previous = a, --i; - continue pack; - } - sj += j._.r, j = j.next; - } else { - if (intersects(k._, c._)) { - a = k, a.next = b, b.previous = a, --i; - continue pack; - } - sk += k._.r, k = k.previous; - } - } while (j !== k.next); - - // Success! Insert the new circle c between a and b. - c.previous = a, c.next = b, a.next = b.previous = b = c; - - // Compute the new closest circle pair to the centroid. - aa = score(a); - while ((c = c.next) !== b) { - if ((ca = score(c)) < aa) { - a = c, aa = ca; - } - } - b = a.next; - } - - // Compute the enclosing circle of the front chain. - a = [b._], c = b; while ((c = c.next) !== b) a.push(c._); c = Object(_enclose__WEBPACK_IMPORTED_MODULE_0__["default"])(a); - - // Translate the circles to put the enclosing circle around the origin. - for (i = 0; i < n; ++i) a = circles[i], a.x -= c.x, a.y -= c.y; - - return c.r; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(circles) { - packEnclose(circles); - return circles; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/partition.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/partition.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _treemap_round__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./treemap/round */ "./node_modules/d3-hierarchy/src/treemap/round.js"); -/* harmony import */ var _treemap_dice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./treemap/dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var dx = 1, - dy = 1, - padding = 0, - round = false; - - function partition(root) { - var n = root.height + 1; - root.x0 = - root.y0 = padding; - root.x1 = dx; - root.y1 = dy / n; - root.eachBefore(positionNode(dy, n)); - if (round) root.eachBefore(_treemap_round__WEBPACK_IMPORTED_MODULE_0__["default"]); - return root; - } - - function positionNode(dy, n) { - return function(node) { - if (node.children) { - Object(_treemap_dice__WEBPACK_IMPORTED_MODULE_1__["default"])(node, node.x0, dy * (node.depth + 1) / n, node.x1, dy * (node.depth + 2) / n); - } - var x0 = node.x0, - y0 = node.y0, - x1 = node.x1 - padding, - y1 = node.y1 - padding; - if (x1 < x0) x0 = x1 = (x0 + x1) / 2; - if (y1 < y0) y0 = y1 = (y0 + y1) / 2; - node.x0 = x0; - node.y0 = y0; - node.x1 = x1; - node.y1 = y1; - }; - } - - partition.round = function(x) { - return arguments.length ? (round = !!x, partition) : round; - }; - - partition.size = function(x) { - return arguments.length ? (dx = +x[0], dy = +x[1], partition) : [dx, dy]; - }; - - partition.padding = function(x) { - return arguments.length ? (padding = +x, partition) : padding; - }; - - return partition; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/stratify.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/stratify.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _accessors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./accessors */ "./node_modules/d3-hierarchy/src/accessors.js"); -/* harmony import */ var _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hierarchy/index */ "./node_modules/d3-hierarchy/src/hierarchy/index.js"); - - - -var keyPrefix = "$", // Protect against keys like “__proto__”. - preroot = {depth: -1}, - ambiguous = {}; - -function defaultId(d) { - return d.id; -} - -function defaultParentId(d) { - return d.parentId; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var id = defaultId, - parentId = defaultParentId; - - function stratify(data) { - var d, - i, - n = data.length, - root, - parent, - node, - nodes = new Array(n), - nodeId, - nodeKey, - nodeByKey = {}; - - for (i = 0; i < n; ++i) { - d = data[i], node = nodes[i] = new _hierarchy_index__WEBPACK_IMPORTED_MODULE_1__["Node"](d); - if ((nodeId = id(d, i, data)) != null && (nodeId += "")) { - nodeKey = keyPrefix + (node.id = nodeId); - nodeByKey[nodeKey] = nodeKey in nodeByKey ? ambiguous : node; - } - } - - for (i = 0; i < n; ++i) { - node = nodes[i], nodeId = parentId(data[i], i, data); - if (nodeId == null || !(nodeId += "")) { - if (root) throw new Error("multiple roots"); - root = node; - } else { - parent = nodeByKey[keyPrefix + nodeId]; - if (!parent) throw new Error("missing: " + nodeId); - if (parent === ambiguous) throw new Error("ambiguous: " + nodeId); - if (parent.children) parent.children.push(node); - else parent.children = [node]; - node.parent = parent; - } - } - - if (!root) throw new Error("no root"); - root.parent = preroot; - root.eachBefore(function(node) { node.depth = node.parent.depth + 1; --n; }).eachBefore(_hierarchy_index__WEBPACK_IMPORTED_MODULE_1__["computeHeight"]); - root.parent = null; - if (n > 0) throw new Error("cycle"); - - return root; - } - - stratify.id = function(x) { - return arguments.length ? (id = Object(_accessors__WEBPACK_IMPORTED_MODULE_0__["required"])(x), stratify) : id; - }; - - stratify.parentId = function(x) { - return arguments.length ? (parentId = Object(_accessors__WEBPACK_IMPORTED_MODULE_0__["required"])(x), stratify) : parentId; - }; - - return stratify; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/tree.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-hierarchy/src/tree.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _hierarchy_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hierarchy/index */ "./node_modules/d3-hierarchy/src/hierarchy/index.js"); - - -function defaultSeparation(a, b) { - return a.parent === b.parent ? 1 : 2; -} - -// function radialSeparation(a, b) { -// return (a.parent === b.parent ? 1 : 2) / a.depth; -// } - -// This function is used to traverse the left contour of a subtree (or -// subforest). It returns the successor of v on this contour. This successor is -// either given by the leftmost child of v or by the thread of v. The function -// returns null if and only if v is on the highest level of its subtree. -function nextLeft(v) { - var children = v.children; - return children ? children[0] : v.t; -} - -// This function works analogously to nextLeft. -function nextRight(v) { - var children = v.children; - return children ? children[children.length - 1] : v.t; -} - -// Shifts the current subtree rooted at w+. This is done by increasing -// prelim(w+) and mod(w+) by shift. -function moveSubtree(wm, wp, shift) { - var change = shift / (wp.i - wm.i); - wp.c -= change; - wp.s += shift; - wm.c += change; - wp.z += shift; - wp.m += shift; -} - -// All other shifts, applied to the smaller subtrees between w- and w+, are -// performed by this function. To prepare the shifts, we have to adjust -// change(w+), shift(w+), and change(w-). -function executeShifts(v) { - var shift = 0, - change = 0, - children = v.children, - i = children.length, - w; - while (--i >= 0) { - w = children[i]; - w.z += shift; - w.m += shift; - shift += w.s + (change += w.c); - } -} - -// If vi-’s ancestor is a sibling of v, returns vi-’s ancestor. Otherwise, -// returns the specified (default) ancestor. -function nextAncestor(vim, v, ancestor) { - return vim.a.parent === v.parent ? vim.a : ancestor; -} - -function TreeNode(node, i) { - this._ = node; - this.parent = null; - this.children = null; - this.A = null; // default ancestor - this.a = this; // ancestor - this.z = 0; // prelim - this.m = 0; // mod - this.c = 0; // change - this.s = 0; // shift - this.t = null; // thread - this.i = i; // number -} - -TreeNode.prototype = Object.create(_hierarchy_index__WEBPACK_IMPORTED_MODULE_0__["Node"].prototype); - -function treeRoot(root) { - var tree = new TreeNode(root, 0), - node, - nodes = [tree], - child, - children, - i, - n; - - while (node = nodes.pop()) { - if (children = node._.children) { - node.children = new Array(n = children.length); - for (i = n - 1; i >= 0; --i) { - nodes.push(child = node.children[i] = new TreeNode(children[i], i)); - child.parent = node; - } - } - } - - (tree.parent = new TreeNode(null, 0)).children = [tree]; - return tree; -} - -// Node-link tree diagram using the Reingold-Tilford "tidy" algorithm -/* harmony default export */ __webpack_exports__["default"] = (function() { - var separation = defaultSeparation, - dx = 1, - dy = 1, - nodeSize = null; - - function tree(root) { - var t = treeRoot(root); - - // Compute the layout using Buchheim et al.’s algorithm. - t.eachAfter(firstWalk), t.parent.m = -t.z; - t.eachBefore(secondWalk); - - // If a fixed node size is specified, scale x and y. - if (nodeSize) root.eachBefore(sizeNode); - - // If a fixed tree size is specified, scale x and y based on the extent. - // Compute the left-most, right-most, and depth-most nodes for extents. - else { - var left = root, - right = root, - bottom = root; - root.eachBefore(function(node) { - if (node.x < left.x) left = node; - if (node.x > right.x) right = node; - if (node.depth > bottom.depth) bottom = node; - }); - var s = left === right ? 1 : separation(left, right) / 2, - tx = s - left.x, - kx = dx / (right.x + s + tx), - ky = dy / (bottom.depth || 1); - root.eachBefore(function(node) { - node.x = (node.x + tx) * kx; - node.y = node.depth * ky; - }); - } - - return root; - } - - // Computes a preliminary x-coordinate for v. Before that, FIRST WALK is - // applied recursively to the children of v, as well as the function - // APPORTION. After spacing out the children by calling EXECUTE SHIFTS, the - // node v is placed to the midpoint of its outermost children. - function firstWalk(v) { - var children = v.children, - siblings = v.parent.children, - w = v.i ? siblings[v.i - 1] : null; - if (children) { - executeShifts(v); - var midpoint = (children[0].z + children[children.length - 1].z) / 2; - if (w) { - v.z = w.z + separation(v._, w._); - v.m = v.z - midpoint; - } else { - v.z = midpoint; - } - } else if (w) { - v.z = w.z + separation(v._, w._); - } - v.parent.A = apportion(v, w, v.parent.A || siblings[0]); - } - - // Computes all real x-coordinates by summing up the modifiers recursively. - function secondWalk(v) { - v._.x = v.z + v.parent.m; - v.m += v.parent.m; - } - - // The core of the algorithm. Here, a new subtree is combined with the - // previous subtrees. Threads are used to traverse the inside and outside - // contours of the left and right subtree up to the highest common level. The - // vertices used for the traversals are vi+, vi-, vo-, and vo+, where the - // superscript o means outside and i means inside, the subscript - means left - // subtree and + means right subtree. For summing up the modifiers along the - // contour, we use respective variables si+, si-, so-, and so+. Whenever two - // nodes of the inside contours conflict, we compute the left one of the - // greatest uncommon ancestors using the function ANCESTOR and call MOVE - // SUBTREE to shift the subtree and prepare the shifts of smaller subtrees. - // Finally, we add a new thread (if necessary). - function apportion(v, w, ancestor) { - if (w) { - var vip = v, - vop = v, - vim = w, - vom = vip.parent.children[0], - sip = vip.m, - sop = vop.m, - sim = vim.m, - som = vom.m, - shift; - while (vim = nextRight(vim), vip = nextLeft(vip), vim && vip) { - vom = nextLeft(vom); - vop = nextRight(vop); - vop.a = v; - shift = vim.z + sim - vip.z - sip + separation(vim._, vip._); - if (shift > 0) { - moveSubtree(nextAncestor(vim, v, ancestor), v, shift); - sip += shift; - sop += shift; - } - sim += vim.m; - sip += vip.m; - som += vom.m; - sop += vop.m; - } - if (vim && !nextRight(vop)) { - vop.t = vim; - vop.m += sim - sop; - } - if (vip && !nextLeft(vom)) { - vom.t = vip; - vom.m += sip - som; - ancestor = v; - } - } - return ancestor; - } - - function sizeNode(node) { - node.x *= dx; - node.y = node.depth * dy; - } - - tree.separation = function(x) { - return arguments.length ? (separation = x, tree) : separation; - }; - - tree.size = function(x) { - return arguments.length ? (nodeSize = false, dx = +x[0], dy = +x[1], tree) : (nodeSize ? null : [dx, dy]); - }; - - tree.nodeSize = function(x) { - return arguments.length ? (nodeSize = true, dx = +x[0], dy = +x[1], tree) : (nodeSize ? [dx, dy] : null); - }; - - return tree; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/binary.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/binary.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) { - var nodes = parent.children, - i, n = nodes.length, - sum, sums = new Array(n + 1); - - for (sums[0] = sum = i = 0; i < n; ++i) { - sums[i + 1] = sum += nodes[i].value; - } - - partition(0, n, parent.value, x0, y0, x1, y1); - - function partition(i, j, value, x0, y0, x1, y1) { - if (i >= j - 1) { - var node = nodes[i]; - node.x0 = x0, node.y0 = y0; - node.x1 = x1, node.y1 = y1; - return; - } - - var valueOffset = sums[i], - valueTarget = (value / 2) + valueOffset, - k = i + 1, - hi = j - 1; - - while (k < hi) { - var mid = k + hi >>> 1; - if (sums[mid] < valueTarget) k = mid + 1; - else hi = mid; - } - - if ((valueTarget - sums[k - 1]) < (sums[k] - valueTarget) && i + 1 < k) --k; - - var valueLeft = sums[k] - valueOffset, - valueRight = value - valueLeft; - - if ((x1 - x0) > (y1 - y0)) { - var xk = (x0 * valueRight + x1 * valueLeft) / value; - partition(i, k, valueLeft, x0, y0, xk, y1); - partition(k, j, valueRight, xk, y0, x1, y1); - } else { - var yk = (y0 * valueRight + y1 * valueLeft) / value; - partition(i, k, valueLeft, x0, y0, x1, yk); - partition(k, j, valueRight, x0, yk, x1, y1); - } - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/dice.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/dice.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) { - var nodes = parent.children, - node, - i = -1, - n = nodes.length, - k = parent.value && (x1 - x0) / parent.value; - - while (++i < n) { - node = nodes[i], node.y0 = y0, node.y1 = y1; - node.x0 = x0, node.x1 = x0 += node.value * k; - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/index.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/index.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _round__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./round */ "./node_modules/d3-hierarchy/src/treemap/round.js"); -/* harmony import */ var _squarify__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./squarify */ "./node_modules/d3-hierarchy/src/treemap/squarify.js"); -/* harmony import */ var _accessors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../accessors */ "./node_modules/d3-hierarchy/src/accessors.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../constant */ "./node_modules/d3-hierarchy/src/constant.js"); - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var tile = _squarify__WEBPACK_IMPORTED_MODULE_1__["default"], - round = false, - dx = 1, - dy = 1, - paddingStack = [0], - paddingInner = _constant__WEBPACK_IMPORTED_MODULE_3__["constantZero"], - paddingTop = _constant__WEBPACK_IMPORTED_MODULE_3__["constantZero"], - paddingRight = _constant__WEBPACK_IMPORTED_MODULE_3__["constantZero"], - paddingBottom = _constant__WEBPACK_IMPORTED_MODULE_3__["constantZero"], - paddingLeft = _constant__WEBPACK_IMPORTED_MODULE_3__["constantZero"]; - - function treemap(root) { - root.x0 = - root.y0 = 0; - root.x1 = dx; - root.y1 = dy; - root.eachBefore(positionNode); - paddingStack = [0]; - if (round) root.eachBefore(_round__WEBPACK_IMPORTED_MODULE_0__["default"]); - return root; - } - - function positionNode(node) { - var p = paddingStack[node.depth], - x0 = node.x0 + p, - y0 = node.y0 + p, - x1 = node.x1 - p, - y1 = node.y1 - p; - if (x1 < x0) x0 = x1 = (x0 + x1) / 2; - if (y1 < y0) y0 = y1 = (y0 + y1) / 2; - node.x0 = x0; - node.y0 = y0; - node.x1 = x1; - node.y1 = y1; - if (node.children) { - p = paddingStack[node.depth + 1] = paddingInner(node) / 2; - x0 += paddingLeft(node) - p; - y0 += paddingTop(node) - p; - x1 -= paddingRight(node) - p; - y1 -= paddingBottom(node) - p; - if (x1 < x0) x0 = x1 = (x0 + x1) / 2; - if (y1 < y0) y0 = y1 = (y0 + y1) / 2; - tile(node, x0, y0, x1, y1); - } - } - - treemap.round = function(x) { - return arguments.length ? (round = !!x, treemap) : round; - }; - - treemap.size = function(x) { - return arguments.length ? (dx = +x[0], dy = +x[1], treemap) : [dx, dy]; - }; - - treemap.tile = function(x) { - return arguments.length ? (tile = Object(_accessors__WEBPACK_IMPORTED_MODULE_2__["required"])(x), treemap) : tile; - }; - - treemap.padding = function(x) { - return arguments.length ? treemap.paddingInner(x).paddingOuter(x) : treemap.paddingInner(); - }; - - treemap.paddingInner = function(x) { - return arguments.length ? (paddingInner = typeof x === "function" ? x : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingInner; - }; - - treemap.paddingOuter = function(x) { - return arguments.length ? treemap.paddingTop(x).paddingRight(x).paddingBottom(x).paddingLeft(x) : treemap.paddingTop(); - }; - - treemap.paddingTop = function(x) { - return arguments.length ? (paddingTop = typeof x === "function" ? x : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingTop; - }; - - treemap.paddingRight = function(x) { - return arguments.length ? (paddingRight = typeof x === "function" ? x : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingRight; - }; - - treemap.paddingBottom = function(x) { - return arguments.length ? (paddingBottom = typeof x === "function" ? x : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingBottom; - }; - - treemap.paddingLeft = function(x) { - return arguments.length ? (paddingLeft = typeof x === "function" ? x : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(+x), treemap) : paddingLeft; - }; - - return treemap; -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/resquarify.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/resquarify.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _dice__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js"); -/* harmony import */ var _slice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js"); -/* harmony import */ var _squarify__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./squarify */ "./node_modules/d3-hierarchy/src/treemap/squarify.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(ratio) { - - function resquarify(parent, x0, y0, x1, y1) { - if ((rows = parent._squarify) && (rows.ratio === ratio)) { - var rows, - row, - nodes, - i, - j = -1, - n, - m = rows.length, - value = parent.value; - - while (++j < m) { - row = rows[j], nodes = row.children; - for (i = row.value = 0, n = nodes.length; i < n; ++i) row.value += nodes[i].value; - if (row.dice) Object(_dice__WEBPACK_IMPORTED_MODULE_0__["default"])(row, x0, y0, x1, y0 += (y1 - y0) * row.value / value); - else Object(_slice__WEBPACK_IMPORTED_MODULE_1__["default"])(row, x0, y0, x0 += (x1 - x0) * row.value / value, y1); - value -= row.value; - } - } else { - parent._squarify = rows = Object(_squarify__WEBPACK_IMPORTED_MODULE_2__["squarifyRatio"])(ratio, parent, x0, y0, x1, y1); - rows.ratio = ratio; - } - } - - resquarify.ratio = function(x) { - return custom((x = +x) > 1 ? x : 1); - }; - - return resquarify; -})(_squarify__WEBPACK_IMPORTED_MODULE_2__["phi"])); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/round.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/round.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(node) { - node.x0 = Math.round(node.x0); - node.y0 = Math.round(node.y0); - node.x1 = Math.round(node.x1); - node.y1 = Math.round(node.y1); -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/slice.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/slice.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) { - var nodes = parent.children, - node, - i = -1, - n = nodes.length, - k = parent.value && (y1 - y0) / parent.value; - - while (++i < n) { - node = nodes[i], node.x0 = x0, node.x1 = x1; - node.y0 = y0, node.y1 = y0 += node.value * k; - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/sliceDice.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/sliceDice.js ***! - \************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _dice__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js"); -/* harmony import */ var _slice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(parent, x0, y0, x1, y1) { - (parent.depth & 1 ? _slice__WEBPACK_IMPORTED_MODULE_1__["default"] : _dice__WEBPACK_IMPORTED_MODULE_0__["default"])(parent, x0, y0, x1, y1); -}); - - -/***/ }), - -/***/ "./node_modules/d3-hierarchy/src/treemap/squarify.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-hierarchy/src/treemap/squarify.js ***! - \***********************************************************/ -/*! exports provided: phi, squarifyRatio, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "phi", function() { return phi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squarifyRatio", function() { return squarifyRatio; }); -/* harmony import */ var _dice__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dice */ "./node_modules/d3-hierarchy/src/treemap/dice.js"); -/* harmony import */ var _slice__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./slice */ "./node_modules/d3-hierarchy/src/treemap/slice.js"); - - - -var phi = (1 + Math.sqrt(5)) / 2; - -function squarifyRatio(ratio, parent, x0, y0, x1, y1) { - var rows = [], - nodes = parent.children, - row, - nodeValue, - i0 = 0, - i1 = 0, - n = nodes.length, - dx, dy, - value = parent.value, - sumValue, - minValue, - maxValue, - newRatio, - minRatio, - alpha, - beta; - - while (i0 < n) { - dx = x1 - x0, dy = y1 - y0; - - // Find the next non-empty node. - do sumValue = nodes[i1++].value; while (!sumValue && i1 < n); - minValue = maxValue = sumValue; - alpha = Math.max(dy / dx, dx / dy) / (value * ratio); - beta = sumValue * sumValue * alpha; - minRatio = Math.max(maxValue / beta, beta / minValue); - - // Keep adding nodes while the aspect ratio maintains or improves. - for (; i1 < n; ++i1) { - sumValue += nodeValue = nodes[i1].value; - if (nodeValue < minValue) minValue = nodeValue; - if (nodeValue > maxValue) maxValue = nodeValue; - beta = sumValue * sumValue * alpha; - newRatio = Math.max(maxValue / beta, beta / minValue); - if (newRatio > minRatio) { sumValue -= nodeValue; break; } - minRatio = newRatio; - } - - // Position and record the row orientation. - rows.push(row = {value: sumValue, dice: dx < dy, children: nodes.slice(i0, i1)}); - if (row.dice) Object(_dice__WEBPACK_IMPORTED_MODULE_0__["default"])(row, x0, y0, x1, value ? y0 += dy * sumValue / value : y1); - else Object(_slice__WEBPACK_IMPORTED_MODULE_1__["default"])(row, x0, y0, value ? x0 += dx * sumValue / value : x1, y1); - value -= sumValue, i0 = i1; - } - - return rows; -} - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(ratio) { - - function squarify(parent, x0, y0, x1, y1) { - squarifyRatio(ratio, parent, x0, y0, x1, y1); - } - - squarify.ratio = function(x) { - return custom((x = +x) > 1 ? x : 1); - }; - - return squarify; -})(phi)); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/array.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-interpolate/src/array.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _value__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./value */ "./node_modules/d3-interpolate/src/value.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var nb = b ? b.length : 0, - na = a ? Math.min(nb, a.length) : 0, - x = new Array(na), - c = new Array(nb), - i; - - for (i = 0; i < na; ++i) x[i] = Object(_value__WEBPACK_IMPORTED_MODULE_0__["default"])(a[i], b[i]); - for (; i < nb; ++i) c[i] = b[i]; - - return function(t) { - for (i = 0; i < na; ++i) c[i] = x[i](t); - return c; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/basis.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-interpolate/src/basis.js ***! - \**************************************************/ -/*! exports provided: basis, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "basis", function() { return basis; }); -function basis(t1, v0, v1, v2, v3) { - var t2 = t1 * t1, t3 = t2 * t1; - return ((1 - 3 * t1 + 3 * t2 - t3) * v0 - + (4 - 6 * t2 + 3 * t3) * v1 - + (1 + 3 * t1 + 3 * t2 - 3 * t3) * v2 - + t3 * v3) / 6; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(values) { - var n = values.length - 1; - return function(t) { - var i = t <= 0 ? (t = 0) : t >= 1 ? (t = 1, n - 1) : Math.floor(t * n), - v1 = values[i], - v2 = values[i + 1], - v0 = i > 0 ? values[i - 1] : 2 * v1 - v2, - v3 = i < n - 1 ? values[i + 2] : 2 * v2 - v1; - return basis((t - i / n) * n, v0, v1, v2, v3); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/basisClosed.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-interpolate/src/basisClosed.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./basis */ "./node_modules/d3-interpolate/src/basis.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(values) { - var n = values.length; - return function(t) { - var i = Math.floor(((t %= 1) < 0 ? ++t : t) * n), - v0 = values[(i + n - 1) % n], - v1 = values[i % n], - v2 = values[(i + 1) % n], - v3 = values[(i + 2) % n]; - return Object(_basis__WEBPACK_IMPORTED_MODULE_0__["basis"])((t - i / n) * n, v0, v1, v2, v3); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/color.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-interpolate/src/color.js ***! - \**************************************************/ -/*! exports provided: hue, gamma, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hue", function() { return hue; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "gamma", function() { return gamma; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return nogamma; }); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-interpolate/src/constant.js"); - - -function linear(a, d) { - return function(t) { - return a + t * d; - }; -} - -function exponential(a, b, y) { - return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { - return Math.pow(a + t * b, y); - }; -} - -function hue(a, b) { - var d = b - a; - return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(isNaN(a) ? b : a); -} - -function gamma(y) { - return (y = +y) === 1 ? nogamma : function(a, b) { - return b - a ? exponential(a, b, y) : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(isNaN(a) ? b : a); - }; -} - -function nogamma(a, b) { - var d = b - a; - return d ? linear(a, d) : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(isNaN(a) ? b : a); -} - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/constant.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-interpolate/src/constant.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/cubehelix.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-interpolate/src/cubehelix.js ***! - \******************************************************/ -/*! exports provided: default, cubehelixLong */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cubehelixLong", function() { return cubehelixLong; }); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./color */ "./node_modules/d3-interpolate/src/color.js"); - - - -function cubehelix(hue) { - return (function cubehelixGamma(y) { - y = +y; - - function cubehelix(start, end) { - var h = hue((start = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(start)).h, (end = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(end)).h), - s = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.s, end.s), - l = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.l, end.l), - opacity = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.opacity, end.opacity); - return function(t) { - start.h = h(t); - start.s = s(t); - start.l = l(Math.pow(t, y)); - start.opacity = opacity(t); - return start + ""; - }; - } - - cubehelix.gamma = cubehelixGamma; - - return cubehelix; - })(1); -} - -/* harmony default export */ __webpack_exports__["default"] = (cubehelix(_color__WEBPACK_IMPORTED_MODULE_1__["hue"])); -var cubehelixLong = cubehelix(_color__WEBPACK_IMPORTED_MODULE_1__["default"]); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/date.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-interpolate/src/date.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var d = new Date; - return a = +a, b -= a, function(t) { - return d.setTime(a + b * t), d; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/discrete.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-interpolate/src/discrete.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(range) { - var n = range.length; - return function(t) { - return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))]; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/hcl.js": -/*!************************************************!*\ - !*** ./node_modules/d3-interpolate/src/hcl.js ***! - \************************************************/ -/*! exports provided: default, hclLong */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hclLong", function() { return hclLong; }); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./color */ "./node_modules/d3-interpolate/src/color.js"); - - - -function hcl(hue) { - return function(start, end) { - var h = hue((start = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["hcl"])(start)).h, (end = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["hcl"])(end)).h), - c = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.c, end.c), - l = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.l, end.l), - opacity = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.opacity, end.opacity); - return function(t) { - start.h = h(t); - start.c = c(t); - start.l = l(t); - start.opacity = opacity(t); - return start + ""; - }; - } -} - -/* harmony default export */ __webpack_exports__["default"] = (hcl(_color__WEBPACK_IMPORTED_MODULE_1__["hue"])); -var hclLong = hcl(_color__WEBPACK_IMPORTED_MODULE_1__["default"]); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/hsl.js": -/*!************************************************!*\ - !*** ./node_modules/d3-interpolate/src/hsl.js ***! - \************************************************/ -/*! exports provided: default, hslLong */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hslLong", function() { return hslLong; }); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./color */ "./node_modules/d3-interpolate/src/color.js"); - - - -function hsl(hue) { - return function(start, end) { - var h = hue((start = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["hsl"])(start)).h, (end = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["hsl"])(end)).h), - s = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.s, end.s), - l = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.l, end.l), - opacity = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.opacity, end.opacity); - return function(t) { - start.h = h(t); - start.s = s(t); - start.l = l(t); - start.opacity = opacity(t); - return start + ""; - }; - } -} - -/* harmony default export */ __webpack_exports__["default"] = (hsl(_color__WEBPACK_IMPORTED_MODULE_1__["hue"])); -var hslLong = hsl(_color__WEBPACK_IMPORTED_MODULE_1__["default"]); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/hue.js": -/*!************************************************!*\ - !*** ./node_modules/d3-interpolate/src/hue.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./color */ "./node_modules/d3-interpolate/src/color.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var i = Object(_color__WEBPACK_IMPORTED_MODULE_0__["hue"])(+a, +b); - return function(t) { - var x = i(t); - return x - 360 * Math.floor(x / 360); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/index.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-interpolate/src/index.js ***! - \**************************************************/ -/*! exports provided: interpolate, interpolateArray, interpolateBasis, interpolateBasisClosed, interpolateDate, interpolateDiscrete, interpolateHue, interpolateNumber, interpolateObject, interpolateRound, interpolateString, interpolateTransformCss, interpolateTransformSvg, interpolateZoom, interpolateRgb, interpolateRgbBasis, interpolateRgbBasisClosed, interpolateHsl, interpolateHslLong, interpolateLab, interpolateHcl, interpolateHclLong, interpolateCubehelix, interpolateCubehelixLong, piecewise, quantize */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _value__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./value */ "./node_modules/d3-interpolate/src/value.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolate", function() { return _value__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-interpolate/src/array.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateArray", function() { return _array__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./basis */ "./node_modules/d3-interpolate/src/basis.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBasis", function() { return _basis__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _basisClosed__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./basisClosed */ "./node_modules/d3-interpolate/src/basisClosed.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBasisClosed", function() { return _basisClosed__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _date__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./date */ "./node_modules/d3-interpolate/src/date.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateDate", function() { return _date__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _discrete__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./discrete */ "./node_modules/d3-interpolate/src/discrete.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateDiscrete", function() { return _discrete__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _hue__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./hue */ "./node_modules/d3-interpolate/src/hue.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHue", function() { return _hue__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./number */ "./node_modules/d3-interpolate/src/number.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateNumber", function() { return _number__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _object__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./object */ "./node_modules/d3-interpolate/src/object.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateObject", function() { return _object__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _round__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./round */ "./node_modules/d3-interpolate/src/round.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRound", function() { return _round__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _string__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./string */ "./node_modules/d3-interpolate/src/string.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateString", function() { return _string__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony import */ var _transform_index__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./transform/index */ "./node_modules/d3-interpolate/src/transform/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateTransformCss", function() { return _transform_index__WEBPACK_IMPORTED_MODULE_11__["interpolateTransformCss"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateTransformSvg", function() { return _transform_index__WEBPACK_IMPORTED_MODULE_11__["interpolateTransformSvg"]; }); - -/* harmony import */ var _zoom__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./zoom */ "./node_modules/d3-interpolate/src/zoom.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateZoom", function() { return _zoom__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony import */ var _rgb__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./rgb */ "./node_modules/d3-interpolate/src/rgb.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRgb", function() { return _rgb__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRgbBasis", function() { return _rgb__WEBPACK_IMPORTED_MODULE_13__["rgbBasis"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRgbBasisClosed", function() { return _rgb__WEBPACK_IMPORTED_MODULE_13__["rgbBasisClosed"]; }); - -/* harmony import */ var _hsl__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./hsl */ "./node_modules/d3-interpolate/src/hsl.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHsl", function() { return _hsl__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHslLong", function() { return _hsl__WEBPACK_IMPORTED_MODULE_14__["hslLong"]; }); - -/* harmony import */ var _lab__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./lab */ "./node_modules/d3-interpolate/src/lab.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateLab", function() { return _lab__WEBPACK_IMPORTED_MODULE_15__["default"]; }); - -/* harmony import */ var _hcl__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./hcl */ "./node_modules/d3-interpolate/src/hcl.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHcl", function() { return _hcl__WEBPACK_IMPORTED_MODULE_16__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHclLong", function() { return _hcl__WEBPACK_IMPORTED_MODULE_16__["hclLong"]; }); - -/* harmony import */ var _cubehelix__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./cubehelix */ "./node_modules/d3-interpolate/src/cubehelix.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCubehelix", function() { return _cubehelix__WEBPACK_IMPORTED_MODULE_17__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCubehelixLong", function() { return _cubehelix__WEBPACK_IMPORTED_MODULE_17__["cubehelixLong"]; }); - -/* harmony import */ var _piecewise__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./piecewise */ "./node_modules/d3-interpolate/src/piecewise.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "piecewise", function() { return _piecewise__WEBPACK_IMPORTED_MODULE_18__["default"]; }); - -/* harmony import */ var _quantize__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./quantize */ "./node_modules/d3-interpolate/src/quantize.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "quantize", function() { return _quantize__WEBPACK_IMPORTED_MODULE_19__["default"]; }); - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/lab.js": -/*!************************************************!*\ - !*** ./node_modules/d3-interpolate/src/lab.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return lab; }); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./color */ "./node_modules/d3-interpolate/src/color.js"); - - - -function lab(start, end) { - var l = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])((start = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["lab"])(start)).l, (end = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["lab"])(end)).l), - a = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.a, end.a), - b = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.b, end.b), - opacity = Object(_color__WEBPACK_IMPORTED_MODULE_1__["default"])(start.opacity, end.opacity); - return function(t) { - start.l = l(t); - start.a = a(t); - start.b = b(t); - start.opacity = opacity(t); - return start + ""; - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/number.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-interpolate/src/number.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return a = +a, b -= a, function(t) { - return a + b * t; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/object.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-interpolate/src/object.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _value__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./value */ "./node_modules/d3-interpolate/src/value.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var i = {}, - c = {}, - k; - - if (a === null || typeof a !== "object") a = {}; - if (b === null || typeof b !== "object") b = {}; - - for (k in b) { - if (k in a) { - i[k] = Object(_value__WEBPACK_IMPORTED_MODULE_0__["default"])(a[k], b[k]); - } else { - c[k] = b[k]; - } - } - - return function(t) { - for (k in i) c[k] = i[k](t); - return c; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/piecewise.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-interpolate/src/piecewise.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return piecewise; }); -function piecewise(interpolate, values) { - var i = 0, n = values.length - 1, v = values[0], I = new Array(n < 0 ? 0 : n); - while (i < n) I[i] = interpolate(v, v = values[++i]); - return function(t) { - var i = Math.max(0, Math.min(n - 1, Math.floor(t *= n))); - return I[i](t - i); - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/quantize.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-interpolate/src/quantize.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(interpolator, n) { - var samples = new Array(n); - for (var i = 0; i < n; ++i) samples[i] = interpolator(i / (n - 1)); - return samples; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/rgb.js": -/*!************************************************!*\ - !*** ./node_modules/d3-interpolate/src/rgb.js ***! - \************************************************/ -/*! exports provided: default, rgbBasis, rgbBasisClosed */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rgbBasis", function() { return rgbBasis; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rgbBasisClosed", function() { return rgbBasisClosed; }); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./basis */ "./node_modules/d3-interpolate/src/basis.js"); -/* harmony import */ var _basisClosed__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./basisClosed */ "./node_modules/d3-interpolate/src/basisClosed.js"); -/* harmony import */ var _color__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./color */ "./node_modules/d3-interpolate/src/color.js"); - - - - - -/* harmony default export */ __webpack_exports__["default"] = ((function rgbGamma(y) { - var color = Object(_color__WEBPACK_IMPORTED_MODULE_3__["gamma"])(y); - - function rgb(start, end) { - var r = color((start = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["rgb"])(start)).r, (end = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["rgb"])(end)).r), - g = color(start.g, end.g), - b = color(start.b, end.b), - opacity = Object(_color__WEBPACK_IMPORTED_MODULE_3__["default"])(start.opacity, end.opacity); - return function(t) { - start.r = r(t); - start.g = g(t); - start.b = b(t); - start.opacity = opacity(t); - return start + ""; - }; - } - - rgb.gamma = rgbGamma; - - return rgb; -})(1)); - -function rgbSpline(spline) { - return function(colors) { - var n = colors.length, - r = new Array(n), - g = new Array(n), - b = new Array(n), - i, color; - for (i = 0; i < n; ++i) { - color = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["rgb"])(colors[i]); - r[i] = color.r || 0; - g[i] = color.g || 0; - b[i] = color.b || 0; - } - r = spline(r); - g = spline(g); - b = spline(b); - color.opacity = 1; - return function(t) { - color.r = r(t); - color.g = g(t); - color.b = b(t); - return color + ""; - }; - }; -} - -var rgbBasis = rgbSpline(_basis__WEBPACK_IMPORTED_MODULE_1__["default"]); -var rgbBasisClosed = rgbSpline(_basisClosed__WEBPACK_IMPORTED_MODULE_2__["default"]); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/round.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-interpolate/src/round.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return a = +a, b -= a, function(t) { - return Math.round(a + b * t); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/string.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-interpolate/src/string.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./number */ "./node_modules/d3-interpolate/src/number.js"); - - -var reA = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g, - reB = new RegExp(reA.source, "g"); - -function zero(b) { - return function() { - return b; - }; -} - -function one(b) { - return function(t) { - return b(t) + ""; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var bi = reA.lastIndex = reB.lastIndex = 0, // scan index for next number in b - am, // current match in a - bm, // current match in b - bs, // string preceding current number in b, if any - i = -1, // index in s - s = [], // string constants and placeholders - q = []; // number interpolators - - // Coerce inputs to strings. - a = a + "", b = b + ""; - - // Interpolate pairs of numbers in a & b. - while ((am = reA.exec(a)) - && (bm = reB.exec(b))) { - if ((bs = bm.index) > bi) { // a string precedes the next number in b - bs = b.slice(bi, bs); - if (s[i]) s[i] += bs; // coalesce with previous string - else s[++i] = bs; - } - if ((am = am[0]) === (bm = bm[0])) { // numbers in a & b match - if (s[i]) s[i] += bm; // coalesce with previous string - else s[++i] = bm; - } else { // interpolate non-matching numbers - s[++i] = null; - q.push({i: i, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(am, bm)}); - } - bi = reB.lastIndex; - } - - // Add remains of b. - if (bi < b.length) { - bs = b.slice(bi); - if (s[i]) s[i] += bs; // coalesce with previous string - else s[++i] = bs; - } - - // Special optimization for only a single match. - // Otherwise, interpolate each of the numbers and rejoin the string. - return s.length < 2 ? (q[0] - ? one(q[0].x) - : zero(b)) - : (b = q.length, function(t) { - for (var i = 0, o; i < b; ++i) s[(o = q[i]).i] = o.x(t); - return s.join(""); - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/transform/decompose.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-interpolate/src/transform/decompose.js ***! - \****************************************************************/ -/*! exports provided: identity, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); -var degrees = 180 / Math.PI; - -var identity = { - translateX: 0, - translateY: 0, - rotate: 0, - skewX: 0, - scaleX: 1, - scaleY: 1 -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b, c, d, e, f) { - var scaleX, scaleY, skewX; - if (scaleX = Math.sqrt(a * a + b * b)) a /= scaleX, b /= scaleX; - if (skewX = a * c + b * d) c -= a * skewX, d -= b * skewX; - if (scaleY = Math.sqrt(c * c + d * d)) c /= scaleY, d /= scaleY, skewX /= scaleY; - if (a * d < b * c) a = -a, b = -b, skewX = -skewX, scaleX = -scaleX; - return { - translateX: e, - translateY: f, - rotate: Math.atan2(b, a) * degrees, - skewX: Math.atan(skewX) * degrees, - scaleX: scaleX, - scaleY: scaleY - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/transform/index.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-interpolate/src/transform/index.js ***! - \************************************************************/ -/*! exports provided: interpolateTransformCss, interpolateTransformSvg */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "interpolateTransformCss", function() { return interpolateTransformCss; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "interpolateTransformSvg", function() { return interpolateTransformSvg; }); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../number */ "./node_modules/d3-interpolate/src/number.js"); -/* harmony import */ var _parse__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./parse */ "./node_modules/d3-interpolate/src/transform/parse.js"); - - - -function interpolateTransform(parse, pxComma, pxParen, degParen) { - - function pop(s) { - return s.length ? s.pop() + " " : ""; - } - - function translate(xa, ya, xb, yb, s, q) { - if (xa !== xb || ya !== yb) { - var i = s.push("translate(", null, pxComma, null, pxParen); - q.push({i: i - 4, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(xa, xb)}, {i: i - 2, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(ya, yb)}); - } else if (xb || yb) { - s.push("translate(" + xb + pxComma + yb + pxParen); - } - } - - function rotate(a, b, s, q) { - if (a !== b) { - if (a - b > 180) b += 360; else if (b - a > 180) a += 360; // shortest path - q.push({i: s.push(pop(s) + "rotate(", null, degParen) - 2, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(a, b)}); - } else if (b) { - s.push(pop(s) + "rotate(" + b + degParen); - } - } - - function skewX(a, b, s, q) { - if (a !== b) { - q.push({i: s.push(pop(s) + "skewX(", null, degParen) - 2, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(a, b)}); - } else if (b) { - s.push(pop(s) + "skewX(" + b + degParen); - } - } - - function scale(xa, ya, xb, yb, s, q) { - if (xa !== xb || ya !== yb) { - var i = s.push(pop(s) + "scale(", null, ",", null, ")"); - q.push({i: i - 4, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(xa, xb)}, {i: i - 2, x: Object(_number__WEBPACK_IMPORTED_MODULE_0__["default"])(ya, yb)}); - } else if (xb !== 1 || yb !== 1) { - s.push(pop(s) + "scale(" + xb + "," + yb + ")"); - } - } - - return function(a, b) { - var s = [], // string constants and placeholders - q = []; // number interpolators - a = parse(a), b = parse(b); - translate(a.translateX, a.translateY, b.translateX, b.translateY, s, q); - rotate(a.rotate, b.rotate, s, q); - skewX(a.skewX, b.skewX, s, q); - scale(a.scaleX, a.scaleY, b.scaleX, b.scaleY, s, q); - a = b = null; // gc - return function(t) { - var i = -1, n = q.length, o; - while (++i < n) s[(o = q[i]).i] = o.x(t); - return s.join(""); - }; - }; -} - -var interpolateTransformCss = interpolateTransform(_parse__WEBPACK_IMPORTED_MODULE_1__["parseCss"], "px, ", "px)", "deg)"); -var interpolateTransformSvg = interpolateTransform(_parse__WEBPACK_IMPORTED_MODULE_1__["parseSvg"], ", ", ")", ")"); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/transform/parse.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-interpolate/src/transform/parse.js ***! - \************************************************************/ -/*! exports provided: parseCss, parseSvg */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseCss", function() { return parseCss; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseSvg", function() { return parseSvg; }); -/* harmony import */ var _decompose__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./decompose */ "./node_modules/d3-interpolate/src/transform/decompose.js"); - - -var cssNode, - cssRoot, - cssView, - svgNode; - -function parseCss(value) { - if (value === "none") return _decompose__WEBPACK_IMPORTED_MODULE_0__["identity"]; - if (!cssNode) cssNode = document.createElement("DIV"), cssRoot = document.documentElement, cssView = document.defaultView; - cssNode.style.transform = value; - value = cssView.getComputedStyle(cssRoot.appendChild(cssNode), null).getPropertyValue("transform"); - cssRoot.removeChild(cssNode); - value = value.slice(7, -1).split(","); - return Object(_decompose__WEBPACK_IMPORTED_MODULE_0__["default"])(+value[0], +value[1], +value[2], +value[3], +value[4], +value[5]); -} - -function parseSvg(value) { - if (value == null) return _decompose__WEBPACK_IMPORTED_MODULE_0__["identity"]; - if (!svgNode) svgNode = document.createElementNS("http://www.w3.org/2000/svg", "g"); - svgNode.setAttribute("transform", value); - if (!(value = svgNode.transform.baseVal.consolidate())) return _decompose__WEBPACK_IMPORTED_MODULE_0__["identity"]; - value = value.matrix; - return Object(_decompose__WEBPACK_IMPORTED_MODULE_0__["default"])(value.a, value.b, value.c, value.d, value.e, value.f); -} - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/value.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-interpolate/src/value.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var _rgb__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./rgb */ "./node_modules/d3-interpolate/src/rgb.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./array */ "./node_modules/d3-interpolate/src/array.js"); -/* harmony import */ var _date__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./date */ "./node_modules/d3-interpolate/src/date.js"); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./number */ "./node_modules/d3-interpolate/src/number.js"); -/* harmony import */ var _object__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./object */ "./node_modules/d3-interpolate/src/object.js"); -/* harmony import */ var _string__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./string */ "./node_modules/d3-interpolate/src/string.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-interpolate/src/constant.js"); - - - - - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var t = typeof b, c; - return b == null || t === "boolean" ? Object(_constant__WEBPACK_IMPORTED_MODULE_7__["default"])(b) - : (t === "number" ? _number__WEBPACK_IMPORTED_MODULE_4__["default"] - : t === "string" ? ((c = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["color"])(b)) ? (b = c, _rgb__WEBPACK_IMPORTED_MODULE_1__["default"]) : _string__WEBPACK_IMPORTED_MODULE_6__["default"]) - : b instanceof d3_color__WEBPACK_IMPORTED_MODULE_0__["color"] ? _rgb__WEBPACK_IMPORTED_MODULE_1__["default"] - : b instanceof Date ? _date__WEBPACK_IMPORTED_MODULE_3__["default"] - : Array.isArray(b) ? _array__WEBPACK_IMPORTED_MODULE_2__["default"] - : typeof b.valueOf !== "function" && typeof b.toString !== "function" || isNaN(b) ? _object__WEBPACK_IMPORTED_MODULE_5__["default"] - : _number__WEBPACK_IMPORTED_MODULE_4__["default"])(a, b); -}); - - -/***/ }), - -/***/ "./node_modules/d3-interpolate/src/zoom.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-interpolate/src/zoom.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var rho = Math.SQRT2, - rho2 = 2, - rho4 = 4, - epsilon2 = 1e-12; - -function cosh(x) { - return ((x = Math.exp(x)) + 1 / x) / 2; -} - -function sinh(x) { - return ((x = Math.exp(x)) - 1 / x) / 2; -} - -function tanh(x) { - return ((x = Math.exp(2 * x)) - 1) / (x + 1); -} - -// p0 = [ux0, uy0, w0] -// p1 = [ux1, uy1, w1] -/* harmony default export */ __webpack_exports__["default"] = (function(p0, p1) { - var ux0 = p0[0], uy0 = p0[1], w0 = p0[2], - ux1 = p1[0], uy1 = p1[1], w1 = p1[2], - dx = ux1 - ux0, - dy = uy1 - uy0, - d2 = dx * dx + dy * dy, - i, - S; - - // Special case for u0 ≅ u1. - if (d2 < epsilon2) { - S = Math.log(w1 / w0) / rho; - i = function(t) { - return [ - ux0 + t * dx, - uy0 + t * dy, - w0 * Math.exp(rho * t * S) - ]; - } - } - - // General case. - else { - var d1 = Math.sqrt(d2), - b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2 * w0 * rho2 * d1), - b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2 * w1 * rho2 * d1), - r0 = Math.log(Math.sqrt(b0 * b0 + 1) - b0), - r1 = Math.log(Math.sqrt(b1 * b1 + 1) - b1); - S = (r1 - r0) / rho; - i = function(t) { - var s = t * S, - coshr0 = cosh(r0), - u = w0 / (rho2 * d1) * (coshr0 * tanh(rho * s + r0) - sinh(r0)); - return [ - ux0 + u * dx, - uy0 + u * dy, - w0 * coshr0 / cosh(rho * s + r0) - ]; - } - } - - i.duration = S * 1000; - - return i; -}); - - -/***/ }), - -/***/ "./node_modules/d3-path/src/index.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-path/src/index.js ***! - \*******************************************/ -/*! exports provided: path */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./path */ "./node_modules/d3-path/src/path.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "path", function() { return _path__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - - - - -/***/ }), - -/***/ "./node_modules/d3-path/src/path.js": -/*!******************************************!*\ - !*** ./node_modules/d3-path/src/path.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var pi = Math.PI, - tau = 2 * pi, - epsilon = 1e-6, - tauEpsilon = tau - epsilon; - -function Path() { - this._x0 = this._y0 = // start of current subpath - this._x1 = this._y1 = null; // end of current subpath - this._ = ""; -} - -function path() { - return new Path; -} - -Path.prototype = path.prototype = { - constructor: Path, - moveTo: function(x, y) { - this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y); - }, - closePath: function() { - if (this._x1 !== null) { - this._x1 = this._x0, this._y1 = this._y0; - this._ += "Z"; - } - }, - lineTo: function(x, y) { - this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y); - }, - quadraticCurveTo: function(x1, y1, x, y) { - this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y); - }, - bezierCurveTo: function(x1, y1, x2, y2, x, y) { - this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y); - }, - arcTo: function(x1, y1, x2, y2, r) { - x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r; - var x0 = this._x1, - y0 = this._y1, - x21 = x2 - x1, - y21 = y2 - y1, - x01 = x0 - x1, - y01 = y0 - y1, - l01_2 = x01 * x01 + y01 * y01; - - // Is the radius negative? Error. - if (r < 0) throw new Error("negative radius: " + r); - - // Is this path empty? Move to (x1,y1). - if (this._x1 === null) { - this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1); - } - - // Or, is (x1,y1) coincident with (x0,y0)? Do nothing. - else if (!(l01_2 > epsilon)); - - // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear? - // Equivalently, is (x1,y1) coincident with (x2,y2)? - // Or, is the radius zero? Line to (x1,y1). - else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) { - this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1); - } - - // Otherwise, draw an arc! - else { - var x20 = x2 - x0, - y20 = y2 - y0, - l21_2 = x21 * x21 + y21 * y21, - l20_2 = x20 * x20 + y20 * y20, - l21 = Math.sqrt(l21_2), - l01 = Math.sqrt(l01_2), - l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), - t01 = l / l01, - t21 = l / l21; - - // If the start tangent is not coincident with (x0,y0), line to. - if (Math.abs(t01 - 1) > epsilon) { - this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01); - } - - this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21); - } - }, - arc: function(x, y, r, a0, a1, ccw) { - x = +x, y = +y, r = +r; - var dx = r * Math.cos(a0), - dy = r * Math.sin(a0), - x0 = x + dx, - y0 = y + dy, - cw = 1 ^ ccw, - da = ccw ? a0 - a1 : a1 - a0; - - // Is the radius negative? Error. - if (r < 0) throw new Error("negative radius: " + r); - - // Is this path empty? Move to (x0,y0). - if (this._x1 === null) { - this._ += "M" + x0 + "," + y0; - } - - // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0). - else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) { - this._ += "L" + x0 + "," + y0; - } - - // Is this arc empty? We’re done. - if (!r) return; - - // Does the angle go the wrong way? Flip the direction. - if (da < 0) da = da % tau + tau; - - // Is this a complete circle? Draw two arcs to complete the circle. - if (da > tauEpsilon) { - this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0); - } - - // Is this arc non-empty? Draw an arc! - else if (da > epsilon) { - this._ += "A" + r + "," + r + ",0," + (+(da >= pi)) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1)); - } - }, - rect: function(x, y, w, h) { - this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + (+w) + "v" + (+h) + "h" + (-w) + "Z"; - }, - toString: function() { - return this._; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (path); - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/area.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-polygon/src/area.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(polygon) { - var i = -1, - n = polygon.length, - a, - b = polygon[n - 1], - area = 0; - - while (++i < n) { - a = b; - b = polygon[i]; - area += a[1] * b[0] - a[0] * b[1]; - } - - return area / 2; -}); - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/centroid.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-polygon/src/centroid.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(polygon) { - var i = -1, - n = polygon.length, - x = 0, - y = 0, - a, - b = polygon[n - 1], - c, - k = 0; - - while (++i < n) { - a = b; - b = polygon[i]; - k += c = a[0] * b[1] - b[0] * a[1]; - x += (a[0] + b[0]) * c; - y += (a[1] + b[1]) * c; - } - - return k *= 3, [x / k, y / k]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/contains.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-polygon/src/contains.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(polygon, point) { - var n = polygon.length, - p = polygon[n - 1], - x = point[0], y = point[1], - x0 = p[0], y0 = p[1], - x1, y1, - inside = false; - - for (var i = 0; i < n; ++i) { - p = polygon[i], x1 = p[0], y1 = p[1]; - if (((y1 > y) !== (y0 > y)) && (x < (x0 - x1) * (y - y1) / (y0 - y1) + x1)) inside = !inside; - x0 = x1, y0 = y1; - } - - return inside; -}); - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/cross.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-polygon/src/cross.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -// Returns the 2D cross product of AB and AC vectors, i.e., the z-component of -// the 3D cross product in a quadrant I Cartesian coordinate system (+x is -// right, +y is up). Returns a positive value if ABC is counter-clockwise, -// negative if clockwise, and zero if the points are collinear. -/* harmony default export */ __webpack_exports__["default"] = (function(a, b, c) { - return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/hull.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-polygon/src/hull.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _cross__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cross */ "./node_modules/d3-polygon/src/cross.js"); - - -function lexicographicOrder(a, b) { - return a[0] - b[0] || a[1] - b[1]; -} - -// Computes the upper convex hull per the monotone chain algorithm. -// Assumes points.length >= 3, is sorted by x, unique in y. -// Returns an array of indices into points in left-to-right order. -function computeUpperHullIndexes(points) { - var n = points.length, - indexes = [0, 1], - size = 2; - - for (var i = 2; i < n; ++i) { - while (size > 1 && Object(_cross__WEBPACK_IMPORTED_MODULE_0__["default"])(points[indexes[size - 2]], points[indexes[size - 1]], points[i]) <= 0) --size; - indexes[size++] = i; - } - - return indexes.slice(0, size); // remove popped points -} - -/* harmony default export */ __webpack_exports__["default"] = (function(points) { - if ((n = points.length) < 3) return null; - - var i, - n, - sortedPoints = new Array(n), - flippedPoints = new Array(n); - - for (i = 0; i < n; ++i) sortedPoints[i] = [+points[i][0], +points[i][1], i]; - sortedPoints.sort(lexicographicOrder); - for (i = 0; i < n; ++i) flippedPoints[i] = [sortedPoints[i][0], -sortedPoints[i][1]]; - - var upperIndexes = computeUpperHullIndexes(sortedPoints), - lowerIndexes = computeUpperHullIndexes(flippedPoints); - - // Construct the hull polygon, removing possible duplicate endpoints. - var skipLeft = lowerIndexes[0] === upperIndexes[0], - skipRight = lowerIndexes[lowerIndexes.length - 1] === upperIndexes[upperIndexes.length - 1], - hull = []; - - // Add upper hull in right-to-l order. - // Then add lower hull in left-to-right order. - for (i = upperIndexes.length - 1; i >= 0; --i) hull.push(points[sortedPoints[upperIndexes[i]][2]]); - for (i = +skipLeft; i < lowerIndexes.length - skipRight; ++i) hull.push(points[sortedPoints[lowerIndexes[i]][2]]); - - return hull; -}); - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/index.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-polygon/src/index.js ***! - \**********************************************/ -/*! exports provided: polygonArea, polygonCentroid, polygonHull, polygonContains, polygonLength */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./area */ "./node_modules/d3-polygon/src/area.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonArea", function() { return _area__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _centroid__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./centroid */ "./node_modules/d3-polygon/src/centroid.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonCentroid", function() { return _centroid__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _hull__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./hull */ "./node_modules/d3-polygon/src/hull.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonHull", function() { return _hull__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _contains__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./contains */ "./node_modules/d3-polygon/src/contains.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonContains", function() { return _contains__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _length__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./length */ "./node_modules/d3-polygon/src/length.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonLength", function() { return _length__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-polygon/src/length.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-polygon/src/length.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(polygon) { - var i = -1, - n = polygon.length, - b = polygon[n - 1], - xa, - ya, - xb = b[0], - yb = b[1], - perimeter = 0; - - while (++i < n) { - xa = xb; - ya = yb; - b = polygon[i]; - xb = b[0]; - yb = b[1]; - xa -= xb; - ya -= yb; - perimeter += Math.sqrt(xa * xa + ya * ya); - } - - return perimeter; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/add.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-quadtree/src/add.js ***! - \*********************************************/ -/*! exports provided: default, addAll */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addAll", function() { return addAll; }); -/* harmony default export */ __webpack_exports__["default"] = (function(d) { - var x = +this._x.call(null, d), - y = +this._y.call(null, d); - return add(this.cover(x, y), x, y, d); -}); - -function add(tree, x, y, d) { - if (isNaN(x) || isNaN(y)) return tree; // ignore invalid points - - var parent, - node = tree._root, - leaf = {data: d}, - x0 = tree._x0, - y0 = tree._y0, - x1 = tree._x1, - y1 = tree._y1, - xm, - ym, - xp, - yp, - right, - bottom, - i, - j; - - // If the tree is empty, initialize the root as a leaf. - if (!node) return tree._root = leaf, tree; - - // Find the existing leaf for the new point, or add it. - while (node.length) { - if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; - if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; - if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree; - } - - // Is the new point is exactly coincident with the existing point? - xp = +tree._x.call(null, node.data); - yp = +tree._y.call(null, node.data); - if (x === xp && y === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree; - - // Otherwise, split the leaf node until the old and new point are separated. - do { - parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4); - if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; - if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; - } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | (xp >= xm))); - return parent[j] = node, parent[i] = leaf, tree; -} - -function addAll(data) { - var d, i, n = data.length, - x, - y, - xz = new Array(n), - yz = new Array(n), - x0 = Infinity, - y0 = Infinity, - x1 = -Infinity, - y1 = -Infinity; - - // Compute the points and their extent. - for (i = 0; i < n; ++i) { - if (isNaN(x = +this._x.call(null, d = data[i])) || isNaN(y = +this._y.call(null, d))) continue; - xz[i] = x; - yz[i] = y; - if (x < x0) x0 = x; - if (x > x1) x1 = x; - if (y < y0) y0 = y; - if (y > y1) y1 = y; - } - - // If there were no (valid) points, inherit the existing extent. - if (x1 < x0) x0 = this._x0, x1 = this._x1; - if (y1 < y0) y0 = this._y0, y1 = this._y1; - - // Expand the tree to cover the new points. - this.cover(x0, y0).cover(x1, y1); - - // Add the new points. - for (i = 0; i < n; ++i) { - add(this, xz[i], yz[i], data[i]); - } - - return this; -} - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/cover.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-quadtree/src/cover.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x, y) { - if (isNaN(x = +x) || isNaN(y = +y)) return this; // ignore invalid points - - var x0 = this._x0, - y0 = this._y0, - x1 = this._x1, - y1 = this._y1; - - // If the quadtree has no extent, initialize them. - // Integer extent are necessary so that if we later double the extent, - // the existing quadrant boundaries don’t change due to floating point error! - if (isNaN(x0)) { - x1 = (x0 = Math.floor(x)) + 1; - y1 = (y0 = Math.floor(y)) + 1; - } - - // Otherwise, double repeatedly to cover. - else if (x0 > x || x > x1 || y0 > y || y > y1) { - var z = x1 - x0, - node = this._root, - parent, - i; - - switch (i = (y < (y0 + y1) / 2) << 1 | (x < (x0 + x1) / 2)) { - case 0: { - do parent = new Array(4), parent[i] = node, node = parent; - while (z *= 2, x1 = x0 + z, y1 = y0 + z, x > x1 || y > y1); - break; - } - case 1: { - do parent = new Array(4), parent[i] = node, node = parent; - while (z *= 2, x0 = x1 - z, y1 = y0 + z, x0 > x || y > y1); - break; - } - case 2: { - do parent = new Array(4), parent[i] = node, node = parent; - while (z *= 2, x1 = x0 + z, y0 = y1 - z, x > x1 || y0 > y); - break; - } - case 3: { - do parent = new Array(4), parent[i] = node, node = parent; - while (z *= 2, x0 = x1 - z, y0 = y1 - z, x0 > x || y0 > y); - break; - } - } - - if (this._root && this._root.length) this._root = node; - } - - // If the quadtree covers the point already, just return. - else return this; - - this._x0 = x0; - this._y0 = y0; - this._x1 = x1; - this._y1 = y1; - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/data.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-quadtree/src/data.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var data = []; - this.visit(function(node) { - if (!node.length) do data.push(node.data); while (node = node.next) - }); - return data; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/extent.js": -/*!************************************************!*\ - !*** ./node_modules/d3-quadtree/src/extent.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(_) { - return arguments.length - ? this.cover(+_[0][0], +_[0][1]).cover(+_[1][0], +_[1][1]) - : isNaN(this._x0) ? undefined : [[this._x0, this._y0], [this._x1, this._y1]]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/find.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-quadtree/src/find.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./quad */ "./node_modules/d3-quadtree/src/quad.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(x, y, radius) { - var data, - x0 = this._x0, - y0 = this._y0, - x1, - y1, - x2, - y2, - x3 = this._x1, - y3 = this._y1, - quads = [], - node = this._root, - q, - i; - - if (node) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](node, x0, y0, x3, y3)); - if (radius == null) radius = Infinity; - else { - x0 = x - radius, y0 = y - radius; - x3 = x + radius, y3 = y + radius; - radius *= radius; - } - - while (q = quads.pop()) { - - // Stop searching if this quadrant can’t contain a closer node. - if (!(node = q.node) - || (x1 = q.x0) > x3 - || (y1 = q.y0) > y3 - || (x2 = q.x1) < x0 - || (y2 = q.y1) < y0) continue; - - // Bisect the current quadrant. - if (node.length) { - var xm = (x1 + x2) / 2, - ym = (y1 + y2) / 2; - - quads.push( - new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](node[3], xm, ym, x2, y2), - new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](node[2], x1, ym, xm, y2), - new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](node[1], xm, y1, x2, ym), - new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](node[0], x1, y1, xm, ym) - ); - - // Visit the closest quadrant first. - if (i = (y >= ym) << 1 | (x >= xm)) { - q = quads[quads.length - 1]; - quads[quads.length - 1] = quads[quads.length - 1 - i]; - quads[quads.length - 1 - i] = q; - } - } - - // Visit this point. (Visiting coincident points isn’t necessary!) - else { - var dx = x - +this._x.call(null, node.data), - dy = y - +this._y.call(null, node.data), - d2 = dx * dx + dy * dy; - if (d2 < radius) { - var d = Math.sqrt(radius = d2); - x0 = x - d, y0 = y - d; - x3 = x + d, y3 = y + d; - data = node.data; - } - } - } - - return data; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/index.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-quadtree/src/index.js ***! - \***********************************************/ -/*! exports provided: quadtree */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _quadtree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./quadtree */ "./node_modules/d3-quadtree/src/quadtree.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "quadtree", function() { return _quadtree__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - - - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/quad.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-quadtree/src/quad.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(node, x0, y0, x1, y1) { - this.node = node; - this.x0 = x0; - this.y0 = y0; - this.x1 = x1; - this.y1 = y1; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/quadtree.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-quadtree/src/quadtree.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return quadtree; }); -/* harmony import */ var _add__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./add */ "./node_modules/d3-quadtree/src/add.js"); -/* harmony import */ var _cover__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./cover */ "./node_modules/d3-quadtree/src/cover.js"); -/* harmony import */ var _data__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./data */ "./node_modules/d3-quadtree/src/data.js"); -/* harmony import */ var _extent__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./extent */ "./node_modules/d3-quadtree/src/extent.js"); -/* harmony import */ var _find__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./find */ "./node_modules/d3-quadtree/src/find.js"); -/* harmony import */ var _remove__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./remove */ "./node_modules/d3-quadtree/src/remove.js"); -/* harmony import */ var _root__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./root */ "./node_modules/d3-quadtree/src/root.js"); -/* harmony import */ var _size__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./size */ "./node_modules/d3-quadtree/src/size.js"); -/* harmony import */ var _visit__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./visit */ "./node_modules/d3-quadtree/src/visit.js"); -/* harmony import */ var _visitAfter__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./visitAfter */ "./node_modules/d3-quadtree/src/visitAfter.js"); -/* harmony import */ var _x__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./x */ "./node_modules/d3-quadtree/src/x.js"); -/* harmony import */ var _y__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./y */ "./node_modules/d3-quadtree/src/y.js"); - - - - - - - - - - - - - -function quadtree(nodes, x, y) { - var tree = new Quadtree(x == null ? _x__WEBPACK_IMPORTED_MODULE_10__["defaultX"] : x, y == null ? _y__WEBPACK_IMPORTED_MODULE_11__["defaultY"] : y, NaN, NaN, NaN, NaN); - return nodes == null ? tree : tree.addAll(nodes); -} - -function Quadtree(x, y, x0, y0, x1, y1) { - this._x = x; - this._y = y; - this._x0 = x0; - this._y0 = y0; - this._x1 = x1; - this._y1 = y1; - this._root = undefined; -} - -function leaf_copy(leaf) { - var copy = {data: leaf.data}, next = copy; - while (leaf = leaf.next) next = next.next = {data: leaf.data}; - return copy; -} - -var treeProto = quadtree.prototype = Quadtree.prototype; - -treeProto.copy = function() { - var copy = new Quadtree(this._x, this._y, this._x0, this._y0, this._x1, this._y1), - node = this._root, - nodes, - child; - - if (!node) return copy; - - if (!node.length) return copy._root = leaf_copy(node), copy; - - nodes = [{source: node, target: copy._root = new Array(4)}]; - while (node = nodes.pop()) { - for (var i = 0; i < 4; ++i) { - if (child = node.source[i]) { - if (child.length) nodes.push({source: child, target: node.target[i] = new Array(4)}); - else node.target[i] = leaf_copy(child); - } - } - } - - return copy; -}; - -treeProto.add = _add__WEBPACK_IMPORTED_MODULE_0__["default"]; -treeProto.addAll = _add__WEBPACK_IMPORTED_MODULE_0__["addAll"]; -treeProto.cover = _cover__WEBPACK_IMPORTED_MODULE_1__["default"]; -treeProto.data = _data__WEBPACK_IMPORTED_MODULE_2__["default"]; -treeProto.extent = _extent__WEBPACK_IMPORTED_MODULE_3__["default"]; -treeProto.find = _find__WEBPACK_IMPORTED_MODULE_4__["default"]; -treeProto.remove = _remove__WEBPACK_IMPORTED_MODULE_5__["default"]; -treeProto.removeAll = _remove__WEBPACK_IMPORTED_MODULE_5__["removeAll"]; -treeProto.root = _root__WEBPACK_IMPORTED_MODULE_6__["default"]; -treeProto.size = _size__WEBPACK_IMPORTED_MODULE_7__["default"]; -treeProto.visit = _visit__WEBPACK_IMPORTED_MODULE_8__["default"]; -treeProto.visitAfter = _visitAfter__WEBPACK_IMPORTED_MODULE_9__["default"]; -treeProto.x = _x__WEBPACK_IMPORTED_MODULE_10__["default"]; -treeProto.y = _y__WEBPACK_IMPORTED_MODULE_11__["default"]; - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/remove.js": -/*!************************************************!*\ - !*** ./node_modules/d3-quadtree/src/remove.js ***! - \************************************************/ -/*! exports provided: default, removeAll */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeAll", function() { return removeAll; }); -/* harmony default export */ __webpack_exports__["default"] = (function(d) { - if (isNaN(x = +this._x.call(null, d)) || isNaN(y = +this._y.call(null, d))) return this; // ignore invalid points - - var parent, - node = this._root, - retainer, - previous, - next, - x0 = this._x0, - y0 = this._y0, - x1 = this._x1, - y1 = this._y1, - x, - y, - xm, - ym, - right, - bottom, - i, - j; - - // If the tree is empty, initialize the root as a leaf. - if (!node) return this; - - // Find the leaf node for the point. - // While descending, also retain the deepest parent with a non-removed sibling. - if (node.length) while (true) { - if (right = x >= (xm = (x0 + x1) / 2)) x0 = xm; else x1 = xm; - if (bottom = y >= (ym = (y0 + y1) / 2)) y0 = ym; else y1 = ym; - if (!(parent = node, node = node[i = bottom << 1 | right])) return this; - if (!node.length) break; - if (parent[(i + 1) & 3] || parent[(i + 2) & 3] || parent[(i + 3) & 3]) retainer = parent, j = i; - } - - // Find the point to remove. - while (node.data !== d) if (!(previous = node, node = node.next)) return this; - if (next = node.next) delete node.next; - - // If there are multiple coincident points, remove just the point. - if (previous) return (next ? previous.next = next : delete previous.next), this; - - // If this is the root point, remove it. - if (!parent) return this._root = next, this; - - // Remove this leaf. - next ? parent[i] = next : delete parent[i]; - - // If the parent now contains exactly one leaf, collapse superfluous parents. - if ((node = parent[0] || parent[1] || parent[2] || parent[3]) - && node === (parent[3] || parent[2] || parent[1] || parent[0]) - && !node.length) { - if (retainer) retainer[j] = node; - else this._root = node; - } - - return this; -}); - -function removeAll(data) { - for (var i = 0, n = data.length; i < n; ++i) this.remove(data[i]); - return this; -} - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/root.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-quadtree/src/root.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - return this._root; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/size.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-quadtree/src/size.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var size = 0; - this.visit(function(node) { - if (!node.length) do ++size; while (node = node.next) - }); - return size; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/visit.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-quadtree/src/visit.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./quad */ "./node_modules/d3-quadtree/src/quad.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(callback) { - var quads = [], q, node = this._root, child, x0, y0, x1, y1; - if (node) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](node, this._x0, this._y0, this._x1, this._y1)); - while (q = quads.pop()) { - if (!callback(node = q.node, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1) && node.length) { - var xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; - if (child = node[3]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, xm, ym, x1, y1)); - if (child = node[2]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, x0, ym, xm, y1)); - if (child = node[1]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, xm, y0, x1, ym)); - if (child = node[0]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, x0, y0, xm, ym)); - } - } - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/visitAfter.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-quadtree/src/visitAfter.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _quad__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./quad */ "./node_modules/d3-quadtree/src/quad.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(callback) { - var quads = [], next = [], q; - if (this._root) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](this._root, this._x0, this._y0, this._x1, this._y1)); - while (q = quads.pop()) { - var node = q.node; - if (node.length) { - var child, x0 = q.x0, y0 = q.y0, x1 = q.x1, y1 = q.y1, xm = (x0 + x1) / 2, ym = (y0 + y1) / 2; - if (child = node[0]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, x0, y0, xm, ym)); - if (child = node[1]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, xm, y0, x1, ym)); - if (child = node[2]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, x0, ym, xm, y1)); - if (child = node[3]) quads.push(new _quad__WEBPACK_IMPORTED_MODULE_0__["default"](child, xm, ym, x1, y1)); - } - next.push(q); - } - while (q = next.pop()) { - callback(q.node, q.x0, q.y0, q.x1, q.y1); - } - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/x.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-quadtree/src/x.js ***! - \*******************************************/ -/*! exports provided: defaultX, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "defaultX", function() { return defaultX; }); -function defaultX(d) { - return d[0]; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(_) { - return arguments.length ? (this._x = _, this) : this._x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-quadtree/src/y.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-quadtree/src/y.js ***! - \*******************************************/ -/*! exports provided: defaultY, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "defaultY", function() { return defaultY; }); -function defaultY(d) { - return d[1]; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(_) { - return arguments.length ? (this._y = _, this) : this._y; -}); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/bates.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-random/src/bates.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js"); -/* harmony import */ var _irwinHall__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./irwinHall */ "./node_modules/d3-random/src/irwinHall.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = ((function sourceRandomBates(source) { - function randomBates(n) { - var randomIrwinHall = _irwinHall__WEBPACK_IMPORTED_MODULE_1__["default"].source(source)(n); - return function() { - return randomIrwinHall() / n; - }; - } - - randomBates.source = sourceRandomBates; - - return randomBates; -})(_defaultSource__WEBPACK_IMPORTED_MODULE_0__["default"])); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/defaultSource.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-random/src/defaultSource.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Math.random(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/exponential.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-random/src/exponential.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js"); - - -/* harmony default export */ __webpack_exports__["default"] = ((function sourceRandomExponential(source) { - function randomExponential(lambda) { - return function() { - return -Math.log(1 - source()) / lambda; - }; - } - - randomExponential.source = sourceRandomExponential; - - return randomExponential; -})(_defaultSource__WEBPACK_IMPORTED_MODULE_0__["default"])); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/index.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-random/src/index.js ***! - \*********************************************/ -/*! exports provided: randomUniform, randomNormal, randomLogNormal, randomBates, randomIrwinHall, randomExponential */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _uniform__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./uniform */ "./node_modules/d3-random/src/uniform.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomUniform", function() { return _uniform__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _normal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./normal */ "./node_modules/d3-random/src/normal.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomNormal", function() { return _normal__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _logNormal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./logNormal */ "./node_modules/d3-random/src/logNormal.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomLogNormal", function() { return _logNormal__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _bates__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./bates */ "./node_modules/d3-random/src/bates.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomBates", function() { return _bates__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _irwinHall__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./irwinHall */ "./node_modules/d3-random/src/irwinHall.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomIrwinHall", function() { return _irwinHall__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _exponential__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./exponential */ "./node_modules/d3-random/src/exponential.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomExponential", function() { return _exponential__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-random/src/irwinHall.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-random/src/irwinHall.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js"); - - -/* harmony default export */ __webpack_exports__["default"] = ((function sourceRandomIrwinHall(source) { - function randomIrwinHall(n) { - return function() { - for (var sum = 0, i = 0; i < n; ++i) sum += source(); - return sum; - }; - } - - randomIrwinHall.source = sourceRandomIrwinHall; - - return randomIrwinHall; -})(_defaultSource__WEBPACK_IMPORTED_MODULE_0__["default"])); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/logNormal.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-random/src/logNormal.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js"); -/* harmony import */ var _normal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./normal */ "./node_modules/d3-random/src/normal.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = ((function sourceRandomLogNormal(source) { - function randomLogNormal() { - var randomNormal = _normal__WEBPACK_IMPORTED_MODULE_1__["default"].source(source).apply(this, arguments); - return function() { - return Math.exp(randomNormal()); - }; - } - - randomLogNormal.source = sourceRandomLogNormal; - - return randomLogNormal; -})(_defaultSource__WEBPACK_IMPORTED_MODULE_0__["default"])); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/normal.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-random/src/normal.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js"); - - -/* harmony default export */ __webpack_exports__["default"] = ((function sourceRandomNormal(source) { - function randomNormal(mu, sigma) { - var x, r; - mu = mu == null ? 0 : +mu; - sigma = sigma == null ? 1 : +sigma; - return function() { - var y; - - // If available, use the second previously-generated uniform random. - if (x != null) y = x, x = null; - - // Otherwise, generate a new x and y. - else do { - x = source() * 2 - 1; - y = source() * 2 - 1; - r = x * x + y * y; - } while (!r || r > 1); - - return mu + sigma * y * Math.sqrt(-2 * Math.log(r) / r); - }; - } - - randomNormal.source = sourceRandomNormal; - - return randomNormal; -})(_defaultSource__WEBPACK_IMPORTED_MODULE_0__["default"])); - - -/***/ }), - -/***/ "./node_modules/d3-random/src/uniform.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-random/src/uniform.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultSource__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultSource */ "./node_modules/d3-random/src/defaultSource.js"); - - -/* harmony default export */ __webpack_exports__["default"] = ((function sourceRandomUniform(source) { - function randomUniform(min, max) { - min = min == null ? 0 : +min; - max = max == null ? 1 : +max; - if (arguments.length === 1) max = min, min = 0; - else max -= min; - return function() { - return source() * max + min; - }; - } - - randomUniform.source = sourceRandomUniform; - - return randomUniform; -})(_defaultSource__WEBPACK_IMPORTED_MODULE_0__["default"])); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Accent.js": -/*!*******************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Accent.js ***! - \*******************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Dark2.js": -/*!******************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Dark2.js ***! - \******************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Paired.js": -/*!*******************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Paired.js ***! - \*******************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Pastel1.js": -/*!********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Pastel1.js ***! - \********************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Pastel2.js": -/*!********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Pastel2.js ***! - \********************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Set1.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Set1.js ***! - \*****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Set2.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Set2.js ***! - \*****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/Set3.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/Set3.js ***! - \*****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/categorical/category10.js": -/*!***********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/categorical/category10.js ***! - \***********************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/colors.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/colors.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(specifier) { - var n = specifier.length / 6 | 0, colors = new Array(n), i = 0; - while (i < n) colors[i] = "#" + specifier.slice(i * 6, ++i * 6); - return colors; -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/BrBG.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/BrBG.js ***! - \***************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "d8b365f5f5f55ab4ac", - "a6611adfc27d80cdc1018571", - "a6611adfc27df5f5f580cdc1018571", - "8c510ad8b365f6e8c3c7eae55ab4ac01665e", - "8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e", - "8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e", - "8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e", - "5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30", - "5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/PRGn.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/PRGn.js ***! - \***************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "af8dc3f7f7f77fbf7b", - "7b3294c2a5cfa6dba0008837", - "7b3294c2a5cff7f7f7a6dba0008837", - "762a83af8dc3e7d4e8d9f0d37fbf7b1b7837", - "762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837", - "762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837", - "762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837", - "40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b", - "40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/PiYG.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/PiYG.js ***! - \***************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "e9a3c9f7f7f7a1d76a", - "d01c8bf1b6dab8e1864dac26", - "d01c8bf1b6daf7f7f7b8e1864dac26", - "c51b7de9a3c9fde0efe6f5d0a1d76a4d9221", - "c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221", - "c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221", - "c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221", - "8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419", - "8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/PuOr.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/PuOr.js ***! - \***************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "998ec3f7f7f7f1a340", - "5e3c99b2abd2fdb863e66101", - "5e3c99b2abd2f7f7f7fdb863e66101", - "542788998ec3d8daebfee0b6f1a340b35806", - "542788998ec3d8daebf7f7f7fee0b6f1a340b35806", - "5427888073acb2abd2d8daebfee0b6fdb863e08214b35806", - "5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806", - "2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08", - "2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/RdBu.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/RdBu.js ***! - \***************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "ef8a62f7f7f767a9cf", - "ca0020f4a58292c5de0571b0", - "ca0020f4a582f7f7f792c5de0571b0", - "b2182bef8a62fddbc7d1e5f067a9cf2166ac", - "b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac", - "b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac", - "b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac", - "67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061", - "67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/RdGy.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/RdGy.js ***! - \***************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "ef8a62ffffff999999", - "ca0020f4a582bababa404040", - "ca0020f4a582ffffffbababa404040", - "b2182bef8a62fddbc7e0e0e09999994d4d4d", - "b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d", - "b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d", - "b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d", - "67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a", - "67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/RdYlBu.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/RdYlBu.js ***! - \*****************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fc8d59ffffbf91bfdb", - "d7191cfdae61abd9e92c7bb6", - "d7191cfdae61ffffbfabd9e92c7bb6", - "d73027fc8d59fee090e0f3f891bfdb4575b4", - "d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4", - "d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4", - "d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4", - "a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695", - "a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/RdYlGn.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/RdYlGn.js ***! - \*****************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fc8d59ffffbf91cf60", - "d7191cfdae61a6d96a1a9641", - "d7191cfdae61ffffbfa6d96a1a9641", - "d73027fc8d59fee08bd9ef8b91cf601a9850", - "d73027fc8d59fee08bffffbfd9ef8b91cf601a9850", - "d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850", - "d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850", - "a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837", - "a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/diverging/Spectral.js": -/*!*******************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/diverging/Spectral.js ***! - \*******************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fc8d59ffffbf99d594", - "d7191cfdae61abdda42b83ba", - "d7191cfdae61ffffbfabdda42b83ba", - "d53e4ffc8d59fee08be6f59899d5943288bd", - "d53e4ffc8d59fee08bffffbfe6f59899d5943288bd", - "d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd", - "d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd", - "9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2", - "9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/index.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/index.js ***! - \******************************************************/ -/*! exports provided: schemeCategory10, schemeAccent, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, interpolateBrBG, schemeBrBG, interpolatePRGn, schemePRGn, interpolatePiYG, schemePiYG, interpolatePuOr, schemePuOr, interpolateRdBu, schemeRdBu, interpolateRdGy, schemeRdGy, interpolateRdYlBu, schemeRdYlBu, interpolateRdYlGn, schemeRdYlGn, interpolateSpectral, schemeSpectral, interpolateBuGn, schemeBuGn, interpolateBuPu, schemeBuPu, interpolateGnBu, schemeGnBu, interpolateOrRd, schemeOrRd, interpolatePuBuGn, schemePuBuGn, interpolatePuBu, schemePuBu, interpolatePuRd, schemePuRd, interpolateRdPu, schemeRdPu, interpolateYlGnBu, schemeYlGnBu, interpolateYlGn, schemeYlGn, interpolateYlOrBr, schemeYlOrBr, interpolateYlOrRd, schemeYlOrRd, interpolateBlues, schemeBlues, interpolateGreens, schemeGreens, interpolateGreys, schemeGreys, interpolatePurples, schemePurples, interpolateReds, schemeReds, interpolateOranges, schemeOranges, interpolateCubehelixDefault, interpolateRainbow, interpolateWarm, interpolateCool, interpolateSinebow, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _categorical_category10__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./categorical/category10 */ "./node_modules/d3-scale-chromatic/src/categorical/category10.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeCategory10", function() { return _categorical_category10__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _categorical_Accent__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./categorical/Accent */ "./node_modules/d3-scale-chromatic/src/categorical/Accent.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeAccent", function() { return _categorical_Accent__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _categorical_Dark2__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./categorical/Dark2 */ "./node_modules/d3-scale-chromatic/src/categorical/Dark2.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeDark2", function() { return _categorical_Dark2__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _categorical_Paired__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./categorical/Paired */ "./node_modules/d3-scale-chromatic/src/categorical/Paired.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePaired", function() { return _categorical_Paired__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _categorical_Pastel1__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./categorical/Pastel1 */ "./node_modules/d3-scale-chromatic/src/categorical/Pastel1.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePastel1", function() { return _categorical_Pastel1__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _categorical_Pastel2__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./categorical/Pastel2 */ "./node_modules/d3-scale-chromatic/src/categorical/Pastel2.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePastel2", function() { return _categorical_Pastel2__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _categorical_Set1__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./categorical/Set1 */ "./node_modules/d3-scale-chromatic/src/categorical/Set1.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSet1", function() { return _categorical_Set1__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _categorical_Set2__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./categorical/Set2 */ "./node_modules/d3-scale-chromatic/src/categorical/Set2.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSet2", function() { return _categorical_Set2__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _categorical_Set3__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./categorical/Set3 */ "./node_modules/d3-scale-chromatic/src/categorical/Set3.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSet3", function() { return _categorical_Set3__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _diverging_BrBG__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./diverging/BrBG */ "./node_modules/d3-scale-chromatic/src/diverging/BrBG.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBrBG", function() { return _diverging_BrBG__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBrBG", function() { return _diverging_BrBG__WEBPACK_IMPORTED_MODULE_9__["scheme"]; }); - -/* harmony import */ var _diverging_PRGn__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./diverging/PRGn */ "./node_modules/d3-scale-chromatic/src/diverging/PRGn.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePRGn", function() { return _diverging_PRGn__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePRGn", function() { return _diverging_PRGn__WEBPACK_IMPORTED_MODULE_10__["scheme"]; }); - -/* harmony import */ var _diverging_PiYG__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./diverging/PiYG */ "./node_modules/d3-scale-chromatic/src/diverging/PiYG.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePiYG", function() { return _diverging_PiYG__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePiYG", function() { return _diverging_PiYG__WEBPACK_IMPORTED_MODULE_11__["scheme"]; }); - -/* harmony import */ var _diverging_PuOr__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./diverging/PuOr */ "./node_modules/d3-scale-chromatic/src/diverging/PuOr.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuOr", function() { return _diverging_PuOr__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuOr", function() { return _diverging_PuOr__WEBPACK_IMPORTED_MODULE_12__["scheme"]; }); - -/* harmony import */ var _diverging_RdBu__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./diverging/RdBu */ "./node_modules/d3-scale-chromatic/src/diverging/RdBu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdBu", function() { return _diverging_RdBu__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdBu", function() { return _diverging_RdBu__WEBPACK_IMPORTED_MODULE_13__["scheme"]; }); - -/* harmony import */ var _diverging_RdGy__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./diverging/RdGy */ "./node_modules/d3-scale-chromatic/src/diverging/RdGy.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdGy", function() { return _diverging_RdGy__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdGy", function() { return _diverging_RdGy__WEBPACK_IMPORTED_MODULE_14__["scheme"]; }); - -/* harmony import */ var _diverging_RdYlBu__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./diverging/RdYlBu */ "./node_modules/d3-scale-chromatic/src/diverging/RdYlBu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdYlBu", function() { return _diverging_RdYlBu__WEBPACK_IMPORTED_MODULE_15__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdYlBu", function() { return _diverging_RdYlBu__WEBPACK_IMPORTED_MODULE_15__["scheme"]; }); - -/* harmony import */ var _diverging_RdYlGn__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./diverging/RdYlGn */ "./node_modules/d3-scale-chromatic/src/diverging/RdYlGn.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdYlGn", function() { return _diverging_RdYlGn__WEBPACK_IMPORTED_MODULE_16__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdYlGn", function() { return _diverging_RdYlGn__WEBPACK_IMPORTED_MODULE_16__["scheme"]; }); - -/* harmony import */ var _diverging_Spectral__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./diverging/Spectral */ "./node_modules/d3-scale-chromatic/src/diverging/Spectral.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateSpectral", function() { return _diverging_Spectral__WEBPACK_IMPORTED_MODULE_17__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSpectral", function() { return _diverging_Spectral__WEBPACK_IMPORTED_MODULE_17__["scheme"]; }); - -/* harmony import */ var _sequential_multi_BuGn__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./sequential-multi/BuGn */ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuGn.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBuGn", function() { return _sequential_multi_BuGn__WEBPACK_IMPORTED_MODULE_18__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBuGn", function() { return _sequential_multi_BuGn__WEBPACK_IMPORTED_MODULE_18__["scheme"]; }); - -/* harmony import */ var _sequential_multi_BuPu__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./sequential-multi/BuPu */ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuPu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBuPu", function() { return _sequential_multi_BuPu__WEBPACK_IMPORTED_MODULE_19__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBuPu", function() { return _sequential_multi_BuPu__WEBPACK_IMPORTED_MODULE_19__["scheme"]; }); - -/* harmony import */ var _sequential_multi_GnBu__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./sequential-multi/GnBu */ "./node_modules/d3-scale-chromatic/src/sequential-multi/GnBu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateGnBu", function() { return _sequential_multi_GnBu__WEBPACK_IMPORTED_MODULE_20__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeGnBu", function() { return _sequential_multi_GnBu__WEBPACK_IMPORTED_MODULE_20__["scheme"]; }); - -/* harmony import */ var _sequential_multi_OrRd__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./sequential-multi/OrRd */ "./node_modules/d3-scale-chromatic/src/sequential-multi/OrRd.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateOrRd", function() { return _sequential_multi_OrRd__WEBPACK_IMPORTED_MODULE_21__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeOrRd", function() { return _sequential_multi_OrRd__WEBPACK_IMPORTED_MODULE_21__["scheme"]; }); - -/* harmony import */ var _sequential_multi_PuBuGn__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./sequential-multi/PuBuGn */ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBuGn.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuBuGn", function() { return _sequential_multi_PuBuGn__WEBPACK_IMPORTED_MODULE_22__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuBuGn", function() { return _sequential_multi_PuBuGn__WEBPACK_IMPORTED_MODULE_22__["scheme"]; }); - -/* harmony import */ var _sequential_multi_PuBu__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./sequential-multi/PuBu */ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuBu", function() { return _sequential_multi_PuBu__WEBPACK_IMPORTED_MODULE_23__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuBu", function() { return _sequential_multi_PuBu__WEBPACK_IMPORTED_MODULE_23__["scheme"]; }); - -/* harmony import */ var _sequential_multi_PuRd__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./sequential-multi/PuRd */ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuRd.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuRd", function() { return _sequential_multi_PuRd__WEBPACK_IMPORTED_MODULE_24__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuRd", function() { return _sequential_multi_PuRd__WEBPACK_IMPORTED_MODULE_24__["scheme"]; }); - -/* harmony import */ var _sequential_multi_RdPu__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./sequential-multi/RdPu */ "./node_modules/d3-scale-chromatic/src/sequential-multi/RdPu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdPu", function() { return _sequential_multi_RdPu__WEBPACK_IMPORTED_MODULE_25__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdPu", function() { return _sequential_multi_RdPu__WEBPACK_IMPORTED_MODULE_25__["scheme"]; }); - -/* harmony import */ var _sequential_multi_YlGnBu__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./sequential-multi/YlGnBu */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGnBu.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlGnBu", function() { return _sequential_multi_YlGnBu__WEBPACK_IMPORTED_MODULE_26__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlGnBu", function() { return _sequential_multi_YlGnBu__WEBPACK_IMPORTED_MODULE_26__["scheme"]; }); - -/* harmony import */ var _sequential_multi_YlGn__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./sequential-multi/YlGn */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGn.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlGn", function() { return _sequential_multi_YlGn__WEBPACK_IMPORTED_MODULE_27__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlGn", function() { return _sequential_multi_YlGn__WEBPACK_IMPORTED_MODULE_27__["scheme"]; }); - -/* harmony import */ var _sequential_multi_YlOrBr__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./sequential-multi/YlOrBr */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrBr.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlOrBr", function() { return _sequential_multi_YlOrBr__WEBPACK_IMPORTED_MODULE_28__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlOrBr", function() { return _sequential_multi_YlOrBr__WEBPACK_IMPORTED_MODULE_28__["scheme"]; }); - -/* harmony import */ var _sequential_multi_YlOrRd__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./sequential-multi/YlOrRd */ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrRd.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlOrRd", function() { return _sequential_multi_YlOrRd__WEBPACK_IMPORTED_MODULE_29__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlOrRd", function() { return _sequential_multi_YlOrRd__WEBPACK_IMPORTED_MODULE_29__["scheme"]; }); - -/* harmony import */ var _sequential_single_Blues__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./sequential-single/Blues */ "./node_modules/d3-scale-chromatic/src/sequential-single/Blues.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBlues", function() { return _sequential_single_Blues__WEBPACK_IMPORTED_MODULE_30__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBlues", function() { return _sequential_single_Blues__WEBPACK_IMPORTED_MODULE_30__["scheme"]; }); - -/* harmony import */ var _sequential_single_Greens__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./sequential-single/Greens */ "./node_modules/d3-scale-chromatic/src/sequential-single/Greens.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateGreens", function() { return _sequential_single_Greens__WEBPACK_IMPORTED_MODULE_31__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeGreens", function() { return _sequential_single_Greens__WEBPACK_IMPORTED_MODULE_31__["scheme"]; }); - -/* harmony import */ var _sequential_single_Greys__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(/*! ./sequential-single/Greys */ "./node_modules/d3-scale-chromatic/src/sequential-single/Greys.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateGreys", function() { return _sequential_single_Greys__WEBPACK_IMPORTED_MODULE_32__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeGreys", function() { return _sequential_single_Greys__WEBPACK_IMPORTED_MODULE_32__["scheme"]; }); - -/* harmony import */ var _sequential_single_Purples__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(/*! ./sequential-single/Purples */ "./node_modules/d3-scale-chromatic/src/sequential-single/Purples.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePurples", function() { return _sequential_single_Purples__WEBPACK_IMPORTED_MODULE_33__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePurples", function() { return _sequential_single_Purples__WEBPACK_IMPORTED_MODULE_33__["scheme"]; }); - -/* harmony import */ var _sequential_single_Reds__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(/*! ./sequential-single/Reds */ "./node_modules/d3-scale-chromatic/src/sequential-single/Reds.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateReds", function() { return _sequential_single_Reds__WEBPACK_IMPORTED_MODULE_34__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeReds", function() { return _sequential_single_Reds__WEBPACK_IMPORTED_MODULE_34__["scheme"]; }); - -/* harmony import */ var _sequential_single_Oranges__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(/*! ./sequential-single/Oranges */ "./node_modules/d3-scale-chromatic/src/sequential-single/Oranges.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateOranges", function() { return _sequential_single_Oranges__WEBPACK_IMPORTED_MODULE_35__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeOranges", function() { return _sequential_single_Oranges__WEBPACK_IMPORTED_MODULE_35__["scheme"]; }); - -/* harmony import */ var _sequential_multi_cubehelix__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./sequential-multi/cubehelix */ "./node_modules/d3-scale-chromatic/src/sequential-multi/cubehelix.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCubehelixDefault", function() { return _sequential_multi_cubehelix__WEBPACK_IMPORTED_MODULE_36__["default"]; }); - -/* harmony import */ var _sequential_multi_rainbow__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ./sequential-multi/rainbow */ "./node_modules/d3-scale-chromatic/src/sequential-multi/rainbow.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRainbow", function() { return _sequential_multi_rainbow__WEBPACK_IMPORTED_MODULE_37__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateWarm", function() { return _sequential_multi_rainbow__WEBPACK_IMPORTED_MODULE_37__["warm"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCool", function() { return _sequential_multi_rainbow__WEBPACK_IMPORTED_MODULE_37__["cool"]; }); - -/* harmony import */ var _sequential_multi_sinebow__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(/*! ./sequential-multi/sinebow */ "./node_modules/d3-scale-chromatic/src/sequential-multi/sinebow.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateSinebow", function() { return _sequential_multi_sinebow__WEBPACK_IMPORTED_MODULE_38__["default"]; }); - -/* harmony import */ var _sequential_multi_viridis__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./sequential-multi/viridis */ "./node_modules/d3-scale-chromatic/src/sequential-multi/viridis.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateViridis", function() { return _sequential_multi_viridis__WEBPACK_IMPORTED_MODULE_39__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateMagma", function() { return _sequential_multi_viridis__WEBPACK_IMPORTED_MODULE_39__["magma"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateInferno", function() { return _sequential_multi_viridis__WEBPACK_IMPORTED_MODULE_39__["inferno"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePlasma", function() { return _sequential_multi_viridis__WEBPACK_IMPORTED_MODULE_39__["plasma"]; }); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/ramp.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/ramp.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(scheme) { - return Object(d3_interpolate__WEBPACK_IMPORTED_MODULE_0__["interpolateRgbBasis"])(scheme[scheme.length - 1]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuGn.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/BuGn.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "e5f5f999d8c92ca25f", - "edf8fbb2e2e266c2a4238b45", - "edf8fbb2e2e266c2a42ca25f006d2c", - "edf8fbccece699d8c966c2a42ca25f006d2c", - "edf8fbccece699d8c966c2a441ae76238b45005824", - "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824", - "f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/BuPu.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/BuPu.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "e0ecf49ebcda8856a7", - "edf8fbb3cde38c96c688419d", - "edf8fbb3cde38c96c68856a7810f7c", - "edf8fbbfd3e69ebcda8c96c68856a7810f7c", - "edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b", - "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b", - "f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/GnBu.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/GnBu.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "e0f3dba8ddb543a2ca", - "f0f9e8bae4bc7bccc42b8cbe", - "f0f9e8bae4bc7bccc443a2ca0868ac", - "f0f9e8ccebc5a8ddb57bccc443a2ca0868ac", - "f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e", - "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e", - "f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/OrRd.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/OrRd.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fee8c8fdbb84e34a33", - "fef0d9fdcc8afc8d59d7301f", - "fef0d9fdcc8afc8d59e34a33b30000", - "fef0d9fdd49efdbb84fc8d59e34a33b30000", - "fef0d9fdd49efdbb84fc8d59ef6548d7301f990000", - "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000", - "fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBu.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/PuBu.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "ece7f2a6bddb2b8cbe", - "f1eef6bdc9e174a9cf0570b0", - "f1eef6bdc9e174a9cf2b8cbe045a8d", - "f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d", - "f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b", - "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b", - "fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuBuGn.js": -/*!************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/PuBuGn.js ***! - \************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "ece2f0a6bddb1c9099", - "f6eff7bdc9e167a9cf02818a", - "f6eff7bdc9e167a9cf1c9099016c59", - "f6eff7d0d1e6a6bddb67a9cf1c9099016c59", - "f6eff7d0d1e6a6bddb67a9cf3690c002818a016450", - "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450", - "fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/PuRd.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/PuRd.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "e7e1efc994c7dd1c77", - "f1eef6d7b5d8df65b0ce1256", - "f1eef6d7b5d8df65b0dd1c77980043", - "f1eef6d4b9dac994c7df65b0dd1c77980043", - "f1eef6d4b9dac994c7df65b0e7298ace125691003f", - "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f", - "f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/RdPu.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/RdPu.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fde0ddfa9fb5c51b8a", - "feebe2fbb4b9f768a1ae017e", - "feebe2fbb4b9f768a1c51b8a7a0177", - "feebe2fcc5c0fa9fb5f768a1c51b8a7a0177", - "feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177", - "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177", - "fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGn.js": -/*!**********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlGn.js ***! - \**********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "f7fcb9addd8e31a354", - "ffffccc2e69978c679238443", - "ffffccc2e69978c67931a354006837", - "ffffccd9f0a3addd8e78c67931a354006837", - "ffffccd9f0a3addd8e78c67941ab5d238443005a32", - "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32", - "ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlGnBu.js": -/*!************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlGnBu.js ***! - \************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "edf8b17fcdbb2c7fb8", - "ffffcca1dab441b6c4225ea8", - "ffffcca1dab441b6c42c7fb8253494", - "ffffccc7e9b47fcdbb41b6c42c7fb8253494", - "ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84", - "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84", - "ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrBr.js": -/*!************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrBr.js ***! - \************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fff7bcfec44fd95f0e", - "ffffd4fed98efe9929cc4c02", - "ffffd4fed98efe9929d95f0e993404", - "ffffd4fee391fec44ffe9929d95f0e993404", - "ffffd4fee391fec44ffe9929ec7014cc4c028c2d04", - "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04", - "ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrRd.js": -/*!************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/YlOrRd.js ***! - \************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "ffeda0feb24cf03b20", - "ffffb2fecc5cfd8d3ce31a1c", - "ffffb2fecc5cfd8d3cf03b20bd0026", - "ffffb2fed976feb24cfd8d3cf03b20bd0026", - "ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026", - "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026", - "ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/cubehelix.js": -/*!***************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/cubehelix.js ***! - \***************************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (Object(d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateCubehelixLong"])(Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(300, 0.5, 0.0), Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(-240, 0.5, 1.0))); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/rainbow.js": -/*!*************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/rainbow.js ***! - \*************************************************************************/ -/*! exports provided: warm, cool, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "warm", function() { return warm; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cool", function() { return cool; }); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); - - - -var warm = Object(d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateCubehelixLong"])(Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(-100, 0.75, 0.35), Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(80, 1.50, 0.8)); - -var cool = Object(d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateCubehelixLong"])(Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(260, 0.75, 0.35), Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(80, 1.50, 0.8)); - -var c = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["cubehelix"])(); - -/* harmony default export */ __webpack_exports__["default"] = (function(t) { - if (t < 0 || t > 1) t -= Math.floor(t); - var ts = Math.abs(t - 0.5); - c.h = 360 * t - 100; - c.s = 1.5 - 1.5 * ts; - c.l = 0.8 - 0.9 * ts; - return c + ""; -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/sinebow.js": -/*!*************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/sinebow.js ***! - \*************************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); - - -var c = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["rgb"])(), - pi_1_3 = Math.PI / 3, - pi_2_3 = Math.PI * 2 / 3; - -/* harmony default export */ __webpack_exports__["default"] = (function(t) { - var x; - t = (0.5 - t) * Math.PI; - c.r = 255 * (x = Math.sin(t)) * x; - c.g = 255 * (x = Math.sin(t + pi_1_3)) * x; - c.b = 255 * (x = Math.sin(t + pi_2_3)) * x; - return c + ""; -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-multi/viridis.js": -/*!*************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-multi/viridis.js ***! - \*************************************************************************/ -/*! exports provided: default, magma, inferno, plasma */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "magma", function() { return magma; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "inferno", function() { return inferno; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "plasma", function() { return plasma; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); - - -function ramp(range) { - var n = range.length; - return function(t) { - return range[Math.max(0, Math.min(n - 1, Math.floor(t * n)))]; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (ramp(Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725"))); - -var magma = ramp(Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")); - -var inferno = ramp(Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")); - -var plasma = ramp(Object(_colors__WEBPACK_IMPORTED_MODULE_0__["default"])("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921")); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Blues.js": -/*!************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Blues.js ***! - \************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "deebf79ecae13182bd", - "eff3ffbdd7e76baed62171b5", - "eff3ffbdd7e76baed63182bd08519c", - "eff3ffc6dbef9ecae16baed63182bd08519c", - "eff3ffc6dbef9ecae16baed64292c62171b5084594", - "f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594", - "f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Greens.js": -/*!*************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Greens.js ***! - \*************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "e5f5e0a1d99b31a354", - "edf8e9bae4b374c476238b45", - "edf8e9bae4b374c47631a354006d2c", - "edf8e9c7e9c0a1d99b74c47631a354006d2c", - "edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32", - "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32", - "f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Greys.js": -/*!************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Greys.js ***! - \************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "f0f0f0bdbdbd636363", - "f7f7f7cccccc969696525252", - "f7f7f7cccccc969696636363252525", - "f7f7f7d9d9d9bdbdbd969696636363252525", - "f7f7f7d9d9d9bdbdbd969696737373525252252525", - "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525", - "fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Oranges.js": -/*!**************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Oranges.js ***! - \**************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fee6cefdae6be6550d", - "feeddefdbe85fd8d3cd94701", - "feeddefdbe85fd8d3ce6550da63603", - "feeddefdd0a2fdae6bfd8d3ce6550da63603", - "feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04", - "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04", - "fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Purples.js": -/*!**************************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Purples.js ***! - \**************************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "efedf5bcbddc756bb1", - "f2f0f7cbc9e29e9ac86a51a3", - "f2f0f7cbc9e29e9ac8756bb154278f", - "f2f0f7dadaebbcbddc9e9ac8756bb154278f", - "f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486", - "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486", - "fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale-chromatic/src/sequential-single/Reds.js": -/*!***********************************************************************!*\ - !*** ./node_modules/d3-scale-chromatic/src/sequential-single/Reds.js ***! - \***********************************************************************/ -/*! exports provided: scheme, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scheme", function() { return scheme; }); -/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../colors */ "./node_modules/d3-scale-chromatic/src/colors.js"); -/* harmony import */ var _ramp__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../ramp */ "./node_modules/d3-scale-chromatic/src/ramp.js"); - - - -var scheme = new Array(3).concat( - "fee0d2fc9272de2d26", - "fee5d9fcae91fb6a4acb181d", - "fee5d9fcae91fb6a4ade2d26a50f15", - "fee5d9fcbba1fc9272fb6a4ade2d26a50f15", - "fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d", - "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d", - "fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d" -).map(_colors__WEBPACK_IMPORTED_MODULE_0__["default"]); - -/* harmony default export */ __webpack_exports__["default"] = (Object(_ramp__WEBPACK_IMPORTED_MODULE_1__["default"])(scheme)); - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/array.js": -/*!********************************************!*\ - !*** ./node_modules/d3-scale/src/array.js ***! - \********************************************/ -/*! exports provided: map, slice */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "map", function() { return map; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -var array = Array.prototype; - -var map = array.map; -var slice = array.slice; - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/band.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-scale/src/band.js ***! - \*******************************************/ -/*! exports provided: default, point */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return band; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "point", function() { return point; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _ordinal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ordinal */ "./node_modules/d3-scale/src/ordinal.js"); - - - -function band() { - var scale = Object(_ordinal__WEBPACK_IMPORTED_MODULE_1__["default"])().unknown(undefined), - domain = scale.domain, - ordinalRange = scale.range, - range = [0, 1], - step, - bandwidth, - round = false, - paddingInner = 0, - paddingOuter = 0, - align = 0.5; - - delete scale.unknown; - - function rescale() { - var n = domain().length, - reverse = range[1] < range[0], - start = range[reverse - 0], - stop = range[1 - reverse]; - step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2); - if (round) step = Math.floor(step); - start += (stop - start - step * (n - paddingInner)) * align; - bandwidth = step * (1 - paddingInner); - if (round) start = Math.round(start), bandwidth = Math.round(bandwidth); - var values = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["range"])(n).map(function(i) { return start + step * i; }); - return ordinalRange(reverse ? values.reverse() : values); - } - - scale.domain = function(_) { - return arguments.length ? (domain(_), rescale()) : domain(); - }; - - scale.range = function(_) { - return arguments.length ? (range = [+_[0], +_[1]], rescale()) : range.slice(); - }; - - scale.rangeRound = function(_) { - return range = [+_[0], +_[1]], round = true, rescale(); - }; - - scale.bandwidth = function() { - return bandwidth; - }; - - scale.step = function() { - return step; - }; - - scale.round = function(_) { - return arguments.length ? (round = !!_, rescale()) : round; - }; - - scale.padding = function(_) { - return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner; - }; - - scale.paddingInner = function(_) { - return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner; - }; - - scale.paddingOuter = function(_) { - return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter; - }; - - scale.align = function(_) { - return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align; - }; - - scale.copy = function() { - return band() - .domain(domain()) - .range(range) - .round(round) - .paddingInner(paddingInner) - .paddingOuter(paddingOuter) - .align(align); - }; - - return rescale(); -} - -function pointish(scale) { - var copy = scale.copy; - - scale.padding = scale.paddingOuter; - delete scale.paddingInner; - delete scale.paddingOuter; - - scale.copy = function() { - return pointish(copy()); - }; - - return scale; -} - -function point() { - return pointish(band().paddingInner(1)); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/constant.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-scale/src/constant.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/continuous.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-scale/src/continuous.js ***! - \*************************************************/ -/*! exports provided: deinterpolateLinear, copy, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "deinterpolateLinear", function() { return deinterpolateLinear; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return continuous; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-scale/src/constant.js"); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./number */ "./node_modules/d3-scale/src/number.js"); - - - - - - -var unit = [0, 1]; - -function deinterpolateLinear(a, b) { - return (b -= (a = +a)) - ? function(x) { return (x - a) / b; } - : Object(_constant__WEBPACK_IMPORTED_MODULE_3__["default"])(b); -} - -function deinterpolateClamp(deinterpolate) { - return function(a, b) { - var d = deinterpolate(a = +a, b = +b); - return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); }; - }; -} - -function reinterpolateClamp(reinterpolate) { - return function(a, b) { - var r = reinterpolate(a = +a, b = +b); - return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); }; - }; -} - -function bimap(domain, range, deinterpolate, reinterpolate) { - var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1]; - if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0); - else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1); - return function(x) { return r0(d0(x)); }; -} - -function polymap(domain, range, deinterpolate, reinterpolate) { - var j = Math.min(domain.length, range.length) - 1, - d = new Array(j), - r = new Array(j), - i = -1; - - // Reverse descending domains. - if (domain[j] < domain[0]) { - domain = domain.slice().reverse(); - range = range.slice().reverse(); - } - - while (++i < j) { - d[i] = deinterpolate(domain[i], domain[i + 1]); - r[i] = reinterpolate(range[i], range[i + 1]); - } - - return function(x) { - var i = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["bisect"])(domain, x, 1, j) - 1; - return r[i](d[i](x)); - }; -} - -function copy(source, target) { - return target - .domain(source.domain()) - .range(source.range()) - .interpolate(source.interpolate()) - .clamp(source.clamp()); -} - -// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1]. -// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b]. -function continuous(deinterpolate, reinterpolate) { - var domain = unit, - range = unit, - interpolate = d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolate"], - clamp = false, - piecewise, - output, - input; - - function rescale() { - piecewise = Math.min(domain.length, range.length) > 2 ? polymap : bimap; - output = input = null; - return scale; - } - - function scale(x) { - return (output || (output = piecewise(domain, range, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate)))(+x); - } - - scale.invert = function(y) { - return (input || (input = piecewise(range, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y); - }; - - scale.domain = function(_) { - return arguments.length ? (domain = _array__WEBPACK_IMPORTED_MODULE_2__["map"].call(_, _number__WEBPACK_IMPORTED_MODULE_4__["default"]), rescale()) : domain.slice(); - }; - - scale.range = function(_) { - return arguments.length ? (range = _array__WEBPACK_IMPORTED_MODULE_2__["slice"].call(_), rescale()) : range.slice(); - }; - - scale.rangeRound = function(_) { - return range = _array__WEBPACK_IMPORTED_MODULE_2__["slice"].call(_), interpolate = d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateRound"], rescale(); - }; - - scale.clamp = function(_) { - return arguments.length ? (clamp = !!_, rescale()) : clamp; - }; - - scale.interpolate = function(_) { - return arguments.length ? (interpolate = _, rescale()) : interpolate; - }; - - return rescale(); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/diverging.js": -/*!************************************************!*\ - !*** ./node_modules/d3-scale/src/diverging.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return diverging; }); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-scale/src/linear.js"); - - -function diverging(interpolator) { - var x0 = 0, - x1 = 0.5, - x2 = 1, - k10 = 1, - k21 = 1, - clamp = false; - - function scale(x) { - var t = 0.5 + ((x = +x) - x1) * (x < x1 ? k10 : k21); - return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t); - } - - scale.domain = function(_) { - return arguments.length ? (x0 = +_[0], x1 = +_[1], x2 = +_[2], k10 = x0 === x1 ? 0 : 0.5 / (x1 - x0), k21 = x1 === x2 ? 0 : 0.5 / (x2 - x1), scale) : [x0, x1, x2]; - }; - - scale.clamp = function(_) { - return arguments.length ? (clamp = !!_, scale) : clamp; - }; - - scale.interpolator = function(_) { - return arguments.length ? (interpolator = _, scale) : interpolator; - }; - - scale.copy = function() { - return diverging(interpolator).domain([x0, x1, x2]).clamp(clamp); - }; - - return Object(_linear__WEBPACK_IMPORTED_MODULE_0__["linearish"])(scale); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/identity.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-scale/src/identity.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return identity; }); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-scale/src/linear.js"); -/* harmony import */ var _number__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./number */ "./node_modules/d3-scale/src/number.js"); - - - - -function identity() { - var domain = [0, 1]; - - function scale(x) { - return +x; - } - - scale.invert = scale; - - scale.domain = scale.range = function(_) { - return arguments.length ? (domain = _array__WEBPACK_IMPORTED_MODULE_0__["map"].call(_, _number__WEBPACK_IMPORTED_MODULE_2__["default"]), scale) : domain.slice(); - }; - - scale.copy = function() { - return identity().domain(domain); - }; - - return Object(_linear__WEBPACK_IMPORTED_MODULE_1__["linearish"])(scale); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-scale/src/index.js ***! - \********************************************/ -/*! exports provided: scaleBand, scalePoint, scaleIdentity, scaleLinear, scaleLog, scaleOrdinal, scaleImplicit, scalePow, scaleSqrt, scaleQuantile, scaleQuantize, scaleThreshold, scaleTime, scaleUtc, scaleSequential, scaleDiverging */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _band__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./band */ "./node_modules/d3-scale/src/band.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleBand", function() { return _band__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scalePoint", function() { return _band__WEBPACK_IMPORTED_MODULE_0__["point"]; }); - -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./identity */ "./node_modules/d3-scale/src/identity.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleIdentity", function() { return _identity__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-scale/src/linear.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleLinear", function() { return _linear__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _log__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./log */ "./node_modules/d3-scale/src/log.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleLog", function() { return _log__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _ordinal__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./ordinal */ "./node_modules/d3-scale/src/ordinal.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleOrdinal", function() { return _ordinal__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleImplicit", function() { return _ordinal__WEBPACK_IMPORTED_MODULE_4__["implicit"]; }); - -/* harmony import */ var _pow__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./pow */ "./node_modules/d3-scale/src/pow.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scalePow", function() { return _pow__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleSqrt", function() { return _pow__WEBPACK_IMPORTED_MODULE_5__["sqrt"]; }); - -/* harmony import */ var _quantile__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./quantile */ "./node_modules/d3-scale/src/quantile.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleQuantile", function() { return _quantile__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _quantize__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./quantize */ "./node_modules/d3-scale/src/quantize.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleQuantize", function() { return _quantize__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _threshold__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./threshold */ "./node_modules/d3-scale/src/threshold.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleThreshold", function() { return _threshold__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _time__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./time */ "./node_modules/d3-scale/src/time.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleTime", function() { return _time__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _utcTime__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./utcTime */ "./node_modules/d3-scale/src/utcTime.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleUtc", function() { return _utcTime__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony import */ var _sequential__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./sequential */ "./node_modules/d3-scale/src/sequential.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleSequential", function() { return _sequential__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony import */ var _diverging__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./diverging */ "./node_modules/d3-scale/src/diverging.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleDiverging", function() { return _diverging__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/linear.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-scale/src/linear.js ***! - \*********************************************/ -/*! exports provided: linearish, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linearish", function() { return linearish; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return linear; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./continuous */ "./node_modules/d3-scale/src/continuous.js"); -/* harmony import */ var _tickFormat__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./tickFormat */ "./node_modules/d3-scale/src/tickFormat.js"); - - - - - -function linearish(scale) { - var domain = scale.domain; - - scale.ticks = function(count) { - var d = domain(); - return Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["ticks"])(d[0], d[d.length - 1], count == null ? 10 : count); - }; - - scale.tickFormat = function(count, specifier) { - return Object(_tickFormat__WEBPACK_IMPORTED_MODULE_3__["default"])(domain(), count, specifier); - }; - - scale.nice = function(count) { - if (count == null) count = 10; - - var d = domain(), - i0 = 0, - i1 = d.length - 1, - start = d[i0], - stop = d[i1], - step; - - if (stop < start) { - step = start, start = stop, stop = step; - step = i0, i0 = i1, i1 = step; - } - - step = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickIncrement"])(start, stop, count); - - if (step > 0) { - start = Math.floor(start / step) * step; - stop = Math.ceil(stop / step) * step; - step = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickIncrement"])(start, stop, count); - } else if (step < 0) { - start = Math.ceil(start * step) / step; - stop = Math.floor(stop * step) / step; - step = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickIncrement"])(start, stop, count); - } - - if (step > 0) { - d[i0] = Math.floor(start / step) * step; - d[i1] = Math.ceil(stop / step) * step; - domain(d); - } else if (step < 0) { - d[i0] = Math.ceil(start * step) / step; - d[i1] = Math.floor(stop * step) / step; - domain(d); - } - - return scale; - }; - - return scale; -} - -function linear() { - var scale = Object(_continuous__WEBPACK_IMPORTED_MODULE_2__["default"])(_continuous__WEBPACK_IMPORTED_MODULE_2__["deinterpolateLinear"], d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateNumber"]); - - scale.copy = function() { - return Object(_continuous__WEBPACK_IMPORTED_MODULE_2__["copy"])(scale, linear()); - }; - - return linearish(scale); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/log.js": -/*!******************************************!*\ - !*** ./node_modules/d3-scale/src/log.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return log; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-format */ "./node_modules/d3-format/src/index.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-scale/src/constant.js"); -/* harmony import */ var _nice__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./nice */ "./node_modules/d3-scale/src/nice.js"); -/* harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./continuous */ "./node_modules/d3-scale/src/continuous.js"); - - - - - - -function deinterpolate(a, b) { - return (b = Math.log(b / a)) - ? function(x) { return Math.log(x / a) / b; } - : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(b); -} - -function reinterpolate(a, b) { - return a < 0 - ? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); } - : function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); }; -} - -function pow10(x) { - return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x; -} - -function powp(base) { - return base === 10 ? pow10 - : base === Math.E ? Math.exp - : function(x) { return Math.pow(base, x); }; -} - -function logp(base) { - return base === Math.E ? Math.log - : base === 10 && Math.log10 - || base === 2 && Math.log2 - || (base = Math.log(base), function(x) { return Math.log(x) / base; }); -} - -function reflect(f) { - return function(x) { - return -f(-x); - }; -} - -function log() { - var scale = Object(_continuous__WEBPACK_IMPORTED_MODULE_4__["default"])(deinterpolate, reinterpolate).domain([1, 10]), - domain = scale.domain, - base = 10, - logs = logp(10), - pows = powp(10); - - function rescale() { - logs = logp(base), pows = powp(base); - if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows); - return scale; - } - - scale.base = function(_) { - return arguments.length ? (base = +_, rescale()) : base; - }; - - scale.domain = function(_) { - return arguments.length ? (domain(_), rescale()) : domain(); - }; - - scale.ticks = function(count) { - var d = domain(), - u = d[0], - v = d[d.length - 1], - r; - - if (r = v < u) i = u, u = v, v = i; - - var i = logs(u), - j = logs(v), - p, - k, - t, - n = count == null ? 10 : +count, - z = []; - - if (!(base % 1) && j - i < n) { - i = Math.round(i) - 1, j = Math.round(j) + 1; - if (u > 0) for (; i < j; ++i) { - for (k = 1, p = pows(i); k < base; ++k) { - t = p * k; - if (t < u) continue; - if (t > v) break; - z.push(t); - } - } else for (; i < j; ++i) { - for (k = base - 1, p = pows(i); k >= 1; --k) { - t = p * k; - if (t < u) continue; - if (t > v) break; - z.push(t); - } - } - } else { - z = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["ticks"])(i, j, Math.min(j - i, n)).map(pows); - } - - return r ? z.reverse() : z; - }; - - scale.tickFormat = function(count, specifier) { - if (specifier == null) specifier = base === 10 ? ".0e" : ","; - if (typeof specifier !== "function") specifier = Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["format"])(specifier); - if (count === Infinity) return specifier; - if (count == null) count = 10; - var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate? - return function(d) { - var i = d / pows(Math.round(logs(d))); - if (i * base < base - 0.5) i *= base; - return i <= k ? specifier(d) : ""; - }; - }; - - scale.nice = function() { - return domain(Object(_nice__WEBPACK_IMPORTED_MODULE_3__["default"])(domain(), { - floor: function(x) { return pows(Math.floor(logs(x))); }, - ceil: function(x) { return pows(Math.ceil(logs(x))); } - })); - }; - - scale.copy = function() { - return Object(_continuous__WEBPACK_IMPORTED_MODULE_4__["copy"])(scale, log().base(base)); - }; - - return scale; -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/nice.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-scale/src/nice.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(domain, interval) { - domain = domain.slice(); - - var i0 = 0, - i1 = domain.length - 1, - x0 = domain[i0], - x1 = domain[i1], - t; - - if (x1 < x0) { - t = i0, i0 = i1, i1 = t; - t = x0, x0 = x1, x1 = t; - } - - domain[i0] = interval.floor(x0); - domain[i1] = interval.ceil(x1); - return domain; -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/number.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-scale/src/number.js ***! - \*********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return +x; -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/ordinal.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-scale/src/ordinal.js ***! - \**********************************************/ -/*! exports provided: implicit, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "implicit", function() { return implicit; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ordinal; }); -/* harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-collection */ "./node_modules/d3-collection/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); - - - -var implicit = {name: "implicit"}; - -function ordinal(range) { - var index = Object(d3_collection__WEBPACK_IMPORTED_MODULE_0__["map"])(), - domain = [], - unknown = implicit; - - range = range == null ? [] : _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(range); - - function scale(d) { - var key = d + "", i = index.get(key); - if (!i) { - if (unknown !== implicit) return unknown; - index.set(key, i = domain.push(d)); - } - return range[(i - 1) % range.length]; - } - - scale.domain = function(_) { - if (!arguments.length) return domain.slice(); - domain = [], index = Object(d3_collection__WEBPACK_IMPORTED_MODULE_0__["map"])(); - var i = -1, n = _.length, d, key; - while (++i < n) if (!index.has(key = (d = _[i]) + "")) index.set(key, domain.push(d)); - return scale; - }; - - scale.range = function(_) { - return arguments.length ? (range = _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_), scale) : range.slice(); - }; - - scale.unknown = function(_) { - return arguments.length ? (unknown = _, scale) : unknown; - }; - - scale.copy = function() { - return ordinal() - .domain(domain) - .range(range) - .unknown(unknown); - }; - - return scale; -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/pow.js": -/*!******************************************!*\ - !*** ./node_modules/d3-scale/src/pow.js ***! - \******************************************/ -/*! exports provided: default, sqrt */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return pow; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrt", function() { return sqrt; }); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-scale/src/constant.js"); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-scale/src/linear.js"); -/* harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./continuous */ "./node_modules/d3-scale/src/continuous.js"); - - - - -function raise(x, exponent) { - return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent); -} - -function pow() { - var exponent = 1, - scale = Object(_continuous__WEBPACK_IMPORTED_MODULE_2__["default"])(deinterpolate, reinterpolate), - domain = scale.domain; - - function deinterpolate(a, b) { - return (b = raise(b, exponent) - (a = raise(a, exponent))) - ? function(x) { return (raise(x, exponent) - a) / b; } - : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(b); - } - - function reinterpolate(a, b) { - b = raise(b, exponent) - (a = raise(a, exponent)); - return function(t) { return raise(a + b * t, 1 / exponent); }; - } - - scale.exponent = function(_) { - return arguments.length ? (exponent = +_, domain(domain())) : exponent; - }; - - scale.copy = function() { - return Object(_continuous__WEBPACK_IMPORTED_MODULE_2__["copy"])(scale, pow().exponent(exponent)); - }; - - return Object(_linear__WEBPACK_IMPORTED_MODULE_1__["linearish"])(scale); -} - -function sqrt() { - return pow().exponent(0.5); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/quantile.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-scale/src/quantile.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return quantile; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); - - - -function quantile() { - var domain = [], - range = [], - thresholds = []; - - function rescale() { - var i = 0, n = Math.max(1, range.length); - thresholds = new Array(n - 1); - while (++i < n) thresholds[i - 1] = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["quantile"])(domain, i / n); - return scale; - } - - function scale(x) { - if (!isNaN(x = +x)) return range[Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["bisect"])(thresholds, x)]; - } - - scale.invertExtent = function(y) { - var i = range.indexOf(y); - return i < 0 ? [NaN, NaN] : [ - i > 0 ? thresholds[i - 1] : domain[0], - i < thresholds.length ? thresholds[i] : domain[domain.length - 1] - ]; - }; - - scale.domain = function(_) { - if (!arguments.length) return domain.slice(); - domain = []; - for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d); - domain.sort(d3_array__WEBPACK_IMPORTED_MODULE_0__["ascending"]); - return rescale(); - }; - - scale.range = function(_) { - return arguments.length ? (range = _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_), rescale()) : range.slice(); - }; - - scale.quantiles = function() { - return thresholds.slice(); - }; - - scale.copy = function() { - return quantile() - .domain(domain) - .range(range); - }; - - return scale; -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/quantize.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-scale/src/quantize.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return quantize; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-scale/src/linear.js"); - - - - -function quantize() { - var x0 = 0, - x1 = 1, - n = 1, - domain = [0.5], - range = [0, 1]; - - function scale(x) { - if (x <= x) return range[Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["bisect"])(domain, x, 0, n)]; - } - - function rescale() { - var i = -1; - domain = new Array(n); - while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1); - return scale; - } - - scale.domain = function(_) { - return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1]; - }; - - scale.range = function(_) { - return arguments.length ? (n = (range = _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_)).length - 1, rescale()) : range.slice(); - }; - - scale.invertExtent = function(y) { - var i = range.indexOf(y); - return i < 0 ? [NaN, NaN] - : i < 1 ? [x0, domain[0]] - : i >= n ? [domain[n - 1], x1] - : [domain[i - 1], domain[i]]; - }; - - scale.copy = function() { - return quantize() - .domain([x0, x1]) - .range(range); - }; - - return Object(_linear__WEBPACK_IMPORTED_MODULE_2__["linearish"])(scale); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/sequential.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-scale/src/sequential.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return sequential; }); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-scale/src/linear.js"); - - -function sequential(interpolator) { - var x0 = 0, - x1 = 1, - k10 = 1, - clamp = false; - - function scale(x) { - var t = (x - x0) * k10; - return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t); - } - - scale.domain = function(_) { - return arguments.length ? (x0 = +_[0], x1 = +_[1], k10 = x0 === x1 ? 0 : 1 / (x1 - x0), scale) : [x0, x1]; - }; - - scale.clamp = function(_) { - return arguments.length ? (clamp = !!_, scale) : clamp; - }; - - scale.interpolator = function(_) { - return arguments.length ? (interpolator = _, scale) : interpolator; - }; - - scale.copy = function() { - return sequential(interpolator).domain([x0, x1]).clamp(clamp); - }; - - return Object(_linear__WEBPACK_IMPORTED_MODULE_0__["linearish"])(scale); -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/threshold.js": -/*!************************************************!*\ - !*** ./node_modules/d3-scale/src/threshold.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return threshold; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); - - - -function threshold() { - var domain = [0.5], - range = [0, 1], - n = 1; - - function scale(x) { - if (x <= x) return range[Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["bisect"])(domain, x, 0, n)]; - } - - scale.domain = function(_) { - return arguments.length ? (domain = _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice(); - }; - - scale.range = function(_) { - return arguments.length ? (range = _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice(); - }; - - scale.invertExtent = function(y) { - var i = range.indexOf(y); - return [domain[i - 1], domain[i]]; - }; - - scale.copy = function() { - return threshold() - .domain(domain) - .range(range); - }; - - return scale; -} - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/tickFormat.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-scale/src/tickFormat.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-format */ "./node_modules/d3-format/src/index.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(domain, count, specifier) { - var start = domain[0], - stop = domain[domain.length - 1], - step = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickStep"])(start, stop, count == null ? 10 : count), - precision; - specifier = Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["formatSpecifier"])(specifier == null ? ",f" : specifier); - switch (specifier.type) { - case "s": { - var value = Math.max(Math.abs(start), Math.abs(stop)); - if (specifier.precision == null && !isNaN(precision = Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["precisionPrefix"])(step, value))) specifier.precision = precision; - return Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["formatPrefix"])(specifier, value); - } - case "": - case "e": - case "g": - case "p": - case "r": { - if (specifier.precision == null && !isNaN(precision = Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["precisionRound"])(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e"); - break; - } - case "f": - case "%": { - if (specifier.precision == null && !isNaN(precision = Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["precisionFixed"])(step))) specifier.precision = precision - (specifier.type === "%") * 2; - break; - } - } - return Object(d3_format__WEBPACK_IMPORTED_MODULE_1__["format"])(specifier); -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/time.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-scale/src/time.js ***! - \*******************************************/ -/*! exports provided: calendar, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "calendar", function() { return calendar; }); -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-time */ "./node_modules/d3-time/src/index.js"); -/* harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! d3-time-format */ "./node_modules/d3-time-format/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./array */ "./node_modules/d3-scale/src/array.js"); -/* harmony import */ var _continuous__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./continuous */ "./node_modules/d3-scale/src/continuous.js"); -/* harmony import */ var _nice__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./nice */ "./node_modules/d3-scale/src/nice.js"); - - - - - - - - -var durationSecond = 1000, - durationMinute = durationSecond * 60, - durationHour = durationMinute * 60, - durationDay = durationHour * 24, - durationWeek = durationDay * 7, - durationMonth = durationDay * 30, - durationYear = durationDay * 365; - -function date(t) { - return new Date(t); -} - -function number(t) { - return t instanceof Date ? +t : +new Date(+t); -} - -function calendar(year, month, week, day, hour, minute, second, millisecond, format) { - var scale = Object(_continuous__WEBPACK_IMPORTED_MODULE_5__["default"])(_continuous__WEBPACK_IMPORTED_MODULE_5__["deinterpolateLinear"], d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateNumber"]), - invert = scale.invert, - domain = scale.domain; - - var formatMillisecond = format(".%L"), - formatSecond = format(":%S"), - formatMinute = format("%I:%M"), - formatHour = format("%I %p"), - formatDay = format("%a %d"), - formatWeek = format("%b %d"), - formatMonth = format("%B"), - formatYear = format("%Y"); - - var tickIntervals = [ - [second, 1, durationSecond], - [second, 5, 5 * durationSecond], - [second, 15, 15 * durationSecond], - [second, 30, 30 * durationSecond], - [minute, 1, durationMinute], - [minute, 5, 5 * durationMinute], - [minute, 15, 15 * durationMinute], - [minute, 30, 30 * durationMinute], - [ hour, 1, durationHour ], - [ hour, 3, 3 * durationHour ], - [ hour, 6, 6 * durationHour ], - [ hour, 12, 12 * durationHour ], - [ day, 1, durationDay ], - [ day, 2, 2 * durationDay ], - [ week, 1, durationWeek ], - [ month, 1, durationMonth ], - [ month, 3, 3 * durationMonth ], - [ year, 1, durationYear ] - ]; - - function tickFormat(date) { - return (second(date) < date ? formatMillisecond - : minute(date) < date ? formatSecond - : hour(date) < date ? formatMinute - : day(date) < date ? formatHour - : month(date) < date ? (week(date) < date ? formatDay : formatWeek) - : year(date) < date ? formatMonth - : formatYear)(date); - } - - function tickInterval(interval, start, stop, step) { - if (interval == null) interval = 10; - - // If a desired tick count is specified, pick a reasonable tick interval - // based on the extent of the domain and a rough estimate of tick size. - // Otherwise, assume interval is already a time interval and use it. - if (typeof interval === "number") { - var target = Math.abs(stop - start) / interval, - i = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["bisector"])(function(i) { return i[2]; }).right(tickIntervals, target); - if (i === tickIntervals.length) { - step = Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickStep"])(start / durationYear, stop / durationYear, interval); - interval = year; - } else if (i) { - i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i]; - step = i[1]; - interval = i[0]; - } else { - step = Math.max(Object(d3_array__WEBPACK_IMPORTED_MODULE_0__["tickStep"])(start, stop, interval), 1); - interval = millisecond; - } - } - - return step == null ? interval : interval.every(step); - } - - scale.invert = function(y) { - return new Date(invert(y)); - }; - - scale.domain = function(_) { - return arguments.length ? domain(_array__WEBPACK_IMPORTED_MODULE_4__["map"].call(_, number)) : domain().map(date); - }; - - scale.ticks = function(interval, step) { - var d = domain(), - t0 = d[0], - t1 = d[d.length - 1], - r = t1 < t0, - t; - if (r) t = t0, t0 = t1, t1 = t; - t = tickInterval(interval, t0, t1, step); - t = t ? t.range(t0, t1 + 1) : []; // inclusive stop - return r ? t.reverse() : t; - }; - - scale.tickFormat = function(count, specifier) { - return specifier == null ? tickFormat : format(specifier); - }; - - scale.nice = function(interval, step) { - var d = domain(); - return (interval = tickInterval(interval, d[0], d[d.length - 1], step)) - ? domain(Object(_nice__WEBPACK_IMPORTED_MODULE_6__["default"])(d, interval)) - : scale; - }; - - scale.copy = function() { - return Object(_continuous__WEBPACK_IMPORTED_MODULE_5__["copy"])(scale, calendar(year, month, week, day, hour, minute, second, millisecond, format)); - }; - - return scale; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return calendar(d3_time__WEBPACK_IMPORTED_MODULE_2__["timeYear"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeMonth"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeWeek"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeDay"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeHour"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeMinute"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeSecond"], d3_time__WEBPACK_IMPORTED_MODULE_2__["timeMillisecond"], d3_time_format__WEBPACK_IMPORTED_MODULE_3__["timeFormat"]).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-scale/src/utcTime.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-scale/src/utcTime.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _time__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./time */ "./node_modules/d3-scale/src/time.js"); -/* harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-time-format */ "./node_modules/d3-time-format/src/index.js"); -/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-time */ "./node_modules/d3-time/src/index.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return Object(_time__WEBPACK_IMPORTED_MODULE_0__["calendar"])(d3_time__WEBPACK_IMPORTED_MODULE_2__["utcYear"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcMonth"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcWeek"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcDay"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcHour"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcMinute"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcSecond"], d3_time__WEBPACK_IMPORTED_MODULE_2__["utcMillisecond"], d3_time_format__WEBPACK_IMPORTED_MODULE_1__["utcFormat"]).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/constant.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-selection/src/constant.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/create.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-selection/src/create.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./creator */ "./node_modules/d3-selection/src/creator.js"); -/* harmony import */ var _select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./select */ "./node_modules/d3-selection/src/select.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(name) { - return Object(_select__WEBPACK_IMPORTED_MODULE_1__["default"])(Object(_creator__WEBPACK_IMPORTED_MODULE_0__["default"])(name).call(document.documentElement)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/creator.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-selection/src/creator.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./namespace */ "./node_modules/d3-selection/src/namespace.js"); -/* harmony import */ var _namespaces__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./namespaces */ "./node_modules/d3-selection/src/namespaces.js"); - - - -function creatorInherit(name) { - return function() { - var document = this.ownerDocument, - uri = this.namespaceURI; - return uri === _namespaces__WEBPACK_IMPORTED_MODULE_1__["xhtml"] && document.documentElement.namespaceURI === _namespaces__WEBPACK_IMPORTED_MODULE_1__["xhtml"] - ? document.createElement(name) - : document.createElementNS(uri, name); - }; -} - -function creatorFixed(fullname) { - return function() { - return this.ownerDocument.createElementNS(fullname.space, fullname.local); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name) { - var fullname = Object(_namespace__WEBPACK_IMPORTED_MODULE_0__["default"])(name); - return (fullname.local - ? creatorFixed - : creatorInherit)(fullname); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/index.js": -/*!************************************************!*\ - !*** ./node_modules/d3-selection/src/index.js ***! - \************************************************/ -/*! exports provided: create, creator, local, matcher, mouse, namespace, namespaces, clientPoint, select, selectAll, selection, selector, selectorAll, style, touch, touches, window, event, customEvent */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _create__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./create */ "./node_modules/d3-selection/src/create.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "create", function() { return _create__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./creator */ "./node_modules/d3-selection/src/creator.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "creator", function() { return _creator__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _local__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./local */ "./node_modules/d3-selection/src/local.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "local", function() { return _local__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _matcher__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./matcher */ "./node_modules/d3-selection/src/matcher.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "matcher", function() { return _matcher__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _mouse__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./mouse */ "./node_modules/d3-selection/src/mouse.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "mouse", function() { return _mouse__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./namespace */ "./node_modules/d3-selection/src/namespace.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "namespace", function() { return _namespace__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _namespaces__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./namespaces */ "./node_modules/d3-selection/src/namespaces.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "namespaces", function() { return _namespaces__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./point */ "./node_modules/d3-selection/src/point.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "clientPoint", function() { return _point__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony import */ var _select__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./select */ "./node_modules/d3-selection/src/select.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "select", function() { return _select__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony import */ var _selectAll__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./selectAll */ "./node_modules/d3-selection/src/selectAll.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selectAll", function() { return _selectAll__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./selection/index */ "./node_modules/d3-selection/src/selection/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selection", function() { return _selection_index__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony import */ var _selector__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./selector */ "./node_modules/d3-selection/src/selector.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selector", function() { return _selector__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony import */ var _selectorAll__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./selectorAll */ "./node_modules/d3-selection/src/selectorAll.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selectorAll", function() { return _selectorAll__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony import */ var _selection_style__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./selection/style */ "./node_modules/d3-selection/src/selection/style.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "style", function() { return _selection_style__WEBPACK_IMPORTED_MODULE_13__["styleValue"]; }); - -/* harmony import */ var _touch__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./touch */ "./node_modules/d3-selection/src/touch.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "touch", function() { return _touch__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony import */ var _touches__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./touches */ "./node_modules/d3-selection/src/touches.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "touches", function() { return _touches__WEBPACK_IMPORTED_MODULE_15__["default"]; }); - -/* harmony import */ var _window__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./window */ "./node_modules/d3-selection/src/window.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "window", function() { return _window__WEBPACK_IMPORTED_MODULE_16__["default"]; }); - -/* harmony import */ var _selection_on__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./selection/on */ "./node_modules/d3-selection/src/selection/on.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "event", function() { return _selection_on__WEBPACK_IMPORTED_MODULE_17__["event"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "customEvent", function() { return _selection_on__WEBPACK_IMPORTED_MODULE_17__["customEvent"]; }); - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/local.js": -/*!************************************************!*\ - !*** ./node_modules/d3-selection/src/local.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return local; }); -var nextId = 0; - -function local() { - return new Local; -} - -function Local() { - this._ = "@" + (++nextId).toString(36); -} - -Local.prototype = local.prototype = { - constructor: Local, - get: function(node) { - var id = this._; - while (!(id in node)) if (!(node = node.parentNode)) return; - return node[id]; - }, - set: function(node, value) { - return node[this._] = value; - }, - remove: function(node) { - return this._ in node && delete node[this._]; - }, - toString: function() { - return this._; - } -}; - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/matcher.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-selection/src/matcher.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var matcher = function(selector) { - return function() { - return this.matches(selector); - }; -}; - -if (typeof document !== "undefined") { - var element = document.documentElement; - if (!element.matches) { - var vendorMatches = element.webkitMatchesSelector - || element.msMatchesSelector - || element.mozMatchesSelector - || element.oMatchesSelector; - matcher = function(selector) { - return function() { - return vendorMatches.call(this, selector); - }; - }; - } -} - -/* harmony default export */ __webpack_exports__["default"] = (matcher); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/mouse.js": -/*!************************************************!*\ - !*** ./node_modules/d3-selection/src/mouse.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _sourceEvent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sourceEvent */ "./node_modules/d3-selection/src/sourceEvent.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./point */ "./node_modules/d3-selection/src/point.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(node) { - var event = Object(_sourceEvent__WEBPACK_IMPORTED_MODULE_0__["default"])(); - if (event.changedTouches) event = event.changedTouches[0]; - return Object(_point__WEBPACK_IMPORTED_MODULE_1__["default"])(node, event); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/namespace.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-selection/src/namespace.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _namespaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./namespaces */ "./node_modules/d3-selection/src/namespaces.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(name) { - var prefix = name += "", i = prefix.indexOf(":"); - if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1); - return _namespaces__WEBPACK_IMPORTED_MODULE_0__["default"].hasOwnProperty(prefix) ? {space: _namespaces__WEBPACK_IMPORTED_MODULE_0__["default"][prefix], local: name} : name; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/namespaces.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-selection/src/namespaces.js ***! - \*****************************************************/ -/*! exports provided: xhtml, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "xhtml", function() { return xhtml; }); -var xhtml = "http://www.w3.org/1999/xhtml"; - -/* harmony default export */ __webpack_exports__["default"] = ({ - svg: "http://www.w3.org/2000/svg", - xhtml: xhtml, - xlink: "http://www.w3.org/1999/xlink", - xml: "http://www.w3.org/XML/1998/namespace", - xmlns: "http://www.w3.org/2000/xmlns/" -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/point.js": -/*!************************************************!*\ - !*** ./node_modules/d3-selection/src/point.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(node, event) { - var svg = node.ownerSVGElement || node; - - if (svg.createSVGPoint) { - var point = svg.createSVGPoint(); - point.x = event.clientX, point.y = event.clientY; - point = point.matrixTransform(node.getScreenCTM().inverse()); - return [point.x, point.y]; - } - - var rect = node.getBoundingClientRect(); - return [event.clientX - rect.left - node.clientLeft, event.clientY - rect.top - node.clientTop]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/select.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-selection/src/select.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./selection/index */ "./node_modules/d3-selection/src/selection/index.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(selector) { - return typeof selector === "string" - ? new _selection_index__WEBPACK_IMPORTED_MODULE_0__["Selection"]([[document.querySelector(selector)]], [document.documentElement]) - : new _selection_index__WEBPACK_IMPORTED_MODULE_0__["Selection"]([[selector]], _selection_index__WEBPACK_IMPORTED_MODULE_0__["root"]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selectAll.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-selection/src/selectAll.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./selection/index */ "./node_modules/d3-selection/src/selection/index.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(selector) { - return typeof selector === "string" - ? new _selection_index__WEBPACK_IMPORTED_MODULE_0__["Selection"]([document.querySelectorAll(selector)], [document.documentElement]) - : new _selection_index__WEBPACK_IMPORTED_MODULE_0__["Selection"]([selector == null ? [] : selector], _selection_index__WEBPACK_IMPORTED_MODULE_0__["root"]); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/append.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/append.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../creator */ "./node_modules/d3-selection/src/creator.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(name) { - var create = typeof name === "function" ? name : Object(_creator__WEBPACK_IMPORTED_MODULE_0__["default"])(name); - return this.select(function() { - return this.appendChild(create.apply(this, arguments)); - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/attr.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/attr.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _namespace__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../namespace */ "./node_modules/d3-selection/src/namespace.js"); - - -function attrRemove(name) { - return function() { - this.removeAttribute(name); - }; -} - -function attrRemoveNS(fullname) { - return function() { - this.removeAttributeNS(fullname.space, fullname.local); - }; -} - -function attrConstant(name, value) { - return function() { - this.setAttribute(name, value); - }; -} - -function attrConstantNS(fullname, value) { - return function() { - this.setAttributeNS(fullname.space, fullname.local, value); - }; -} - -function attrFunction(name, value) { - return function() { - var v = value.apply(this, arguments); - if (v == null) this.removeAttribute(name); - else this.setAttribute(name, v); - }; -} - -function attrFunctionNS(fullname, value) { - return function() { - var v = value.apply(this, arguments); - if (v == null) this.removeAttributeNS(fullname.space, fullname.local); - else this.setAttributeNS(fullname.space, fullname.local, v); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value) { - var fullname = Object(_namespace__WEBPACK_IMPORTED_MODULE_0__["default"])(name); - - if (arguments.length < 2) { - var node = this.node(); - return fullname.local - ? node.getAttributeNS(fullname.space, fullname.local) - : node.getAttribute(fullname); - } - - return this.each((value == null - ? (fullname.local ? attrRemoveNS : attrRemove) : (typeof value === "function" - ? (fullname.local ? attrFunctionNS : attrFunction) - : (fullname.local ? attrConstantNS : attrConstant)))(fullname, value)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/call.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/call.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var callback = arguments[0]; - arguments[0] = this; - callback.apply(null, arguments); - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/classed.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/classed.js ***! - \************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function classArray(string) { - return string.trim().split(/^|\s+/); -} - -function classList(node) { - return node.classList || new ClassList(node); -} - -function ClassList(node) { - this._node = node; - this._names = classArray(node.getAttribute("class") || ""); -} - -ClassList.prototype = { - add: function(name) { - var i = this._names.indexOf(name); - if (i < 0) { - this._names.push(name); - this._node.setAttribute("class", this._names.join(" ")); - } - }, - remove: function(name) { - var i = this._names.indexOf(name); - if (i >= 0) { - this._names.splice(i, 1); - this._node.setAttribute("class", this._names.join(" ")); - } - }, - contains: function(name) { - return this._names.indexOf(name) >= 0; - } -}; - -function classedAdd(node, names) { - var list = classList(node), i = -1, n = names.length; - while (++i < n) list.add(names[i]); -} - -function classedRemove(node, names) { - var list = classList(node), i = -1, n = names.length; - while (++i < n) list.remove(names[i]); -} - -function classedTrue(names) { - return function() { - classedAdd(this, names); - }; -} - -function classedFalse(names) { - return function() { - classedRemove(this, names); - }; -} - -function classedFunction(names, value) { - return function() { - (value.apply(this, arguments) ? classedAdd : classedRemove)(this, names); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value) { - var names = classArray(name + ""); - - if (arguments.length < 2) { - var list = classList(this.node()), i = -1, n = names.length; - while (++i < n) if (!list.contains(names[i])) return false; - return true; - } - - return this.each((typeof value === "function" - ? classedFunction : value - ? classedTrue - : classedFalse)(names, value)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/clone.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/clone.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function selection_cloneShallow() { - return this.parentNode.insertBefore(this.cloneNode(false), this.nextSibling); -} - -function selection_cloneDeep() { - return this.parentNode.insertBefore(this.cloneNode(true), this.nextSibling); -} - -/* harmony default export */ __webpack_exports__["default"] = (function(deep) { - return this.select(deep ? selection_cloneDeep : selection_cloneShallow); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/data.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/data.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); -/* harmony import */ var _enter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./enter */ "./node_modules/d3-selection/src/selection/enter.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../constant */ "./node_modules/d3-selection/src/constant.js"); - - - - -var keyPrefix = "$"; // Protect against keys like “__proto__”. - -function bindIndex(parent, group, enter, update, exit, data) { - var i = 0, - node, - groupLength = group.length, - dataLength = data.length; - - // Put any non-null nodes that fit into update. - // Put any null nodes into enter. - // Put any remaining data into enter. - for (; i < dataLength; ++i) { - if (node = group[i]) { - node.__data__ = data[i]; - update[i] = node; - } else { - enter[i] = new _enter__WEBPACK_IMPORTED_MODULE_1__["EnterNode"](parent, data[i]); - } - } - - // Put any non-null nodes that don’t fit into exit. - for (; i < groupLength; ++i) { - if (node = group[i]) { - exit[i] = node; - } - } -} - -function bindKey(parent, group, enter, update, exit, data, key) { - var i, - node, - nodeByKeyValue = {}, - groupLength = group.length, - dataLength = data.length, - keyValues = new Array(groupLength), - keyValue; - - // Compute the key for each node. - // If multiple nodes have the same key, the duplicates are added to exit. - for (i = 0; i < groupLength; ++i) { - if (node = group[i]) { - keyValues[i] = keyValue = keyPrefix + key.call(node, node.__data__, i, group); - if (keyValue in nodeByKeyValue) { - exit[i] = node; - } else { - nodeByKeyValue[keyValue] = node; - } - } - } - - // Compute the key for each datum. - // If there a node associated with this key, join and add it to update. - // If there is not (or the key is a duplicate), add it to enter. - for (i = 0; i < dataLength; ++i) { - keyValue = keyPrefix + key.call(parent, data[i], i, data); - if (node = nodeByKeyValue[keyValue]) { - update[i] = node; - node.__data__ = data[i]; - nodeByKeyValue[keyValue] = null; - } else { - enter[i] = new _enter__WEBPACK_IMPORTED_MODULE_1__["EnterNode"](parent, data[i]); - } - } - - // Add any remaining nodes that were not bound to data to exit. - for (i = 0; i < groupLength; ++i) { - if ((node = group[i]) && (nodeByKeyValue[keyValues[i]] === node)) { - exit[i] = node; - } - } -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value, key) { - if (!value) { - data = new Array(this.size()), j = -1; - this.each(function(d) { data[++j] = d; }); - return data; - } - - var bind = key ? bindKey : bindIndex, - parents = this._parents, - groups = this._groups; - - if (typeof value !== "function") value = Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(value); - - for (var m = groups.length, update = new Array(m), enter = new Array(m), exit = new Array(m), j = 0; j < m; ++j) { - var parent = parents[j], - group = groups[j], - groupLength = group.length, - data = value.call(parent, parent && parent.__data__, j, parents), - dataLength = data.length, - enterGroup = enter[j] = new Array(dataLength), - updateGroup = update[j] = new Array(dataLength), - exitGroup = exit[j] = new Array(groupLength); - - bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); - - // Now connect the enter nodes to their following update node, such that - // appendChild can insert the materialized enter node before this node, - // rather than at the end of the parent node. - for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) { - if (previous = enterGroup[i0]) { - if (i0 >= i1) i1 = i0 + 1; - while (!(next = updateGroup[i1]) && ++i1 < dataLength); - previous._next = next || null; - } - } - } - - update = new _index__WEBPACK_IMPORTED_MODULE_0__["Selection"](update, parents); - update._enter = enter; - update._exit = exit; - return update; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/datum.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/datum.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - return arguments.length - ? this.property("__data__", value) - : this.node().__data__; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/dispatch.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/dispatch.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _window__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../window */ "./node_modules/d3-selection/src/window.js"); - - -function dispatchEvent(node, type, params) { - var window = Object(_window__WEBPACK_IMPORTED_MODULE_0__["default"])(node), - event = window.CustomEvent; - - if (typeof event === "function") { - event = new event(type, params); - } else { - event = window.document.createEvent("Event"); - if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail; - else event.initEvent(type, false, false); - } - - node.dispatchEvent(event); -} - -function dispatchConstant(type, params) { - return function() { - return dispatchEvent(this, type, params); - }; -} - -function dispatchFunction(type, params) { - return function() { - return dispatchEvent(this, type, params.apply(this, arguments)); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(type, params) { - return this.each((typeof params === "function" - ? dispatchFunction - : dispatchConstant)(type, params)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/each.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/each.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(callback) { - - for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { - for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) { - if (node = group[i]) callback.call(node, node.__data__, i, group); - } - } - - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/empty.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/empty.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - return !this.node(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/enter.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/enter.js ***! - \**********************************************************/ -/*! exports provided: default, EnterNode */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EnterNode", function() { return EnterNode; }); -/* harmony import */ var _sparse__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sparse */ "./node_modules/d3-selection/src/selection/sparse.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return new _index__WEBPACK_IMPORTED_MODULE_1__["Selection"](this._enter || this._groups.map(_sparse__WEBPACK_IMPORTED_MODULE_0__["default"]), this._parents); -}); - -function EnterNode(parent, datum) { - this.ownerDocument = parent.ownerDocument; - this.namespaceURI = parent.namespaceURI; - this._next = null; - this._parent = parent; - this.__data__ = datum; -} - -EnterNode.prototype = { - constructor: EnterNode, - appendChild: function(child) { return this._parent.insertBefore(child, this._next); }, - insertBefore: function(child, next) { return this._parent.insertBefore(child, next); }, - querySelector: function(selector) { return this._parent.querySelector(selector); }, - querySelectorAll: function(selector) { return this._parent.querySelectorAll(selector); } -}; - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/exit.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/exit.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _sparse__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sparse */ "./node_modules/d3-selection/src/selection/sparse.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return new _index__WEBPACK_IMPORTED_MODULE_1__["Selection"](this._exit || this._groups.map(_sparse__WEBPACK_IMPORTED_MODULE_0__["default"]), this._parents); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/filter.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/filter.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); -/* harmony import */ var _matcher__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../matcher */ "./node_modules/d3-selection/src/matcher.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(match) { - if (typeof match !== "function") match = Object(_matcher__WEBPACK_IMPORTED_MODULE_1__["default"])(match); - - for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { - if ((node = group[i]) && match.call(node, node.__data__, i, group)) { - subgroup.push(node); - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Selection"](subgroups, this._parents); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/html.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/html.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function htmlRemove() { - this.innerHTML = ""; -} - -function htmlConstant(value) { - return function() { - this.innerHTML = value; - }; -} - -function htmlFunction(value) { - return function() { - var v = value.apply(this, arguments); - this.innerHTML = v == null ? "" : v; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - return arguments.length - ? this.each(value == null - ? htmlRemove : (typeof value === "function" - ? htmlFunction - : htmlConstant)(value)) - : this.node().innerHTML; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/index.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/index.js ***! - \**********************************************************/ -/*! exports provided: root, Selection, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "root", function() { return root; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Selection", function() { return Selection; }); -/* harmony import */ var _select__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./select */ "./node_modules/d3-selection/src/selection/select.js"); -/* harmony import */ var _selectAll__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./selectAll */ "./node_modules/d3-selection/src/selection/selectAll.js"); -/* harmony import */ var _filter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./filter */ "./node_modules/d3-selection/src/selection/filter.js"); -/* harmony import */ var _data__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./data */ "./node_modules/d3-selection/src/selection/data.js"); -/* harmony import */ var _enter__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./enter */ "./node_modules/d3-selection/src/selection/enter.js"); -/* harmony import */ var _exit__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./exit */ "./node_modules/d3-selection/src/selection/exit.js"); -/* harmony import */ var _merge__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./merge */ "./node_modules/d3-selection/src/selection/merge.js"); -/* harmony import */ var _order__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./order */ "./node_modules/d3-selection/src/selection/order.js"); -/* harmony import */ var _sort__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./sort */ "./node_modules/d3-selection/src/selection/sort.js"); -/* harmony import */ var _call__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./call */ "./node_modules/d3-selection/src/selection/call.js"); -/* harmony import */ var _nodes__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./nodes */ "./node_modules/d3-selection/src/selection/nodes.js"); -/* harmony import */ var _node__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./node */ "./node_modules/d3-selection/src/selection/node.js"); -/* harmony import */ var _size__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./size */ "./node_modules/d3-selection/src/selection/size.js"); -/* harmony import */ var _empty__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./empty */ "./node_modules/d3-selection/src/selection/empty.js"); -/* harmony import */ var _each__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./each */ "./node_modules/d3-selection/src/selection/each.js"); -/* harmony import */ var _attr__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./attr */ "./node_modules/d3-selection/src/selection/attr.js"); -/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./style */ "./node_modules/d3-selection/src/selection/style.js"); -/* harmony import */ var _property__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./property */ "./node_modules/d3-selection/src/selection/property.js"); -/* harmony import */ var _classed__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./classed */ "./node_modules/d3-selection/src/selection/classed.js"); -/* harmony import */ var _text__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./text */ "./node_modules/d3-selection/src/selection/text.js"); -/* harmony import */ var _html__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./html */ "./node_modules/d3-selection/src/selection/html.js"); -/* harmony import */ var _raise__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./raise */ "./node_modules/d3-selection/src/selection/raise.js"); -/* harmony import */ var _lower__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./lower */ "./node_modules/d3-selection/src/selection/lower.js"); -/* harmony import */ var _append__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./append */ "./node_modules/d3-selection/src/selection/append.js"); -/* harmony import */ var _insert__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./insert */ "./node_modules/d3-selection/src/selection/insert.js"); -/* harmony import */ var _remove__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./remove */ "./node_modules/d3-selection/src/selection/remove.js"); -/* harmony import */ var _clone__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./clone */ "./node_modules/d3-selection/src/selection/clone.js"); -/* harmony import */ var _datum__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./datum */ "./node_modules/d3-selection/src/selection/datum.js"); -/* harmony import */ var _on__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./on */ "./node_modules/d3-selection/src/selection/on.js"); -/* harmony import */ var _dispatch__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./dispatch */ "./node_modules/d3-selection/src/selection/dispatch.js"); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -var root = [null]; - -function Selection(groups, parents) { - this._groups = groups; - this._parents = parents; -} - -function selection() { - return new Selection([[document.documentElement]], root); -} - -Selection.prototype = selection.prototype = { - constructor: Selection, - select: _select__WEBPACK_IMPORTED_MODULE_0__["default"], - selectAll: _selectAll__WEBPACK_IMPORTED_MODULE_1__["default"], - filter: _filter__WEBPACK_IMPORTED_MODULE_2__["default"], - data: _data__WEBPACK_IMPORTED_MODULE_3__["default"], - enter: _enter__WEBPACK_IMPORTED_MODULE_4__["default"], - exit: _exit__WEBPACK_IMPORTED_MODULE_5__["default"], - merge: _merge__WEBPACK_IMPORTED_MODULE_6__["default"], - order: _order__WEBPACK_IMPORTED_MODULE_7__["default"], - sort: _sort__WEBPACK_IMPORTED_MODULE_8__["default"], - call: _call__WEBPACK_IMPORTED_MODULE_9__["default"], - nodes: _nodes__WEBPACK_IMPORTED_MODULE_10__["default"], - node: _node__WEBPACK_IMPORTED_MODULE_11__["default"], - size: _size__WEBPACK_IMPORTED_MODULE_12__["default"], - empty: _empty__WEBPACK_IMPORTED_MODULE_13__["default"], - each: _each__WEBPACK_IMPORTED_MODULE_14__["default"], - attr: _attr__WEBPACK_IMPORTED_MODULE_15__["default"], - style: _style__WEBPACK_IMPORTED_MODULE_16__["default"], - property: _property__WEBPACK_IMPORTED_MODULE_17__["default"], - classed: _classed__WEBPACK_IMPORTED_MODULE_18__["default"], - text: _text__WEBPACK_IMPORTED_MODULE_19__["default"], - html: _html__WEBPACK_IMPORTED_MODULE_20__["default"], - raise: _raise__WEBPACK_IMPORTED_MODULE_21__["default"], - lower: _lower__WEBPACK_IMPORTED_MODULE_22__["default"], - append: _append__WEBPACK_IMPORTED_MODULE_23__["default"], - insert: _insert__WEBPACK_IMPORTED_MODULE_24__["default"], - remove: _remove__WEBPACK_IMPORTED_MODULE_25__["default"], - clone: _clone__WEBPACK_IMPORTED_MODULE_26__["default"], - datum: _datum__WEBPACK_IMPORTED_MODULE_27__["default"], - on: _on__WEBPACK_IMPORTED_MODULE_28__["default"], - dispatch: _dispatch__WEBPACK_IMPORTED_MODULE_29__["default"] -}; - -/* harmony default export */ __webpack_exports__["default"] = (selection); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/insert.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/insert.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _creator__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../creator */ "./node_modules/d3-selection/src/creator.js"); -/* harmony import */ var _selector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../selector */ "./node_modules/d3-selection/src/selector.js"); - - - -function constantNull() { - return null; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, before) { - var create = typeof name === "function" ? name : Object(_creator__WEBPACK_IMPORTED_MODULE_0__["default"])(name), - select = before == null ? constantNull : typeof before === "function" ? before : Object(_selector__WEBPACK_IMPORTED_MODULE_1__["default"])(before); - return this.select(function() { - return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null); - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/lower.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/lower.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function lower() { - if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return this.each(lower); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/merge.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/merge.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(selection) { - - for (var groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { - for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { - if (node = group0[i] || group1[i]) { - merge[i] = node; - } - } - } - - for (; j < m0; ++j) { - merges[j] = groups0[j]; - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Selection"](merges, this._parents); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/node.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/node.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - - for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) { - for (var group = groups[j], i = 0, n = group.length; i < n; ++i) { - var node = group[i]; - if (node) return node; - } - } - - return null; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/nodes.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/nodes.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var nodes = new Array(this.size()), i = -1; - this.each(function() { nodes[++i] = this; }); - return nodes; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/on.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/on.js ***! - \*******************************************************/ -/*! exports provided: event, default, customEvent */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "event", function() { return event; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "customEvent", function() { return customEvent; }); -var filterEvents = {}; - -var event = null; - -if (typeof document !== "undefined") { - var element = document.documentElement; - if (!("onmouseenter" in element)) { - filterEvents = {mouseenter: "mouseover", mouseleave: "mouseout"}; - } -} - -function filterContextListener(listener, index, group) { - listener = contextListener(listener, index, group); - return function(event) { - var related = event.relatedTarget; - if (!related || (related !== this && !(related.compareDocumentPosition(this) & 8))) { - listener.call(this, event); - } - }; -} - -function contextListener(listener, index, group) { - return function(event1) { - var event0 = event; // Events can be reentrant (e.g., focus). - event = event1; - try { - listener.call(this, this.__data__, index, group); - } finally { - event = event0; - } - }; -} - -function parseTypenames(typenames) { - return typenames.trim().split(/^|\s+/).map(function(t) { - var name = "", i = t.indexOf("."); - if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i); - return {type: t, name: name}; - }); -} - -function onRemove(typename) { - return function() { - var on = this.__on; - if (!on) return; - for (var j = 0, i = -1, m = on.length, o; j < m; ++j) { - if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) { - this.removeEventListener(o.type, o.listener, o.capture); - } else { - on[++i] = o; - } - } - if (++i) on.length = i; - else delete this.__on; - }; -} - -function onAdd(typename, value, capture) { - var wrap = filterEvents.hasOwnProperty(typename.type) ? filterContextListener : contextListener; - return function(d, i, group) { - var on = this.__on, o, listener = wrap(value, i, group); - if (on) for (var j = 0, m = on.length; j < m; ++j) { - if ((o = on[j]).type === typename.type && o.name === typename.name) { - this.removeEventListener(o.type, o.listener, o.capture); - this.addEventListener(o.type, o.listener = listener, o.capture = capture); - o.value = value; - return; - } - } - this.addEventListener(typename.type, listener, capture); - o = {type: typename.type, name: typename.name, value: value, listener: listener, capture: capture}; - if (!on) this.__on = [o]; - else on.push(o); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(typename, value, capture) { - var typenames = parseTypenames(typename + ""), i, n = typenames.length, t; - - if (arguments.length < 2) { - var on = this.node().__on; - if (on) for (var j = 0, m = on.length, o; j < m; ++j) { - for (i = 0, o = on[j]; i < n; ++i) { - if ((t = typenames[i]).type === o.type && t.name === o.name) { - return o.value; - } - } - } - return; - } - - on = value ? onAdd : onRemove; - if (capture == null) capture = false; - for (i = 0; i < n; ++i) this.each(on(typenames[i], value, capture)); - return this; -}); - -function customEvent(event1, listener, that, args) { - var event0 = event; - event1.sourceEvent = event; - event = event1; - try { - return listener.apply(that, args); - } finally { - event = event0; - } -} - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/order.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/order.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - - for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) { - for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) { - if (node = group[i]) { - if (next && next !== node.nextSibling) next.parentNode.insertBefore(node, next); - next = node; - } - } - } - - return this; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/property.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/property.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function propertyRemove(name) { - return function() { - delete this[name]; - }; -} - -function propertyConstant(name, value) { - return function() { - this[name] = value; - }; -} - -function propertyFunction(name, value) { - return function() { - var v = value.apply(this, arguments); - if (v == null) delete this[name]; - else this[name] = v; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value) { - return arguments.length > 1 - ? this.each((value == null - ? propertyRemove : typeof value === "function" - ? propertyFunction - : propertyConstant)(name, value)) - : this.node()[name]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/raise.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/raise.js ***! - \**********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function raise() { - if (this.nextSibling) this.parentNode.appendChild(this); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return this.each(raise); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/remove.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/remove.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function remove() { - var parent = this.parentNode; - if (parent) parent.removeChild(this); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return this.each(remove); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/select.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/select.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); -/* harmony import */ var _selector__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../selector */ "./node_modules/d3-selection/src/selector.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(select) { - if (typeof select !== "function") select = Object(_selector__WEBPACK_IMPORTED_MODULE_1__["default"])(select); - - for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { - if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { - if ("__data__" in node) subnode.__data__ = node.__data__; - subgroup[i] = subnode; - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Selection"](subgroups, this._parents); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/selectAll.js": -/*!**************************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/selectAll.js ***! - \**************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); -/* harmony import */ var _selectorAll__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../selectorAll */ "./node_modules/d3-selection/src/selectorAll.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(select) { - if (typeof select !== "function") select = Object(_selectorAll__WEBPACK_IMPORTED_MODULE_1__["default"])(select); - - for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { - if (node = group[i]) { - subgroups.push(select.call(node, node.__data__, i, group)); - parents.push(node); - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Selection"](subgroups, parents); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/size.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/size.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() { - var size = 0; - this.each(function() { ++size; }); - return size; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/sort.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/sort.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-selection/src/selection/index.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(compare) { - if (!compare) compare = ascending; - - function compareNode(a, b) { - return a && b ? compare(a.__data__, b.__data__) : !a - !b; - } - - for (var groups = this._groups, m = groups.length, sortgroups = new Array(m), j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = new Array(n), node, i = 0; i < n; ++i) { - if (node = group[i]) { - sortgroup[i] = node; - } - } - sortgroup.sort(compareNode); - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Selection"](sortgroups, this._parents).order(); -}); - -function ascending(a, b) { - return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; -} - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/sparse.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/sparse.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(update) { - return new Array(update.length); -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/style.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/style.js ***! - \**********************************************************/ -/*! exports provided: default, styleValue */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "styleValue", function() { return styleValue; }); -/* harmony import */ var _window__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../window */ "./node_modules/d3-selection/src/window.js"); - - -function styleRemove(name) { - return function() { - this.style.removeProperty(name); - }; -} - -function styleConstant(name, value, priority) { - return function() { - this.style.setProperty(name, value, priority); - }; -} - -function styleFunction(name, value, priority) { - return function() { - var v = value.apply(this, arguments); - if (v == null) this.style.removeProperty(name); - else this.style.setProperty(name, v, priority); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value, priority) { - return arguments.length > 1 - ? this.each((value == null - ? styleRemove : typeof value === "function" - ? styleFunction - : styleConstant)(name, value, priority == null ? "" : priority)) - : styleValue(this.node(), name); -}); - -function styleValue(node, name) { - return node.style.getPropertyValue(name) - || Object(_window__WEBPACK_IMPORTED_MODULE_0__["default"])(node).getComputedStyle(node, null).getPropertyValue(name); -} - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selection/text.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-selection/src/selection/text.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function textRemove() { - this.textContent = ""; -} - -function textConstant(value) { - return function() { - this.textContent = value; - }; -} - -function textFunction(value) { - return function() { - var v = value.apply(this, arguments); - this.textContent = v == null ? "" : v; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - return arguments.length - ? this.each(value == null - ? textRemove : (typeof value === "function" - ? textFunction - : textConstant)(value)) - : this.node().textContent; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selector.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-selection/src/selector.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function none() {} - -/* harmony default export */ __webpack_exports__["default"] = (function(selector) { - return selector == null ? none : function() { - return this.querySelector(selector); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/selectorAll.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-selection/src/selectorAll.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function empty() { - return []; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(selector) { - return selector == null ? empty : function() { - return this.querySelectorAll(selector); - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/sourceEvent.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-selection/src/sourceEvent.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _selection_on__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./selection/on */ "./node_modules/d3-selection/src/selection/on.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var current = _selection_on__WEBPACK_IMPORTED_MODULE_0__["event"], source; - while (source = current.sourceEvent) current = source; - return current; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/touch.js": -/*!************************************************!*\ - !*** ./node_modules/d3-selection/src/touch.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _sourceEvent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sourceEvent */ "./node_modules/d3-selection/src/sourceEvent.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./point */ "./node_modules/d3-selection/src/point.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(node, touches, identifier) { - if (arguments.length < 3) identifier = touches, touches = Object(_sourceEvent__WEBPACK_IMPORTED_MODULE_0__["default"])().changedTouches; - - for (var i = 0, n = touches ? touches.length : 0, touch; i < n; ++i) { - if ((touch = touches[i]).identifier === identifier) { - return Object(_point__WEBPACK_IMPORTED_MODULE_1__["default"])(node, touch); - } - } - - return null; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/touches.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-selection/src/touches.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _sourceEvent__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./sourceEvent */ "./node_modules/d3-selection/src/sourceEvent.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./point */ "./node_modules/d3-selection/src/point.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(node, touches) { - if (touches == null) touches = Object(_sourceEvent__WEBPACK_IMPORTED_MODULE_0__["default"])().touches; - - for (var i = 0, n = touches ? touches.length : 0, points = new Array(n); i < n; ++i) { - points[i] = Object(_point__WEBPACK_IMPORTED_MODULE_1__["default"])(node, touches[i]); - } - - return points; -}); - - -/***/ }), - -/***/ "./node_modules/d3-selection/src/window.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-selection/src/window.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(node) { - return (node.ownerDocument && node.ownerDocument.defaultView) // node is a Node - || (node.document && node) // node is a Window - || node.defaultView; // node is a Document -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/arc.js": -/*!******************************************!*\ - !*** ./node_modules/d3-shape/src/arc.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-shape/src/constant.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./math */ "./node_modules/d3-shape/src/math.js"); - - - - -function arcInnerRadius(d) { - return d.innerRadius; -} - -function arcOuterRadius(d) { - return d.outerRadius; -} - -function arcStartAngle(d) { - return d.startAngle; -} - -function arcEndAngle(d) { - return d.endAngle; -} - -function arcPadAngle(d) { - return d && d.padAngle; // Note: optional! -} - -function intersect(x0, y0, x1, y1, x2, y2, x3, y3) { - var x10 = x1 - x0, y10 = y1 - y0, - x32 = x3 - x2, y32 = y3 - y2, - t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / (y32 * x10 - x32 * y10); - return [x0 + t * x10, y0 + t * y10]; -} - -// Compute perpendicular offset line of length rc. -// http://mathworld.wolfram.com/Circle-LineIntersection.html -function cornerTangents(x0, y0, x1, y1, r1, rc, cw) { - var x01 = x0 - x1, - y01 = y0 - y1, - lo = (cw ? rc : -rc) / Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(x01 * x01 + y01 * y01), - ox = lo * y01, - oy = -lo * x01, - x11 = x0 + ox, - y11 = y0 + oy, - x10 = x1 + ox, - y10 = y1 + oy, - x00 = (x11 + x10) / 2, - y00 = (y11 + y10) / 2, - dx = x10 - x11, - dy = y10 - y11, - d2 = dx * dx + dy * dy, - r = r1 - rc, - D = x11 * y10 - x10 * y11, - d = (dy < 0 ? -1 : 1) * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(Object(_math__WEBPACK_IMPORTED_MODULE_2__["max"])(0, r * r * d2 - D * D)), - cx0 = (D * dy - dx * d) / d2, - cy0 = (-D * dx - dy * d) / d2, - cx1 = (D * dy + dx * d) / d2, - cy1 = (-D * dx + dy * d) / d2, - dx0 = cx0 - x00, - dy0 = cy0 - y00, - dx1 = cx1 - x00, - dy1 = cy1 - y00; - - // Pick the closer of the two intersection points. - // TODO Is there a faster way to determine which intersection to use? - if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1; - - return { - cx: cx0, - cy: cy0, - x01: -ox, - y01: -oy, - x11: cx0 * (r1 / r - 1), - y11: cy0 * (r1 / r - 1) - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var innerRadius = arcInnerRadius, - outerRadius = arcOuterRadius, - cornerRadius = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(0), - padRadius = null, - startAngle = arcStartAngle, - endAngle = arcEndAngle, - padAngle = arcPadAngle, - context = null; - - function arc() { - var buffer, - r, - r0 = +innerRadius.apply(this, arguments), - r1 = +outerRadius.apply(this, arguments), - a0 = startAngle.apply(this, arguments) - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"], - a1 = endAngle.apply(this, arguments) - _math__WEBPACK_IMPORTED_MODULE_2__["halfPi"], - da = Object(_math__WEBPACK_IMPORTED_MODULE_2__["abs"])(a1 - a0), - cw = a1 > a0; - - if (!context) context = buffer = Object(d3_path__WEBPACK_IMPORTED_MODULE_0__["path"])(); - - // Ensure that the outer radius is always larger than the inner radius. - if (r1 < r0) r = r1, r1 = r0, r0 = r; - - // Is it a point? - if (!(r1 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"])) context.moveTo(0, 0); - - // Or is it a circle or annulus? - else if (da > _math__WEBPACK_IMPORTED_MODULE_2__["tau"] - _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) { - context.moveTo(r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a0), r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a0)); - context.arc(0, 0, r1, a0, a1, !cw); - if (r0 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) { - context.moveTo(r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a1), r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a1)); - context.arc(0, 0, r0, a1, a0, cw); - } - } - - // Or is it a circular or annular sector? - else { - var a01 = a0, - a11 = a1, - a00 = a0, - a10 = a1, - da0 = da, - da1 = da, - ap = padAngle.apply(this, arguments) / 2, - rp = (ap > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) && (padRadius ? +padRadius.apply(this, arguments) : Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(r0 * r0 + r1 * r1)), - rc = Object(_math__WEBPACK_IMPORTED_MODULE_2__["min"])(Object(_math__WEBPACK_IMPORTED_MODULE_2__["abs"])(r1 - r0) / 2, +cornerRadius.apply(this, arguments)), - rc0 = rc, - rc1 = rc, - t0, - t1; - - // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0. - if (rp > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) { - var p0 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["asin"])(rp / r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(ap)), - p1 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["asin"])(rp / r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(ap)); - if ((da0 -= p0 * 2) > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0; - else da0 = 0, a00 = a10 = (a0 + a1) / 2; - if ((da1 -= p1 * 2) > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1; - else da1 = 0, a01 = a11 = (a0 + a1) / 2; - } - - var x01 = r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a01), - y01 = r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a01), - x10 = r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a10), - y10 = r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a10); - - // Apply rounded corners? - if (rc > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) { - var x11 = r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a11), - y11 = r1 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a11), - x00 = r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a00), - y00 = r0 * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a00); - - // Restrict the corner radius according to the sector angle. - if (da < _math__WEBPACK_IMPORTED_MODULE_2__["pi"]) { - var oc = da0 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"] ? intersect(x01, y01, x00, y00, x11, y11, x10, y10) : [x10, y10], - ax = x01 - oc[0], - ay = y01 - oc[1], - bx = x11 - oc[0], - by = y11 - oc[1], - kc = 1 / Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(Object(_math__WEBPACK_IMPORTED_MODULE_2__["acos"])((ax * bx + ay * by) / (Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(ax * ax + ay * ay) * Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(bx * bx + by * by))) / 2), - lc = Object(_math__WEBPACK_IMPORTED_MODULE_2__["sqrt"])(oc[0] * oc[0] + oc[1] * oc[1]); - rc0 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["min"])(rc, (r0 - lc) / (kc - 1)); - rc1 = Object(_math__WEBPACK_IMPORTED_MODULE_2__["min"])(rc, (r1 - lc) / (kc + 1)); - } - } - - // Is the sector collapsed to a line? - if (!(da1 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"])) context.moveTo(x01, y01); - - // Does the sector’s outer ring have rounded corners? - else if (rc1 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) { - t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw); - t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw); - - context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01); - - // Have the corners merged? - if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.y01, t0.x01), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.y01, t1.x01), !cw); - - // Otherwise, draw the two corners and the ring. - else { - context.arc(t0.cx, t0.cy, rc1, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.y01, t0.x01), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.y11, t0.x11), !cw); - context.arc(0, 0, r1, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.cy + t0.y11, t0.cx + t0.x11), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.cy + t1.y11, t1.cx + t1.x11), !cw); - context.arc(t1.cx, t1.cy, rc1, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.y11, t1.x11), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.y01, t1.x01), !cw); - } - } - - // Or is the outer ring just a circular arc? - else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw); - - // Is there no inner ring, and it’s a circular sector? - // Or perhaps it’s an annular sector collapsed due to padding? - if (!(r0 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) || !(da0 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"])) context.lineTo(x10, y10); - - // Does the sector’s inner ring (or point) have rounded corners? - else if (rc0 > _math__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) { - t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw); - t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw); - - context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01); - - // Have the corners merged? - if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.y01, t0.x01), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.y01, t1.x01), !cw); - - // Otherwise, draw the two corners and the ring. - else { - context.arc(t0.cx, t0.cy, rc0, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.y01, t0.x01), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.y11, t0.x11), !cw); - context.arc(0, 0, r0, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t0.cy + t0.y11, t0.cx + t0.x11), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.cy + t1.y11, t1.cx + t1.x11), cw); - context.arc(t1.cx, t1.cy, rc0, Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.y11, t1.x11), Object(_math__WEBPACK_IMPORTED_MODULE_2__["atan2"])(t1.y01, t1.x01), !cw); - } - } - - // Or is the inner ring just a circular arc? - else context.arc(0, 0, r0, a10, a00, cw); - } - - context.closePath(); - - if (buffer) return context = null, buffer + "" || null; - } - - arc.centroid = function() { - var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2, - a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - _math__WEBPACK_IMPORTED_MODULE_2__["pi"] / 2; - return [Object(_math__WEBPACK_IMPORTED_MODULE_2__["cos"])(a) * r, Object(_math__WEBPACK_IMPORTED_MODULE_2__["sin"])(a) * r]; - }; - - arc.innerRadius = function(_) { - return arguments.length ? (innerRadius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : innerRadius; - }; - - arc.outerRadius = function(_) { - return arguments.length ? (outerRadius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : outerRadius; - }; - - arc.cornerRadius = function(_) { - return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : cornerRadius; - }; - - arc.padRadius = function(_) { - return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : padRadius; - }; - - arc.startAngle = function(_) { - return arguments.length ? (startAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : startAngle; - }; - - arc.endAngle = function(_) { - return arguments.length ? (endAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : endAngle; - }; - - arc.padAngle = function(_) { - return arguments.length ? (padAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), arc) : padAngle; - }; - - arc.context = function(_) { - return arguments.length ? ((context = _ == null ? null : _), arc) : context; - }; - - return arc; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/area.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-shape/src/area.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-shape/src/constant.js"); -/* harmony import */ var _curve_linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./curve/linear */ "./node_modules/d3-shape/src/curve/linear.js"); -/* harmony import */ var _line__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./line */ "./node_modules/d3-shape/src/line.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./point */ "./node_modules/d3-shape/src/point.js"); - - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var x0 = _point__WEBPACK_IMPORTED_MODULE_4__["x"], - x1 = null, - y0 = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(0), - y1 = _point__WEBPACK_IMPORTED_MODULE_4__["y"], - defined = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(true), - context = null, - curve = _curve_linear__WEBPACK_IMPORTED_MODULE_2__["default"], - output = null; - - function area(data) { - var i, - j, - k, - n = data.length, - d, - defined0 = false, - buffer, - x0z = new Array(n), - y0z = new Array(n); - - if (context == null) output = curve(buffer = Object(d3_path__WEBPACK_IMPORTED_MODULE_0__["path"])()); - - for (i = 0; i <= n; ++i) { - if (!(i < n && defined(d = data[i], i, data)) === defined0) { - if (defined0 = !defined0) { - j = i; - output.areaStart(); - output.lineStart(); - } else { - output.lineEnd(); - output.lineStart(); - for (k = i - 1; k >= j; --k) { - output.point(x0z[k], y0z[k]); - } - output.lineEnd(); - output.areaEnd(); - } - } - if (defined0) { - x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data); - output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]); - } - } - - if (buffer) return output = null, buffer + "" || null; - } - - function arealine() { - return Object(_line__WEBPACK_IMPORTED_MODULE_3__["default"])().defined(defined).curve(curve).context(context); - } - - area.x = function(_) { - return arguments.length ? (x0 = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), x1 = null, area) : x0; - }; - - area.x0 = function(_) { - return arguments.length ? (x0 = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), area) : x0; - }; - - area.x1 = function(_) { - return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), area) : x1; - }; - - area.y = function(_) { - return arguments.length ? (y0 = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), y1 = null, area) : y0; - }; - - area.y0 = function(_) { - return arguments.length ? (y0 = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), area) : y0; - }; - - area.y1 = function(_) { - return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), area) : y1; - }; - - area.lineX0 = - area.lineY0 = function() { - return arealine().x(x0).y(y0); - }; - - area.lineY1 = function() { - return arealine().x(x0).y(y1); - }; - - area.lineX1 = function() { - return arealine().x(x1).y(y0); - }; - - area.defined = function(_) { - return arguments.length ? (defined = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(!!_), area) : defined; - }; - - area.curve = function(_) { - return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve; - }; - - area.context = function(_) { - return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context; - }; - - return area; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/areaRadial.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/areaRadial.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _curve_radial__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./curve/radial */ "./node_modules/d3-shape/src/curve/radial.js"); -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./area */ "./node_modules/d3-shape/src/area.js"); -/* harmony import */ var _lineRadial__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./lineRadial */ "./node_modules/d3-shape/src/lineRadial.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var a = Object(_area__WEBPACK_IMPORTED_MODULE_1__["default"])().curve(_curve_radial__WEBPACK_IMPORTED_MODULE_0__["curveRadialLinear"]), - c = a.curve, - x0 = a.lineX0, - x1 = a.lineX1, - y0 = a.lineY0, - y1 = a.lineY1; - - a.angle = a.x, delete a.x; - a.startAngle = a.x0, delete a.x0; - a.endAngle = a.x1, delete a.x1; - a.radius = a.y, delete a.y; - a.innerRadius = a.y0, delete a.y0; - a.outerRadius = a.y1, delete a.y1; - a.lineStartAngle = function() { return Object(_lineRadial__WEBPACK_IMPORTED_MODULE_2__["lineRadial"])(x0()); }, delete a.lineX0; - a.lineEndAngle = function() { return Object(_lineRadial__WEBPACK_IMPORTED_MODULE_2__["lineRadial"])(x1()); }, delete a.lineX1; - a.lineInnerRadius = function() { return Object(_lineRadial__WEBPACK_IMPORTED_MODULE_2__["lineRadial"])(y0()); }, delete a.lineY0; - a.lineOuterRadius = function() { return Object(_lineRadial__WEBPACK_IMPORTED_MODULE_2__["lineRadial"])(y1()); }, delete a.lineY1; - - a.curve = function(_) { - return arguments.length ? c(Object(_curve_radial__WEBPACK_IMPORTED_MODULE_0__["default"])(_)) : c()._curve; - }; - - return a; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/array.js": -/*!********************************************!*\ - !*** ./node_modules/d3-shape/src/array.js ***! - \********************************************/ -/*! exports provided: slice */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slice", function() { return slice; }); -var slice = Array.prototype.slice; - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/constant.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-shape/src/constant.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function constant() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/basis.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/basis.js ***! - \**************************************************/ -/*! exports provided: point, Basis, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "point", function() { return point; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Basis", function() { return Basis; }); -function point(that, x, y) { - that._context.bezierCurveTo( - (2 * that._x0 + that._x1) / 3, - (2 * that._y0 + that._y1) / 3, - (that._x0 + 2 * that._x1) / 3, - (that._y0 + 2 * that._y1) / 3, - (that._x0 + 4 * that._x1 + x) / 6, - (that._y0 + 4 * that._y1 + y) / 6 - ); -} - -function Basis(context) { - this._context = context; -} - -Basis.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = - this._y0 = this._y1 = NaN; - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 3: point(this, this._x1, this._y1); // proceed - case 2: this._context.lineTo(this._x1, this._y1); break; - } - if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; - case 1: this._point = 2; break; - case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed - default: point(this, x, y); break; - } - this._x0 = this._x1, this._x1 = x; - this._y0 = this._y1, this._y1 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new Basis(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/basisClosed.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/basisClosed.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-shape/src/noop.js"); -/* harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./basis */ "./node_modules/d3-shape/src/curve/basis.js"); - - - -function BasisClosed(context) { - this._context = context; -} - -BasisClosed.prototype = { - areaStart: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - areaEnd: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - lineStart: function() { - this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = - this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN; - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 1: { - this._context.moveTo(this._x2, this._y2); - this._context.closePath(); - break; - } - case 2: { - this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3); - this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3); - this._context.closePath(); - break; - } - case 3: { - this.point(this._x2, this._y2); - this.point(this._x3, this._y3); - this.point(this._x4, this._y4); - break; - } - } - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; this._x2 = x, this._y2 = y; break; - case 1: this._point = 2; this._x3 = x, this._y3 = y; break; - case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break; - default: Object(_basis__WEBPACK_IMPORTED_MODULE_1__["point"])(this, x, y); break; - } - this._x0 = this._x1, this._x1 = x; - this._y0 = this._y1, this._y1 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new BasisClosed(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/basisOpen.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/basisOpen.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./basis */ "./node_modules/d3-shape/src/curve/basis.js"); - - -function BasisOpen(context) { - this._context = context; -} - -BasisOpen.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = - this._y0 = this._y1 = NaN; - this._point = 0; - }, - lineEnd: function() { - if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; break; - case 1: this._point = 2; break; - case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break; - case 3: this._point = 4; // proceed - default: Object(_basis__WEBPACK_IMPORTED_MODULE_0__["point"])(this, x, y); break; - } - this._x0 = this._x1, this._x1 = x; - this._y0 = this._y1, this._y1 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new BasisOpen(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/bundle.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/bundle.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _basis__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./basis */ "./node_modules/d3-shape/src/curve/basis.js"); - - -function Bundle(context, beta) { - this._basis = new _basis__WEBPACK_IMPORTED_MODULE_0__["Basis"](context); - this._beta = beta; -} - -Bundle.prototype = { - lineStart: function() { - this._x = []; - this._y = []; - this._basis.lineStart(); - }, - lineEnd: function() { - var x = this._x, - y = this._y, - j = x.length - 1; - - if (j > 0) { - var x0 = x[0], - y0 = y[0], - dx = x[j] - x0, - dy = y[j] - y0, - i = -1, - t; - - while (++i <= j) { - t = i / j; - this._basis.point( - this._beta * x[i] + (1 - this._beta) * (x0 + t * dx), - this._beta * y[i] + (1 - this._beta) * (y0 + t * dy) - ); - } - } - - this._x = this._y = null; - this._basis.lineEnd(); - }, - point: function(x, y) { - this._x.push(+x); - this._y.push(+y); - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(beta) { - - function bundle(context) { - return beta === 1 ? new _basis__WEBPACK_IMPORTED_MODULE_0__["Basis"](context) : new Bundle(context, beta); - } - - bundle.beta = function(beta) { - return custom(+beta); - }; - - return bundle; -})(0.85)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/cardinal.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/cardinal.js ***! - \*****************************************************/ -/*! exports provided: point, Cardinal, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "point", function() { return point; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Cardinal", function() { return Cardinal; }); -function point(that, x, y) { - that._context.bezierCurveTo( - that._x1 + that._k * (that._x2 - that._x0), - that._y1 + that._k * (that._y2 - that._y0), - that._x2 + that._k * (that._x1 - x), - that._y2 + that._k * (that._y1 - y), - that._x2, - that._y2 - ); -} - -function Cardinal(context, tension) { - this._context = context; - this._k = (1 - tension) / 6; -} - -Cardinal.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = this._x2 = - this._y0 = this._y1 = this._y2 = NaN; - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 2: this._context.lineTo(this._x2, this._y2); break; - case 3: point(this, this._x1, this._y1); break; - } - if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; - case 1: this._point = 2; this._x1 = x, this._y1 = y; break; - case 2: this._point = 3; // proceed - default: point(this, x, y); break; - } - this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; - this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(tension) { - - function cardinal(context) { - return new Cardinal(context, tension); - } - - cardinal.tension = function(tension) { - return custom(+tension); - }; - - return cardinal; -})(0)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/cardinalClosed.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/cardinalClosed.js ***! - \***********************************************************/ -/*! exports provided: CardinalClosed, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CardinalClosed", function() { return CardinalClosed; }); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-shape/src/noop.js"); -/* harmony import */ var _cardinal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js"); - - - -function CardinalClosed(context, tension) { - this._context = context; - this._k = (1 - tension) / 6; -} - -CardinalClosed.prototype = { - areaStart: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - areaEnd: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - lineStart: function() { - this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = - this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 1: { - this._context.moveTo(this._x3, this._y3); - this._context.closePath(); - break; - } - case 2: { - this._context.lineTo(this._x3, this._y3); - this._context.closePath(); - break; - } - case 3: { - this.point(this._x3, this._y3); - this.point(this._x4, this._y4); - this.point(this._x5, this._y5); - break; - } - } - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; this._x3 = x, this._y3 = y; break; - case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; - case 2: this._point = 3; this._x5 = x, this._y5 = y; break; - default: Object(_cardinal__WEBPACK_IMPORTED_MODULE_1__["point"])(this, x, y); break; - } - this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; - this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(tension) { - - function cardinal(context) { - return new CardinalClosed(context, tension); - } - - cardinal.tension = function(tension) { - return custom(+tension); - }; - - return cardinal; -})(0)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/cardinalOpen.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/cardinalOpen.js ***! - \*********************************************************/ -/*! exports provided: CardinalOpen, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CardinalOpen", function() { return CardinalOpen; }); -/* harmony import */ var _cardinal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js"); - - -function CardinalOpen(context, tension) { - this._context = context; - this._k = (1 - tension) / 6; -} - -CardinalOpen.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = this._x2 = - this._y0 = this._y1 = this._y2 = NaN; - this._point = 0; - }, - lineEnd: function() { - if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; break; - case 1: this._point = 2; break; - case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break; - case 3: this._point = 4; // proceed - default: Object(_cardinal__WEBPACK_IMPORTED_MODULE_0__["point"])(this, x, y); break; - } - this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; - this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(tension) { - - function cardinal(context) { - return new CardinalOpen(context, tension); - } - - cardinal.tension = function(tension) { - return custom(+tension); - }; - - return cardinal; -})(0)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/catmullRom.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/catmullRom.js ***! - \*******************************************************/ -/*! exports provided: point, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "point", function() { return point; }); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-shape/src/math.js"); -/* harmony import */ var _cardinal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js"); - - - -function point(that, x, y) { - var x1 = that._x1, - y1 = that._y1, - x2 = that._x2, - y2 = that._y2; - - if (that._l01_a > _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) { - var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a, - n = 3 * that._l01_a * (that._l01_a + that._l12_a); - x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n; - y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n; - } - - if (that._l23_a > _math__WEBPACK_IMPORTED_MODULE_0__["epsilon"]) { - var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a, - m = 3 * that._l23_a * (that._l23_a + that._l12_a); - x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m; - y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m; - } - - that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2); -} - -function CatmullRom(context, alpha) { - this._context = context; - this._alpha = alpha; -} - -CatmullRom.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = this._x2 = - this._y0 = this._y1 = this._y2 = NaN; - this._l01_a = this._l12_a = this._l23_a = - this._l01_2a = this._l12_2a = this._l23_2a = - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 2: this._context.lineTo(this._x2, this._y2); break; - case 3: this.point(this._x2, this._y2); break; - } - if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - - if (this._point) { - var x23 = this._x2 - x, - y23 = this._y2 - y; - this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); - } - - switch (this._point) { - case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; - case 1: this._point = 2; break; - case 2: this._point = 3; // proceed - default: point(this, x, y); break; - } - - this._l01_a = this._l12_a, this._l12_a = this._l23_a; - this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; - this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; - this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(alpha) { - - function catmullRom(context) { - return alpha ? new CatmullRom(context, alpha) : new _cardinal__WEBPACK_IMPORTED_MODULE_1__["Cardinal"](context, 0); - } - - catmullRom.alpha = function(alpha) { - return custom(+alpha); - }; - - return catmullRom; -})(0.5)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/catmullRomClosed.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/catmullRomClosed.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _cardinalClosed__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cardinalClosed */ "./node_modules/d3-shape/src/curve/cardinalClosed.js"); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-shape/src/noop.js"); -/* harmony import */ var _catmullRom__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./catmullRom */ "./node_modules/d3-shape/src/curve/catmullRom.js"); - - - - -function CatmullRomClosed(context, alpha) { - this._context = context; - this._alpha = alpha; -} - -CatmullRomClosed.prototype = { - areaStart: _noop__WEBPACK_IMPORTED_MODULE_1__["default"], - areaEnd: _noop__WEBPACK_IMPORTED_MODULE_1__["default"], - lineStart: function() { - this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 = - this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN; - this._l01_a = this._l12_a = this._l23_a = - this._l01_2a = this._l12_2a = this._l23_2a = - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 1: { - this._context.moveTo(this._x3, this._y3); - this._context.closePath(); - break; - } - case 2: { - this._context.lineTo(this._x3, this._y3); - this._context.closePath(); - break; - } - case 3: { - this.point(this._x3, this._y3); - this.point(this._x4, this._y4); - this.point(this._x5, this._y5); - break; - } - } - }, - point: function(x, y) { - x = +x, y = +y; - - if (this._point) { - var x23 = this._x2 - x, - y23 = this._y2 - y; - this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); - } - - switch (this._point) { - case 0: this._point = 1; this._x3 = x, this._y3 = y; break; - case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break; - case 2: this._point = 3; this._x5 = x, this._y5 = y; break; - default: Object(_catmullRom__WEBPACK_IMPORTED_MODULE_2__["point"])(this, x, y); break; - } - - this._l01_a = this._l12_a, this._l12_a = this._l23_a; - this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; - this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; - this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(alpha) { - - function catmullRom(context) { - return alpha ? new CatmullRomClosed(context, alpha) : new _cardinalClosed__WEBPACK_IMPORTED_MODULE_0__["CardinalClosed"](context, 0); - } - - catmullRom.alpha = function(alpha) { - return custom(+alpha); - }; - - return catmullRom; -})(0.5)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/catmullRomOpen.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/catmullRomOpen.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _cardinalOpen__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./cardinalOpen */ "./node_modules/d3-shape/src/curve/cardinalOpen.js"); -/* harmony import */ var _catmullRom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./catmullRom */ "./node_modules/d3-shape/src/curve/catmullRom.js"); - - - -function CatmullRomOpen(context, alpha) { - this._context = context; - this._alpha = alpha; -} - -CatmullRomOpen.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = this._x2 = - this._y0 = this._y1 = this._y2 = NaN; - this._l01_a = this._l12_a = this._l23_a = - this._l01_2a = this._l12_2a = this._l23_2a = - this._point = 0; - }, - lineEnd: function() { - if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - - if (this._point) { - var x23 = this._x2 - x, - y23 = this._y2 - y; - this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha)); - } - - switch (this._point) { - case 0: this._point = 1; break; - case 1: this._point = 2; break; - case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break; - case 3: this._point = 4; // proceed - default: Object(_catmullRom__WEBPACK_IMPORTED_MODULE_1__["point"])(this, x, y); break; - } - - this._l01_a = this._l12_a, this._l12_a = this._l23_a; - this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a; - this._x0 = this._x1, this._x1 = this._x2, this._x2 = x; - this._y0 = this._y1, this._y1 = this._y2, this._y2 = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = ((function custom(alpha) { - - function catmullRom(context) { - return alpha ? new CatmullRomOpen(context, alpha) : new _cardinalOpen__WEBPACK_IMPORTED_MODULE_0__["CardinalOpen"](context, 0); - } - - catmullRom.alpha = function(alpha) { - return custom(+alpha); - }; - - return catmullRom; -})(0.5)); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/linear.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/linear.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function Linear(context) { - this._context = context; -} - -Linear.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._point = 0; - }, - lineEnd: function() { - if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; - case 1: this._point = 2; // proceed - default: this._context.lineTo(x, y); break; - } - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new Linear(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/linearClosed.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/linearClosed.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _noop__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../noop */ "./node_modules/d3-shape/src/noop.js"); - - -function LinearClosed(context) { - this._context = context; -} - -LinearClosed.prototype = { - areaStart: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - areaEnd: _noop__WEBPACK_IMPORTED_MODULE_0__["default"], - lineStart: function() { - this._point = 0; - }, - lineEnd: function() { - if (this._point) this._context.closePath(); - }, - point: function(x, y) { - x = +x, y = +y; - if (this._point) this._context.lineTo(x, y); - else this._point = 1, this._context.moveTo(x, y); - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new LinearClosed(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/monotone.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/monotone.js ***! - \*****************************************************/ -/*! exports provided: monotoneX, monotoneY */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "monotoneX", function() { return monotoneX; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "monotoneY", function() { return monotoneY; }); -function sign(x) { - return x < 0 ? -1 : 1; -} - -// Calculate the slopes of the tangents (Hermite-type interpolation) based on -// the following paper: Steffen, M. 1990. A Simple Method for Monotonic -// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO. -// NOV(II), P. 443, 1990. -function slope3(that, x2, y2) { - var h0 = that._x1 - that._x0, - h1 = x2 - that._x1, - s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0), - s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0), - p = (s0 * h1 + s1 * h0) / (h0 + h1); - return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0; -} - -// Calculate a one-sided slope. -function slope2(that, t) { - var h = that._x1 - that._x0; - return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t; -} - -// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations -// "you can express cubic Hermite interpolation in terms of cubic Bézier curves -// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1". -function point(that, t0, t1) { - var x0 = that._x0, - y0 = that._y0, - x1 = that._x1, - y1 = that._y1, - dx = (x1 - x0) / 3; - that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1); -} - -function MonotoneX(context) { - this._context = context; -} - -MonotoneX.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x0 = this._x1 = - this._y0 = this._y1 = - this._t0 = NaN; - this._point = 0; - }, - lineEnd: function() { - switch (this._point) { - case 2: this._context.lineTo(this._x1, this._y1); break; - case 3: point(this, this._t0, slope2(this, this._t0)); break; - } - if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); - this._line = 1 - this._line; - }, - point: function(x, y) { - var t1 = NaN; - - x = +x, y = +y; - if (x === this._x1 && y === this._y1) return; // Ignore coincident points. - switch (this._point) { - case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; - case 1: this._point = 2; break; - case 2: this._point = 3; point(this, slope2(this, t1 = slope3(this, x, y)), t1); break; - default: point(this, this._t0, t1 = slope3(this, x, y)); break; - } - - this._x0 = this._x1, this._x1 = x; - this._y0 = this._y1, this._y1 = y; - this._t0 = t1; - } -} - -function MonotoneY(context) { - this._context = new ReflectContext(context); -} - -(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) { - MonotoneX.prototype.point.call(this, y, x); -}; - -function ReflectContext(context) { - this._context = context; -} - -ReflectContext.prototype = { - moveTo: function(x, y) { this._context.moveTo(y, x); }, - closePath: function() { this._context.closePath(); }, - lineTo: function(x, y) { this._context.lineTo(y, x); }, - bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); } -}; - -function monotoneX(context) { - return new MonotoneX(context); -} - -function monotoneY(context) { - return new MonotoneY(context); -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/natural.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/natural.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function Natural(context) { - this._context = context; -} - -Natural.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x = []; - this._y = []; - }, - lineEnd: function() { - var x = this._x, - y = this._y, - n = x.length; - - if (n) { - this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]); - if (n === 2) { - this._context.lineTo(x[1], y[1]); - } else { - var px = controlPoints(x), - py = controlPoints(y); - for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) { - this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]); - } - } - } - - if (this._line || (this._line !== 0 && n === 1)) this._context.closePath(); - this._line = 1 - this._line; - this._x = this._y = null; - }, - point: function(x, y) { - this._x.push(+x); - this._y.push(+y); - } -}; - -// See https://www.particleincell.com/2012/bezier-splines/ for derivation. -function controlPoints(x) { - var i, - n = x.length - 1, - m, - a = new Array(n), - b = new Array(n), - r = new Array(n); - a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1]; - for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1]; - a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n]; - for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1]; - a[n - 1] = r[n - 1] / b[n - 1]; - for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i]; - b[n - 1] = (x[n] + a[n - 1]) / 2; - for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1]; - return [a, b]; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new Natural(context); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/radial.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/radial.js ***! - \***************************************************/ -/*! exports provided: curveRadialLinear, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "curveRadialLinear", function() { return curveRadialLinear; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return curveRadial; }); -/* harmony import */ var _linear__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./linear */ "./node_modules/d3-shape/src/curve/linear.js"); - - -var curveRadialLinear = curveRadial(_linear__WEBPACK_IMPORTED_MODULE_0__["default"]); - -function Radial(curve) { - this._curve = curve; -} - -Radial.prototype = { - areaStart: function() { - this._curve.areaStart(); - }, - areaEnd: function() { - this._curve.areaEnd(); - }, - lineStart: function() { - this._curve.lineStart(); - }, - lineEnd: function() { - this._curve.lineEnd(); - }, - point: function(a, r) { - this._curve.point(r * Math.sin(a), r * -Math.cos(a)); - } -}; - -function curveRadial(curve) { - - function radial(context) { - return new Radial(curve(context)); - } - - radial._curve = curve; - - return radial; -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/curve/step.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/curve/step.js ***! - \*************************************************/ -/*! exports provided: default, stepBefore, stepAfter */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stepBefore", function() { return stepBefore; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "stepAfter", function() { return stepAfter; }); -function Step(context, t) { - this._context = context; - this._t = t; -} - -Step.prototype = { - areaStart: function() { - this._line = 0; - }, - areaEnd: function() { - this._line = NaN; - }, - lineStart: function() { - this._x = this._y = NaN; - this._point = 0; - }, - lineEnd: function() { - if (0 < this._t && this._t < 1 && this._point === 2) this._context.lineTo(this._x, this._y); - if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath(); - if (this._line >= 0) this._t = 1 - this._t, this._line = 1 - this._line; - }, - point: function(x, y) { - x = +x, y = +y; - switch (this._point) { - case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break; - case 1: this._point = 2; // proceed - default: { - if (this._t <= 0) { - this._context.lineTo(this._x, y); - this._context.lineTo(x, y); - } else { - var x1 = this._x * (1 - this._t) + x * this._t; - this._context.lineTo(x1, this._y); - this._context.lineTo(x1, y); - } - break; - } - } - this._x = x, this._y = y; - } -}; - -/* harmony default export */ __webpack_exports__["default"] = (function(context) { - return new Step(context, 0.5); -}); - -function stepBefore(context) { - return new Step(context, 0); -} - -function stepAfter(context) { - return new Step(context, 1); -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/descending.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/descending.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/identity.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-shape/src/identity.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(d) { - return d; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-shape/src/index.js ***! - \********************************************/ -/*! exports provided: arc, area, line, pie, areaRadial, radialArea, lineRadial, radialLine, pointRadial, linkHorizontal, linkVertical, linkRadial, symbol, symbols, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye, curveBasisClosed, curveBasisOpen, curveBasis, curveBundle, curveCardinalClosed, curveCardinalOpen, curveCardinal, curveCatmullRomClosed, curveCatmullRomOpen, curveCatmullRom, curveLinearClosed, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, stack, stackOffsetExpand, stackOffsetDiverging, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone, stackOrderReverse */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _arc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./arc */ "./node_modules/d3-shape/src/arc.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "arc", function() { return _arc__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _area__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./area */ "./node_modules/d3-shape/src/area.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "area", function() { return _area__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _line__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./line */ "./node_modules/d3-shape/src/line.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "line", function() { return _line__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _pie__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./pie */ "./node_modules/d3-shape/src/pie.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pie", function() { return _pie__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony import */ var _areaRadial__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./areaRadial */ "./node_modules/d3-shape/src/areaRadial.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "areaRadial", function() { return _areaRadial__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "radialArea", function() { return _areaRadial__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony import */ var _lineRadial__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./lineRadial */ "./node_modules/d3-shape/src/lineRadial.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "lineRadial", function() { return _lineRadial__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "radialLine", function() { return _lineRadial__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony import */ var _pointRadial__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./pointRadial */ "./node_modules/d3-shape/src/pointRadial.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pointRadial", function() { return _pointRadial__WEBPACK_IMPORTED_MODULE_6__["default"]; }); - -/* harmony import */ var _link_index__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./link/index */ "./node_modules/d3-shape/src/link/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "linkHorizontal", function() { return _link_index__WEBPACK_IMPORTED_MODULE_7__["linkHorizontal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "linkVertical", function() { return _link_index__WEBPACK_IMPORTED_MODULE_7__["linkVertical"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "linkRadial", function() { return _link_index__WEBPACK_IMPORTED_MODULE_7__["linkRadial"]; }); - -/* harmony import */ var _symbol__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./symbol */ "./node_modules/d3-shape/src/symbol.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbol", function() { return _symbol__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbols", function() { return _symbol__WEBPACK_IMPORTED_MODULE_8__["symbols"]; }); - -/* harmony import */ var _symbol_circle__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./symbol/circle */ "./node_modules/d3-shape/src/symbol/circle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolCircle", function() { return _symbol_circle__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony import */ var _symbol_cross__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./symbol/cross */ "./node_modules/d3-shape/src/symbol/cross.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolCross", function() { return _symbol_cross__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony import */ var _symbol_diamond__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./symbol/diamond */ "./node_modules/d3-shape/src/symbol/diamond.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolDiamond", function() { return _symbol_diamond__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony import */ var _symbol_square__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./symbol/square */ "./node_modules/d3-shape/src/symbol/square.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolSquare", function() { return _symbol_square__WEBPACK_IMPORTED_MODULE_12__["default"]; }); - -/* harmony import */ var _symbol_star__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./symbol/star */ "./node_modules/d3-shape/src/symbol/star.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolStar", function() { return _symbol_star__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony import */ var _symbol_triangle__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./symbol/triangle */ "./node_modules/d3-shape/src/symbol/triangle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolTriangle", function() { return _symbol_triangle__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony import */ var _symbol_wye__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./symbol/wye */ "./node_modules/d3-shape/src/symbol/wye.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolWye", function() { return _symbol_wye__WEBPACK_IMPORTED_MODULE_15__["default"]; }); - -/* harmony import */ var _curve_basisClosed__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./curve/basisClosed */ "./node_modules/d3-shape/src/curve/basisClosed.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBasisClosed", function() { return _curve_basisClosed__WEBPACK_IMPORTED_MODULE_16__["default"]; }); - -/* harmony import */ var _curve_basisOpen__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./curve/basisOpen */ "./node_modules/d3-shape/src/curve/basisOpen.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBasisOpen", function() { return _curve_basisOpen__WEBPACK_IMPORTED_MODULE_17__["default"]; }); - -/* harmony import */ var _curve_basis__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./curve/basis */ "./node_modules/d3-shape/src/curve/basis.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBasis", function() { return _curve_basis__WEBPACK_IMPORTED_MODULE_18__["default"]; }); - -/* harmony import */ var _curve_bundle__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./curve/bundle */ "./node_modules/d3-shape/src/curve/bundle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBundle", function() { return _curve_bundle__WEBPACK_IMPORTED_MODULE_19__["default"]; }); - -/* harmony import */ var _curve_cardinalClosed__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./curve/cardinalClosed */ "./node_modules/d3-shape/src/curve/cardinalClosed.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCardinalClosed", function() { return _curve_cardinalClosed__WEBPACK_IMPORTED_MODULE_20__["default"]; }); - -/* harmony import */ var _curve_cardinalOpen__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./curve/cardinalOpen */ "./node_modules/d3-shape/src/curve/cardinalOpen.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCardinalOpen", function() { return _curve_cardinalOpen__WEBPACK_IMPORTED_MODULE_21__["default"]; }); - -/* harmony import */ var _curve_cardinal__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./curve/cardinal */ "./node_modules/d3-shape/src/curve/cardinal.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCardinal", function() { return _curve_cardinal__WEBPACK_IMPORTED_MODULE_22__["default"]; }); - -/* harmony import */ var _curve_catmullRomClosed__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./curve/catmullRomClosed */ "./node_modules/d3-shape/src/curve/catmullRomClosed.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCatmullRomClosed", function() { return _curve_catmullRomClosed__WEBPACK_IMPORTED_MODULE_23__["default"]; }); - -/* harmony import */ var _curve_catmullRomOpen__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./curve/catmullRomOpen */ "./node_modules/d3-shape/src/curve/catmullRomOpen.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCatmullRomOpen", function() { return _curve_catmullRomOpen__WEBPACK_IMPORTED_MODULE_24__["default"]; }); - -/* harmony import */ var _curve_catmullRom__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./curve/catmullRom */ "./node_modules/d3-shape/src/curve/catmullRom.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCatmullRom", function() { return _curve_catmullRom__WEBPACK_IMPORTED_MODULE_25__["default"]; }); - -/* harmony import */ var _curve_linearClosed__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./curve/linearClosed */ "./node_modules/d3-shape/src/curve/linearClosed.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveLinearClosed", function() { return _curve_linearClosed__WEBPACK_IMPORTED_MODULE_26__["default"]; }); - -/* harmony import */ var _curve_linear__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./curve/linear */ "./node_modules/d3-shape/src/curve/linear.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveLinear", function() { return _curve_linear__WEBPACK_IMPORTED_MODULE_27__["default"]; }); - -/* harmony import */ var _curve_monotone__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./curve/monotone */ "./node_modules/d3-shape/src/curve/monotone.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveMonotoneX", function() { return _curve_monotone__WEBPACK_IMPORTED_MODULE_28__["monotoneX"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveMonotoneY", function() { return _curve_monotone__WEBPACK_IMPORTED_MODULE_28__["monotoneY"]; }); - -/* harmony import */ var _curve_natural__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./curve/natural */ "./node_modules/d3-shape/src/curve/natural.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveNatural", function() { return _curve_natural__WEBPACK_IMPORTED_MODULE_29__["default"]; }); - -/* harmony import */ var _curve_step__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./curve/step */ "./node_modules/d3-shape/src/curve/step.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveStep", function() { return _curve_step__WEBPACK_IMPORTED_MODULE_30__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveStepAfter", function() { return _curve_step__WEBPACK_IMPORTED_MODULE_30__["stepAfter"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveStepBefore", function() { return _curve_step__WEBPACK_IMPORTED_MODULE_30__["stepBefore"]; }); - -/* harmony import */ var _stack__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./stack */ "./node_modules/d3-shape/src/stack.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stack", function() { return _stack__WEBPACK_IMPORTED_MODULE_31__["default"]; }); - -/* harmony import */ var _offset_expand__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(/*! ./offset/expand */ "./node_modules/d3-shape/src/offset/expand.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetExpand", function() { return _offset_expand__WEBPACK_IMPORTED_MODULE_32__["default"]; }); - -/* harmony import */ var _offset_diverging__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(/*! ./offset/diverging */ "./node_modules/d3-shape/src/offset/diverging.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetDiverging", function() { return _offset_diverging__WEBPACK_IMPORTED_MODULE_33__["default"]; }); - -/* harmony import */ var _offset_none__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(/*! ./offset/none */ "./node_modules/d3-shape/src/offset/none.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetNone", function() { return _offset_none__WEBPACK_IMPORTED_MODULE_34__["default"]; }); - -/* harmony import */ var _offset_silhouette__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(/*! ./offset/silhouette */ "./node_modules/d3-shape/src/offset/silhouette.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetSilhouette", function() { return _offset_silhouette__WEBPACK_IMPORTED_MODULE_35__["default"]; }); - -/* harmony import */ var _offset_wiggle__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./offset/wiggle */ "./node_modules/d3-shape/src/offset/wiggle.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetWiggle", function() { return _offset_wiggle__WEBPACK_IMPORTED_MODULE_36__["default"]; }); - -/* harmony import */ var _order_ascending__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ./order/ascending */ "./node_modules/d3-shape/src/order/ascending.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderAscending", function() { return _order_ascending__WEBPACK_IMPORTED_MODULE_37__["default"]; }); - -/* harmony import */ var _order_descending__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(/*! ./order/descending */ "./node_modules/d3-shape/src/order/descending.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderDescending", function() { return _order_descending__WEBPACK_IMPORTED_MODULE_38__["default"]; }); - -/* harmony import */ var _order_insideOut__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./order/insideOut */ "./node_modules/d3-shape/src/order/insideOut.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderInsideOut", function() { return _order_insideOut__WEBPACK_IMPORTED_MODULE_39__["default"]; }); - -/* harmony import */ var _order_none__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(/*! ./order/none */ "./node_modules/d3-shape/src/order/none.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderNone", function() { return _order_none__WEBPACK_IMPORTED_MODULE_40__["default"]; }); - -/* harmony import */ var _order_reverse__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(/*! ./order/reverse */ "./node_modules/d3-shape/src/order/reverse.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderReverse", function() { return _order_reverse__WEBPACK_IMPORTED_MODULE_41__["default"]; }); - - - - - - // Note: radialArea is deprecated! - // Note: radialLine is deprecated! - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/line.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-shape/src/line.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-shape/src/constant.js"); -/* harmony import */ var _curve_linear__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./curve/linear */ "./node_modules/d3-shape/src/curve/linear.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./point */ "./node_modules/d3-shape/src/point.js"); - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var x = _point__WEBPACK_IMPORTED_MODULE_3__["x"], - y = _point__WEBPACK_IMPORTED_MODULE_3__["y"], - defined = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(true), - context = null, - curve = _curve_linear__WEBPACK_IMPORTED_MODULE_2__["default"], - output = null; - - function line(data) { - var i, - n = data.length, - d, - defined0 = false, - buffer; - - if (context == null) output = curve(buffer = Object(d3_path__WEBPACK_IMPORTED_MODULE_0__["path"])()); - - for (i = 0; i <= n; ++i) { - if (!(i < n && defined(d = data[i], i, data)) === defined0) { - if (defined0 = !defined0) output.lineStart(); - else output.lineEnd(); - } - if (defined0) output.point(+x(d, i, data), +y(d, i, data)); - } - - if (buffer) return output = null, buffer + "" || null; - } - - line.x = function(_) { - return arguments.length ? (x = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), line) : x; - }; - - line.y = function(_) { - return arguments.length ? (y = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), line) : y; - }; - - line.defined = function(_) { - return arguments.length ? (defined = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(!!_), line) : defined; - }; - - line.curve = function(_) { - return arguments.length ? (curve = _, context != null && (output = curve(context)), line) : curve; - }; - - line.context = function(_) { - return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), line) : context; - }; - - return line; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/lineRadial.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/lineRadial.js ***! - \*************************************************/ -/*! exports provided: lineRadial, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lineRadial", function() { return lineRadial; }); -/* harmony import */ var _curve_radial__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./curve/radial */ "./node_modules/d3-shape/src/curve/radial.js"); -/* harmony import */ var _line__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./line */ "./node_modules/d3-shape/src/line.js"); - - - -function lineRadial(l) { - var c = l.curve; - - l.angle = l.x, delete l.x; - l.radius = l.y, delete l.y; - - l.curve = function(_) { - return arguments.length ? c(Object(_curve_radial__WEBPACK_IMPORTED_MODULE_0__["default"])(_)) : c()._curve; - }; - - return l; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return lineRadial(Object(_line__WEBPACK_IMPORTED_MODULE_1__["default"])().curve(_curve_radial__WEBPACK_IMPORTED_MODULE_0__["curveRadialLinear"])); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/link/index.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/link/index.js ***! - \*************************************************/ -/*! exports provided: linkHorizontal, linkVertical, linkRadial */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linkHorizontal", function() { return linkHorizontal; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linkVertical", function() { return linkVertical; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "linkRadial", function() { return linkRadial; }); -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../array */ "./node_modules/d3-shape/src/array.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../constant */ "./node_modules/d3-shape/src/constant.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../point */ "./node_modules/d3-shape/src/point.js"); -/* harmony import */ var _pointRadial__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../pointRadial */ "./node_modules/d3-shape/src/pointRadial.js"); - - - - - - -function linkSource(d) { - return d.source; -} - -function linkTarget(d) { - return d.target; -} - -function link(curve) { - var source = linkSource, - target = linkTarget, - x = _point__WEBPACK_IMPORTED_MODULE_3__["x"], - y = _point__WEBPACK_IMPORTED_MODULE_3__["y"], - context = null; - - function link() { - var buffer, argv = _array__WEBPACK_IMPORTED_MODULE_1__["slice"].call(arguments), s = source.apply(this, argv), t = target.apply(this, argv); - if (!context) context = buffer = Object(d3_path__WEBPACK_IMPORTED_MODULE_0__["path"])(); - curve(context, +x.apply(this, (argv[0] = s, argv)), +y.apply(this, argv), +x.apply(this, (argv[0] = t, argv)), +y.apply(this, argv)); - if (buffer) return context = null, buffer + "" || null; - } - - link.source = function(_) { - return arguments.length ? (source = _, link) : source; - }; - - link.target = function(_) { - return arguments.length ? (target = _, link) : target; - }; - - link.x = function(_) { - return arguments.length ? (x = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(+_), link) : x; - }; - - link.y = function(_) { - return arguments.length ? (y = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_2__["default"])(+_), link) : y; - }; - - link.context = function(_) { - return arguments.length ? ((context = _ == null ? null : _), link) : context; - }; - - return link; -} - -function curveHorizontal(context, x0, y0, x1, y1) { - context.moveTo(x0, y0); - context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1); -} - -function curveVertical(context, x0, y0, x1, y1) { - context.moveTo(x0, y0); - context.bezierCurveTo(x0, y0 = (y0 + y1) / 2, x1, y0, x1, y1); -} - -function curveRadial(context, x0, y0, x1, y1) { - var p0 = Object(_pointRadial__WEBPACK_IMPORTED_MODULE_4__["default"])(x0, y0), - p1 = Object(_pointRadial__WEBPACK_IMPORTED_MODULE_4__["default"])(x0, y0 = (y0 + y1) / 2), - p2 = Object(_pointRadial__WEBPACK_IMPORTED_MODULE_4__["default"])(x1, y0), - p3 = Object(_pointRadial__WEBPACK_IMPORTED_MODULE_4__["default"])(x1, y1); - context.moveTo(p0[0], p0[1]); - context.bezierCurveTo(p1[0], p1[1], p2[0], p2[1], p3[0], p3[1]); -} - -function linkHorizontal() { - return link(curveHorizontal); -} - -function linkVertical() { - return link(curveVertical); -} - -function linkRadial() { - var l = link(curveRadial); - l.angle = l.x, delete l.x; - l.radius = l.y, delete l.y; - return l; -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/math.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-shape/src/math.js ***! - \*******************************************/ -/*! exports provided: abs, atan2, cos, max, min, sin, sqrt, epsilon, pi, halfPi, tau, acos, asin */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "abs", function() { return abs; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "atan2", function() { return atan2; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cos", function() { return cos; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "max", function() { return max; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "min", function() { return min; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sin", function() { return sin; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrt", function() { return sqrt; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "epsilon", function() { return epsilon; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pi", function() { return pi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "halfPi", function() { return halfPi; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tau", function() { return tau; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "acos", function() { return acos; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "asin", function() { return asin; }); -var abs = Math.abs; -var atan2 = Math.atan2; -var cos = Math.cos; -var max = Math.max; -var min = Math.min; -var sin = Math.sin; -var sqrt = Math.sqrt; - -var epsilon = 1e-12; -var pi = Math.PI; -var halfPi = pi / 2; -var tau = 2 * pi; - -function acos(x) { - return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); -} - -function asin(x) { - return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x); -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/noop.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-shape/src/noop.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function() {}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/offset/diverging.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-shape/src/offset/diverging.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(series, order) { - if (!((n = series.length) > 1)) return; - for (var i, j = 0, d, dy, yp, yn, n, m = series[order[0]].length; j < m; ++j) { - for (yp = yn = 0, i = 0; i < n; ++i) { - if ((dy = (d = series[order[i]][j])[1] - d[0]) >= 0) { - d[0] = yp, d[1] = yp += dy; - } else if (dy < 0) { - d[1] = yn, d[0] = yn += dy; - } else { - d[0] = yp; - } - } - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/offset/expand.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-shape/src/offset/expand.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./none */ "./node_modules/d3-shape/src/offset/none.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(series, order) { - if (!((n = series.length) > 0)) return; - for (var i, n, j = 0, m = series[0].length, y; j < m; ++j) { - for (y = i = 0; i < n; ++i) y += series[i][j][1] || 0; - if (y) for (i = 0; i < n; ++i) series[i][j][1] /= y; - } - Object(_none__WEBPACK_IMPORTED_MODULE_0__["default"])(series, order); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/offset/none.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-shape/src/offset/none.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(series, order) { - if (!((n = series.length) > 1)) return; - for (var i = 1, j, s0, s1 = series[order[0]], n, m = s1.length; i < n; ++i) { - s0 = s1, s1 = series[order[i]]; - for (j = 0; j < m; ++j) { - s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1]; - } - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/offset/silhouette.js": -/*!********************************************************!*\ - !*** ./node_modules/d3-shape/src/offset/silhouette.js ***! - \********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./none */ "./node_modules/d3-shape/src/offset/none.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(series, order) { - if (!((n = series.length) > 0)) return; - for (var j = 0, s0 = series[order[0]], n, m = s0.length; j < m; ++j) { - for (var i = 0, y = 0; i < n; ++i) y += series[i][j][1] || 0; - s0[j][1] += s0[j][0] = -y / 2; - } - Object(_none__WEBPACK_IMPORTED_MODULE_0__["default"])(series, order); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/offset/wiggle.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-shape/src/offset/wiggle.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./none */ "./node_modules/d3-shape/src/offset/none.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(series, order) { - if (!((n = series.length) > 0) || !((m = (s0 = series[order[0]]).length) > 0)) return; - for (var y = 0, j = 1, s0, m, n; j < m; ++j) { - for (var i = 0, s1 = 0, s2 = 0; i < n; ++i) { - var si = series[order[i]], - sij0 = si[j][1] || 0, - sij1 = si[j - 1][1] || 0, - s3 = (sij0 - sij1) / 2; - for (var k = 0; k < i; ++k) { - var sk = series[order[k]], - skj0 = sk[j][1] || 0, - skj1 = sk[j - 1][1] || 0; - s3 += skj0 - skj1; - } - s1 += sij0, s2 += s3 * sij0; - } - s0[j - 1][1] += s0[j - 1][0] = y; - if (s1) y -= s2 / s1; - } - s0[j - 1][1] += s0[j - 1][0] = y; - Object(_none__WEBPACK_IMPORTED_MODULE_0__["default"])(series, order); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/order/ascending.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-shape/src/order/ascending.js ***! - \******************************************************/ -/*! exports provided: default, sum */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sum", function() { return sum; }); -/* harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./none */ "./node_modules/d3-shape/src/order/none.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(series) { - var sums = series.map(sum); - return Object(_none__WEBPACK_IMPORTED_MODULE_0__["default"])(series).sort(function(a, b) { return sums[a] - sums[b]; }); -}); - -function sum(series) { - var s = 0, i = -1, n = series.length, v; - while (++i < n) if (v = +series[i][1]) s += v; - return s; -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/order/descending.js": -/*!*******************************************************!*\ - !*** ./node_modules/d3-shape/src/order/descending.js ***! - \*******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-shape/src/order/ascending.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(series) { - return Object(_ascending__WEBPACK_IMPORTED_MODULE_0__["default"])(series).reverse(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/order/insideOut.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-shape/src/order/insideOut.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./none */ "./node_modules/d3-shape/src/order/none.js"); -/* harmony import */ var _ascending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ascending */ "./node_modules/d3-shape/src/order/ascending.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(series) { - var n = series.length, - i, - j, - sums = series.map(_ascending__WEBPACK_IMPORTED_MODULE_1__["sum"]), - order = Object(_none__WEBPACK_IMPORTED_MODULE_0__["default"])(series).sort(function(a, b) { return sums[b] - sums[a]; }), - top = 0, - bottom = 0, - tops = [], - bottoms = []; - - for (i = 0; i < n; ++i) { - j = order[i]; - if (top < bottom) { - top += sums[j]; - tops.push(j); - } else { - bottom += sums[j]; - bottoms.push(j); - } - } - - return bottoms.reverse().concat(tops); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/order/none.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/order/none.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(series) { - var n = series.length, o = new Array(n); - while (--n >= 0) o[n] = n; - return o; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/order/reverse.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-shape/src/order/reverse.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _none__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./none */ "./node_modules/d3-shape/src/order/none.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(series) { - return Object(_none__WEBPACK_IMPORTED_MODULE_0__["default"])(series).reverse(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/pie.js": -/*!******************************************!*\ - !*** ./node_modules/d3-shape/src/pie.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-shape/src/constant.js"); -/* harmony import */ var _descending__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./descending */ "./node_modules/d3-shape/src/descending.js"); -/* harmony import */ var _identity__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./identity */ "./node_modules/d3-shape/src/identity.js"); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./math */ "./node_modules/d3-shape/src/math.js"); - - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var value = _identity__WEBPACK_IMPORTED_MODULE_2__["default"], - sortValues = _descending__WEBPACK_IMPORTED_MODULE_1__["default"], - sort = null, - startAngle = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(0), - endAngle = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(_math__WEBPACK_IMPORTED_MODULE_3__["tau"]), - padAngle = Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(0); - - function pie(data) { - var i, - n = data.length, - j, - k, - sum = 0, - index = new Array(n), - arcs = new Array(n), - a0 = +startAngle.apply(this, arguments), - da = Math.min(_math__WEBPACK_IMPORTED_MODULE_3__["tau"], Math.max(-_math__WEBPACK_IMPORTED_MODULE_3__["tau"], endAngle.apply(this, arguments) - a0)), - a1, - p = Math.min(Math.abs(da) / n, padAngle.apply(this, arguments)), - pa = p * (da < 0 ? -1 : 1), - v; - - for (i = 0; i < n; ++i) { - if ((v = arcs[index[i] = i] = +value(data[i], i, data)) > 0) { - sum += v; - } - } - - // Optionally sort the arcs by previously-computed values or by data. - if (sortValues != null) index.sort(function(i, j) { return sortValues(arcs[i], arcs[j]); }); - else if (sort != null) index.sort(function(i, j) { return sort(data[i], data[j]); }); - - // Compute the arcs! They are stored in the original data's order. - for (i = 0, k = sum ? (da - n * pa) / sum : 0; i < n; ++i, a0 = a1) { - j = index[i], v = arcs[j], a1 = a0 + (v > 0 ? v * k : 0) + pa, arcs[j] = { - data: data[j], - index: i, - value: v, - startAngle: a0, - endAngle: a1, - padAngle: p - }; - } - - return arcs; - } - - pie.value = function(_) { - return arguments.length ? (value = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), pie) : value; - }; - - pie.sortValues = function(_) { - return arguments.length ? (sortValues = _, sort = null, pie) : sortValues; - }; - - pie.sort = function(_) { - return arguments.length ? (sort = _, sortValues = null, pie) : sort; - }; - - pie.startAngle = function(_) { - return arguments.length ? (startAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), pie) : startAngle; - }; - - pie.endAngle = function(_) { - return arguments.length ? (endAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), pie) : endAngle; - }; - - pie.padAngle = function(_) { - return arguments.length ? (padAngle = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), pie) : padAngle; - }; - - return pie; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/point.js": -/*!********************************************!*\ - !*** ./node_modules/d3-shape/src/point.js ***! - \********************************************/ -/*! exports provided: x, y */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return x; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return y; }); -function x(p) { - return p[0]; -} - -function y(p) { - return p[1]; -} - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/pointRadial.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-shape/src/pointRadial.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x, y) { - return [(y = +y) * Math.cos(x -= Math.PI / 2), y * Math.sin(x)]; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/stack.js": -/*!********************************************!*\ - !*** ./node_modules/d3-shape/src/stack.js ***! - \********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./array */ "./node_modules/d3-shape/src/array.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-shape/src/constant.js"); -/* harmony import */ var _offset_none__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./offset/none */ "./node_modules/d3-shape/src/offset/none.js"); -/* harmony import */ var _order_none__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./order/none */ "./node_modules/d3-shape/src/order/none.js"); - - - - - -function stackValue(d, key) { - return d[key]; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var keys = Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])([]), - order = _order_none__WEBPACK_IMPORTED_MODULE_3__["default"], - offset = _offset_none__WEBPACK_IMPORTED_MODULE_2__["default"], - value = stackValue; - - function stack(data) { - var kz = keys.apply(this, arguments), - i, - m = data.length, - n = kz.length, - sz = new Array(n), - oz; - - for (i = 0; i < n; ++i) { - for (var ki = kz[i], si = sz[i] = new Array(m), j = 0, sij; j < m; ++j) { - si[j] = sij = [0, +value(data[j], ki, j, data)]; - sij.data = data[j]; - } - si.key = ki; - } - - for (i = 0, oz = order(sz); i < n; ++i) { - sz[oz[i]].index = i; - } - - offset(sz, oz); - return sz; - } - - stack.keys = function(_) { - return arguments.length ? (keys = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(_array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(_)), stack) : keys; - }; - - stack.value = function(_) { - return arguments.length ? (value = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(+_), stack) : value; - }; - - stack.order = function(_) { - return arguments.length ? (order = _ == null ? _order_none__WEBPACK_IMPORTED_MODULE_3__["default"] : typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_1__["default"])(_array__WEBPACK_IMPORTED_MODULE_0__["slice"].call(_)), stack) : order; - }; - - stack.offset = function(_) { - return arguments.length ? (offset = _ == null ? _offset_none__WEBPACK_IMPORTED_MODULE_2__["default"] : _, stack) : offset; - }; - - return stack; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-shape/src/symbol.js ***! - \*********************************************/ -/*! exports provided: symbols, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "symbols", function() { return symbols; }); -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); -/* harmony import */ var _symbol_circle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./symbol/circle */ "./node_modules/d3-shape/src/symbol/circle.js"); -/* harmony import */ var _symbol_cross__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./symbol/cross */ "./node_modules/d3-shape/src/symbol/cross.js"); -/* harmony import */ var _symbol_diamond__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./symbol/diamond */ "./node_modules/d3-shape/src/symbol/diamond.js"); -/* harmony import */ var _symbol_star__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./symbol/star */ "./node_modules/d3-shape/src/symbol/star.js"); -/* harmony import */ var _symbol_square__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./symbol/square */ "./node_modules/d3-shape/src/symbol/square.js"); -/* harmony import */ var _symbol_triangle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./symbol/triangle */ "./node_modules/d3-shape/src/symbol/triangle.js"); -/* harmony import */ var _symbol_wye__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./symbol/wye */ "./node_modules/d3-shape/src/symbol/wye.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-shape/src/constant.js"); - - - - - - - - - - -var symbols = [ - _symbol_circle__WEBPACK_IMPORTED_MODULE_1__["default"], - _symbol_cross__WEBPACK_IMPORTED_MODULE_2__["default"], - _symbol_diamond__WEBPACK_IMPORTED_MODULE_3__["default"], - _symbol_square__WEBPACK_IMPORTED_MODULE_5__["default"], - _symbol_star__WEBPACK_IMPORTED_MODULE_4__["default"], - _symbol_triangle__WEBPACK_IMPORTED_MODULE_6__["default"], - _symbol_wye__WEBPACK_IMPORTED_MODULE_7__["default"] -]; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var type = Object(_constant__WEBPACK_IMPORTED_MODULE_8__["default"])(_symbol_circle__WEBPACK_IMPORTED_MODULE_1__["default"]), - size = Object(_constant__WEBPACK_IMPORTED_MODULE_8__["default"])(64), - context = null; - - function symbol() { - var buffer; - if (!context) context = buffer = Object(d3_path__WEBPACK_IMPORTED_MODULE_0__["path"])(); - type.apply(this, arguments).draw(context, +size.apply(this, arguments)); - if (buffer) return context = null, buffer + "" || null; - } - - symbol.type = function(_) { - return arguments.length ? (type = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_8__["default"])(_), symbol) : type; - }; - - symbol.size = function(_) { - return arguments.length ? (size = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_8__["default"])(+_), symbol) : size; - }; - - symbol.context = function(_) { - return arguments.length ? (context = _ == null ? null : _, symbol) : context; - }; - - return symbol; -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/circle.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/circle.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-shape/src/math.js"); - - -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var r = Math.sqrt(size / _math__WEBPACK_IMPORTED_MODULE_0__["pi"]); - context.moveTo(r, 0); - context.arc(0, 0, r, 0, _math__WEBPACK_IMPORTED_MODULE_0__["tau"]); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/cross.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/cross.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var r = Math.sqrt(size / 5) / 2; - context.moveTo(-3 * r, -r); - context.lineTo(-r, -r); - context.lineTo(-r, -3 * r); - context.lineTo(r, -3 * r); - context.lineTo(r, -r); - context.lineTo(3 * r, -r); - context.lineTo(3 * r, r); - context.lineTo(r, r); - context.lineTo(r, 3 * r); - context.lineTo(-r, 3 * r); - context.lineTo(-r, r); - context.lineTo(-3 * r, r); - context.closePath(); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/diamond.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/diamond.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var tan30 = Math.sqrt(1 / 3), - tan30_2 = tan30 * 2; - -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var y = Math.sqrt(size / tan30_2), - x = y * tan30; - context.moveTo(0, -y); - context.lineTo(x, 0); - context.lineTo(0, y); - context.lineTo(-x, 0); - context.closePath(); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/square.js": -/*!****************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/square.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var w = Math.sqrt(size), - x = -w / 2; - context.rect(x, x, w, w); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/star.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/star.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _math__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../math */ "./node_modules/d3-shape/src/math.js"); - - -var ka = 0.89081309152928522810, - kr = Math.sin(_math__WEBPACK_IMPORTED_MODULE_0__["pi"] / 10) / Math.sin(7 * _math__WEBPACK_IMPORTED_MODULE_0__["pi"] / 10), - kx = Math.sin(_math__WEBPACK_IMPORTED_MODULE_0__["tau"] / 10) * kr, - ky = -Math.cos(_math__WEBPACK_IMPORTED_MODULE_0__["tau"] / 10) * kr; - -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var r = Math.sqrt(size * ka), - x = kx * r, - y = ky * r; - context.moveTo(0, -r); - context.lineTo(x, y); - for (var i = 1; i < 5; ++i) { - var a = _math__WEBPACK_IMPORTED_MODULE_0__["tau"] * i / 5, - c = Math.cos(a), - s = Math.sin(a); - context.lineTo(s * r, -c * r); - context.lineTo(c * x - s * y, s * x + c * y); - } - context.closePath(); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/triangle.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/triangle.js ***! - \******************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var sqrt3 = Math.sqrt(3); - -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var y = -Math.sqrt(size / (sqrt3 * 3)); - context.moveTo(0, y * 2); - context.lineTo(-sqrt3 * y, -y); - context.lineTo(sqrt3 * y, -y); - context.closePath(); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-shape/src/symbol/wye.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-shape/src/symbol/wye.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -var c = -0.5, - s = Math.sqrt(3) / 2, - k = 1 / Math.sqrt(12), - a = (k / 2 + 1) * 3; - -/* harmony default export */ __webpack_exports__["default"] = ({ - draw: function(context, size) { - var r = Math.sqrt(size / a), - x0 = r / 2, - y0 = r * k, - x1 = x0, - y1 = r * k + r, - x2 = -x1, - y2 = y1; - context.moveTo(x0, y0); - context.lineTo(x1, y1); - context.lineTo(x2, y2); - context.lineTo(c * x0 - s * y0, s * x0 + c * y0); - context.lineTo(c * x1 - s * y1, s * x1 + c * y1); - context.lineTo(c * x2 - s * y2, s * x2 + c * y2); - context.lineTo(c * x0 + s * y0, c * y0 - s * x0); - context.lineTo(c * x1 + s * y1, c * y1 - s * x1); - context.lineTo(c * x2 + s * y2, c * y2 - s * x2); - context.closePath(); - } -}); - - -/***/ }), - -/***/ "./node_modules/d3-time-format/src/defaultLocale.js": -/*!**********************************************************!*\ - !*** ./node_modules/d3-time-format/src/defaultLocale.js ***! - \**********************************************************/ -/*! exports provided: timeFormat, timeParse, utcFormat, utcParse, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "timeFormat", function() { return timeFormat; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "timeParse", function() { return timeParse; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcFormat", function() { return utcFormat; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcParse", function() { return utcParse; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return defaultLocale; }); -/* harmony import */ var _locale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./locale */ "./node_modules/d3-time-format/src/locale.js"); - - -var locale; -var timeFormat; -var timeParse; -var utcFormat; -var utcParse; - -defaultLocale({ - dateTime: "%x, %X", - date: "%-m/%-d/%Y", - time: "%-I:%M:%S %p", - periods: ["AM", "PM"], - days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], - shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], - months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], - shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] -}); - -function defaultLocale(definition) { - locale = Object(_locale__WEBPACK_IMPORTED_MODULE_0__["default"])(definition); - timeFormat = locale.format; - timeParse = locale.parse; - utcFormat = locale.utcFormat; - utcParse = locale.utcParse; - return locale; -} - - -/***/ }), - -/***/ "./node_modules/d3-time-format/src/index.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-time-format/src/index.js ***! - \**************************************************/ -/*! exports provided: timeFormatDefaultLocale, timeFormat, timeParse, utcFormat, utcParse, timeFormatLocale, isoFormat, isoParse */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultLocale */ "./node_modules/d3-time-format/src/defaultLocale.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFormatDefaultLocale", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFormat", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["timeFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeParse", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["timeParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcFormat", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["utcFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcParse", function() { return _defaultLocale__WEBPACK_IMPORTED_MODULE_0__["utcParse"]; }); - -/* harmony import */ var _locale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./locale */ "./node_modules/d3-time-format/src/locale.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFormatLocale", function() { return _locale__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _isoFormat__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./isoFormat */ "./node_modules/d3-time-format/src/isoFormat.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isoFormat", function() { return _isoFormat__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _isoParse__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./isoParse */ "./node_modules/d3-time-format/src/isoParse.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isoParse", function() { return _isoParse__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-time-format/src/isoFormat.js": -/*!******************************************************!*\ - !*** ./node_modules/d3-time-format/src/isoFormat.js ***! - \******************************************************/ -/*! exports provided: isoSpecifier, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isoSpecifier", function() { return isoSpecifier; }); -/* harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./defaultLocale */ "./node_modules/d3-time-format/src/defaultLocale.js"); - - -var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ"; - -function formatIsoNative(date) { - return date.toISOString(); -} - -var formatIso = Date.prototype.toISOString - ? formatIsoNative - : Object(_defaultLocale__WEBPACK_IMPORTED_MODULE_0__["utcFormat"])(isoSpecifier); - -/* harmony default export */ __webpack_exports__["default"] = (formatIso); - - -/***/ }), - -/***/ "./node_modules/d3-time-format/src/isoParse.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-time-format/src/isoParse.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _isoFormat__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./isoFormat */ "./node_modules/d3-time-format/src/isoFormat.js"); -/* harmony import */ var _defaultLocale__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./defaultLocale */ "./node_modules/d3-time-format/src/defaultLocale.js"); - - - -function parseIsoNative(string) { - var date = new Date(string); - return isNaN(date) ? null : date; -} - -var parseIso = +new Date("2000-01-01T00:00:00.000Z") - ? parseIsoNative - : Object(_defaultLocale__WEBPACK_IMPORTED_MODULE_1__["utcParse"])(_isoFormat__WEBPACK_IMPORTED_MODULE_0__["isoSpecifier"]); - -/* harmony default export */ __webpack_exports__["default"] = (parseIso); - - -/***/ }), - -/***/ "./node_modules/d3-time-format/src/locale.js": -/*!***************************************************!*\ - !*** ./node_modules/d3-time-format/src/locale.js ***! - \***************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return formatLocale; }); -/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-time */ "./node_modules/d3-time/src/index.js"); - - -function localDate(d) { - if (0 <= d.y && d.y < 100) { - var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L); - date.setFullYear(d.y); - return date; - } - return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L); -} - -function utcDate(d) { - if (0 <= d.y && d.y < 100) { - var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L)); - date.setUTCFullYear(d.y); - return date; - } - return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L)); -} - -function newYear(y) { - return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0}; -} - -function formatLocale(locale) { - var locale_dateTime = locale.dateTime, - locale_date = locale.date, - locale_time = locale.time, - locale_periods = locale.periods, - locale_weekdays = locale.days, - locale_shortWeekdays = locale.shortDays, - locale_months = locale.months, - locale_shortMonths = locale.shortMonths; - - var periodRe = formatRe(locale_periods), - periodLookup = formatLookup(locale_periods), - weekdayRe = formatRe(locale_weekdays), - weekdayLookup = formatLookup(locale_weekdays), - shortWeekdayRe = formatRe(locale_shortWeekdays), - shortWeekdayLookup = formatLookup(locale_shortWeekdays), - monthRe = formatRe(locale_months), - monthLookup = formatLookup(locale_months), - shortMonthRe = formatRe(locale_shortMonths), - shortMonthLookup = formatLookup(locale_shortMonths); - - var formats = { - "a": formatShortWeekday, - "A": formatWeekday, - "b": formatShortMonth, - "B": formatMonth, - "c": null, - "d": formatDayOfMonth, - "e": formatDayOfMonth, - "f": formatMicroseconds, - "H": formatHour24, - "I": formatHour12, - "j": formatDayOfYear, - "L": formatMilliseconds, - "m": formatMonthNumber, - "M": formatMinutes, - "p": formatPeriod, - "Q": formatUnixTimestamp, - "s": formatUnixTimestampSeconds, - "S": formatSeconds, - "u": formatWeekdayNumberMonday, - "U": formatWeekNumberSunday, - "V": formatWeekNumberISO, - "w": formatWeekdayNumberSunday, - "W": formatWeekNumberMonday, - "x": null, - "X": null, - "y": formatYear, - "Y": formatFullYear, - "Z": formatZone, - "%": formatLiteralPercent - }; - - var utcFormats = { - "a": formatUTCShortWeekday, - "A": formatUTCWeekday, - "b": formatUTCShortMonth, - "B": formatUTCMonth, - "c": null, - "d": formatUTCDayOfMonth, - "e": formatUTCDayOfMonth, - "f": formatUTCMicroseconds, - "H": formatUTCHour24, - "I": formatUTCHour12, - "j": formatUTCDayOfYear, - "L": formatUTCMilliseconds, - "m": formatUTCMonthNumber, - "M": formatUTCMinutes, - "p": formatUTCPeriod, - "Q": formatUnixTimestamp, - "s": formatUnixTimestampSeconds, - "S": formatUTCSeconds, - "u": formatUTCWeekdayNumberMonday, - "U": formatUTCWeekNumberSunday, - "V": formatUTCWeekNumberISO, - "w": formatUTCWeekdayNumberSunday, - "W": formatUTCWeekNumberMonday, - "x": null, - "X": null, - "y": formatUTCYear, - "Y": formatUTCFullYear, - "Z": formatUTCZone, - "%": formatLiteralPercent - }; - - var parses = { - "a": parseShortWeekday, - "A": parseWeekday, - "b": parseShortMonth, - "B": parseMonth, - "c": parseLocaleDateTime, - "d": parseDayOfMonth, - "e": parseDayOfMonth, - "f": parseMicroseconds, - "H": parseHour24, - "I": parseHour24, - "j": parseDayOfYear, - "L": parseMilliseconds, - "m": parseMonthNumber, - "M": parseMinutes, - "p": parsePeriod, - "Q": parseUnixTimestamp, - "s": parseUnixTimestampSeconds, - "S": parseSeconds, - "u": parseWeekdayNumberMonday, - "U": parseWeekNumberSunday, - "V": parseWeekNumberISO, - "w": parseWeekdayNumberSunday, - "W": parseWeekNumberMonday, - "x": parseLocaleDate, - "X": parseLocaleTime, - "y": parseYear, - "Y": parseFullYear, - "Z": parseZone, - "%": parseLiteralPercent - }; - - // These recursive directive definitions must be deferred. - formats.x = newFormat(locale_date, formats); - formats.X = newFormat(locale_time, formats); - formats.c = newFormat(locale_dateTime, formats); - utcFormats.x = newFormat(locale_date, utcFormats); - utcFormats.X = newFormat(locale_time, utcFormats); - utcFormats.c = newFormat(locale_dateTime, utcFormats); - - function newFormat(specifier, formats) { - return function(date) { - var string = [], - i = -1, - j = 0, - n = specifier.length, - c, - pad, - format; - - if (!(date instanceof Date)) date = new Date(+date); - - while (++i < n) { - if (specifier.charCodeAt(i) === 37) { - string.push(specifier.slice(j, i)); - if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i); - else pad = c === "e" ? " " : "0"; - if (format = formats[c]) c = format(date, pad); - string.push(c); - j = i + 1; - } - } - - string.push(specifier.slice(j, i)); - return string.join(""); - }; - } - - function newParse(specifier, newDate) { - return function(string) { - var d = newYear(1900), - i = parseSpecifier(d, specifier, string += "", 0), - week, day; - if (i != string.length) return null; - - // If a UNIX timestamp is specified, return it. - if ("Q" in d) return new Date(d.Q); - - // The am-pm flag is 0 for AM, and 1 for PM. - if ("p" in d) d.H = d.H % 12 + d.p * 12; - - // Convert day-of-week and week-of-year to day-of-year. - if ("V" in d) { - if (d.V < 1 || d.V > 53) return null; - if (!("w" in d)) d.w = 1; - if ("Z" in d) { - week = utcDate(newYear(d.y)), day = week.getUTCDay(); - week = day > 4 || day === 0 ? d3_time__WEBPACK_IMPORTED_MODULE_0__["utcMonday"].ceil(week) : Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcMonday"])(week); - week = d3_time__WEBPACK_IMPORTED_MODULE_0__["utcDay"].offset(week, (d.V - 1) * 7); - d.y = week.getUTCFullYear(); - d.m = week.getUTCMonth(); - d.d = week.getUTCDate() + (d.w + 6) % 7; - } else { - week = newDate(newYear(d.y)), day = week.getDay(); - week = day > 4 || day === 0 ? d3_time__WEBPACK_IMPORTED_MODULE_0__["timeMonday"].ceil(week) : Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeMonday"])(week); - week = d3_time__WEBPACK_IMPORTED_MODULE_0__["timeDay"].offset(week, (d.V - 1) * 7); - d.y = week.getFullYear(); - d.m = week.getMonth(); - d.d = week.getDate() + (d.w + 6) % 7; - } - } else if ("W" in d || "U" in d) { - if (!("w" in d)) d.w = "u" in d ? d.u % 7 : "W" in d ? 1 : 0; - day = "Z" in d ? utcDate(newYear(d.y)).getUTCDay() : newDate(newYear(d.y)).getDay(); - d.m = 0; - d.d = "W" in d ? (d.w + 6) % 7 + d.W * 7 - (day + 5) % 7 : d.w + d.U * 7 - (day + 6) % 7; - } - - // If a time zone is specified, all fields are interpreted as UTC and then - // offset according to the specified time zone. - if ("Z" in d) { - d.H += d.Z / 100 | 0; - d.M += d.Z % 100; - return utcDate(d); - } - - // Otherwise, all fields are in local time. - return newDate(d); - }; - } - - function parseSpecifier(d, specifier, string, j) { - var i = 0, - n = specifier.length, - m = string.length, - c, - parse; - - while (i < n) { - if (j >= m) return -1; - c = specifier.charCodeAt(i++); - if (c === 37) { - c = specifier.charAt(i++); - parse = parses[c in pads ? specifier.charAt(i++) : c]; - if (!parse || ((j = parse(d, string, j)) < 0)) return -1; - } else if (c != string.charCodeAt(j++)) { - return -1; - } - } - - return j; - } - - function parsePeriod(d, string, i) { - var n = periodRe.exec(string.slice(i)); - return n ? (d.p = periodLookup[n[0].toLowerCase()], i + n[0].length) : -1; - } - - function parseShortWeekday(d, string, i) { - var n = shortWeekdayRe.exec(string.slice(i)); - return n ? (d.w = shortWeekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; - } - - function parseWeekday(d, string, i) { - var n = weekdayRe.exec(string.slice(i)); - return n ? (d.w = weekdayLookup[n[0].toLowerCase()], i + n[0].length) : -1; - } - - function parseShortMonth(d, string, i) { - var n = shortMonthRe.exec(string.slice(i)); - return n ? (d.m = shortMonthLookup[n[0].toLowerCase()], i + n[0].length) : -1; - } - - function parseMonth(d, string, i) { - var n = monthRe.exec(string.slice(i)); - return n ? (d.m = monthLookup[n[0].toLowerCase()], i + n[0].length) : -1; - } - - function parseLocaleDateTime(d, string, i) { - return parseSpecifier(d, locale_dateTime, string, i); - } - - function parseLocaleDate(d, string, i) { - return parseSpecifier(d, locale_date, string, i); - } - - function parseLocaleTime(d, string, i) { - return parseSpecifier(d, locale_time, string, i); - } - - function formatShortWeekday(d) { - return locale_shortWeekdays[d.getDay()]; - } - - function formatWeekday(d) { - return locale_weekdays[d.getDay()]; - } - - function formatShortMonth(d) { - return locale_shortMonths[d.getMonth()]; - } - - function formatMonth(d) { - return locale_months[d.getMonth()]; - } - - function formatPeriod(d) { - return locale_periods[+(d.getHours() >= 12)]; - } - - function formatUTCShortWeekday(d) { - return locale_shortWeekdays[d.getUTCDay()]; - } - - function formatUTCWeekday(d) { - return locale_weekdays[d.getUTCDay()]; - } - - function formatUTCShortMonth(d) { - return locale_shortMonths[d.getUTCMonth()]; - } - - function formatUTCMonth(d) { - return locale_months[d.getUTCMonth()]; - } - - function formatUTCPeriod(d) { - return locale_periods[+(d.getUTCHours() >= 12)]; - } - - return { - format: function(specifier) { - var f = newFormat(specifier += "", formats); - f.toString = function() { return specifier; }; - return f; - }, - parse: function(specifier) { - var p = newParse(specifier += "", localDate); - p.toString = function() { return specifier; }; - return p; - }, - utcFormat: function(specifier) { - var f = newFormat(specifier += "", utcFormats); - f.toString = function() { return specifier; }; - return f; - }, - utcParse: function(specifier) { - var p = newParse(specifier, utcDate); - p.toString = function() { return specifier; }; - return p; - } - }; -} - -var pads = {"-": "", "_": " ", "0": "0"}, - numberRe = /^\s*\d+/, // note: ignores next directive - percentRe = /^%/, - requoteRe = /[\\^$*+?|[\]().{}]/g; - -function pad(value, fill, width) { - var sign = value < 0 ? "-" : "", - string = (sign ? -value : value) + "", - length = string.length; - return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string); -} - -function requote(s) { - return s.replace(requoteRe, "\\$&"); -} - -function formatRe(names) { - return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i"); -} - -function formatLookup(names) { - var map = {}, i = -1, n = names.length; - while (++i < n) map[names[i].toLowerCase()] = i; - return map; -} - -function parseWeekdayNumberSunday(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 1)); - return n ? (d.w = +n[0], i + n[0].length) : -1; -} - -function parseWeekdayNumberMonday(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 1)); - return n ? (d.u = +n[0], i + n[0].length) : -1; -} - -function parseWeekNumberSunday(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.U = +n[0], i + n[0].length) : -1; -} - -function parseWeekNumberISO(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.V = +n[0], i + n[0].length) : -1; -} - -function parseWeekNumberMonday(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.W = +n[0], i + n[0].length) : -1; -} - -function parseFullYear(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 4)); - return n ? (d.y = +n[0], i + n[0].length) : -1; -} - -function parseYear(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1; -} - -function parseZone(d, string, i) { - var n = /^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(string.slice(i, i + 6)); - return n ? (d.Z = n[1] ? 0 : -(n[2] + (n[3] || "00")), i + n[0].length) : -1; -} - -function parseMonthNumber(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.m = n[0] - 1, i + n[0].length) : -1; -} - -function parseDayOfMonth(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.d = +n[0], i + n[0].length) : -1; -} - -function parseDayOfYear(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 3)); - return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1; -} - -function parseHour24(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.H = +n[0], i + n[0].length) : -1; -} - -function parseMinutes(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.M = +n[0], i + n[0].length) : -1; -} - -function parseSeconds(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 2)); - return n ? (d.S = +n[0], i + n[0].length) : -1; -} - -function parseMilliseconds(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 3)); - return n ? (d.L = +n[0], i + n[0].length) : -1; -} - -function parseMicroseconds(d, string, i) { - var n = numberRe.exec(string.slice(i, i + 6)); - return n ? (d.L = Math.floor(n[0] / 1000), i + n[0].length) : -1; -} - -function parseLiteralPercent(d, string, i) { - var n = percentRe.exec(string.slice(i, i + 1)); - return n ? i + n[0].length : -1; -} - -function parseUnixTimestamp(d, string, i) { - var n = numberRe.exec(string.slice(i)); - return n ? (d.Q = +n[0], i + n[0].length) : -1; -} - -function parseUnixTimestampSeconds(d, string, i) { - var n = numberRe.exec(string.slice(i)); - return n ? (d.Q = (+n[0]) * 1000, i + n[0].length) : -1; -} - -function formatDayOfMonth(d, p) { - return pad(d.getDate(), p, 2); -} - -function formatHour24(d, p) { - return pad(d.getHours(), p, 2); -} - -function formatHour12(d, p) { - return pad(d.getHours() % 12 || 12, p, 2); -} - -function formatDayOfYear(d, p) { - return pad(1 + d3_time__WEBPACK_IMPORTED_MODULE_0__["timeDay"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeYear"])(d), d), p, 3); -} - -function formatMilliseconds(d, p) { - return pad(d.getMilliseconds(), p, 3); -} - -function formatMicroseconds(d, p) { - return formatMilliseconds(d, p) + "000"; -} - -function formatMonthNumber(d, p) { - return pad(d.getMonth() + 1, p, 2); -} - -function formatMinutes(d, p) { - return pad(d.getMinutes(), p, 2); -} - -function formatSeconds(d, p) { - return pad(d.getSeconds(), p, 2); -} - -function formatWeekdayNumberMonday(d) { - var day = d.getDay(); - return day === 0 ? 7 : day; -} - -function formatWeekNumberSunday(d, p) { - return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeSunday"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeYear"])(d), d), p, 2); -} - -function formatWeekNumberISO(d, p) { - var day = d.getDay(); - d = (day >= 4 || day === 0) ? Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeThursday"])(d) : d3_time__WEBPACK_IMPORTED_MODULE_0__["timeThursday"].ceil(d); - return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeThursday"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeYear"])(d), d) + (Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeYear"])(d).getDay() === 4), p, 2); -} - -function formatWeekdayNumberSunday(d) { - return d.getDay(); -} - -function formatWeekNumberMonday(d, p) { - return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeMonday"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["timeYear"])(d), d), p, 2); -} - -function formatYear(d, p) { - return pad(d.getFullYear() % 100, p, 2); -} - -function formatFullYear(d, p) { - return pad(d.getFullYear() % 10000, p, 4); -} - -function formatZone(d) { - var z = d.getTimezoneOffset(); - return (z > 0 ? "-" : (z *= -1, "+")) - + pad(z / 60 | 0, "0", 2) - + pad(z % 60, "0", 2); -} - -function formatUTCDayOfMonth(d, p) { - return pad(d.getUTCDate(), p, 2); -} - -function formatUTCHour24(d, p) { - return pad(d.getUTCHours(), p, 2); -} - -function formatUTCHour12(d, p) { - return pad(d.getUTCHours() % 12 || 12, p, 2); -} - -function formatUTCDayOfYear(d, p) { - return pad(1 + d3_time__WEBPACK_IMPORTED_MODULE_0__["utcDay"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcYear"])(d), d), p, 3); -} - -function formatUTCMilliseconds(d, p) { - return pad(d.getUTCMilliseconds(), p, 3); -} - -function formatUTCMicroseconds(d, p) { - return formatUTCMilliseconds(d, p) + "000"; -} - -function formatUTCMonthNumber(d, p) { - return pad(d.getUTCMonth() + 1, p, 2); -} - -function formatUTCMinutes(d, p) { - return pad(d.getUTCMinutes(), p, 2); -} - -function formatUTCSeconds(d, p) { - return pad(d.getUTCSeconds(), p, 2); -} - -function formatUTCWeekdayNumberMonday(d) { - var dow = d.getUTCDay(); - return dow === 0 ? 7 : dow; -} - -function formatUTCWeekNumberSunday(d, p) { - return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcSunday"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcYear"])(d), d), p, 2); -} - -function formatUTCWeekNumberISO(d, p) { - var day = d.getUTCDay(); - d = (day >= 4 || day === 0) ? Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcThursday"])(d) : d3_time__WEBPACK_IMPORTED_MODULE_0__["utcThursday"].ceil(d); - return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcThursday"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcYear"])(d), d) + (Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcYear"])(d).getUTCDay() === 4), p, 2); -} - -function formatUTCWeekdayNumberSunday(d) { - return d.getUTCDay(); -} - -function formatUTCWeekNumberMonday(d, p) { - return pad(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcMonday"].count(Object(d3_time__WEBPACK_IMPORTED_MODULE_0__["utcYear"])(d), d), p, 2); -} - -function formatUTCYear(d, p) { - return pad(d.getUTCFullYear() % 100, p, 2); -} - -function formatUTCFullYear(d, p) { - return pad(d.getUTCFullYear() % 10000, p, 4); -} - -function formatUTCZone() { - return "+0000"; -} - -function formatLiteralPercent() { - return "%"; -} - -function formatUnixTimestamp(d) { - return +d; -} - -function formatUnixTimestampSeconds(d) { - return Math.floor(+d / 1000); -} - - -/***/ }), - -/***/ "./node_modules/d3-time/src/day.js": -/*!*****************************************!*\ - !*** ./node_modules/d3-time/src/day.js ***! - \*****************************************/ -/*! exports provided: default, days */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "days", function() { return days; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var day = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setHours(0, 0, 0, 0); -}, function(date, step) { - date.setDate(date.getDate() + step); -}, function(start, end) { - return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationDay"]; -}, function(date) { - return date.getDate() - 1; -}); - -/* harmony default export */ __webpack_exports__["default"] = (day); -var days = day.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/duration.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-time/src/duration.js ***! - \**********************************************/ -/*! exports provided: durationSecond, durationMinute, durationHour, durationDay, durationWeek */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "durationSecond", function() { return durationSecond; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "durationMinute", function() { return durationMinute; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "durationHour", function() { return durationHour; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "durationDay", function() { return durationDay; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "durationWeek", function() { return durationWeek; }); -var durationSecond = 1e3; -var durationMinute = 6e4; -var durationHour = 36e5; -var durationDay = 864e5; -var durationWeek = 6048e5; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/hour.js": -/*!******************************************!*\ - !*** ./node_modules/d3-time/src/hour.js ***! - \******************************************/ -/*! exports provided: default, hours */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hours", function() { return hours; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var hour = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - var offset = date.getTimezoneOffset() * _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"] % _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]; - if (offset < 0) offset += _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]; - date.setTime(Math.floor((+date - offset) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]) * _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"] + offset); -}, function(date, step) { - date.setTime(+date + step * _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]); -}, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]; -}, function(date) { - return date.getHours(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (hour); -var hours = hour.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/index.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-time/src/index.js ***! - \*******************************************/ -/*! exports provided: timeInterval, timeMillisecond, timeMilliseconds, utcMillisecond, utcMilliseconds, timeSecond, timeSeconds, utcSecond, utcSeconds, timeMinute, timeMinutes, timeHour, timeHours, timeDay, timeDays, timeWeek, timeWeeks, timeSunday, timeSundays, timeMonday, timeMondays, timeTuesday, timeTuesdays, timeWednesday, timeWednesdays, timeThursday, timeThursdays, timeFriday, timeFridays, timeSaturday, timeSaturdays, timeMonth, timeMonths, timeYear, timeYears, utcMinute, utcMinutes, utcHour, utcHours, utcDay, utcDays, utcWeek, utcWeeks, utcSunday, utcSundays, utcMonday, utcMondays, utcTuesday, utcTuesdays, utcWednesday, utcWednesdays, utcThursday, utcThursdays, utcFriday, utcFridays, utcSaturday, utcSaturdays, utcMonth, utcMonths, utcYear, utcYears */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeInterval", function() { return _interval__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _millisecond__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./millisecond */ "./node_modules/d3-time/src/millisecond.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMillisecond", function() { return _millisecond__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMilliseconds", function() { return _millisecond__WEBPACK_IMPORTED_MODULE_1__["milliseconds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMillisecond", function() { return _millisecond__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMilliseconds", function() { return _millisecond__WEBPACK_IMPORTED_MODULE_1__["milliseconds"]; }); - -/* harmony import */ var _second__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./second */ "./node_modules/d3-time/src/second.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSecond", function() { return _second__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSeconds", function() { return _second__WEBPACK_IMPORTED_MODULE_2__["seconds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSecond", function() { return _second__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSeconds", function() { return _second__WEBPACK_IMPORTED_MODULE_2__["seconds"]; }); - -/* harmony import */ var _minute__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./minute */ "./node_modules/d3-time/src/minute.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMinute", function() { return _minute__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMinutes", function() { return _minute__WEBPACK_IMPORTED_MODULE_3__["minutes"]; }); - -/* harmony import */ var _hour__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./hour */ "./node_modules/d3-time/src/hour.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeHour", function() { return _hour__WEBPACK_IMPORTED_MODULE_4__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeHours", function() { return _hour__WEBPACK_IMPORTED_MODULE_4__["hours"]; }); - -/* harmony import */ var _day__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./day */ "./node_modules/d3-time/src/day.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeDay", function() { return _day__WEBPACK_IMPORTED_MODULE_5__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeDays", function() { return _day__WEBPACK_IMPORTED_MODULE_5__["days"]; }); - -/* harmony import */ var _week__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./week */ "./node_modules/d3-time/src/week.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWeek", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["sunday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWeeks", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["sundays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSunday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["sunday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSundays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["sundays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMonday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["monday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMondays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["mondays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeTuesday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["tuesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeTuesdays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["tuesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWednesday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["wednesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWednesdays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["wednesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeThursday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["thursday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeThursdays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["thursdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFriday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["friday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFridays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["fridays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSaturday", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["saturday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSaturdays", function() { return _week__WEBPACK_IMPORTED_MODULE_6__["saturdays"]; }); - -/* harmony import */ var _month__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./month */ "./node_modules/d3-time/src/month.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMonth", function() { return _month__WEBPACK_IMPORTED_MODULE_7__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMonths", function() { return _month__WEBPACK_IMPORTED_MODULE_7__["months"]; }); - -/* harmony import */ var _year__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./year */ "./node_modules/d3-time/src/year.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeYear", function() { return _year__WEBPACK_IMPORTED_MODULE_8__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeYears", function() { return _year__WEBPACK_IMPORTED_MODULE_8__["years"]; }); - -/* harmony import */ var _utcMinute__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./utcMinute */ "./node_modules/d3-time/src/utcMinute.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMinute", function() { return _utcMinute__WEBPACK_IMPORTED_MODULE_9__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMinutes", function() { return _utcMinute__WEBPACK_IMPORTED_MODULE_9__["utcMinutes"]; }); - -/* harmony import */ var _utcHour__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./utcHour */ "./node_modules/d3-time/src/utcHour.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcHour", function() { return _utcHour__WEBPACK_IMPORTED_MODULE_10__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcHours", function() { return _utcHour__WEBPACK_IMPORTED_MODULE_10__["utcHours"]; }); - -/* harmony import */ var _utcDay__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./utcDay */ "./node_modules/d3-time/src/utcDay.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcDay", function() { return _utcDay__WEBPACK_IMPORTED_MODULE_11__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcDays", function() { return _utcDay__WEBPACK_IMPORTED_MODULE_11__["utcDays"]; }); - -/* harmony import */ var _utcWeek__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./utcWeek */ "./node_modules/d3-time/src/utcWeek.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWeek", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcSunday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWeeks", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcSundays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSunday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcSunday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSundays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcSundays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMonday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcMonday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMondays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcMondays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcTuesday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcTuesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcTuesdays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcTuesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWednesday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcWednesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWednesdays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcWednesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcThursday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcThursday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcThursdays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcThursdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcFriday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcFriday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcFridays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcFridays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSaturday", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcSaturday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSaturdays", function() { return _utcWeek__WEBPACK_IMPORTED_MODULE_12__["utcSaturdays"]; }); - -/* harmony import */ var _utcMonth__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./utcMonth */ "./node_modules/d3-time/src/utcMonth.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMonth", function() { return _utcMonth__WEBPACK_IMPORTED_MODULE_13__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMonths", function() { return _utcMonth__WEBPACK_IMPORTED_MODULE_13__["utcMonths"]; }); - -/* harmony import */ var _utcYear__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./utcYear */ "./node_modules/d3-time/src/utcYear.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcYear", function() { return _utcYear__WEBPACK_IMPORTED_MODULE_14__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcYears", function() { return _utcYear__WEBPACK_IMPORTED_MODULE_14__["utcYears"]; }); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-time/src/interval.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-time/src/interval.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return newInterval; }); -var t0 = new Date, - t1 = new Date; - -function newInterval(floori, offseti, count, field) { - - function interval(date) { - return floori(date = new Date(+date)), date; - } - - interval.floor = interval; - - interval.ceil = function(date) { - return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date; - }; - - interval.round = function(date) { - var d0 = interval(date), - d1 = interval.ceil(date); - return date - d0 < d1 - date ? d0 : d1; - }; - - interval.offset = function(date, step) { - return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date; - }; - - interval.range = function(start, stop, step) { - var range = [], previous; - start = interval.ceil(start); - step = step == null ? 1 : Math.floor(step); - if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date - do range.push(previous = new Date(+start)), offseti(start, step), floori(start); - while (previous < start && start < stop); - return range; - }; - - interval.filter = function(test) { - return newInterval(function(date) { - if (date >= date) while (floori(date), !test(date)) date.setTime(date - 1); - }, function(date, step) { - if (date >= date) { - if (step < 0) while (++step <= 0) { - while (offseti(date, -1), !test(date)) {} // eslint-disable-line no-empty - } else while (--step >= 0) { - while (offseti(date, +1), !test(date)) {} // eslint-disable-line no-empty - } - } - }); - }; - - if (count) { - interval.count = function(start, end) { - t0.setTime(+start), t1.setTime(+end); - floori(t0), floori(t1); - return Math.floor(count(t0, t1)); - }; - - interval.every = function(step) { - step = Math.floor(step); - return !isFinite(step) || !(step > 0) ? null - : !(step > 1) ? interval - : interval.filter(field - ? function(d) { return field(d) % step === 0; } - : function(d) { return interval.count(0, d) % step === 0; }); - }; - } - - return interval; -} - - -/***/ }), - -/***/ "./node_modules/d3-time/src/millisecond.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-time/src/millisecond.js ***! - \*************************************************/ -/*! exports provided: default, milliseconds */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "milliseconds", function() { return milliseconds; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); - - -var millisecond = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function() { - // noop -}, function(date, step) { - date.setTime(+date + step); -}, function(start, end) { - return end - start; -}); - -// An optimized implementation for this simple case. -millisecond.every = function(k) { - k = Math.floor(k); - if (!isFinite(k) || !(k > 0)) return null; - if (!(k > 1)) return millisecond; - return Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setTime(Math.floor(date / k) * k); - }, function(date, step) { - date.setTime(+date + step * k); - }, function(start, end) { - return (end - start) / k; - }); -}; - -/* harmony default export */ __webpack_exports__["default"] = (millisecond); -var milliseconds = millisecond.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/minute.js": -/*!********************************************!*\ - !*** ./node_modules/d3-time/src/minute.js ***! - \********************************************/ -/*! exports provided: default, minutes */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "minutes", function() { return minutes; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var minute = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setTime(Math.floor(date / _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]) * _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]); -}, function(date, step) { - date.setTime(+date + step * _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]); -}, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]; -}, function(date) { - return date.getMinutes(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (minute); -var minutes = minute.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/month.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-time/src/month.js ***! - \*******************************************/ -/*! exports provided: default, months */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "months", function() { return months; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); - - -var month = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setDate(1); - date.setHours(0, 0, 0, 0); -}, function(date, step) { - date.setMonth(date.getMonth() + step); -}, function(start, end) { - return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12; -}, function(date) { - return date.getMonth(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (month); -var months = month.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/second.js": -/*!********************************************!*\ - !*** ./node_modules/d3-time/src/second.js ***! - \********************************************/ -/*! exports provided: default, seconds */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "seconds", function() { return seconds; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var second = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setTime(Math.floor(date / _duration__WEBPACK_IMPORTED_MODULE_1__["durationSecond"]) * _duration__WEBPACK_IMPORTED_MODULE_1__["durationSecond"]); -}, function(date, step) { - date.setTime(+date + step * _duration__WEBPACK_IMPORTED_MODULE_1__["durationSecond"]); -}, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationSecond"]; -}, function(date) { - return date.getUTCSeconds(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (second); -var seconds = second.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/utcDay.js": -/*!********************************************!*\ - !*** ./node_modules/d3-time/src/utcDay.js ***! - \********************************************/ -/*! exports provided: default, utcDays */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcDays", function() { return utcDays; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var utcDay = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCHours(0, 0, 0, 0); -}, function(date, step) { - date.setUTCDate(date.getUTCDate() + step); -}, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationDay"]; -}, function(date) { - return date.getUTCDate() - 1; -}); - -/* harmony default export */ __webpack_exports__["default"] = (utcDay); -var utcDays = utcDay.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/utcHour.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-time/src/utcHour.js ***! - \*********************************************/ -/*! exports provided: default, utcHours */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcHours", function() { return utcHours; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var utcHour = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCMinutes(0, 0, 0); -}, function(date, step) { - date.setTime(+date + step * _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]); -}, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationHour"]; -}, function(date) { - return date.getUTCHours(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (utcHour); -var utcHours = utcHour.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/utcMinute.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-time/src/utcMinute.js ***! - \***********************************************/ -/*! exports provided: default, utcMinutes */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcMinutes", function() { return utcMinutes; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -var utcMinute = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCSeconds(0, 0); -}, function(date, step) { - date.setTime(+date + step * _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]); -}, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]; -}, function(date) { - return date.getUTCMinutes(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (utcMinute); -var utcMinutes = utcMinute.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/utcMonth.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-time/src/utcMonth.js ***! - \**********************************************/ -/*! exports provided: default, utcMonths */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcMonths", function() { return utcMonths; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); - - -var utcMonth = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCDate(1); - date.setUTCHours(0, 0, 0, 0); -}, function(date, step) { - date.setUTCMonth(date.getUTCMonth() + step); -}, function(start, end) { - return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12; -}, function(date) { - return date.getUTCMonth(); -}); - -/* harmony default export */ __webpack_exports__["default"] = (utcMonth); -var utcMonths = utcMonth.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/utcWeek.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-time/src/utcWeek.js ***! - \*********************************************/ -/*! exports provided: utcSunday, utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSundays, utcMondays, utcTuesdays, utcWednesdays, utcThursdays, utcFridays, utcSaturdays */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcSunday", function() { return utcSunday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcMonday", function() { return utcMonday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcTuesday", function() { return utcTuesday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcWednesday", function() { return utcWednesday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcThursday", function() { return utcThursday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcFriday", function() { return utcFriday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcSaturday", function() { return utcSaturday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcSundays", function() { return utcSundays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcMondays", function() { return utcMondays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcTuesdays", function() { return utcTuesdays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcWednesdays", function() { return utcWednesdays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcThursdays", function() { return utcThursdays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcFridays", function() { return utcFridays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcSaturdays", function() { return utcSaturdays; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -function utcWeekday(i) { - return Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7); - date.setUTCHours(0, 0, 0, 0); - }, function(date, step) { - date.setUTCDate(date.getUTCDate() + step * 7); - }, function(start, end) { - return (end - start) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationWeek"]; - }); -} - -var utcSunday = utcWeekday(0); -var utcMonday = utcWeekday(1); -var utcTuesday = utcWeekday(2); -var utcWednesday = utcWeekday(3); -var utcThursday = utcWeekday(4); -var utcFriday = utcWeekday(5); -var utcSaturday = utcWeekday(6); - -var utcSundays = utcSunday.range; -var utcMondays = utcMonday.range; -var utcTuesdays = utcTuesday.range; -var utcWednesdays = utcWednesday.range; -var utcThursdays = utcThursday.range; -var utcFridays = utcFriday.range; -var utcSaturdays = utcSaturday.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/utcYear.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-time/src/utcYear.js ***! - \*********************************************/ -/*! exports provided: default, utcYears */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utcYears", function() { return utcYears; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); - - -var utcYear = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCMonth(0, 1); - date.setUTCHours(0, 0, 0, 0); -}, function(date, step) { - date.setUTCFullYear(date.getUTCFullYear() + step); -}, function(start, end) { - return end.getUTCFullYear() - start.getUTCFullYear(); -}, function(date) { - return date.getUTCFullYear(); -}); - -// An optimized implementation for this simple case. -utcYear.every = function(k) { - return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setUTCFullYear(Math.floor(date.getUTCFullYear() / k) * k); - date.setUTCMonth(0, 1); - date.setUTCHours(0, 0, 0, 0); - }, function(date, step) { - date.setUTCFullYear(date.getUTCFullYear() + step * k); - }); -}; - -/* harmony default export */ __webpack_exports__["default"] = (utcYear); -var utcYears = utcYear.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/week.js": -/*!******************************************!*\ - !*** ./node_modules/d3-time/src/week.js ***! - \******************************************/ -/*! exports provided: sunday, monday, tuesday, wednesday, thursday, friday, saturday, sundays, mondays, tuesdays, wednesdays, thursdays, fridays, saturdays */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sunday", function() { return sunday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "monday", function() { return monday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tuesday", function() { return tuesday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "wednesday", function() { return wednesday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "thursday", function() { return thursday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "friday", function() { return friday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "saturday", function() { return saturday; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sundays", function() { return sundays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mondays", function() { return mondays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tuesdays", function() { return tuesdays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "wednesdays", function() { return wednesdays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "thursdays", function() { return thursdays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fridays", function() { return fridays; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "saturdays", function() { return saturdays; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-time/src/duration.js"); - - - -function weekday(i) { - return Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7); - date.setHours(0, 0, 0, 0); - }, function(date, step) { - date.setDate(date.getDate() + step * 7); - }, function(start, end) { - return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * _duration__WEBPACK_IMPORTED_MODULE_1__["durationMinute"]) / _duration__WEBPACK_IMPORTED_MODULE_1__["durationWeek"]; - }); -} - -var sunday = weekday(0); -var monday = weekday(1); -var tuesday = weekday(2); -var wednesday = weekday(3); -var thursday = weekday(4); -var friday = weekday(5); -var saturday = weekday(6); - -var sundays = sunday.range; -var mondays = monday.range; -var tuesdays = tuesday.range; -var wednesdays = wednesday.range; -var thursdays = thursday.range; -var fridays = friday.range; -var saturdays = saturday.range; - - -/***/ }), - -/***/ "./node_modules/d3-time/src/year.js": -/*!******************************************!*\ - !*** ./node_modules/d3-time/src/year.js ***! - \******************************************/ -/*! exports provided: default, years */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "years", function() { return years; }); -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-time/src/interval.js"); - - -var year = Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setMonth(0, 1); - date.setHours(0, 0, 0, 0); -}, function(date, step) { - date.setFullYear(date.getFullYear() + step); -}, function(start, end) { - return end.getFullYear() - start.getFullYear(); -}, function(date) { - return date.getFullYear(); -}); - -// An optimized implementation for this simple case. -year.every = function(k) { - return !isFinite(k = Math.floor(k)) || !(k > 0) ? null : Object(_interval__WEBPACK_IMPORTED_MODULE_0__["default"])(function(date) { - date.setFullYear(Math.floor(date.getFullYear() / k) * k); - date.setMonth(0, 1); - date.setHours(0, 0, 0, 0); - }, function(date, step) { - date.setFullYear(date.getFullYear() + step * k); - }); -}; - -/* harmony default export */ __webpack_exports__["default"] = (year); -var years = year.range; - - -/***/ }), - -/***/ "./node_modules/d3-timer/src/index.js": -/*!********************************************!*\ - !*** ./node_modules/d3-timer/src/index.js ***! - \********************************************/ -/*! exports provided: now, timer, timerFlush, timeout, interval */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _timer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./timer */ "./node_modules/d3-timer/src/timer.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "now", function() { return _timer__WEBPACK_IMPORTED_MODULE_0__["now"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timer", function() { return _timer__WEBPACK_IMPORTED_MODULE_0__["timer"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timerFlush", function() { return _timer__WEBPACK_IMPORTED_MODULE_0__["timerFlush"]; }); - -/* harmony import */ var _timeout__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./timeout */ "./node_modules/d3-timer/src/timeout.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeout", function() { return _timeout__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _interval__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./interval */ "./node_modules/d3-timer/src/interval.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interval", function() { return _interval__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-timer/src/interval.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-timer/src/interval.js ***! - \***********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _timer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./timer */ "./node_modules/d3-timer/src/timer.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(callback, delay, time) { - var t = new _timer__WEBPACK_IMPORTED_MODULE_0__["Timer"], total = delay; - if (delay == null) return t.restart(callback, delay, time), t; - delay = +delay, time = time == null ? Object(_timer__WEBPACK_IMPORTED_MODULE_0__["now"])() : +time; - t.restart(function tick(elapsed) { - elapsed += total; - t.restart(tick, total += delay, time); - callback(elapsed); - }, delay, time); - return t; -}); - - -/***/ }), - -/***/ "./node_modules/d3-timer/src/timeout.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-timer/src/timeout.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _timer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./timer */ "./node_modules/d3-timer/src/timer.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(callback, delay, time) { - var t = new _timer__WEBPACK_IMPORTED_MODULE_0__["Timer"]; - delay = delay == null ? 0 : +delay; - t.restart(function(elapsed) { - t.stop(); - callback(elapsed + delay); - }, delay, time); - return t; -}); - - -/***/ }), - -/***/ "./node_modules/d3-timer/src/timer.js": -/*!********************************************!*\ - !*** ./node_modules/d3-timer/src/timer.js ***! - \********************************************/ -/*! exports provided: now, Timer, timer, timerFlush */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "now", function() { return now; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Timer", function() { return Timer; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "timer", function() { return timer; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "timerFlush", function() { return timerFlush; }); -var frame = 0, // is an animation frame pending? - timeout = 0, // is a timeout pending? - interval = 0, // are any timers active? - pokeDelay = 1000, // how frequently we check for clock skew - taskHead, - taskTail, - clockLast = 0, - clockNow = 0, - clockSkew = 0, - clock = typeof performance === "object" && performance.now ? performance : Date, - setFrame = typeof window === "object" && window.requestAnimationFrame ? window.requestAnimationFrame.bind(window) : function(f) { setTimeout(f, 17); }; - -function now() { - return clockNow || (setFrame(clearNow), clockNow = clock.now() + clockSkew); -} - -function clearNow() { - clockNow = 0; -} - -function Timer() { - this._call = - this._time = - this._next = null; -} - -Timer.prototype = timer.prototype = { - constructor: Timer, - restart: function(callback, delay, time) { - if (typeof callback !== "function") throw new TypeError("callback is not a function"); - time = (time == null ? now() : +time) + (delay == null ? 0 : +delay); - if (!this._next && taskTail !== this) { - if (taskTail) taskTail._next = this; - else taskHead = this; - taskTail = this; - } - this._call = callback; - this._time = time; - sleep(); - }, - stop: function() { - if (this._call) { - this._call = null; - this._time = Infinity; - sleep(); - } - } -}; - -function timer(callback, delay, time) { - var t = new Timer; - t.restart(callback, delay, time); - return t; -} - -function timerFlush() { - now(); // Get the current time, if not already set. - ++frame; // Pretend we’ve set an alarm, if we haven’t already. - var t = taskHead, e; - while (t) { - if ((e = clockNow - t._time) >= 0) t._call.call(null, e); - t = t._next; - } - --frame; -} - -function wake() { - clockNow = (clockLast = clock.now()) + clockSkew; - frame = timeout = 0; - try { - timerFlush(); - } finally { - frame = 0; - nap(); - clockNow = 0; - } -} - -function poke() { - var now = clock.now(), delay = now - clockLast; - if (delay > pokeDelay) clockSkew -= delay, clockLast = now; -} - -function nap() { - var t0, t1 = taskHead, t2, time = Infinity; - while (t1) { - if (t1._call) { - if (time > t1._time) time = t1._time; - t0 = t1, t1 = t1._next; - } else { - t2 = t1._next, t1._next = null; - t1 = t0 ? t0._next = t2 : taskHead = t2; - } - } - taskTail = t0; - sleep(time); -} - -function sleep(time) { - if (frame) return; // Soonest alarm already set, or will be. - if (timeout) timeout = clearTimeout(timeout); - var delay = time - clockNow; // Strictly less than if we recomputed clockNow. - if (delay > 24) { - if (time < Infinity) timeout = setTimeout(wake, time - clock.now() - clockSkew); - if (interval) interval = clearInterval(interval); - } else { - if (!interval) clockLast = clock.now(), interval = setInterval(poke, pokeDelay); - frame = 1, setFrame(wake); - } -} - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/active.js": -/*!**************************************************!*\ - !*** ./node_modules/d3-transition/src/active.js ***! - \**************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./transition/index */ "./node_modules/d3-transition/src/transition/index.js"); -/* harmony import */ var _transition_schedule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./transition/schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - - -var root = [null]; - -/* harmony default export */ __webpack_exports__["default"] = (function(node, name) { - var schedules = node.__transition, - schedule, - i; - - if (schedules) { - name = name == null ? null : name + ""; - for (i in schedules) { - if ((schedule = schedules[i]).state > _transition_schedule__WEBPACK_IMPORTED_MODULE_1__["SCHEDULED"] && schedule.name === name) { - return new _transition_index__WEBPACK_IMPORTED_MODULE_0__["Transition"]([[node]], root, name, +i); - } - } - } - - return null; -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/index.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-transition/src/index.js ***! - \*************************************************/ -/*! exports provided: transition, active, interrupt */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _selection_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./selection/index */ "./node_modules/d3-transition/src/selection/index.js"); -/* harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./transition/index */ "./node_modules/d3-transition/src/transition/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "transition", function() { return _transition_index__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony import */ var _active__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./active */ "./node_modules/d3-transition/src/active.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "active", function() { return _active__WEBPACK_IMPORTED_MODULE_2__["default"]; }); - -/* harmony import */ var _interrupt__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./interrupt */ "./node_modules/d3-transition/src/interrupt.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interrupt", function() { return _interrupt__WEBPACK_IMPORTED_MODULE_3__["default"]; }); - - - - - - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/interrupt.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-transition/src/interrupt.js ***! - \*****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _transition_schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./transition/schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(node, name) { - var schedules = node.__transition, - schedule, - active, - empty = true, - i; - - if (!schedules) return; - - name = name == null ? null : name + ""; - - for (i in schedules) { - if ((schedule = schedules[i]).name !== name) { empty = false; continue; } - active = schedule.state > _transition_schedule__WEBPACK_IMPORTED_MODULE_0__["STARTING"] && schedule.state < _transition_schedule__WEBPACK_IMPORTED_MODULE_0__["ENDING"]; - schedule.state = _transition_schedule__WEBPACK_IMPORTED_MODULE_0__["ENDED"]; - schedule.timer.stop(); - if (active) schedule.on.call("interrupt", node, node.__data__, schedule.index, schedule.group); - delete schedules[i]; - } - - if (empty) delete node.__transition; -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/selection/index.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-transition/src/selection/index.js ***! - \***********************************************************/ -/*! no exports provided */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _interrupt__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./interrupt */ "./node_modules/d3-transition/src/selection/interrupt.js"); -/* harmony import */ var _transition__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./transition */ "./node_modules/d3-transition/src/selection/transition.js"); - - - - -d3_selection__WEBPACK_IMPORTED_MODULE_0__["selection"].prototype.interrupt = _interrupt__WEBPACK_IMPORTED_MODULE_1__["default"]; -d3_selection__WEBPACK_IMPORTED_MODULE_0__["selection"].prototype.transition = _transition__WEBPACK_IMPORTED_MODULE_2__["default"]; - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/selection/interrupt.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-transition/src/selection/interrupt.js ***! - \***************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _interrupt__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../interrupt */ "./node_modules/d3-transition/src/interrupt.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(name) { - return this.each(function() { - Object(_interrupt__WEBPACK_IMPORTED_MODULE_0__["default"])(this, name); - }); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/selection/transition.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-transition/src/selection/transition.js ***! - \****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _transition_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../transition/index */ "./node_modules/d3-transition/src/transition/index.js"); -/* harmony import */ var _transition_schedule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../transition/schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); -/* harmony import */ var d3_ease__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-ease */ "./node_modules/d3-ease/src/index.js"); -/* harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! d3-timer */ "./node_modules/d3-timer/src/index.js"); - - - - - -var defaultTiming = { - time: null, // Set on use. - delay: 0, - duration: 250, - ease: d3_ease__WEBPACK_IMPORTED_MODULE_2__["easeCubicInOut"] -}; - -function inherit(node, id) { - var timing; - while (!(timing = node.__transition) || !(timing = timing[id])) { - if (!(node = node.parentNode)) { - return defaultTiming.time = Object(d3_timer__WEBPACK_IMPORTED_MODULE_3__["now"])(), defaultTiming; - } - } - return timing; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name) { - var id, - timing; - - if (name instanceof _transition_index__WEBPACK_IMPORTED_MODULE_0__["Transition"]) { - id = name._id, name = name._name; - } else { - id = Object(_transition_index__WEBPACK_IMPORTED_MODULE_0__["newId"])(), (timing = defaultTiming).time = Object(d3_timer__WEBPACK_IMPORTED_MODULE_3__["now"])(), name = name == null ? null : name + ""; - } - - for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { - if (node = group[i]) { - Object(_transition_schedule__WEBPACK_IMPORTED_MODULE_1__["default"])(node, name, id, i, group, timing || inherit(node, id)); - } - } - } - - return new _transition_index__WEBPACK_IMPORTED_MODULE_0__["Transition"](groups, this._parents, name, id); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/attr.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/attr.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./tween */ "./node_modules/d3-transition/src/transition/tween.js"); -/* harmony import */ var _interpolate__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./interpolate */ "./node_modules/d3-transition/src/transition/interpolate.js"); - - - - - -function attrRemove(name) { - return function() { - this.removeAttribute(name); - }; -} - -function attrRemoveNS(fullname) { - return function() { - this.removeAttributeNS(fullname.space, fullname.local); - }; -} - -function attrConstant(name, interpolate, value1) { - var value00, - interpolate0; - return function() { - var value0 = this.getAttribute(name); - return value0 === value1 ? null - : value0 === value00 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value1); - }; -} - -function attrConstantNS(fullname, interpolate, value1) { - var value00, - interpolate0; - return function() { - var value0 = this.getAttributeNS(fullname.space, fullname.local); - return value0 === value1 ? null - : value0 === value00 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value1); - }; -} - -function attrFunction(name, interpolate, value) { - var value00, - value10, - interpolate0; - return function() { - var value0, value1 = value(this); - if (value1 == null) return void this.removeAttribute(name); - value0 = this.getAttribute(name); - return value0 === value1 ? null - : value0 === value00 && value1 === value10 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value10 = value1); - }; -} - -function attrFunctionNS(fullname, interpolate, value) { - var value00, - value10, - interpolate0; - return function() { - var value0, value1 = value(this); - if (value1 == null) return void this.removeAttributeNS(fullname.space, fullname.local); - value0 = this.getAttributeNS(fullname.space, fullname.local); - return value0 === value1 ? null - : value0 === value00 && value1 === value10 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value10 = value1); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value) { - var fullname = Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["namespace"])(name), i = fullname === "transform" ? d3_interpolate__WEBPACK_IMPORTED_MODULE_0__["interpolateTransformSvg"] : _interpolate__WEBPACK_IMPORTED_MODULE_3__["default"]; - return this.attrTween(name, typeof value === "function" - ? (fullname.local ? attrFunctionNS : attrFunction)(fullname, i, Object(_tween__WEBPACK_IMPORTED_MODULE_2__["tweenValue"])(this, "attr." + name, value)) - : value == null ? (fullname.local ? attrRemoveNS : attrRemove)(fullname) - : (fullname.local ? attrConstantNS : attrConstant)(fullname, i, value + "")); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/attrTween.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/attrTween.js ***! - \****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); - - -function attrTweenNS(fullname, value) { - function tween() { - var node = this, i = value.apply(node, arguments); - return i && function(t) { - node.setAttributeNS(fullname.space, fullname.local, i(t)); - }; - } - tween._value = value; - return tween; -} - -function attrTween(name, value) { - function tween() { - var node = this, i = value.apply(node, arguments); - return i && function(t) { - node.setAttribute(name, i(t)); - }; - } - tween._value = value; - return tween; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value) { - var key = "attr." + name; - if (arguments.length < 2) return (key = this.tween(key)) && key._value; - if (value == null) return this.tween(key, null); - if (typeof value !== "function") throw new Error; - var fullname = Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["namespace"])(name); - return this.tween(key, (fullname.local ? attrTweenNS : attrTween)(fullname, value)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/delay.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/delay.js ***! - \************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - -function delayFunction(id, value) { - return function() { - Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["init"])(this, id).delay = +value.apply(this, arguments); - }; -} - -function delayConstant(id, value) { - return value = +value, function() { - Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["init"])(this, id).delay = value; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - var id = this._id; - - return arguments.length - ? this.each((typeof value === "function" - ? delayFunction - : delayConstant)(id, value)) - : Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["get"])(this.node(), id).delay; -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/duration.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/duration.js ***! - \***************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - -function durationFunction(id, value) { - return function() { - Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["set"])(this, id).duration = +value.apply(this, arguments); - }; -} - -function durationConstant(id, value) { - return value = +value, function() { - Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["set"])(this, id).duration = value; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - var id = this._id; - - return arguments.length - ? this.each((typeof value === "function" - ? durationFunction - : durationConstant)(id, value)) - : Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["get"])(this.node(), id).duration; -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/ease.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/ease.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - -function easeConstant(id, value) { - if (typeof value !== "function") throw new Error; - return function() { - Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["set"])(this, id).ease = value; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - var id = this._id; - - return arguments.length - ? this.each(easeConstant(id, value)) - : Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["get"])(this.node(), id).ease; -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/filter.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/filter.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index */ "./node_modules/d3-transition/src/transition/index.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(match) { - if (typeof match !== "function") match = Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["matcher"])(match); - - for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) { - if ((node = group[i]) && match.call(node, node.__data__, i, group)) { - subgroup.push(node); - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_1__["Transition"](subgroups, this._parents, this._name, this._id); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/index.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/index.js ***! - \************************************************************/ -/*! exports provided: Transition, default, newId */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Transition", function() { return Transition; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return transition; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "newId", function() { return newId; }); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _attr__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./attr */ "./node_modules/d3-transition/src/transition/attr.js"); -/* harmony import */ var _attrTween__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./attrTween */ "./node_modules/d3-transition/src/transition/attrTween.js"); -/* harmony import */ var _delay__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./delay */ "./node_modules/d3-transition/src/transition/delay.js"); -/* harmony import */ var _duration__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./duration */ "./node_modules/d3-transition/src/transition/duration.js"); -/* harmony import */ var _ease__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ease */ "./node_modules/d3-transition/src/transition/ease.js"); -/* harmony import */ var _filter__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./filter */ "./node_modules/d3-transition/src/transition/filter.js"); -/* harmony import */ var _merge__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./merge */ "./node_modules/d3-transition/src/transition/merge.js"); -/* harmony import */ var _on__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./on */ "./node_modules/d3-transition/src/transition/on.js"); -/* harmony import */ var _remove__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./remove */ "./node_modules/d3-transition/src/transition/remove.js"); -/* harmony import */ var _select__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./select */ "./node_modules/d3-transition/src/transition/select.js"); -/* harmony import */ var _selectAll__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./selectAll */ "./node_modules/d3-transition/src/transition/selectAll.js"); -/* harmony import */ var _selection__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./selection */ "./node_modules/d3-transition/src/transition/selection.js"); -/* harmony import */ var _style__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./style */ "./node_modules/d3-transition/src/transition/style.js"); -/* harmony import */ var _styleTween__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./styleTween */ "./node_modules/d3-transition/src/transition/styleTween.js"); -/* harmony import */ var _text__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./text */ "./node_modules/d3-transition/src/transition/text.js"); -/* harmony import */ var _transition__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./transition */ "./node_modules/d3-transition/src/transition/transition.js"); -/* harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./tween */ "./node_modules/d3-transition/src/transition/tween.js"); - - - - - - - - - - - - - - - - - - - -var id = 0; - -function Transition(groups, parents, name, id) { - this._groups = groups; - this._parents = parents; - this._name = name; - this._id = id; -} - -function transition(name) { - return Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["selection"])().transition(name); -} - -function newId() { - return ++id; -} - -var selection_prototype = d3_selection__WEBPACK_IMPORTED_MODULE_0__["selection"].prototype; - -Transition.prototype = transition.prototype = { - constructor: Transition, - select: _select__WEBPACK_IMPORTED_MODULE_10__["default"], - selectAll: _selectAll__WEBPACK_IMPORTED_MODULE_11__["default"], - filter: _filter__WEBPACK_IMPORTED_MODULE_6__["default"], - merge: _merge__WEBPACK_IMPORTED_MODULE_7__["default"], - selection: _selection__WEBPACK_IMPORTED_MODULE_12__["default"], - transition: _transition__WEBPACK_IMPORTED_MODULE_16__["default"], - call: selection_prototype.call, - nodes: selection_prototype.nodes, - node: selection_prototype.node, - size: selection_prototype.size, - empty: selection_prototype.empty, - each: selection_prototype.each, - on: _on__WEBPACK_IMPORTED_MODULE_8__["default"], - attr: _attr__WEBPACK_IMPORTED_MODULE_1__["default"], - attrTween: _attrTween__WEBPACK_IMPORTED_MODULE_2__["default"], - style: _style__WEBPACK_IMPORTED_MODULE_13__["default"], - styleTween: _styleTween__WEBPACK_IMPORTED_MODULE_14__["default"], - text: _text__WEBPACK_IMPORTED_MODULE_15__["default"], - remove: _remove__WEBPACK_IMPORTED_MODULE_9__["default"], - tween: _tween__WEBPACK_IMPORTED_MODULE_17__["default"], - delay: _delay__WEBPACK_IMPORTED_MODULE_3__["default"], - duration: _duration__WEBPACK_IMPORTED_MODULE_4__["default"], - ease: _ease__WEBPACK_IMPORTED_MODULE_5__["default"] -}; - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/interpolate.js": -/*!******************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/interpolate.js ***! - \******************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function(a, b) { - var c; - return (typeof b === "number" ? d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateNumber"] - : b instanceof d3_color__WEBPACK_IMPORTED_MODULE_0__["color"] ? d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateRgb"] - : (c = Object(d3_color__WEBPACK_IMPORTED_MODULE_0__["color"])(b)) ? (b = c, d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateRgb"]) - : d3_interpolate__WEBPACK_IMPORTED_MODULE_1__["interpolateString"])(a, b); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/merge.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/merge.js ***! - \************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-transition/src/transition/index.js"); - - -/* harmony default export */ __webpack_exports__["default"] = (function(transition) { - if (transition._id !== this._id) throw new Error; - - for (var groups0 = this._groups, groups1 = transition._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = new Array(m0), j = 0; j < m; ++j) { - for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = new Array(n), node, i = 0; i < n; ++i) { - if (node = group0[i] || group1[i]) { - merge[i] = node; - } - } - } - - for (; j < m0; ++j) { - merges[j] = groups0[j]; - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Transition"](merges, this._parents, this._name, this._id); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/on.js": -/*!*********************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/on.js ***! - \*********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - -function start(name) { - return (name + "").trim().split(/^|\s+/).every(function(t) { - var i = t.indexOf("."); - if (i >= 0) t = t.slice(0, i); - return !t || t === "start"; - }); -} - -function onFunction(id, name, listener) { - var on0, on1, sit = start(name) ? _schedule__WEBPACK_IMPORTED_MODULE_0__["init"] : _schedule__WEBPACK_IMPORTED_MODULE_0__["set"]; - return function() { - var schedule = sit(this, id), - on = schedule.on; - - // If this node shared a dispatch with the previous node, - // just assign the updated shared dispatch and we’re done! - // Otherwise, copy-on-write. - if (on !== on0) (on1 = (on0 = on).copy()).on(name, listener); - - schedule.on = on1; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, listener) { - var id = this._id; - - return arguments.length < 2 - ? Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["get"])(this.node(), id).on.on(name) - : this.each(onFunction(id, name, listener)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/remove.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/remove.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function removeFunction(id) { - return function() { - var parent = this.parentNode; - for (var i in this.__transition) if (+i !== id) return; - if (parent) parent.removeChild(this); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return this.on("end.remove", removeFunction(this._id)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/schedule.js": -/*!***************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/schedule.js ***! - \***************************************************************/ -/*! exports provided: CREATED, SCHEDULED, STARTING, STARTED, RUNNING, ENDING, ENDED, default, init, set, get */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CREATED", function() { return CREATED; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SCHEDULED", function() { return SCHEDULED; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "STARTING", function() { return STARTING; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "STARTED", function() { return STARTED; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RUNNING", function() { return RUNNING; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ENDING", function() { return ENDING; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ENDED", function() { return ENDED; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "init", function() { return init; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "get", function() { return get; }); -/* harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js"); -/* harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-timer */ "./node_modules/d3-timer/src/index.js"); - - - -var emptyOn = Object(d3_dispatch__WEBPACK_IMPORTED_MODULE_0__["dispatch"])("start", "end", "interrupt"); -var emptyTween = []; - -var CREATED = 0; -var SCHEDULED = 1; -var STARTING = 2; -var STARTED = 3; -var RUNNING = 4; -var ENDING = 5; -var ENDED = 6; - -/* harmony default export */ __webpack_exports__["default"] = (function(node, name, id, index, group, timing) { - var schedules = node.__transition; - if (!schedules) node.__transition = {}; - else if (id in schedules) return; - create(node, id, { - name: name, - index: index, // For context during callback. - group: group, // For context during callback. - on: emptyOn, - tween: emptyTween, - time: timing.time, - delay: timing.delay, - duration: timing.duration, - ease: timing.ease, - timer: null, - state: CREATED - }); -}); - -function init(node, id) { - var schedule = get(node, id); - if (schedule.state > CREATED) throw new Error("too late; already scheduled"); - return schedule; -} - -function set(node, id) { - var schedule = get(node, id); - if (schedule.state > STARTING) throw new Error("too late; already started"); - return schedule; -} - -function get(node, id) { - var schedule = node.__transition; - if (!schedule || !(schedule = schedule[id])) throw new Error("transition not found"); - return schedule; -} - -function create(node, id, self) { - var schedules = node.__transition, - tween; - - // Initialize the self timer when the transition is created. - // Note the actual delay is not known until the first callback! - schedules[id] = self; - self.timer = Object(d3_timer__WEBPACK_IMPORTED_MODULE_1__["timer"])(schedule, 0, self.time); - - function schedule(elapsed) { - self.state = SCHEDULED; - self.timer.restart(start, self.delay, self.time); - - // If the elapsed delay is less than our first sleep, start immediately. - if (self.delay <= elapsed) start(elapsed - self.delay); - } - - function start(elapsed) { - var i, j, n, o; - - // If the state is not SCHEDULED, then we previously errored on start. - if (self.state !== SCHEDULED) return stop(); - - for (i in schedules) { - o = schedules[i]; - if (o.name !== self.name) continue; - - // While this element already has a starting transition during this frame, - // defer starting an interrupting transition until that transition has a - // chance to tick (and possibly end); see d3/d3-transition#54! - if (o.state === STARTED) return Object(d3_timer__WEBPACK_IMPORTED_MODULE_1__["timeout"])(start); - - // Interrupt the active transition, if any. - // Dispatch the interrupt event. - if (o.state === RUNNING) { - o.state = ENDED; - o.timer.stop(); - o.on.call("interrupt", node, node.__data__, o.index, o.group); - delete schedules[i]; - } - - // Cancel any pre-empted transitions. No interrupt event is dispatched - // because the cancelled transitions never started. Note that this also - // removes this transition from the pending list! - else if (+i < id) { - o.state = ENDED; - o.timer.stop(); - delete schedules[i]; - } - } - - // Defer the first tick to end of the current frame; see d3/d3#1576. - // Note the transition may be canceled after start and before the first tick! - // Note this must be scheduled before the start event; see d3/d3-transition#16! - // Assuming this is successful, subsequent callbacks go straight to tick. - Object(d3_timer__WEBPACK_IMPORTED_MODULE_1__["timeout"])(function() { - if (self.state === STARTED) { - self.state = RUNNING; - self.timer.restart(tick, self.delay, self.time); - tick(elapsed); - } - }); - - // Dispatch the start event. - // Note this must be done before the tween are initialized. - self.state = STARTING; - self.on.call("start", node, node.__data__, self.index, self.group); - if (self.state !== STARTING) return; // interrupted - self.state = STARTED; - - // Initialize the tween, deleting null tween. - tween = new Array(n = self.tween.length); - for (i = 0, j = -1; i < n; ++i) { - if (o = self.tween[i].value.call(node, node.__data__, self.index, self.group)) { - tween[++j] = o; - } - } - tween.length = j + 1; - } - - function tick(elapsed) { - var t = elapsed < self.duration ? self.ease.call(null, elapsed / self.duration) : (self.timer.restart(stop), self.state = ENDING, 1), - i = -1, - n = tween.length; - - while (++i < n) { - tween[i].call(null, t); - } - - // Dispatch the end event. - if (self.state === ENDING) { - self.on.call("end", node, node.__data__, self.index, self.group); - stop(); - } - } - - function stop() { - self.state = ENDED; - self.timer.stop(); - delete schedules[id]; - for (var i in schedules) return; // eslint-disable-line no-unused-vars - delete node.__transition; - } -} - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/select.js": -/*!*************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/select.js ***! - \*************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index */ "./node_modules/d3-transition/src/transition/index.js"); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(select) { - var name = this._name, - id = this._id; - - if (typeof select !== "function") select = Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["selector"])(select); - - for (var groups = this._groups, m = groups.length, subgroups = new Array(m), j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, subgroup = subgroups[j] = new Array(n), node, subnode, i = 0; i < n; ++i) { - if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) { - if ("__data__" in node) subnode.__data__ = node.__data__; - subgroup[i] = subnode; - Object(_schedule__WEBPACK_IMPORTED_MODULE_2__["default"])(subgroup[i], name, id, i, subgroup, Object(_schedule__WEBPACK_IMPORTED_MODULE_2__["get"])(node, id)); - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_1__["Transition"](subgroups, this._parents, name, id); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/selectAll.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/selectAll.js ***! - \****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./index */ "./node_modules/d3-transition/src/transition/index.js"); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = (function(select) { - var name = this._name, - id = this._id; - - if (typeof select !== "function") select = Object(d3_selection__WEBPACK_IMPORTED_MODULE_0__["selectorAll"])(select); - - for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { - if (node = group[i]) { - for (var children = select.call(node, node.__data__, i, group), child, inherit = Object(_schedule__WEBPACK_IMPORTED_MODULE_2__["get"])(node, id), k = 0, l = children.length; k < l; ++k) { - if (child = children[k]) { - Object(_schedule__WEBPACK_IMPORTED_MODULE_2__["default"])(child, name, id, k, children, inherit); - } - } - subgroups.push(children); - parents.push(node); - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_1__["Transition"](subgroups, parents, name, id); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/selection.js": -/*!****************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/selection.js ***! - \****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); - - -var Selection = d3_selection__WEBPACK_IMPORTED_MODULE_0__["selection"].prototype.constructor; - -/* harmony default export */ __webpack_exports__["default"] = (function() { - return new Selection(this._groups, this._parents); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/style.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/style.js ***! - \************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./tween */ "./node_modules/d3-transition/src/transition/tween.js"); -/* harmony import */ var _interpolate__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./interpolate */ "./node_modules/d3-transition/src/transition/interpolate.js"); - - - - - -function styleRemove(name, interpolate) { - var value00, - value10, - interpolate0; - return function() { - var value0 = Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["style"])(this, name), - value1 = (this.style.removeProperty(name), Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["style"])(this, name)); - return value0 === value1 ? null - : value0 === value00 && value1 === value10 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value10 = value1); - }; -} - -function styleRemoveEnd(name) { - return function() { - this.style.removeProperty(name); - }; -} - -function styleConstant(name, interpolate, value1) { - var value00, - interpolate0; - return function() { - var value0 = Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["style"])(this, name); - return value0 === value1 ? null - : value0 === value00 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value1); - }; -} - -function styleFunction(name, interpolate, value) { - var value00, - value10, - interpolate0; - return function() { - var value0 = Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["style"])(this, name), - value1 = value(this); - if (value1 == null) value1 = (this.style.removeProperty(name), Object(d3_selection__WEBPACK_IMPORTED_MODULE_1__["style"])(this, name)); - return value0 === value1 ? null - : value0 === value00 && value1 === value10 ? interpolate0 - : interpolate0 = interpolate(value00 = value0, value10 = value1); - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value, priority) { - var i = (name += "") === "transform" ? d3_interpolate__WEBPACK_IMPORTED_MODULE_0__["interpolateTransformCss"] : _interpolate__WEBPACK_IMPORTED_MODULE_3__["default"]; - return value == null ? this - .styleTween(name, styleRemove(name, i)) - .on("end.style." + name, styleRemoveEnd(name)) - : this.styleTween(name, typeof value === "function" - ? styleFunction(name, i, Object(_tween__WEBPACK_IMPORTED_MODULE_2__["tweenValue"])(this, "style." + name, value)) - : styleConstant(name, i, value + ""), priority); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/styleTween.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/styleTween.js ***! - \*****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -function styleTween(name, value, priority) { - function tween() { - var node = this, i = value.apply(node, arguments); - return i && function(t) { - node.style.setProperty(name, i(t), priority); - }; - } - tween._value = value; - return tween; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value, priority) { - var key = "style." + (name += ""); - if (arguments.length < 2) return (key = this.tween(key)) && key._value; - if (value == null) return this.tween(key, null); - if (typeof value !== "function") throw new Error; - return this.tween(key, styleTween(name, value, priority == null ? "" : priority)); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/text.js": -/*!***********************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/text.js ***! - \***********************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _tween__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./tween */ "./node_modules/d3-transition/src/transition/tween.js"); - - -function textConstant(value) { - return function() { - this.textContent = value; - }; -} - -function textFunction(value) { - return function() { - var value1 = value(this); - this.textContent = value1 == null ? "" : value1; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(value) { - return this.tween("text", typeof value === "function" - ? textFunction(Object(_tween__WEBPACK_IMPORTED_MODULE_0__["tweenValue"])(this, "text", value)) - : textConstant(value == null ? "" : value + "")); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/transition.js": -/*!*****************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/transition.js ***! - \*****************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./index */ "./node_modules/d3-transition/src/transition/index.js"); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var name = this._name, - id0 = this._id, - id1 = Object(_index__WEBPACK_IMPORTED_MODULE_0__["newId"])(); - - for (var groups = this._groups, m = groups.length, j = 0; j < m; ++j) { - for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) { - if (node = group[i]) { - var inherit = Object(_schedule__WEBPACK_IMPORTED_MODULE_1__["get"])(node, id0); - Object(_schedule__WEBPACK_IMPORTED_MODULE_1__["default"])(node, name, id1, i, group, { - time: inherit.time + inherit.delay + inherit.duration, - delay: 0, - duration: inherit.duration, - ease: inherit.ease - }); - } - } - } - - return new _index__WEBPACK_IMPORTED_MODULE_0__["Transition"](groups, this._parents, name, id1); -}); - - -/***/ }), - -/***/ "./node_modules/d3-transition/src/transition/tween.js": -/*!************************************************************!*\ - !*** ./node_modules/d3-transition/src/transition/tween.js ***! - \************************************************************/ -/*! exports provided: default, tweenValue */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tweenValue", function() { return tweenValue; }); -/* harmony import */ var _schedule__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./schedule */ "./node_modules/d3-transition/src/transition/schedule.js"); - - -function tweenRemove(id, name) { - var tween0, tween1; - return function() { - var schedule = Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["set"])(this, id), - tween = schedule.tween; - - // If this node shared tween with the previous node, - // just assign the updated shared tween and we’re done! - // Otherwise, copy-on-write. - if (tween !== tween0) { - tween1 = tween0 = tween; - for (var i = 0, n = tween1.length; i < n; ++i) { - if (tween1[i].name === name) { - tween1 = tween1.slice(); - tween1.splice(i, 1); - break; - } - } - } - - schedule.tween = tween1; - }; -} - -function tweenFunction(id, name, value) { - var tween0, tween1; - if (typeof value !== "function") throw new Error; - return function() { - var schedule = Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["set"])(this, id), - tween = schedule.tween; - - // If this node shared tween with the previous node, - // just assign the updated shared tween and we’re done! - // Otherwise, copy-on-write. - if (tween !== tween0) { - tween1 = (tween0 = tween).slice(); - for (var t = {name: name, value: value}, i = 0, n = tween1.length; i < n; ++i) { - if (tween1[i].name === name) { - tween1[i] = t; - break; - } - } - if (i === n) tween1.push(t); - } - - schedule.tween = tween1; - }; -} - -/* harmony default export */ __webpack_exports__["default"] = (function(name, value) { - var id = this._id; - - name += ""; - - if (arguments.length < 2) { - var tween = Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["get"])(this.node(), id).tween; - for (var i = 0, n = tween.length, t; i < n; ++i) { - if ((t = tween[i]).name === name) { - return t.value; - } - } - return null; - } - - return this.each((value == null ? tweenRemove : tweenFunction)(id, name, value)); -}); - -function tweenValue(transition, name, value) { - var id = transition._id; - - transition.each(function() { - var schedule = Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["set"])(this, id); - (schedule.value || (schedule.value = {}))[name] = value.apply(this, arguments); - }); - - return function(node) { - return Object(_schedule__WEBPACK_IMPORTED_MODULE_0__["get"])(node, id).value[name]; - }; -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/Beach.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-voronoi/src/Beach.js ***! - \**********************************************/ -/*! exports provided: removeBeach, addBeach */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeBeach", function() { return removeBeach; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addBeach", function() { return addBeach; }); -/* harmony import */ var _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./RedBlackTree */ "./node_modules/d3-voronoi/src/RedBlackTree.js"); -/* harmony import */ var _Cell__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Cell */ "./node_modules/d3-voronoi/src/Cell.js"); -/* harmony import */ var _Circle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Circle */ "./node_modules/d3-voronoi/src/Circle.js"); -/* harmony import */ var _Edge__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Edge */ "./node_modules/d3-voronoi/src/Edge.js"); -/* harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js"); - - - - - - -var beachPool = []; - -function Beach() { - Object(_RedBlackTree__WEBPACK_IMPORTED_MODULE_0__["RedBlackNode"])(this); - this.edge = - this.site = - this.circle = null; -} - -function createBeach(site) { - var beach = beachPool.pop() || new Beach; - beach.site = site; - return beach; -} - -function detachBeach(beach) { - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["detachCircle"])(beach); - _Diagram__WEBPACK_IMPORTED_MODULE_4__["beaches"].remove(beach); - beachPool.push(beach); - Object(_RedBlackTree__WEBPACK_IMPORTED_MODULE_0__["RedBlackNode"])(beach); -} - -function removeBeach(beach) { - var circle = beach.circle, - x = circle.x, - y = circle.cy, - vertex = [x, y], - previous = beach.P, - next = beach.N, - disappearing = [beach]; - - detachBeach(beach); - - var lArc = previous; - while (lArc.circle - && Math.abs(x - lArc.circle.x) < _Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"] - && Math.abs(y - lArc.circle.cy) < _Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"]) { - previous = lArc.P; - disappearing.unshift(lArc); - detachBeach(lArc); - lArc = previous; - } - - disappearing.unshift(lArc); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["detachCircle"])(lArc); - - var rArc = next; - while (rArc.circle - && Math.abs(x - rArc.circle.x) < _Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"] - && Math.abs(y - rArc.circle.cy) < _Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"]) { - next = rArc.N; - disappearing.push(rArc); - detachBeach(rArc); - rArc = next; - } - - disappearing.push(rArc); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["detachCircle"])(rArc); - - var nArcs = disappearing.length, - iArc; - for (iArc = 1; iArc < nArcs; ++iArc) { - rArc = disappearing[iArc]; - lArc = disappearing[iArc - 1]; - Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["setEdgeEnd"])(rArc.edge, lArc.site, rArc.site, vertex); - } - - lArc = disappearing[0]; - rArc = disappearing[nArcs - 1]; - rArc.edge = Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["createEdge"])(lArc.site, rArc.site, null, vertex); - - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["attachCircle"])(lArc); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["attachCircle"])(rArc); -} - -function addBeach(site) { - var x = site[0], - directrix = site[1], - lArc, - rArc, - dxl, - dxr, - node = _Diagram__WEBPACK_IMPORTED_MODULE_4__["beaches"]._; - - while (node) { - dxl = leftBreakPoint(node, directrix) - x; - if (dxl > _Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"]) node = node.L; else { - dxr = x - rightBreakPoint(node, directrix); - if (dxr > _Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"]) { - if (!node.R) { - lArc = node; - break; - } - node = node.R; - } else { - if (dxl > -_Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"]) { - lArc = node.P; - rArc = node; - } else if (dxr > -_Diagram__WEBPACK_IMPORTED_MODULE_4__["epsilon"]) { - lArc = node; - rArc = node.N; - } else { - lArc = rArc = node; - } - break; - } - } - } - - Object(_Cell__WEBPACK_IMPORTED_MODULE_1__["createCell"])(site); - var newArc = createBeach(site); - _Diagram__WEBPACK_IMPORTED_MODULE_4__["beaches"].insert(lArc, newArc); - - if (!lArc && !rArc) return; - - if (lArc === rArc) { - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["detachCircle"])(lArc); - rArc = createBeach(lArc.site); - _Diagram__WEBPACK_IMPORTED_MODULE_4__["beaches"].insert(newArc, rArc); - newArc.edge = rArc.edge = Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["createEdge"])(lArc.site, newArc.site); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["attachCircle"])(lArc); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["attachCircle"])(rArc); - return; - } - - if (!rArc) { // && lArc - newArc.edge = Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["createEdge"])(lArc.site, newArc.site); - return; - } - - // else lArc !== rArc - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["detachCircle"])(lArc); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["detachCircle"])(rArc); - - var lSite = lArc.site, - ax = lSite[0], - ay = lSite[1], - bx = site[0] - ax, - by = site[1] - ay, - rSite = rArc.site, - cx = rSite[0] - ax, - cy = rSite[1] - ay, - d = 2 * (bx * cy - by * cx), - hb = bx * bx + by * by, - hc = cx * cx + cy * cy, - vertex = [(cy * hb - by * hc) / d + ax, (bx * hc - cx * hb) / d + ay]; - - Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["setEdgeEnd"])(rArc.edge, lSite, rSite, vertex); - newArc.edge = Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["createEdge"])(lSite, site, null, vertex); - rArc.edge = Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["createEdge"])(site, rSite, null, vertex); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["attachCircle"])(lArc); - Object(_Circle__WEBPACK_IMPORTED_MODULE_2__["attachCircle"])(rArc); -} - -function leftBreakPoint(arc, directrix) { - var site = arc.site, - rfocx = site[0], - rfocy = site[1], - pby2 = rfocy - directrix; - - if (!pby2) return rfocx; - - var lArc = arc.P; - if (!lArc) return -Infinity; - - site = lArc.site; - var lfocx = site[0], - lfocy = site[1], - plby2 = lfocy - directrix; - - if (!plby2) return lfocx; - - var hl = lfocx - rfocx, - aby2 = 1 / pby2 - 1 / plby2, - b = hl / plby2; - - if (aby2) return (-b + Math.sqrt(b * b - 2 * aby2 * (hl * hl / (-2 * plby2) - lfocy + plby2 / 2 + rfocy - pby2 / 2))) / aby2 + rfocx; - - return (rfocx + lfocx) / 2; -} - -function rightBreakPoint(arc, directrix) { - var rArc = arc.N; - if (rArc) return leftBreakPoint(rArc, directrix); - var site = arc.site; - return site[1] === directrix ? site[0] : Infinity; -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/Cell.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-voronoi/src/Cell.js ***! - \*********************************************/ -/*! exports provided: createCell, cellHalfedgeStart, cellHalfedgeEnd, sortCellHalfedges, clipCells */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createCell", function() { return createCell; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cellHalfedgeStart", function() { return cellHalfedgeStart; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cellHalfedgeEnd", function() { return cellHalfedgeEnd; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sortCellHalfedges", function() { return sortCellHalfedges; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clipCells", function() { return clipCells; }); -/* harmony import */ var _Edge__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Edge */ "./node_modules/d3-voronoi/src/Edge.js"); -/* harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js"); - - - -function createCell(site) { - return _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"][site.index] = { - site: site, - halfedges: [] - }; -} - -function cellHalfedgeAngle(cell, edge) { - var site = cell.site, - va = edge.left, - vb = edge.right; - if (site === vb) vb = va, va = site; - if (vb) return Math.atan2(vb[1] - va[1], vb[0] - va[0]); - if (site === va) va = edge[1], vb = edge[0]; - else va = edge[0], vb = edge[1]; - return Math.atan2(va[0] - vb[0], vb[1] - va[1]); -} - -function cellHalfedgeStart(cell, edge) { - return edge[+(edge.left !== cell.site)]; -} - -function cellHalfedgeEnd(cell, edge) { - return edge[+(edge.left === cell.site)]; -} - -function sortCellHalfedges() { - for (var i = 0, n = _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"].length, cell, halfedges, j, m; i < n; ++i) { - if ((cell = _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"][i]) && (m = (halfedges = cell.halfedges).length)) { - var index = new Array(m), - array = new Array(m); - for (j = 0; j < m; ++j) index[j] = j, array[j] = cellHalfedgeAngle(cell, _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"][halfedges[j]]); - index.sort(function(i, j) { return array[j] - array[i]; }); - for (j = 0; j < m; ++j) array[j] = halfedges[index[j]]; - for (j = 0; j < m; ++j) halfedges[j] = array[j]; - } - } -} - -function clipCells(x0, y0, x1, y1) { - var nCells = _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"].length, - iCell, - cell, - site, - iHalfedge, - halfedges, - nHalfedges, - start, - startX, - startY, - end, - endX, - endY, - cover = true; - - for (iCell = 0; iCell < nCells; ++iCell) { - if (cell = _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"][iCell]) { - site = cell.site; - halfedges = cell.halfedges; - iHalfedge = halfedges.length; - - // Remove any dangling clipped edges. - while (iHalfedge--) { - if (!_Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"][halfedges[iHalfedge]]) { - halfedges.splice(iHalfedge, 1); - } - } - - // Insert any border edges as necessary. - iHalfedge = 0, nHalfedges = halfedges.length; - while (iHalfedge < nHalfedges) { - end = cellHalfedgeEnd(cell, _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"][halfedges[iHalfedge]]), endX = end[0], endY = end[1]; - start = cellHalfedgeStart(cell, _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"][halfedges[++iHalfedge % nHalfedges]]), startX = start[0], startY = start[1]; - if (Math.abs(endX - startX) > _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] || Math.abs(endY - startY) > _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"]) { - halfedges.splice(iHalfedge, 0, _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"].push(Object(_Edge__WEBPACK_IMPORTED_MODULE_0__["createBorderEdge"])(site, end, - Math.abs(endX - x0) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] && y1 - endY > _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? [x0, Math.abs(startX - x0) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? startY : y1] - : Math.abs(endY - y1) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] && x1 - endX > _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? [Math.abs(startY - y1) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? startX : x1, y1] - : Math.abs(endX - x1) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] && endY - y0 > _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? [x1, Math.abs(startX - x1) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? startY : y0] - : Math.abs(endY - y0) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] && endX - x0 > _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? [Math.abs(startY - y0) < _Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon"] ? startX : x0, y0] - : null)) - 1); - ++nHalfedges; - } - } - - if (nHalfedges) cover = false; - } - } - - // If there weren’t any edges, have the closest site cover the extent. - // It doesn’t matter which corner of the extent we measure! - if (cover) { - var dx, dy, d2, dc = Infinity; - - for (iCell = 0, cover = null; iCell < nCells; ++iCell) { - if (cell = _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"][iCell]) { - site = cell.site; - dx = site[0] - x0; - dy = site[1] - y0; - d2 = dx * dx + dy * dy; - if (d2 < dc) dc = d2, cover = cell; - } - } - - if (cover) { - var v00 = [x0, y0], v01 = [x0, y1], v11 = [x1, y1], v10 = [x1, y0]; - cover.halfedges.push( - _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"].push(Object(_Edge__WEBPACK_IMPORTED_MODULE_0__["createBorderEdge"])(site = cover.site, v00, v01)) - 1, - _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"].push(Object(_Edge__WEBPACK_IMPORTED_MODULE_0__["createBorderEdge"])(site, v01, v11)) - 1, - _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"].push(Object(_Edge__WEBPACK_IMPORTED_MODULE_0__["createBorderEdge"])(site, v11, v10)) - 1, - _Diagram__WEBPACK_IMPORTED_MODULE_1__["edges"].push(Object(_Edge__WEBPACK_IMPORTED_MODULE_0__["createBorderEdge"])(site, v10, v00)) - 1 - ); - } - } - - // Lastly delete any cells with no edges; these were entirely clipped. - for (iCell = 0; iCell < nCells; ++iCell) { - if (cell = _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"][iCell]) { - if (!cell.halfedges.length) { - delete _Diagram__WEBPACK_IMPORTED_MODULE_1__["cells"][iCell]; - } - } - } -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/Circle.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-voronoi/src/Circle.js ***! - \***********************************************/ -/*! exports provided: firstCircle, attachCircle, detachCircle */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "firstCircle", function() { return firstCircle; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "attachCircle", function() { return attachCircle; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "detachCircle", function() { return detachCircle; }); -/* harmony import */ var _RedBlackTree__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./RedBlackTree */ "./node_modules/d3-voronoi/src/RedBlackTree.js"); -/* harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js"); - - - -var circlePool = []; - -var firstCircle; - -function Circle() { - Object(_RedBlackTree__WEBPACK_IMPORTED_MODULE_0__["RedBlackNode"])(this); - this.x = - this.y = - this.arc = - this.site = - this.cy = null; -} - -function attachCircle(arc) { - var lArc = arc.P, - rArc = arc.N; - - if (!lArc || !rArc) return; - - var lSite = lArc.site, - cSite = arc.site, - rSite = rArc.site; - - if (lSite === rSite) return; - - var bx = cSite[0], - by = cSite[1], - ax = lSite[0] - bx, - ay = lSite[1] - by, - cx = rSite[0] - bx, - cy = rSite[1] - by; - - var d = 2 * (ax * cy - ay * cx); - if (d >= -_Diagram__WEBPACK_IMPORTED_MODULE_1__["epsilon2"]) return; - - var ha = ax * ax + ay * ay, - hc = cx * cx + cy * cy, - x = (cy * ha - ay * hc) / d, - y = (ax * hc - cx * ha) / d; - - var circle = circlePool.pop() || new Circle; - circle.arc = arc; - circle.site = cSite; - circle.x = x + bx; - circle.y = (circle.cy = y + by) + Math.sqrt(x * x + y * y); // y bottom - - arc.circle = circle; - - var before = null, - node = _Diagram__WEBPACK_IMPORTED_MODULE_1__["circles"]._; - - while (node) { - if (circle.y < node.y || (circle.y === node.y && circle.x <= node.x)) { - if (node.L) node = node.L; - else { before = node.P; break; } - } else { - if (node.R) node = node.R; - else { before = node; break; } - } - } - - _Diagram__WEBPACK_IMPORTED_MODULE_1__["circles"].insert(before, circle); - if (!before) firstCircle = circle; -} - -function detachCircle(arc) { - var circle = arc.circle; - if (circle) { - if (!circle.P) firstCircle = circle.N; - _Diagram__WEBPACK_IMPORTED_MODULE_1__["circles"].remove(circle); - circlePool.push(circle); - Object(_RedBlackTree__WEBPACK_IMPORTED_MODULE_0__["RedBlackNode"])(circle); - arc.circle = null; - } -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/Diagram.js": -/*!************************************************!*\ - !*** ./node_modules/d3-voronoi/src/Diagram.js ***! - \************************************************/ -/*! exports provided: epsilon, epsilon2, beaches, cells, circles, edges, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "epsilon", function() { return epsilon; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "epsilon2", function() { return epsilon2; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "beaches", function() { return beaches; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cells", function() { return cells; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "circles", function() { return circles; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "edges", function() { return edges; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Diagram; }); -/* harmony import */ var _Beach__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Beach */ "./node_modules/d3-voronoi/src/Beach.js"); -/* harmony import */ var _Cell__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Cell */ "./node_modules/d3-voronoi/src/Cell.js"); -/* harmony import */ var _Circle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Circle */ "./node_modules/d3-voronoi/src/Circle.js"); -/* harmony import */ var _Edge__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Edge */ "./node_modules/d3-voronoi/src/Edge.js"); -/* harmony import */ var _RedBlackTree__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./RedBlackTree */ "./node_modules/d3-voronoi/src/RedBlackTree.js"); - - - - - - -var epsilon = 1e-6; -var epsilon2 = 1e-12; -var beaches; -var cells; -var circles; -var edges; - -function triangleArea(a, b, c) { - return (a[0] - c[0]) * (b[1] - a[1]) - (a[0] - b[0]) * (c[1] - a[1]); -} - -function lexicographic(a, b) { - return b[1] - a[1] - || b[0] - a[0]; -} - -function Diagram(sites, extent) { - var site = sites.sort(lexicographic).pop(), - x, - y, - circle; - - edges = []; - cells = new Array(sites.length); - beaches = new _RedBlackTree__WEBPACK_IMPORTED_MODULE_4__["default"]; - circles = new _RedBlackTree__WEBPACK_IMPORTED_MODULE_4__["default"]; - - while (true) { - circle = _Circle__WEBPACK_IMPORTED_MODULE_2__["firstCircle"]; - if (site && (!circle || site[1] < circle.y || (site[1] === circle.y && site[0] < circle.x))) { - if (site[0] !== x || site[1] !== y) { - Object(_Beach__WEBPACK_IMPORTED_MODULE_0__["addBeach"])(site); - x = site[0], y = site[1]; - } - site = sites.pop(); - } else if (circle) { - Object(_Beach__WEBPACK_IMPORTED_MODULE_0__["removeBeach"])(circle.arc); - } else { - break; - } - } - - Object(_Cell__WEBPACK_IMPORTED_MODULE_1__["sortCellHalfedges"])(); - - if (extent) { - var x0 = +extent[0][0], - y0 = +extent[0][1], - x1 = +extent[1][0], - y1 = +extent[1][1]; - Object(_Edge__WEBPACK_IMPORTED_MODULE_3__["clipEdges"])(x0, y0, x1, y1); - Object(_Cell__WEBPACK_IMPORTED_MODULE_1__["clipCells"])(x0, y0, x1, y1); - } - - this.edges = edges; - this.cells = cells; - - beaches = - circles = - edges = - cells = null; -} - -Diagram.prototype = { - constructor: Diagram, - - polygons: function() { - var edges = this.edges; - - return this.cells.map(function(cell) { - var polygon = cell.halfedges.map(function(i) { return Object(_Cell__WEBPACK_IMPORTED_MODULE_1__["cellHalfedgeStart"])(cell, edges[i]); }); - polygon.data = cell.site.data; - return polygon; - }); - }, - - triangles: function() { - var triangles = [], - edges = this.edges; - - this.cells.forEach(function(cell, i) { - if (!(m = (halfedges = cell.halfedges).length)) return; - var site = cell.site, - halfedges, - j = -1, - m, - s0, - e1 = edges[halfedges[m - 1]], - s1 = e1.left === site ? e1.right : e1.left; - - while (++j < m) { - s0 = s1; - e1 = edges[halfedges[j]]; - s1 = e1.left === site ? e1.right : e1.left; - if (s0 && s1 && i < s0.index && i < s1.index && triangleArea(site, s0, s1) < 0) { - triangles.push([site.data, s0.data, s1.data]); - } - } - }); - - return triangles; - }, - - links: function() { - return this.edges.filter(function(edge) { - return edge.right; - }).map(function(edge) { - return { - source: edge.left.data, - target: edge.right.data - }; - }); - }, - - find: function(x, y, radius) { - var that = this, i0, i1 = that._found || 0, n = that.cells.length, cell; - - // Use the previously-found cell, or start with an arbitrary one. - while (!(cell = that.cells[i1])) if (++i1 >= n) return null; - var dx = x - cell.site[0], dy = y - cell.site[1], d2 = dx * dx + dy * dy; - - // Traverse the half-edges to find a closer cell, if any. - do { - cell = that.cells[i0 = i1], i1 = null; - cell.halfedges.forEach(function(e) { - var edge = that.edges[e], v = edge.left; - if ((v === cell.site || !v) && !(v = edge.right)) return; - var vx = x - v[0], vy = y - v[1], v2 = vx * vx + vy * vy; - if (v2 < d2) d2 = v2, i1 = v.index; - }); - } while (i1 !== null); - - that._found = i0; - - return radius == null || d2 <= radius * radius ? cell.site : null; - } -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/Edge.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-voronoi/src/Edge.js ***! - \*********************************************/ -/*! exports provided: createEdge, createBorderEdge, setEdgeEnd, clipEdges */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createEdge", function() { return createEdge; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createBorderEdge", function() { return createBorderEdge; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setEdgeEnd", function() { return setEdgeEnd; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clipEdges", function() { return clipEdges; }); -/* harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js"); - - -function createEdge(left, right, v0, v1) { - var edge = [null, null], - index = _Diagram__WEBPACK_IMPORTED_MODULE_0__["edges"].push(edge) - 1; - edge.left = left; - edge.right = right; - if (v0) setEdgeEnd(edge, left, right, v0); - if (v1) setEdgeEnd(edge, right, left, v1); - _Diagram__WEBPACK_IMPORTED_MODULE_0__["cells"][left.index].halfedges.push(index); - _Diagram__WEBPACK_IMPORTED_MODULE_0__["cells"][right.index].halfedges.push(index); - return edge; -} - -function createBorderEdge(left, v0, v1) { - var edge = [v0, v1]; - edge.left = left; - return edge; -} - -function setEdgeEnd(edge, left, right, vertex) { - if (!edge[0] && !edge[1]) { - edge[0] = vertex; - edge.left = left; - edge.right = right; - } else if (edge.left === right) { - edge[1] = vertex; - } else { - edge[0] = vertex; - } -} - -// Liang–Barsky line clipping. -function clipEdge(edge, x0, y0, x1, y1) { - var a = edge[0], - b = edge[1], - ax = a[0], - ay = a[1], - bx = b[0], - by = b[1], - t0 = 0, - t1 = 1, - dx = bx - ax, - dy = by - ay, - r; - - r = x0 - ax; - if (!dx && r > 0) return; - r /= dx; - if (dx < 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } else if (dx > 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } - - r = x1 - ax; - if (!dx && r < 0) return; - r /= dx; - if (dx < 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } else if (dx > 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } - - r = y0 - ay; - if (!dy && r > 0) return; - r /= dy; - if (dy < 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } else if (dy > 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } - - r = y1 - ay; - if (!dy && r < 0) return; - r /= dy; - if (dy < 0) { - if (r > t1) return; - if (r > t0) t0 = r; - } else if (dy > 0) { - if (r < t0) return; - if (r < t1) t1 = r; - } - - if (!(t0 > 0) && !(t1 < 1)) return true; // TODO Better check? - - if (t0 > 0) edge[0] = [ax + t0 * dx, ay + t0 * dy]; - if (t1 < 1) edge[1] = [ax + t1 * dx, ay + t1 * dy]; - return true; -} - -function connectEdge(edge, x0, y0, x1, y1) { - var v1 = edge[1]; - if (v1) return true; - - var v0 = edge[0], - left = edge.left, - right = edge.right, - lx = left[0], - ly = left[1], - rx = right[0], - ry = right[1], - fx = (lx + rx) / 2, - fy = (ly + ry) / 2, - fm, - fb; - - if (ry === ly) { - if (fx < x0 || fx >= x1) return; - if (lx > rx) { - if (!v0) v0 = [fx, y0]; - else if (v0[1] >= y1) return; - v1 = [fx, y1]; - } else { - if (!v0) v0 = [fx, y1]; - else if (v0[1] < y0) return; - v1 = [fx, y0]; - } - } else { - fm = (lx - rx) / (ry - ly); - fb = fy - fm * fx; - if (fm < -1 || fm > 1) { - if (lx > rx) { - if (!v0) v0 = [(y0 - fb) / fm, y0]; - else if (v0[1] >= y1) return; - v1 = [(y1 - fb) / fm, y1]; - } else { - if (!v0) v0 = [(y1 - fb) / fm, y1]; - else if (v0[1] < y0) return; - v1 = [(y0 - fb) / fm, y0]; - } - } else { - if (ly < ry) { - if (!v0) v0 = [x0, fm * x0 + fb]; - else if (v0[0] >= x1) return; - v1 = [x1, fm * x1 + fb]; - } else { - if (!v0) v0 = [x1, fm * x1 + fb]; - else if (v0[0] < x0) return; - v1 = [x0, fm * x0 + fb]; - } - } - } - - edge[0] = v0; - edge[1] = v1; - return true; -} - -function clipEdges(x0, y0, x1, y1) { - var i = _Diagram__WEBPACK_IMPORTED_MODULE_0__["edges"].length, - edge; - - while (i--) { - if (!connectEdge(edge = _Diagram__WEBPACK_IMPORTED_MODULE_0__["edges"][i], x0, y0, x1, y1) - || !clipEdge(edge, x0, y0, x1, y1) - || !(Math.abs(edge[0][0] - edge[1][0]) > _Diagram__WEBPACK_IMPORTED_MODULE_0__["epsilon"] - || Math.abs(edge[0][1] - edge[1][1]) > _Diagram__WEBPACK_IMPORTED_MODULE_0__["epsilon"])) { - delete _Diagram__WEBPACK_IMPORTED_MODULE_0__["edges"][i]; - } - } -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/RedBlackTree.js": -/*!*****************************************************!*\ - !*** ./node_modules/d3-voronoi/src/RedBlackTree.js ***! - \*****************************************************/ -/*! exports provided: RedBlackNode, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RedBlackNode", function() { return RedBlackNode; }); -function RedBlackTree() { - this._ = null; // root node -} - -function RedBlackNode(node) { - node.U = // parent node - node.C = // color - true for red, false for black - node.L = // left node - node.R = // right node - node.P = // previous node - node.N = null; // next node -} - -RedBlackTree.prototype = { - constructor: RedBlackTree, - - insert: function(after, node) { - var parent, grandpa, uncle; - - if (after) { - node.P = after; - node.N = after.N; - if (after.N) after.N.P = node; - after.N = node; - if (after.R) { - after = after.R; - while (after.L) after = after.L; - after.L = node; - } else { - after.R = node; - } - parent = after; - } else if (this._) { - after = RedBlackFirst(this._); - node.P = null; - node.N = after; - after.P = after.L = node; - parent = after; - } else { - node.P = node.N = null; - this._ = node; - parent = null; - } - node.L = node.R = null; - node.U = parent; - node.C = true; - - after = node; - while (parent && parent.C) { - grandpa = parent.U; - if (parent === grandpa.L) { - uncle = grandpa.R; - if (uncle && uncle.C) { - parent.C = uncle.C = false; - grandpa.C = true; - after = grandpa; - } else { - if (after === parent.R) { - RedBlackRotateLeft(this, parent); - after = parent; - parent = after.U; - } - parent.C = false; - grandpa.C = true; - RedBlackRotateRight(this, grandpa); - } - } else { - uncle = grandpa.L; - if (uncle && uncle.C) { - parent.C = uncle.C = false; - grandpa.C = true; - after = grandpa; - } else { - if (after === parent.L) { - RedBlackRotateRight(this, parent); - after = parent; - parent = after.U; - } - parent.C = false; - grandpa.C = true; - RedBlackRotateLeft(this, grandpa); - } - } - parent = after.U; - } - this._.C = false; - }, - - remove: function(node) { - if (node.N) node.N.P = node.P; - if (node.P) node.P.N = node.N; - node.N = node.P = null; - - var parent = node.U, - sibling, - left = node.L, - right = node.R, - next, - red; - - if (!left) next = right; - else if (!right) next = left; - else next = RedBlackFirst(right); - - if (parent) { - if (parent.L === node) parent.L = next; - else parent.R = next; - } else { - this._ = next; - } - - if (left && right) { - red = next.C; - next.C = node.C; - next.L = left; - left.U = next; - if (next !== right) { - parent = next.U; - next.U = node.U; - node = next.R; - parent.L = node; - next.R = right; - right.U = next; - } else { - next.U = parent; - parent = next; - node = next.R; - } - } else { - red = node.C; - node = next; - } - - if (node) node.U = parent; - if (red) return; - if (node && node.C) { node.C = false; return; } - - do { - if (node === this._) break; - if (node === parent.L) { - sibling = parent.R; - if (sibling.C) { - sibling.C = false; - parent.C = true; - RedBlackRotateLeft(this, parent); - sibling = parent.R; - } - if ((sibling.L && sibling.L.C) - || (sibling.R && sibling.R.C)) { - if (!sibling.R || !sibling.R.C) { - sibling.L.C = false; - sibling.C = true; - RedBlackRotateRight(this, sibling); - sibling = parent.R; - } - sibling.C = parent.C; - parent.C = sibling.R.C = false; - RedBlackRotateLeft(this, parent); - node = this._; - break; - } - } else { - sibling = parent.L; - if (sibling.C) { - sibling.C = false; - parent.C = true; - RedBlackRotateRight(this, parent); - sibling = parent.L; - } - if ((sibling.L && sibling.L.C) - || (sibling.R && sibling.R.C)) { - if (!sibling.L || !sibling.L.C) { - sibling.R.C = false; - sibling.C = true; - RedBlackRotateLeft(this, sibling); - sibling = parent.L; - } - sibling.C = parent.C; - parent.C = sibling.L.C = false; - RedBlackRotateRight(this, parent); - node = this._; - break; - } - } - sibling.C = true; - node = parent; - parent = parent.U; - } while (!node.C); - - if (node) node.C = false; - } -}; - -function RedBlackRotateLeft(tree, node) { - var p = node, - q = node.R, - parent = p.U; - - if (parent) { - if (parent.L === p) parent.L = q; - else parent.R = q; - } else { - tree._ = q; - } - - q.U = parent; - p.U = q; - p.R = q.L; - if (p.R) p.R.U = p; - q.L = p; -} - -function RedBlackRotateRight(tree, node) { - var p = node, - q = node.L, - parent = p.U; - - if (parent) { - if (parent.L === p) parent.L = q; - else parent.R = q; - } else { - tree._ = q; - } - - q.U = parent; - p.U = q; - p.L = q.R; - if (p.L) p.L.U = p; - q.R = p; -} - -function RedBlackFirst(node) { - while (node.L) node = node.L; - return node; -} - -/* harmony default export */ __webpack_exports__["default"] = (RedBlackTree); - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/constant.js": -/*!*************************************************!*\ - !*** ./node_modules/d3-voronoi/src/constant.js ***! - \*************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/index.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-voronoi/src/index.js ***! - \**********************************************/ -/*! exports provided: voronoi */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _voronoi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./voronoi */ "./node_modules/d3-voronoi/src/voronoi.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "voronoi", function() { return _voronoi__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - - - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/point.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-voronoi/src/point.js ***! - \**********************************************/ -/*! exports provided: x, y */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "x", function() { return x; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "y", function() { return y; }); -function x(d) { - return d[0]; -} - -function y(d) { - return d[1]; -} - - -/***/ }), - -/***/ "./node_modules/d3-voronoi/src/voronoi.js": -/*!************************************************!*\ - !*** ./node_modules/d3-voronoi/src/voronoi.js ***! - \************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-voronoi/src/constant.js"); -/* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./point */ "./node_modules/d3-voronoi/src/point.js"); -/* harmony import */ var _Diagram__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Diagram */ "./node_modules/d3-voronoi/src/Diagram.js"); - - - - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var x = _point__WEBPACK_IMPORTED_MODULE_1__["x"], - y = _point__WEBPACK_IMPORTED_MODULE_1__["y"], - extent = null; - - function voronoi(data) { - return new _Diagram__WEBPACK_IMPORTED_MODULE_2__["default"](data.map(function(d, i) { - var s = [Math.round(x(d, i, data) / _Diagram__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) * _Diagram__WEBPACK_IMPORTED_MODULE_2__["epsilon"], Math.round(y(d, i, data) / _Diagram__WEBPACK_IMPORTED_MODULE_2__["epsilon"]) * _Diagram__WEBPACK_IMPORTED_MODULE_2__["epsilon"]]; - s.index = i; - s.data = d; - return s; - }), extent); - } - - voronoi.polygons = function(data) { - return voronoi(data).polygons(); - }; - - voronoi.links = function(data) { - return voronoi(data).links(); - }; - - voronoi.triangles = function(data) { - return voronoi(data).triangles(); - }; - - voronoi.x = function(_) { - return arguments.length ? (x = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), voronoi) : x; - }; - - voronoi.y = function(_) { - return arguments.length ? (y = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_0__["default"])(+_), voronoi) : y; - }; - - voronoi.extent = function(_) { - return arguments.length ? (extent = _ == null ? null : [[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]], voronoi) : extent && [[extent[0][0], extent[0][1]], [extent[1][0], extent[1][1]]]; - }; - - voronoi.size = function(_) { - return arguments.length ? (extent = _ == null ? null : [[0, 0], [+_[0], +_[1]]], voronoi) : extent && [extent[1][0] - extent[0][0], extent[1][1] - extent[0][1]]; - }; - - return voronoi; -}); - - -/***/ }), - -/***/ "./node_modules/d3-zoom/src/constant.js": -/*!**********************************************!*\ - !*** ./node_modules/d3-zoom/src/constant.js ***! - \**********************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony default export */ __webpack_exports__["default"] = (function(x) { - return function() { - return x; - }; -}); - - -/***/ }), - -/***/ "./node_modules/d3-zoom/src/event.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-zoom/src/event.js ***! - \*******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ZoomEvent; }); -function ZoomEvent(target, type, transform) { - this.target = target; - this.type = type; - this.transform = transform; -} - - -/***/ }), - -/***/ "./node_modules/d3-zoom/src/index.js": -/*!*******************************************!*\ - !*** ./node_modules/d3-zoom/src/index.js ***! - \*******************************************/ -/*! exports provided: zoom, zoomTransform, zoomIdentity */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _zoom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./zoom */ "./node_modules/d3-zoom/src/zoom.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zoom", function() { return _zoom__WEBPACK_IMPORTED_MODULE_0__["default"]; }); - -/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./transform */ "./node_modules/d3-zoom/src/transform.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zoomTransform", function() { return _transform__WEBPACK_IMPORTED_MODULE_1__["default"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zoomIdentity", function() { return _transform__WEBPACK_IMPORTED_MODULE_1__["identity"]; }); - - - - - -/***/ }), - -/***/ "./node_modules/d3-zoom/src/noevent.js": -/*!*********************************************!*\ - !*** ./node_modules/d3-zoom/src/noevent.js ***! - \*********************************************/ -/*! exports provided: nopropagation, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "nopropagation", function() { return nopropagation; }); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); - - -function nopropagation() { - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].stopImmediatePropagation(); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].preventDefault(); - d3_selection__WEBPACK_IMPORTED_MODULE_0__["event"].stopImmediatePropagation(); -}); - - -/***/ }), - -/***/ "./node_modules/d3-zoom/src/transform.js": -/*!***********************************************!*\ - !*** ./node_modules/d3-zoom/src/transform.js ***! - \***********************************************/ -/*! exports provided: Transform, identity, default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Transform", function() { return Transform; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return transform; }); -function Transform(k, x, y) { - this.k = k; - this.x = x; - this.y = y; -} - -Transform.prototype = { - constructor: Transform, - scale: function(k) { - return k === 1 ? this : new Transform(this.k * k, this.x, this.y); - }, - translate: function(x, y) { - return x === 0 & y === 0 ? this : new Transform(this.k, this.x + this.k * x, this.y + this.k * y); - }, - apply: function(point) { - return [point[0] * this.k + this.x, point[1] * this.k + this.y]; - }, - applyX: function(x) { - return x * this.k + this.x; - }, - applyY: function(y) { - return y * this.k + this.y; - }, - invert: function(location) { - return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k]; - }, - invertX: function(x) { - return (x - this.x) / this.k; - }, - invertY: function(y) { - return (y - this.y) / this.k; - }, - rescaleX: function(x) { - return x.copy().domain(x.range().map(this.invertX, this).map(x.invert, x)); - }, - rescaleY: function(y) { - return y.copy().domain(y.range().map(this.invertY, this).map(y.invert, y)); - }, - toString: function() { - return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")"; - } -}; - -var identity = new Transform(1, 0, 0); - -transform.prototype = Transform.prototype; - -function transform(node) { - return node.__zoom || identity; -} - - -/***/ }), - -/***/ "./node_modules/d3-zoom/src/zoom.js": -/*!******************************************!*\ - !*** ./node_modules/d3-zoom/src/zoom.js ***! - \******************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js"); -/* harmony import */ var d3_drag__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-drag */ "./node_modules/d3-drag/src/index.js"); -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony import */ var d3_transition__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! d3-transition */ "./node_modules/d3-transition/src/index.js"); -/* harmony import */ var _constant__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./constant */ "./node_modules/d3-zoom/src/constant.js"); -/* harmony import */ var _event__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./event */ "./node_modules/d3-zoom/src/event.js"); -/* harmony import */ var _transform__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./transform */ "./node_modules/d3-zoom/src/transform.js"); -/* harmony import */ var _noevent__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./noevent */ "./node_modules/d3-zoom/src/noevent.js"); - - - - - - - - - - -// Ignore right-click, since that should open the context menu. -function defaultFilter() { - return !d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].button; -} - -function defaultExtent() { - var e = this, w, h; - if (e instanceof SVGElement) { - e = e.ownerSVGElement || e; - w = e.width.baseVal.value; - h = e.height.baseVal.value; - } else { - w = e.clientWidth; - h = e.clientHeight; - } - return [[0, 0], [w, h]]; -} - -function defaultTransform() { - return this.__zoom || _transform__WEBPACK_IMPORTED_MODULE_7__["identity"]; -} - -function defaultWheelDelta() { - return -d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].deltaY * (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].deltaMode ? 120 : 1) / 500; -} - -function defaultTouchable() { - return "ontouchstart" in this; -} - -function defaultConstrain(transform, extent, translateExtent) { - var dx0 = transform.invertX(extent[0][0]) - translateExtent[0][0], - dx1 = transform.invertX(extent[1][0]) - translateExtent[1][0], - dy0 = transform.invertY(extent[0][1]) - translateExtent[0][1], - dy1 = transform.invertY(extent[1][1]) - translateExtent[1][1]; - return transform.translate( - dx1 > dx0 ? (dx0 + dx1) / 2 : Math.min(0, dx0) || Math.max(0, dx1), - dy1 > dy0 ? (dy0 + dy1) / 2 : Math.min(0, dy0) || Math.max(0, dy1) - ); -} - -/* harmony default export */ __webpack_exports__["default"] = (function() { - var filter = defaultFilter, - extent = defaultExtent, - constrain = defaultConstrain, - wheelDelta = defaultWheelDelta, - touchable = defaultTouchable, - scaleExtent = [0, Infinity], - translateExtent = [[-Infinity, -Infinity], [Infinity, Infinity]], - duration = 250, - interpolate = d3_interpolate__WEBPACK_IMPORTED_MODULE_2__["interpolateZoom"], - gestures = [], - listeners = Object(d3_dispatch__WEBPACK_IMPORTED_MODULE_0__["dispatch"])("start", "zoom", "end"), - touchstarting, - touchending, - touchDelay = 500, - wheelDelay = 150, - clickDistance2 = 0; - - function zoom(selection) { - selection - .property("__zoom", defaultTransform) - .on("wheel.zoom", wheeled) - .on("mousedown.zoom", mousedowned) - .on("dblclick.zoom", dblclicked) - .filter(touchable) - .on("touchstart.zoom", touchstarted) - .on("touchmove.zoom", touchmoved) - .on("touchend.zoom touchcancel.zoom", touchended) - .style("touch-action", "none") - .style("-webkit-tap-highlight-color", "rgba(0,0,0,0)"); - } - - zoom.transform = function(collection, transform) { - var selection = collection.selection ? collection.selection() : collection; - selection.property("__zoom", defaultTransform); - if (collection !== selection) { - schedule(collection, transform); - } else { - selection.interrupt().each(function() { - gesture(this, arguments) - .start() - .zoom(null, typeof transform === "function" ? transform.apply(this, arguments) : transform) - .end(); - }); - } - }; - - zoom.scaleBy = function(selection, k) { - zoom.scaleTo(selection, function() { - var k0 = this.__zoom.k, - k1 = typeof k === "function" ? k.apply(this, arguments) : k; - return k0 * k1; - }); - }; - - zoom.scaleTo = function(selection, k) { - zoom.transform(selection, function() { - var e = extent.apply(this, arguments), - t0 = this.__zoom, - p0 = centroid(e), - p1 = t0.invert(p0), - k1 = typeof k === "function" ? k.apply(this, arguments) : k; - return constrain(translate(scale(t0, k1), p0, p1), e, translateExtent); - }); - }; - - zoom.translateBy = function(selection, x, y) { - zoom.transform(selection, function() { - return constrain(this.__zoom.translate( - typeof x === "function" ? x.apply(this, arguments) : x, - typeof y === "function" ? y.apply(this, arguments) : y - ), extent.apply(this, arguments), translateExtent); - }); - }; - - zoom.translateTo = function(selection, x, y) { - zoom.transform(selection, function() { - var e = extent.apply(this, arguments), - t = this.__zoom, - p = centroid(e); - return constrain(_transform__WEBPACK_IMPORTED_MODULE_7__["identity"].translate(p[0], p[1]).scale(t.k).translate( - typeof x === "function" ? -x.apply(this, arguments) : -x, - typeof y === "function" ? -y.apply(this, arguments) : -y - ), e, translateExtent); - }); - }; - - function scale(transform, k) { - k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], k)); - return k === transform.k ? transform : new _transform__WEBPACK_IMPORTED_MODULE_7__["Transform"](k, transform.x, transform.y); - } - - function translate(transform, p0, p1) { - var x = p0[0] - p1[0] * transform.k, y = p0[1] - p1[1] * transform.k; - return x === transform.x && y === transform.y ? transform : new _transform__WEBPACK_IMPORTED_MODULE_7__["Transform"](transform.k, x, y); - } - - function centroid(extent) { - return [(+extent[0][0] + +extent[1][0]) / 2, (+extent[0][1] + +extent[1][1]) / 2]; - } - - function schedule(transition, transform, center) { - transition - .on("start.zoom", function() { gesture(this, arguments).start(); }) - .on("interrupt.zoom end.zoom", function() { gesture(this, arguments).end(); }) - .tween("zoom", function() { - var that = this, - args = arguments, - g = gesture(that, args), - e = extent.apply(that, args), - p = center || centroid(e), - w = Math.max(e[1][0] - e[0][0], e[1][1] - e[0][1]), - a = that.__zoom, - b = typeof transform === "function" ? transform.apply(that, args) : transform, - i = interpolate(a.invert(p).concat(w / a.k), b.invert(p).concat(w / b.k)); - return function(t) { - if (t === 1) t = b; // Avoid rounding error on end. - else { var l = i(t), k = w / l[2]; t = new _transform__WEBPACK_IMPORTED_MODULE_7__["Transform"](k, p[0] - l[0] * k, p[1] - l[1] * k); } - g.zoom(null, t); - }; - }); - } - - function gesture(that, args) { - for (var i = 0, n = gestures.length, g; i < n; ++i) { - if ((g = gestures[i]).that === that) { - return g; - } - } - return new Gesture(that, args); - } - - function Gesture(that, args) { - this.that = that; - this.args = args; - this.index = -1; - this.active = 0; - this.extent = extent.apply(that, args); - } - - Gesture.prototype = { - start: function() { - if (++this.active === 1) { - this.index = gestures.push(this) - 1; - this.emit("start"); - } - return this; - }, - zoom: function(key, transform) { - if (this.mouse && key !== "mouse") this.mouse[1] = transform.invert(this.mouse[0]); - if (this.touch0 && key !== "touch") this.touch0[1] = transform.invert(this.touch0[0]); - if (this.touch1 && key !== "touch") this.touch1[1] = transform.invert(this.touch1[0]); - this.that.__zoom = transform; - this.emit("zoom"); - return this; - }, - end: function() { - if (--this.active === 0) { - gestures.splice(this.index, 1); - this.index = -1; - this.emit("end"); - } - return this; - }, - emit: function(type) { - Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["customEvent"])(new _event__WEBPACK_IMPORTED_MODULE_6__["default"](zoom, type, this.that.__zoom), listeners.apply, listeners, [type, this.that, this.args]); - } - }; - - function wheeled() { - if (!filter.apply(this, arguments)) return; - var g = gesture(this, arguments), - t = this.__zoom, - k = Math.max(scaleExtent[0], Math.min(scaleExtent[1], t.k * Math.pow(2, wheelDelta.apply(this, arguments)))), - p = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["mouse"])(this); - - // If the mouse is in the same location as before, reuse it. - // If there were recent wheel events, reset the wheel idle timeout. - if (g.wheel) { - if (g.mouse[0][0] !== p[0] || g.mouse[0][1] !== p[1]) { - g.mouse[1] = t.invert(g.mouse[0] = p); - } - clearTimeout(g.wheel); - } - - // If this wheel event won’t trigger a transform change, ignore it. - else if (t.k === k) return; - - // Otherwise, capture the mouse point and location at the start. - else { - g.mouse = [p, t.invert(p)]; - Object(d3_transition__WEBPACK_IMPORTED_MODULE_4__["interrupt"])(this); - g.start(); - } - - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["default"])(); - g.wheel = setTimeout(wheelidled, wheelDelay); - g.zoom("mouse", constrain(translate(scale(t, k), g.mouse[0], g.mouse[1]), g.extent, translateExtent)); - - function wheelidled() { - g.wheel = null; - g.end(); - } - } - - function mousedowned() { - if (touchending || !filter.apply(this, arguments)) return; - var g = gesture(this, arguments), - v = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].view).on("mousemove.zoom", mousemoved, true).on("mouseup.zoom", mouseupped, true), - p = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["mouse"])(this), - x0 = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].clientX, - y0 = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].clientY; - - Object(d3_drag__WEBPACK_IMPORTED_MODULE_1__["dragDisable"])(d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].view); - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["nopropagation"])(); - g.mouse = [p, this.__zoom.invert(p)]; - Object(d3_transition__WEBPACK_IMPORTED_MODULE_4__["interrupt"])(this); - g.start(); - - function mousemoved() { - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["default"])(); - if (!g.moved) { - var dx = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].clientX - x0, dy = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].clientY - y0; - g.moved = dx * dx + dy * dy > clickDistance2; - } - g.zoom("mouse", constrain(translate(g.that.__zoom, g.mouse[0] = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["mouse"])(g.that), g.mouse[1]), g.extent, translateExtent)); - } - - function mouseupped() { - v.on("mousemove.zoom mouseup.zoom", null); - Object(d3_drag__WEBPACK_IMPORTED_MODULE_1__["dragEnable"])(d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].view, g.moved); - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["default"])(); - g.end(); - } - } - - function dblclicked() { - if (!filter.apply(this, arguments)) return; - var t0 = this.__zoom, - p0 = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["mouse"])(this), - p1 = t0.invert(p0), - k1 = t0.k * (d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].shiftKey ? 0.5 : 2), - t1 = constrain(translate(scale(t0, k1), p0, p1), extent.apply(this, arguments), translateExtent); - - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["default"])(); - if (duration > 0) Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(this).transition().duration(duration).call(schedule, t1, p0); - else Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(this).call(zoom.transform, t1); - } - - function touchstarted() { - if (!filter.apply(this, arguments)) return; - var g = gesture(this, arguments), - touches = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].changedTouches, - started, - n = touches.length, i, t, p; - - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["nopropagation"])(); - for (i = 0; i < n; ++i) { - t = touches[i], p = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["touch"])(this, touches, t.identifier); - p = [p, this.__zoom.invert(p), t.identifier]; - if (!g.touch0) g.touch0 = p, started = true; - else if (!g.touch1) g.touch1 = p; - } - - // If this is a dbltap, reroute to the (optional) dblclick.zoom handler. - if (touchstarting) { - touchstarting = clearTimeout(touchstarting); - if (!g.touch1) { - g.end(); - p = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["select"])(this).on("dblclick.zoom"); - if (p) p.apply(this, arguments); - return; - } - } - - if (started) { - touchstarting = setTimeout(function() { touchstarting = null; }, touchDelay); - Object(d3_transition__WEBPACK_IMPORTED_MODULE_4__["interrupt"])(this); - g.start(); - } - } - - function touchmoved() { - var g = gesture(this, arguments), - touches = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].changedTouches, - n = touches.length, i, t, p, l; - - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["default"])(); - if (touchstarting) touchstarting = clearTimeout(touchstarting); - for (i = 0; i < n; ++i) { - t = touches[i], p = Object(d3_selection__WEBPACK_IMPORTED_MODULE_3__["touch"])(this, touches, t.identifier); - if (g.touch0 && g.touch0[2] === t.identifier) g.touch0[0] = p; - else if (g.touch1 && g.touch1[2] === t.identifier) g.touch1[0] = p; - } - t = g.that.__zoom; - if (g.touch1) { - var p0 = g.touch0[0], l0 = g.touch0[1], - p1 = g.touch1[0], l1 = g.touch1[1], - dp = (dp = p1[0] - p0[0]) * dp + (dp = p1[1] - p0[1]) * dp, - dl = (dl = l1[0] - l0[0]) * dl + (dl = l1[1] - l0[1]) * dl; - t = scale(t, Math.sqrt(dp / dl)); - p = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2]; - l = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2]; - } - else if (g.touch0) p = g.touch0[0], l = g.touch0[1]; - else return; - g.zoom("touch", constrain(translate(t, p, l), g.extent, translateExtent)); - } - - function touchended() { - var g = gesture(this, arguments), - touches = d3_selection__WEBPACK_IMPORTED_MODULE_3__["event"].changedTouches, - n = touches.length, i, t; - - Object(_noevent__WEBPACK_IMPORTED_MODULE_8__["nopropagation"])(); - if (touchending) clearTimeout(touchending); - touchending = setTimeout(function() { touchending = null; }, touchDelay); - for (i = 0; i < n; ++i) { - t = touches[i]; - if (g.touch0 && g.touch0[2] === t.identifier) delete g.touch0; - else if (g.touch1 && g.touch1[2] === t.identifier) delete g.touch1; - } - if (g.touch1 && !g.touch0) g.touch0 = g.touch1, delete g.touch1; - if (g.touch0) g.touch0[1] = this.__zoom.invert(g.touch0[0]); - else g.end(); - } - - zoom.wheelDelta = function(_) { - return arguments.length ? (wheelDelta = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_5__["default"])(+_), zoom) : wheelDelta; - }; - - zoom.filter = function(_) { - return arguments.length ? (filter = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_5__["default"])(!!_), zoom) : filter; - }; - - zoom.touchable = function(_) { - return arguments.length ? (touchable = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_5__["default"])(!!_), zoom) : touchable; - }; - - zoom.extent = function(_) { - return arguments.length ? (extent = typeof _ === "function" ? _ : Object(_constant__WEBPACK_IMPORTED_MODULE_5__["default"])([[+_[0][0], +_[0][1]], [+_[1][0], +_[1][1]]]), zoom) : extent; - }; - - zoom.scaleExtent = function(_) { - return arguments.length ? (scaleExtent[0] = +_[0], scaleExtent[1] = +_[1], zoom) : [scaleExtent[0], scaleExtent[1]]; - }; - - zoom.translateExtent = function(_) { - return arguments.length ? (translateExtent[0][0] = +_[0][0], translateExtent[1][0] = +_[1][0], translateExtent[0][1] = +_[0][1], translateExtent[1][1] = +_[1][1], zoom) : [[translateExtent[0][0], translateExtent[0][1]], [translateExtent[1][0], translateExtent[1][1]]]; - }; - - zoom.constrain = function(_) { - return arguments.length ? (constrain = _, zoom) : constrain; - }; - - zoom.duration = function(_) { - return arguments.length ? (duration = +_, zoom) : duration; - }; - - zoom.interpolate = function(_) { - return arguments.length ? (interpolate = _, zoom) : interpolate; - }; - - zoom.on = function() { - var value = listeners.on.apply(listeners, arguments); - return value === listeners ? zoom : value; - }; - - zoom.clickDistance = function(_) { - return arguments.length ? (clickDistance2 = (_ = +_) * _, zoom) : Math.sqrt(clickDistance2); - }; - - return zoom; -}); - - -/***/ }), - -/***/ "./node_modules/d3/dist/package.js": -/*!*****************************************!*\ - !*** ./node_modules/d3/dist/package.js ***! - \*****************************************/ -/*! exports provided: name, version, description, keywords, homepage, license, author, main, unpkg, jsdelivr, module, repository, scripts, devDependencies, dependencies */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "name", function() { return name; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "version", function() { return version; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "description", function() { return description; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "keywords", function() { return keywords; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "homepage", function() { return homepage; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "license", function() { return license; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "author", function() { return author; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "main", function() { return main; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "unpkg", function() { return unpkg; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "jsdelivr", function() { return jsdelivr; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "module", function() { return module; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "repository", function() { return repository; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scripts", function() { return scripts; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "devDependencies", function() { return devDependencies; }); -/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dependencies", function() { return dependencies; }); -var name = "d3"; -var version = "5.7.0"; -var description = "Data-Driven Documents"; -var keywords = ["dom","visualization","svg","animation","canvas"]; -var homepage = "https://d3js.org"; -var license = "BSD-3-Clause"; -var author = {"name":"Mike Bostock","url":"https://bost.ocks.org/mike"}; -var main = "dist/d3.node.js"; -var unpkg = "dist/d3.min.js"; -var jsdelivr = "dist/d3.min.js"; -var module = "index.js"; -var repository = {"type":"git","url":"https://github.com/d3/d3.git"}; -var scripts = {"pretest":"rimraf dist && mkdir dist && json2module package.json > dist/package.js && node rollup.node","test":"tape 'test/**/*-test.js'","prepublishOnly":"yarn test && rollup -c","postpublish":"git push && git push --tags && cd ../d3.github.com && git pull && cp ../d3/dist/d3.js d3.v5.js && cp ../d3/dist/d3.min.js d3.v5.min.js && git add d3.v5.js d3.v5.min.js && git commit -m \"d3 ${npm_package_version}\" && git push && cd - && cd ../d3-bower && git pull && cp ../d3/LICENSE ../d3/README.md ../d3/dist/d3.js ../d3/dist/d3.min.js . && git add -- LICENSE README.md d3.js d3.min.js && git commit -m \"${npm_package_version}\" && git tag -am \"${npm_package_version}\" v${npm_package_version} && git push && git push --tags && cd - && zip -j dist/d3.zip -- LICENSE README.md API.md CHANGES.md dist/d3.js dist/d3.min.js"}; -var devDependencies = {"json2module":"0.0","rimraf":"2","rollup":"0.64","rollup-plugin-ascii":"0.0","rollup-plugin-node-resolve":"3","rollup-plugin-terser":"1","tape":"4"}; -var dependencies = {"d3-array":"1","d3-axis":"1","d3-brush":"1","d3-chord":"1","d3-collection":"1","d3-color":"1","d3-contour":"1","d3-dispatch":"1","d3-drag":"1","d3-dsv":"1","d3-ease":"1","d3-fetch":"1","d3-force":"1","d3-format":"1","d3-geo":"1","d3-hierarchy":"1","d3-interpolate":"1","d3-path":"1","d3-polygon":"1","d3-quadtree":"1","d3-random":"1","d3-scale":"2","d3-scale-chromatic":"1","d3-selection":"1","d3-shape":"1","d3-time":"1","d3-time-format":"2","d3-timer":"1","d3-transition":"1","d3-voronoi":"1","d3-zoom":"1"}; - - -/***/ }), - -/***/ "./node_modules/d3/index.js": -/*!**********************************!*\ - !*** ./node_modules/d3/index.js ***! - \**********************************/ -/*! exports provided: version, bisect, bisectRight, bisectLeft, ascending, bisector, cross, descending, deviation, extent, histogram, thresholdFreedmanDiaconis, thresholdScott, thresholdSturges, max, mean, median, merge, min, pairs, permute, quantile, range, scan, shuffle, sum, ticks, tickIncrement, tickStep, transpose, variance, zip, axisTop, axisRight, axisBottom, axisLeft, brush, brushX, brushY, brushSelection, chord, ribbon, nest, set, map, keys, values, entries, color, rgb, hsl, lab, hcl, lch, gray, cubehelix, contours, contourDensity, dispatch, drag, dragDisable, dragEnable, dsvFormat, csvParse, csvParseRows, csvFormat, csvFormatRows, tsvParse, tsvParseRows, tsvFormat, tsvFormatRows, easeLinear, easeQuad, easeQuadIn, easeQuadOut, easeQuadInOut, easeCubic, easeCubicIn, easeCubicOut, easeCubicInOut, easePoly, easePolyIn, easePolyOut, easePolyInOut, easeSin, easeSinIn, easeSinOut, easeSinInOut, easeExp, easeExpIn, easeExpOut, easeExpInOut, easeCircle, easeCircleIn, easeCircleOut, easeCircleInOut, easeBounce, easeBounceIn, easeBounceOut, easeBounceInOut, easeBack, easeBackIn, easeBackOut, easeBackInOut, easeElastic, easeElasticIn, easeElasticOut, easeElasticInOut, blob, buffer, dsv, csv, tsv, image, json, text, xml, html, svg, forceCenter, forceCollide, forceLink, forceManyBody, forceRadial, forceSimulation, forceX, forceY, formatDefaultLocale, format, formatPrefix, formatLocale, formatSpecifier, precisionFixed, precisionPrefix, precisionRound, geoArea, geoBounds, geoCentroid, geoCircle, geoClipAntimeridian, geoClipCircle, geoClipExtent, geoClipRectangle, geoContains, geoDistance, geoGraticule, geoGraticule10, geoInterpolate, geoLength, geoPath, geoAlbers, geoAlbersUsa, geoAzimuthalEqualArea, geoAzimuthalEqualAreaRaw, geoAzimuthalEquidistant, geoAzimuthalEquidistantRaw, geoConicConformal, geoConicConformalRaw, geoConicEqualArea, geoConicEqualAreaRaw, geoConicEquidistant, geoConicEquidistantRaw, geoEqualEarth, geoEqualEarthRaw, geoEquirectangular, geoEquirectangularRaw, geoGnomonic, geoGnomonicRaw, geoIdentity, geoProjection, geoProjectionMutator, geoMercator, geoMercatorRaw, geoNaturalEarth1, geoNaturalEarth1Raw, geoOrthographic, geoOrthographicRaw, geoStereographic, geoStereographicRaw, geoTransverseMercator, geoTransverseMercatorRaw, geoRotation, geoStream, geoTransform, cluster, hierarchy, pack, packSiblings, packEnclose, partition, stratify, tree, treemap, treemapBinary, treemapDice, treemapSlice, treemapSliceDice, treemapSquarify, treemapResquarify, interpolate, interpolateArray, interpolateBasis, interpolateBasisClosed, interpolateDate, interpolateDiscrete, interpolateHue, interpolateNumber, interpolateObject, interpolateRound, interpolateString, interpolateTransformCss, interpolateTransformSvg, interpolateZoom, interpolateRgb, interpolateRgbBasis, interpolateRgbBasisClosed, interpolateHsl, interpolateHslLong, interpolateLab, interpolateHcl, interpolateHclLong, interpolateCubehelix, interpolateCubehelixLong, piecewise, quantize, path, polygonArea, polygonCentroid, polygonHull, polygonContains, polygonLength, quadtree, randomUniform, randomNormal, randomLogNormal, randomBates, randomIrwinHall, randomExponential, scaleBand, scalePoint, scaleIdentity, scaleLinear, scaleLog, scaleOrdinal, scaleImplicit, scalePow, scaleSqrt, scaleQuantile, scaleQuantize, scaleThreshold, scaleTime, scaleUtc, scaleSequential, scaleDiverging, schemeCategory10, schemeAccent, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, interpolateBrBG, schemeBrBG, interpolatePRGn, schemePRGn, interpolatePiYG, schemePiYG, interpolatePuOr, schemePuOr, interpolateRdBu, schemeRdBu, interpolateRdGy, schemeRdGy, interpolateRdYlBu, schemeRdYlBu, interpolateRdYlGn, schemeRdYlGn, interpolateSpectral, schemeSpectral, interpolateBuGn, schemeBuGn, interpolateBuPu, schemeBuPu, interpolateGnBu, schemeGnBu, interpolateOrRd, schemeOrRd, interpolatePuBuGn, schemePuBuGn, interpolatePuBu, schemePuBu, interpolatePuRd, schemePuRd, interpolateRdPu, schemeRdPu, interpolateYlGnBu, schemeYlGnBu, interpolateYlGn, schemeYlGn, interpolateYlOrBr, schemeYlOrBr, interpolateYlOrRd, schemeYlOrRd, interpolateBlues, schemeBlues, interpolateGreens, schemeGreens, interpolateGreys, schemeGreys, interpolatePurples, schemePurples, interpolateReds, schemeReds, interpolateOranges, schemeOranges, interpolateCubehelixDefault, interpolateRainbow, interpolateWarm, interpolateCool, interpolateSinebow, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma, create, creator, local, matcher, mouse, namespace, namespaces, clientPoint, select, selectAll, selection, selector, selectorAll, style, touch, touches, window, event, customEvent, arc, area, line, pie, areaRadial, radialArea, lineRadial, radialLine, pointRadial, linkHorizontal, linkVertical, linkRadial, symbol, symbols, symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye, curveBasisClosed, curveBasisOpen, curveBasis, curveBundle, curveCardinalClosed, curveCardinalOpen, curveCardinal, curveCatmullRomClosed, curveCatmullRomOpen, curveCatmullRom, curveLinearClosed, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, stack, stackOffsetExpand, stackOffsetDiverging, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAscending, stackOrderDescending, stackOrderInsideOut, stackOrderNone, stackOrderReverse, timeInterval, timeMillisecond, timeMilliseconds, utcMillisecond, utcMilliseconds, timeSecond, timeSeconds, utcSecond, utcSeconds, timeMinute, timeMinutes, timeHour, timeHours, timeDay, timeDays, timeWeek, timeWeeks, timeSunday, timeSundays, timeMonday, timeMondays, timeTuesday, timeTuesdays, timeWednesday, timeWednesdays, timeThursday, timeThursdays, timeFriday, timeFridays, timeSaturday, timeSaturdays, timeMonth, timeMonths, timeYear, timeYears, utcMinute, utcMinutes, utcHour, utcHours, utcDay, utcDays, utcWeek, utcWeeks, utcSunday, utcSundays, utcMonday, utcMondays, utcTuesday, utcTuesdays, utcWednesday, utcWednesdays, utcThursday, utcThursdays, utcFriday, utcFridays, utcSaturday, utcSaturdays, utcMonth, utcMonths, utcYear, utcYears, timeFormatDefaultLocale, timeFormat, timeParse, utcFormat, utcParse, timeFormatLocale, isoFormat, isoParse, now, timer, timerFlush, timeout, interval, transition, active, interrupt, voronoi, zoom, zoomTransform, zoomIdentity */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _dist_package__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dist/package */ "./node_modules/d3/dist/package.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "version", function() { return _dist_package__WEBPACK_IMPORTED_MODULE_0__["version"]; }); - -/* harmony import */ var d3_array__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! d3-array */ "./node_modules/d3-array/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisect", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["bisect"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisectRight", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["bisectRight"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisectLeft", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["bisectLeft"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ascending", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["ascending"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "bisector", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["bisector"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cross", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["cross"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "descending", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["descending"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "deviation", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["deviation"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "extent", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["extent"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "histogram", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["histogram"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "thresholdFreedmanDiaconis", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["thresholdFreedmanDiaconis"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "thresholdScott", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["thresholdScott"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "thresholdSturges", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["thresholdSturges"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "max", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["max"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "mean", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["mean"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "median", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["median"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "merge", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["merge"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "min", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["min"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pairs", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["pairs"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "permute", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["permute"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "quantile", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["quantile"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "range", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["range"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scan", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["scan"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "shuffle", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["shuffle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "sum", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["sum"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ticks", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["ticks"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tickIncrement", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["tickIncrement"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tickStep", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["tickStep"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "transpose", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["transpose"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "variance", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["variance"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zip", function() { return d3_array__WEBPACK_IMPORTED_MODULE_1__["zip"]; }); - -/* harmony import */ var d3_axis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! d3-axis */ "./node_modules/d3-axis/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisTop", function() { return d3_axis__WEBPACK_IMPORTED_MODULE_2__["axisTop"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisRight", function() { return d3_axis__WEBPACK_IMPORTED_MODULE_2__["axisRight"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisBottom", function() { return d3_axis__WEBPACK_IMPORTED_MODULE_2__["axisBottom"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "axisLeft", function() { return d3_axis__WEBPACK_IMPORTED_MODULE_2__["axisLeft"]; }); - -/* harmony import */ var d3_brush__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! d3-brush */ "./node_modules/d3-brush/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brush", function() { return d3_brush__WEBPACK_IMPORTED_MODULE_3__["brush"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brushX", function() { return d3_brush__WEBPACK_IMPORTED_MODULE_3__["brushX"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brushY", function() { return d3_brush__WEBPACK_IMPORTED_MODULE_3__["brushY"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "brushSelection", function() { return d3_brush__WEBPACK_IMPORTED_MODULE_3__["brushSelection"]; }); - -/* harmony import */ var d3_chord__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! d3-chord */ "./node_modules/d3-chord/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "chord", function() { return d3_chord__WEBPACK_IMPORTED_MODULE_4__["chord"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ribbon", function() { return d3_chord__WEBPACK_IMPORTED_MODULE_4__["ribbon"]; }); - -/* harmony import */ var d3_collection__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! d3-collection */ "./node_modules/d3-collection/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "nest", function() { return d3_collection__WEBPACK_IMPORTED_MODULE_5__["nest"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "set", function() { return d3_collection__WEBPACK_IMPORTED_MODULE_5__["set"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "map", function() { return d3_collection__WEBPACK_IMPORTED_MODULE_5__["map"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "keys", function() { return d3_collection__WEBPACK_IMPORTED_MODULE_5__["keys"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "values", function() { return d3_collection__WEBPACK_IMPORTED_MODULE_5__["values"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "entries", function() { return d3_collection__WEBPACK_IMPORTED_MODULE_5__["entries"]; }); - -/* harmony import */ var d3_color__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! d3-color */ "./node_modules/d3-color/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "color", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["color"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "rgb", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["rgb"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hsl", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["hsl"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "lab", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["lab"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hcl", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["hcl"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "lch", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["lch"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "gray", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["gray"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cubehelix", function() { return d3_color__WEBPACK_IMPORTED_MODULE_6__["cubehelix"]; }); - -/* harmony import */ var d3_contour__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! d3-contour */ "./node_modules/d3-contour/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "contours", function() { return d3_contour__WEBPACK_IMPORTED_MODULE_7__["contours"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "contourDensity", function() { return d3_contour__WEBPACK_IMPORTED_MODULE_7__["contourDensity"]; }); - -/* harmony import */ var d3_dispatch__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! d3-dispatch */ "./node_modules/d3-dispatch/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dispatch", function() { return d3_dispatch__WEBPACK_IMPORTED_MODULE_8__["dispatch"]; }); - -/* harmony import */ var d3_drag__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! d3-drag */ "./node_modules/d3-drag/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "drag", function() { return d3_drag__WEBPACK_IMPORTED_MODULE_9__["drag"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dragDisable", function() { return d3_drag__WEBPACK_IMPORTED_MODULE_9__["dragDisable"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dragEnable", function() { return d3_drag__WEBPACK_IMPORTED_MODULE_9__["dragEnable"]; }); - -/* harmony import */ var d3_dsv__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! d3-dsv */ "./node_modules/d3-dsv/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dsvFormat", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["dsvFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvParse", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["csvParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvParseRows", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["csvParseRows"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvFormat", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["csvFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csvFormatRows", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["csvFormatRows"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvParse", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["tsvParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvParseRows", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["tsvParseRows"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvFormat", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["tsvFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsvFormatRows", function() { return d3_dsv__WEBPACK_IMPORTED_MODULE_10__["tsvFormatRows"]; }); - -/* harmony import */ var d3_ease__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! d3-ease */ "./node_modules/d3-ease/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeLinear", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeLinear"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuad", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeQuad"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuadIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeQuadIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuadOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeQuadOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeQuadInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeQuadInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubic", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCubic"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubicIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCubicIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubicOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCubicOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCubicInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCubicInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePoly", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easePoly"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePolyIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easePolyIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePolyOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easePolyOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easePolyInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easePolyInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSin", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeSin"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSinIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeSinIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSinOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeSinOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeSinInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeSinInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExp", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeExp"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExpIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeExpIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExpOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeExpOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeExpInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeExpInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircle", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCircle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircleIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCircleIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircleOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCircleOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeCircleInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeCircleInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounce", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBounce"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounceIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBounceIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounceOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBounceOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBounceInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBounceInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBack", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBack"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBackIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBackIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBackOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBackOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeBackInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeBackInOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElastic", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeElastic"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElasticIn", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeElasticIn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElasticOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeElasticOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "easeElasticInOut", function() { return d3_ease__WEBPACK_IMPORTED_MODULE_11__["easeElasticInOut"]; }); - -/* harmony import */ var d3_fetch__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! d3-fetch */ "./node_modules/d3-fetch/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "blob", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["blob"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "buffer", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["buffer"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "dsv", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["dsv"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "csv", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["csv"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tsv", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["tsv"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "image", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["image"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "json", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["json"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "text", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["text"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "xml", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["xml"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "html", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["html"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "svg", function() { return d3_fetch__WEBPACK_IMPORTED_MODULE_12__["svg"]; }); - -/* harmony import */ var d3_force__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! d3-force */ "./node_modules/d3-force/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceCenter", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceCenter"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceCollide", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceCollide"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceLink", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceLink"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceManyBody", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceManyBody"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceRadial", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceRadial"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceSimulation", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceSimulation"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceX", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceX"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "forceY", function() { return d3_force__WEBPACK_IMPORTED_MODULE_13__["forceY"]; }); - -/* harmony import */ var d3_format__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! d3-format */ "./node_modules/d3-format/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatDefaultLocale", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["formatDefaultLocale"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "format", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["format"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatPrefix", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["formatPrefix"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatLocale", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["formatLocale"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "formatSpecifier", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["formatSpecifier"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "precisionFixed", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["precisionFixed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "precisionPrefix", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["precisionPrefix"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "precisionRound", function() { return d3_format__WEBPACK_IMPORTED_MODULE_14__["precisionRound"]; }); - -/* harmony import */ var d3_geo__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! d3-geo */ "./node_modules/d3-geo/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoArea", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoArea"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoBounds", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoBounds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoCentroid", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoCentroid"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoCircle", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoCircle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipAntimeridian", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoClipAntimeridian"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipCircle", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoClipCircle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipExtent", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoClipExtent"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoClipRectangle", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoClipRectangle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoContains", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoContains"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoDistance", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoDistance"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGraticule", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoGraticule"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGraticule10", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoGraticule10"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoInterpolate", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoInterpolate"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoLength", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoLength"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoPath", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoPath"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAlbers", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoAlbers"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAlbersUsa", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoAlbersUsa"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEqualArea", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoAzimuthalEqualArea"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEqualAreaRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoAzimuthalEqualAreaRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEquidistant", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoAzimuthalEquidistant"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoAzimuthalEquidistantRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoAzimuthalEquidistantRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicConformal", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoConicConformal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicConformalRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoConicConformalRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEqualArea", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoConicEqualArea"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEqualAreaRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoConicEqualAreaRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEquidistant", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoConicEquidistant"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoConicEquidistantRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoConicEquidistantRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEqualEarth", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoEqualEarth"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEqualEarthRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoEqualEarthRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEquirectangular", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoEquirectangular"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoEquirectangularRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoEquirectangularRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGnomonic", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoGnomonic"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoGnomonicRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoGnomonicRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoIdentity", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoIdentity"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoProjection", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoProjection"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoProjectionMutator", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoProjectionMutator"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoMercator", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoMercator"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoMercatorRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoMercatorRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoNaturalEarth1", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoNaturalEarth1"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoNaturalEarth1Raw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoNaturalEarth1Raw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoOrthographic", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoOrthographic"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoOrthographicRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoOrthographicRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoStereographic", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoStereographic"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoStereographicRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoStereographicRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoTransverseMercator", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoTransverseMercator"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoTransverseMercatorRaw", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoTransverseMercatorRaw"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoRotation", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoRotation"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoStream", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoStream"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "geoTransform", function() { return d3_geo__WEBPACK_IMPORTED_MODULE_15__["geoTransform"]; }); - -/* harmony import */ var d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! d3-hierarchy */ "./node_modules/d3-hierarchy/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "cluster", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["cluster"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "hierarchy", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["hierarchy"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pack", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["pack"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "packSiblings", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["packSiblings"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "packEnclose", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["packEnclose"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "partition", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["partition"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stratify", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["stratify"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "tree", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["tree"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemap", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemap"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapBinary", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemapBinary"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapDice", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemapDice"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSlice", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemapSlice"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSliceDice", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemapSliceDice"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapSquarify", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemapSquarify"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "treemapResquarify", function() { return d3_hierarchy__WEBPACK_IMPORTED_MODULE_16__["treemapResquarify"]; }); - -/* harmony import */ var d3_interpolate__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! d3-interpolate */ "./node_modules/d3-interpolate/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolate", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolate"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateArray", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateArray"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBasis", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateBasis"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBasisClosed", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateBasisClosed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateDate", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateDate"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateDiscrete", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateDiscrete"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHue", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateHue"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateNumber", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateNumber"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateObject", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateObject"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRound", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateRound"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateString", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateString"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateTransformCss", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateTransformCss"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateTransformSvg", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateTransformSvg"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateZoom", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateZoom"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRgb", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateRgb"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRgbBasis", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateRgbBasis"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRgbBasisClosed", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateRgbBasisClosed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHsl", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateHsl"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHslLong", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateHslLong"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateLab", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateLab"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHcl", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateHcl"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateHclLong", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateHclLong"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCubehelix", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateCubehelix"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCubehelixLong", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["interpolateCubehelixLong"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "piecewise", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["piecewise"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "quantize", function() { return d3_interpolate__WEBPACK_IMPORTED_MODULE_17__["quantize"]; }); - -/* harmony import */ var d3_path__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! d3-path */ "./node_modules/d3-path/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "path", function() { return d3_path__WEBPACK_IMPORTED_MODULE_18__["path"]; }); - -/* harmony import */ var d3_polygon__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! d3-polygon */ "./node_modules/d3-polygon/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonArea", function() { return d3_polygon__WEBPACK_IMPORTED_MODULE_19__["polygonArea"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonCentroid", function() { return d3_polygon__WEBPACK_IMPORTED_MODULE_19__["polygonCentroid"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonHull", function() { return d3_polygon__WEBPACK_IMPORTED_MODULE_19__["polygonHull"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonContains", function() { return d3_polygon__WEBPACK_IMPORTED_MODULE_19__["polygonContains"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "polygonLength", function() { return d3_polygon__WEBPACK_IMPORTED_MODULE_19__["polygonLength"]; }); - -/* harmony import */ var d3_quadtree__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! d3-quadtree */ "./node_modules/d3-quadtree/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "quadtree", function() { return d3_quadtree__WEBPACK_IMPORTED_MODULE_20__["quadtree"]; }); - -/* harmony import */ var d3_random__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! d3-random */ "./node_modules/d3-random/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomUniform", function() { return d3_random__WEBPACK_IMPORTED_MODULE_21__["randomUniform"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomNormal", function() { return d3_random__WEBPACK_IMPORTED_MODULE_21__["randomNormal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomLogNormal", function() { return d3_random__WEBPACK_IMPORTED_MODULE_21__["randomLogNormal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomBates", function() { return d3_random__WEBPACK_IMPORTED_MODULE_21__["randomBates"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomIrwinHall", function() { return d3_random__WEBPACK_IMPORTED_MODULE_21__["randomIrwinHall"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "randomExponential", function() { return d3_random__WEBPACK_IMPORTED_MODULE_21__["randomExponential"]; }); - -/* harmony import */ var d3_scale__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! d3-scale */ "./node_modules/d3-scale/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleBand", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleBand"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scalePoint", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scalePoint"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleIdentity", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleIdentity"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleLinear", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleLinear"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleLog", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleLog"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleOrdinal", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleOrdinal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleImplicit", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleImplicit"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scalePow", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scalePow"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleSqrt", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleSqrt"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleQuantile", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleQuantile"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleQuantize", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleQuantize"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleThreshold", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleThreshold"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleTime", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleTime"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleUtc", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleUtc"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleSequential", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleSequential"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "scaleDiverging", function() { return d3_scale__WEBPACK_IMPORTED_MODULE_22__["scaleDiverging"]; }); - -/* harmony import */ var d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! d3-scale-chromatic */ "./node_modules/d3-scale-chromatic/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeCategory10", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeCategory10"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeAccent", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeAccent"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeDark2", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeDark2"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePaired", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePaired"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePastel1", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePastel1"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePastel2", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePastel2"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSet1", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeSet1"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSet2", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeSet2"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSet3", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeSet3"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBrBG", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateBrBG"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBrBG", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeBrBG"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePRGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePRGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePRGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePRGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePiYG", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePiYG"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePiYG", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePiYG"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuOr", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePuOr"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuOr", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePuOr"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateRdBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeRdBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdGy", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateRdGy"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdGy", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeRdGy"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdYlBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateRdYlBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdYlBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeRdYlBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdYlGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateRdYlGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdYlGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeRdYlGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateSpectral", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateSpectral"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeSpectral", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeSpectral"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBuGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateBuGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBuGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeBuGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBuPu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateBuPu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBuPu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeBuPu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateGnBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateGnBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeGnBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeGnBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateOrRd", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateOrRd"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeOrRd", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeOrRd"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuBuGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePuBuGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuBuGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePuBuGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePuBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePuBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePuRd", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePuRd"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePuRd", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePuRd"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRdPu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateRdPu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeRdPu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeRdPu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlGnBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateYlGnBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlGnBu", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeYlGnBu"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateYlGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlGn", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeYlGn"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlOrBr", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateYlOrBr"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlOrBr", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeYlOrBr"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateYlOrRd", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateYlOrRd"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeYlOrRd", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeYlOrRd"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateBlues", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateBlues"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeBlues", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeBlues"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateGreens", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateGreens"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeGreens", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeGreens"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateGreys", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateGreys"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeGreys", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeGreys"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePurples", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePurples"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemePurples", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemePurples"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateReds", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateReds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeReds", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeReds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateOranges", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateOranges"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "schemeOranges", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["schemeOranges"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCubehelixDefault", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateCubehelixDefault"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateRainbow", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateRainbow"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateWarm", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateWarm"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateCool", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateCool"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateSinebow", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateSinebow"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateViridis", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateViridis"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateMagma", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateMagma"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolateInferno", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolateInferno"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interpolatePlasma", function() { return d3_scale_chromatic__WEBPACK_IMPORTED_MODULE_23__["interpolatePlasma"]; }); - -/* harmony import */ var d3_selection__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! d3-selection */ "./node_modules/d3-selection/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "create", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["create"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "creator", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["creator"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "local", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["local"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "matcher", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["matcher"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "mouse", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["mouse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "namespace", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["namespace"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "namespaces", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["namespaces"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "clientPoint", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["clientPoint"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "select", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["select"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selectAll", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["selectAll"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selection", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["selection"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selector", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["selector"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "selectorAll", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["selectorAll"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "style", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["style"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "touch", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["touch"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "touches", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["touches"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "window", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["window"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "event", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["event"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "customEvent", function() { return d3_selection__WEBPACK_IMPORTED_MODULE_24__["customEvent"]; }); - -/* harmony import */ var d3_shape__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! d3-shape */ "./node_modules/d3-shape/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "arc", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["arc"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "area", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["area"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "line", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["line"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pie", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["pie"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "areaRadial", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["areaRadial"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "radialArea", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["radialArea"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "lineRadial", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["lineRadial"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "radialLine", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["radialLine"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "pointRadial", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["pointRadial"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "linkHorizontal", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["linkHorizontal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "linkVertical", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["linkVertical"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "linkRadial", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["linkRadial"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbol", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbol"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbols", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbols"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolCircle", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolCircle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolCross", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolCross"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolDiamond", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolDiamond"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolSquare", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolSquare"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolStar", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolStar"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolTriangle", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolTriangle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "symbolWye", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["symbolWye"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBasisClosed", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveBasisClosed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBasisOpen", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveBasisOpen"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBasis", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveBasis"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveBundle", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveBundle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCardinalClosed", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveCardinalClosed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCardinalOpen", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveCardinalOpen"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCardinal", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveCardinal"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCatmullRomClosed", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveCatmullRomClosed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCatmullRomOpen", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveCatmullRomOpen"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveCatmullRom", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveCatmullRom"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveLinearClosed", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveLinearClosed"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveLinear", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveLinear"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveMonotoneX", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveMonotoneX"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveMonotoneY", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveMonotoneY"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveNatural", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveNatural"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveStep", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveStep"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveStepAfter", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveStepAfter"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "curveStepBefore", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["curveStepBefore"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stack", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stack"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetExpand", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOffsetExpand"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetDiverging", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOffsetDiverging"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetNone", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOffsetNone"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetSilhouette", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOffsetSilhouette"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOffsetWiggle", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOffsetWiggle"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderAscending", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOrderAscending"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderDescending", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOrderDescending"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderInsideOut", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOrderInsideOut"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderNone", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOrderNone"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "stackOrderReverse", function() { return d3_shape__WEBPACK_IMPORTED_MODULE_25__["stackOrderReverse"]; }); - -/* harmony import */ var d3_time__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! d3-time */ "./node_modules/d3-time/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeInterval", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeInterval"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMillisecond", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMillisecond"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMilliseconds", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMilliseconds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMillisecond", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMillisecond"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMilliseconds", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMilliseconds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSecond", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeSecond"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSeconds", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeSeconds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSecond", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcSecond"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSeconds", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcSeconds"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMinute", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMinute"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMinutes", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMinutes"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeHour", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeHour"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeHours", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeHours"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeDay", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeDay"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeDays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeDays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWeek", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeWeek"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWeeks", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeWeeks"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSunday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeSunday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSundays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeSundays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMonday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMonday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMondays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMondays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeTuesday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeTuesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeTuesdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeTuesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWednesday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeWednesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeWednesdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeWednesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeThursday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeThursday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeThursdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeThursdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFriday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeFriday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFridays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeFridays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSaturday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeSaturday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeSaturdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeSaturdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMonth", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMonth"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeMonths", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeMonths"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeYear", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeYear"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeYears", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["timeYears"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMinute", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMinute"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMinutes", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMinutes"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcHour", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcHour"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcHours", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcHours"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcDay", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcDay"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcDays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcDays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWeek", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcWeek"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWeeks", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcWeeks"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSunday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcSunday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSundays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcSundays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMonday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMonday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMondays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMondays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcTuesday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcTuesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcTuesdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcTuesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWednesday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcWednesday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcWednesdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcWednesdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcThursday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcThursday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcThursdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcThursdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcFriday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcFriday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcFridays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcFridays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSaturday", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcSaturday"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcSaturdays", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcSaturdays"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMonth", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMonth"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcMonths", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcMonths"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcYear", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcYear"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcYears", function() { return d3_time__WEBPACK_IMPORTED_MODULE_26__["utcYears"]; }); - -/* harmony import */ var d3_time_format__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! d3-time-format */ "./node_modules/d3-time-format/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFormatDefaultLocale", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["timeFormatDefaultLocale"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFormat", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["timeFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeParse", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["timeParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcFormat", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["utcFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "utcParse", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["utcParse"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeFormatLocale", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["timeFormatLocale"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isoFormat", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["isoFormat"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isoParse", function() { return d3_time_format__WEBPACK_IMPORTED_MODULE_27__["isoParse"]; }); - -/* harmony import */ var d3_timer__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! d3-timer */ "./node_modules/d3-timer/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "now", function() { return d3_timer__WEBPACK_IMPORTED_MODULE_28__["now"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timer", function() { return d3_timer__WEBPACK_IMPORTED_MODULE_28__["timer"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timerFlush", function() { return d3_timer__WEBPACK_IMPORTED_MODULE_28__["timerFlush"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "timeout", function() { return d3_timer__WEBPACK_IMPORTED_MODULE_28__["timeout"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interval", function() { return d3_timer__WEBPACK_IMPORTED_MODULE_28__["interval"]; }); - -/* harmony import */ var d3_transition__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! d3-transition */ "./node_modules/d3-transition/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "transition", function() { return d3_transition__WEBPACK_IMPORTED_MODULE_29__["transition"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "active", function() { return d3_transition__WEBPACK_IMPORTED_MODULE_29__["active"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "interrupt", function() { return d3_transition__WEBPACK_IMPORTED_MODULE_29__["interrupt"]; }); - -/* harmony import */ var d3_voronoi__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! d3-voronoi */ "./node_modules/d3-voronoi/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "voronoi", function() { return d3_voronoi__WEBPACK_IMPORTED_MODULE_30__["voronoi"]; }); - -/* harmony import */ var d3_zoom__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! d3-zoom */ "./node_modules/d3-zoom/src/index.js"); -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zoom", function() { return d3_zoom__WEBPACK_IMPORTED_MODULE_31__["zoom"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zoomTransform", function() { return d3_zoom__WEBPACK_IMPORTED_MODULE_31__["zoomTransform"]; }); - -/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "zoomIdentity", function() { return d3_zoom__WEBPACK_IMPORTED_MODULE_31__["zoomIdentity"]; }); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -/***/ }), - -/***/ "./node_modules/dagre-d3-renderer/dist/dagre-d3.core.js": -/*!**************************************************************!*\ - !*** ./node_modules/dagre-d3-renderer/dist/dagre-d3.core.js ***! - \**************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -module.exports=function(t){var e={};function a(r){if(e[r])return e[r].exports;var n=e[r]={i:r,l:!1,exports:{}};return t[r].call(n.exports,n,n.exports,a),n.l=!0,n.exports}return a.m=t,a.c=e,a.d=function(t,e,r){a.o(t,e)||Object.defineProperty(t,e,{configurable:!1,enumerable:!0,get:r})},a.r=function(t){Object.defineProperty(t,"__esModule",{value:!0})},a.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return a.d(e,"a",e),e},a.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},a.p="",a.w={},a(a.s=25)}([function(t,e,a){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var r,n=a(2),l=(r=n)&&r.__esModule?r:{default:r};var u=/:/g;function i(t){return t?String(t).replace(u,"\\:"):""}e.default={isSubgraph:function(t,e){return!!t.children(e).length},edgeToId:function(t){return i(t.v)+":"+i(t.w)+":"+i(t.name)},applyStyle:function(t,e){e&&t.attr("style",e)},applyClass:function(t,e,a){e&&t.attr("class",e).attr("class",a+" "+t.attr("class"))},applyTransition:function(t,e){var a=e.graph();if(l.default.isPlainObject(a)){var r=a.transition;if(l.default.isFunction(r))return r(t)}return t}}},function(t,e){t.exports=__webpack_require__(/*! d3 */ "./node_modules/d3/index.js")},function(t,e){t.exports=__webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js")},function(t,e,a){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var r=u(a(16)),n=u(a(15)),l=u(a(14));function u(t){return t&&t.__esModule?t:{default:t}}e.default=function(t,e,a){var u=e.label,i=t.append("g");"svg"===e.labelType?(0,l.default)(i,e):"string"!=typeof u||"html"===e.labelType?(0,n.default)(i,e):(0,r.default)(i,e);var d=i.node().getBBox(),o=void 0;switch(a){case"top":o=-e.height/2;break;case"bottom":o=e.height/2-d.height;break;default:o=-d.height/2}return i.attr("transform","translate("+-d.width/2+","+o+")"),i}},function(t,e,a){"use strict";Object.defineProperty(e,"__esModule",{value:!0}),e.default=function(t,e,a,r){var n=t.x,l=t.y,u=n-r.x,i=l-r.y,d=Math.sqrt(e*e*i*i+a*a*u*u),o=Math.abs(e*a*u/d);r.xMath.abs(n)*i?(l<0&&(i=-i),d=0===l?0:i*n/l,o=i):(n<0&&(u=-u),d=u,o=0===n?0:u*l/n),{x:a+d,y:r+o}}},function(t,e,a){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var r,n=a(23),l=(r=n)&&r.__esModule?r:{default:r};e.default=function(t,e,a){var r=t.x,n=t.y,u=[],i=Number.POSITIVE_INFINITY,d=Number.POSITIVE_INFINITY;e.forEach(function(t){i=Math.min(i,t.x),d=Math.min(d,t.y)});for(var o=r-t.width/2-i,s=n-t.height/2-d,f=0;f1&&u.sort(function(t,e){var r=t.x-a.x,n=t.y-a.y,l=Math.sqrt(r*r+n*n),u=e.x-a.x,i=e.y-a.y,d=Math.sqrt(u*u+i*i);return l0}Object.defineProperty(e,"__esModule",{value:!0}),e.default=function(t,e,a,n){var l=e.y-t.y,u=t.x-e.x,i=e.x*t.y-t.x*e.y,d=l*a.x+u*a.y+i,o=l*n.x+u*n.y+i;if(0===d||0===o||!r(d,o)){var s=n.y-a.y,f=a.x-n.x,c=n.x*a.y-a.x*n.y,h=s*t.x+f*t.y+c,p=s*e.x+f*e.y+c;if(0===h||0===p||!r(h,p)){var y=l*f-s*u;if(0!==y){var g=Math.abs(y/2),v=u*c-f*i;return{x:v<0?(v-g)/y:(v+g)/y,y:(v=s*i-l*c)<0?(v-g)/y:(v+g)/y}}}}}},function(t,e,a){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var r=d(a(8)),n=d(a(7)),l=d(a(4)),u=d(a(6)),i=d(a(5));function d(t){return t&&t.__esModule?t:{default:t}}e.default={node:r.default,circle:n.default,ellipse:l.default,polygon:u.default,rect:i.default}},function(t,e,a){"use strict";Object.defineProperty(e,"__esModule",{value:!0});var r=u(a(24)),n=u(a(22)),l=u(a(0));function u(t){return t&&t.__esModule?t:{default:t}}e.default={intersect:r.default,render:n.default,util:l.default}}]); -//# sourceMappingURL=dagre-d3.core.js.map - -/***/ }), - -/***/ "./node_modules/dagre-d3-renderer/lib/label/add-html-label.js": -/*!********************************************************************!*\ - !*** ./node_modules/dagre-d3-renderer/lib/label/add-html-label.js ***! - \********************************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../util */ "./node_modules/dagre-d3-renderer/lib/util.js"); - - -function addHtmlLabel(root, node) { - const fo = root.append('foreignObject').attr('width', '100000'); - const div = fo.append('xhtml:div'); - div.attr('xmlns', 'http://www.w3.org/1999/xhtml'); - const label = node.label; - - switch (typeof label) { - case 'function': - div.insert(label); - break; - - case 'object': - // Currently we assume this is a DOM object. - div.insert(function () { - return label; - }); - break; - - default: - div.html(label); - } - - _util__WEBPACK_IMPORTED_MODULE_0__["default"].applyStyle(div, node.labelStyle); - div.style('display', 'inline-block'); // Fix for firefox - - div.style('white-space', 'nowrap'); - const client = div.node().getBoundingClientRect(); - fo.attr('width', client.width).attr('height', client.height); - return fo; -} - -/* harmony default export */ __webpack_exports__["default"] = (addHtmlLabel); - -/***/ }), - -/***/ "./node_modules/dagre-d3-renderer/lib/util.js": -/*!****************************************************!*\ - !*** ./node_modules/dagre-d3-renderer/lib/util.js ***! - \****************************************************/ -/*! exports provided: default */ -/***/ (function(module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js"); -/* harmony import */ var lodash__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lodash__WEBPACK_IMPORTED_MODULE_0__); - -/* - * Returns true if the specified node in the graph is a subgraph node. A - * subgraph node is one that contains other nodes. - */ - -function isSubgraph(g, v) { - return !!g.children(v).length; -} - -function edgeToId(e) { - return escapeId(e.v) + ':' + escapeId(e.w) + ':' + escapeId(e.name); -} - -const ID_DELIM = /:/g; - -function escapeId(str) { - return str ? String(str).replace(ID_DELIM, '\\:') : ''; -} - -function applyStyle(dom, styleFn) { - if (styleFn) { - dom.attr('style', styleFn); - } -} - -function applyClass(dom, classFn, otherClasses) { - if (classFn) { - dom.attr('class', classFn).attr('class', otherClasses + ' ' + dom.attr('class')); - } -} - -function applyTransition(selection, g) { - const graph = g.graph(); - - if (lodash__WEBPACK_IMPORTED_MODULE_0___default.a.isPlainObject(graph)) { - const transition = graph.transition; - - if (lodash__WEBPACK_IMPORTED_MODULE_0___default.a.isFunction(transition)) { - return transition(selection); - } - } - - return selection; -} // Public utility functions - - -/* harmony default export */ __webpack_exports__["default"] = ({ - isSubgraph, - edgeToId, - applyStyle, - applyClass, - applyTransition -}); - -/***/ }), - -/***/ "./node_modules/dagre-layout/dist/dagre-layout.core.js": -/*!*************************************************************!*\ - !*** ./node_modules/dagre-layout/dist/dagre-layout.core.js ***! - \*************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -module.exports=function(e){var t={};function n(r){if(t[r])return t[r].exports;var a=t[r]={i:r,l:!1,exports:{}};return e[r].call(a.exports,a,a.exports,n),a.l=!0,a.exports}return n.m=e,n.c=t,n.d=function(e,t,r){n.o(e,t)||Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:r})},n.r=function(e){Object.defineProperty(e,"__esModule",{value:!0})},n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,"a",t),t},n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},n.p="",n.w={},n(n.s=27)}([function(e,t){e.exports=__webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js")},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.addDummyNode=d,t.simplify=f,t.asNonCompoundGraph=i,t.successorWeights=l,t.predecessorWeights=c,t.intersectRect=s,t.buildLayerMatrix=h,t.normalizeRanks=v,t.removeEmptyRanks=g,t.addBorderNode=p,t.maxRank=m,t.partition=E,t.time=b,t.notime=w;var r,a=n(0),u=(r=a)&&r.__esModule?r:{default:r},o=n(2);function d(e,t,n,r){var a=void 0;do{a=u.default.uniqueId(r)}while(e.hasNode(a));return n.dummy=t,e.setNode(a,n),a}function f(e){var t=(new o.Graph).setGraph(e.graph());return u.default.forEach(e.nodes(),function(n){t.setNode(n,e.node(n))}),u.default.forEach(e.edges(),function(n){var r=t.edge(n.v,n.w)||{weight:0,minlen:1},a=e.edge(n);t.setEdge(n.v,n.w,{weight:r.weight+a.weight,minlen:Math.max(r.minlen,a.minlen)})}),t}function i(e){var t=new o.Graph({multigraph:e.isMultigraph()}).setGraph(e.graph());return u.default.forEach(e.nodes(),function(n){e.children(n).length||t.setNode(n,e.node(n))}),u.default.forEach(e.edges(),function(n){t.setEdge(n,e.edge(n))}),t}function l(e){var t=u.default.map(e.nodes(),function(t){var n={};return u.default.forEach(e.outEdges(t),function(t){n[t.w]=(n[t.w]||0)+e.edge(t).weight}),n});return u.default.zipObject(e.nodes(),t)}function c(e){var t=u.default.map(e.nodes(),function(t){var n={};return u.default.forEach(e.inEdges(t),function(t){n[t.v]=(n[t.v]||0)+e.edge(t).weight}),n});return u.default.zipObject(e.nodes(),t)}function s(e,t){var n=e.x,r=e.y,a=t.x-n,u=t.y-r,o=e.width/2,d=e.height/2;if(!a&&!u)throw new Error("Not possible to find intersection inside of the rectangle");var f=void 0,i=void 0;return Math.abs(u)*o>Math.abs(a)*d?(u<0&&(d=-d),f=d*a/u,i=d):(a<0&&(o=-o),f=o,i=o*u/a),{x:n+f,y:r+i}}function h(e){var t=u.default.map(u.default.range(m(e)+1),function(){return[]});return u.default.forEach(e.nodes(),function(n){var r=e.node(n),a=r.rank;u.default.isUndefined(a)||(t[a][r.order]=n)}),t}function v(e){var t=u.default.min(u.default.map(e.nodes(),function(t){return e.node(t).rank}));u.default.forEach(e.nodes(),function(n){var r=e.node(n);u.default.has(r,"rank")&&(r.rank-=t)})}function g(e){var t=u.default.min(u.default.map(e.nodes(),function(t){return e.node(t).rank})),n=[];u.default.forEach(e.nodes(),function(r){var a=e.node(r).rank-t;n[a]||(n[a]=[]),n[a].push(r)});var r=0,a=e.graph().nodeRankFactor;u.default.forEach(n,function(t,n){u.default.isUndefined(t)&&n%a!=0?--r:r&&u.default.forEach(t,function(t){e.node(t).rank+=r})})}function p(e,t,n,r){var a={width:0,height:0};return arguments.length>=4&&(a.rank=n,a.order=r),d(e,"border",a,t)}function m(e){return u.default.max(u.default.map(e.nodes(),function(t){var n=e.node(t).rank;if(!u.default.isUndefined(n))return n}))}function E(e,t){var n={lhs:[],rhs:[]};return u.default.forEach(e,function(e){t(e)?n.lhs.push(e):n.rhs.push(e)}),n}function b(e,t){var n=u.default.now();try{return t()}finally{console.log(e+" time: "+(u.default.now()-n)+"ms")}}function w(e,t){return t()}t.default={addDummyNode:d,simplify:f,asNonCompoundGraph:i,successorWeights:l,predecessorWeights:c,intersectRect:s,buildLayerMatrix:h,normalizeRanks:v,removeEmptyRanks:g,addBorderNode:p,maxRank:m,partition:E,time:b,notime:w}},function(e,t){e.exports=__webpack_require__(/*! graphlibrary */ "./node_modules/graphlibrary/index.js")},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.longestPath=o,t.slack=d;var r,a=n(0),u=(r=a)&&r.__esModule?r:{default:r};function o(e){var t={};u.default.forEach(e.sources(),function n(r){var a=e.node(r);if(u.default.has(t,r))return a.rank;t[r]=!0;var o=u.default.min(u.default.map(e.outEdges(r),function(t){return n(t.w)-e.edge(t).minlen}))||0;return a.rank=o})}function d(e,t){return e.node(t.w).rank-e.node(t.v).rank-e.edge(t).minlen}t.default={longestPath:o,slack:d}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,a=n(0),u=(r=a)&&r.__esModule?r:{default:r},o=n(2),d=n(3);function f(e,t){return u.default.forEach(e.nodes(),function n(r){u.default.forEach(t.nodeEdges(r),function(a){var u=a.v,o=r===u?a.w:u;e.hasNode(o)||(0,d.slack)(t,a)||(e.setNode(o,{}),e.setEdge(r,o,{}),n(o))})}),e.nodeCount()}function i(e,t){return u.default.minBy(t.edges(),function(n){if(e.hasNode(n.v)!==e.hasNode(n.w))return(0,d.slack)(t,n)})}function l(e,t,n){u.default.forEach(e.nodes(),function(e){t.node(e).rank+=n})}t.default=function(e){var t=new o.Graph({directed:!1}),n=e.nodes()[0],r=e.nodeCount();t.setNode(n,{});for(var a=void 0;f(t,e)d)&&i(n,t,f)})})}return r.default.reduce(t,function(t,n){var u=-1,o=void 0,d=0;return r.default.forEach(n,function(r,f){if("border"===e.node(r).dummy){var i=e.predecessors(r);i.length&&(o=e.node(i[0]).order,a(n,d,f,u,o),d=f,u=o)}a(n,d,n.length,o,t.length)}),n}),n}function i(e,t,n){if(t>n){var r=t;t=n,n=r}var a=e[t];a||(e[t]=a={}),a[n]=!0}function l(e,t,n){if(t>n){var a=t;t=n,n=a}return r.default.has(e[t],n)}function c(e,t,n,a){var u={},o={},d={};return r.default.forEach(t,function(e){r.default.forEach(e,function(e,t){u[e]=e,o[e]=e,d[e]=t})}),r.default.forEach(t,function(e){var t=-1;r.default.forEach(e,function(e){var f=a(e);if(f.length)for(var i=((f=r.default.sortBy(f,function(e){return d[e]})).length-1)/2,c=Math.floor(i),s=Math.ceil(i);c<=s;++c){var h=f[c];o[e]===e&&tt.barycenter?1:n?t.i-e.i:e.i-t.i})),s=o(i,f,s),r.default.forEach(d,function(e){s+=e.vs.length,i.push(e.vs),l+=e.barycenter*e.weight,c+=e.weight,s=o(i,f,s)});var h={vs:r.default.flatten(i,!0)};return c&&(h.barycenter=l/c,h.weight=c),h}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,a=n(0),u=(r=a)&&r.__esModule?r:{default:r};t.default=function(e,t){var n={};return u.default.forEach(e,function(e,t){var r=n[e.v]={indegree:0,in:[],out:[],vs:[e.v],i:t};u.default.isUndefined(e.barycenter)||(r.barycenter=e.barycenter,r.weight=e.weight)}),u.default.forEach(t.edges(),function(e){var t=n[e.v],r=n[e.w];u.default.isUndefined(t)||u.default.isUndefined(r)||(r.indegree++,t.out.push(n[e.w]))}),function(e){var t=[];function n(e){return function(t){var n,r,a,o;t.merged||(u.default.isUndefined(t.barycenter)||u.default.isUndefined(e.barycenter)||t.barycenter>=e.barycenter)&&(r=t,a=0,o=0,(n=e).weight&&(a+=n.barycenter*n.weight,o+=n.weight),r.weight&&(a+=r.barycenter*r.weight,o+=r.weight),n.vs=r.vs.concat(n.vs),n.barycenter=a/o,n.weight=o,n.i=Math.min(r.i,n.i),r.merged=!0)}}function r(t){return function(n){n.in.push(t),0==--n.indegree&&e.push(n)}}for(;e.length;){var a=e.pop();t.push(a),u.default.forEach(a.in.reverse(),n(a)),u.default.forEach(a.out,r(a))}return u.default.chain(t).filter(function(e){return!e.merged}).map(function(e){return u.default.pick(e,["vs","i","barycenter","weight"])}).value()}(u.default.filter(n,function(e){return!e.indegree}))}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,a=n(0),u=(r=a)&&r.__esModule?r:{default:r};t.default=function(e,t){return u.default.map(t,function(t){var n=e.inEdges(t);if(n.length){var r=u.default.reduce(n,function(t,n){var r=e.edge(n),a=e.node(n.v);return{sum:t.sum+r.weight*a.order,weight:t.weight+r.weight}},{sum:0,weight:0});return{v:t,barycenter:r.sum/r.weight,weight:r.weight}}return{v:t}})}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=d(n(0)),a=d(n(11)),u=d(n(10)),o=d(n(9));function d(e){return e&&e.__esModule?e:{default:e}}t.default=function e(t,n,d,f){var i=t.children(n),l=t.node(n),c=l?l.borderLeft:void 0,s=l?l.borderRight:void 0,h={};c&&(i=r.default.filter(i,function(e){return e!==c&&e!==s}));var v=(0,a.default)(t,i);r.default.forEach(v,function(n){if(t.children(n.v).length){var a=e(t,n.v,d,f);h[n.v]=a,r.default.has(a,"barycenter")&&(u=n,o=a,r.default.isUndefined(u.barycenter)?(u.barycenter=o.barycenter,u.weight=o.weight):(u.barycenter=(u.barycenter*u.weight+o.barycenter*o.weight)/(u.weight+o.weight),u.weight+=o.weight))}var u,o});var g=(0,u.default)(v,d);!function(e,t){r.default.forEach(e,function(e){e.vs=r.default.flatten(e.vs.map(function(e){return t[e]?t[e].vs:e}),!0)})}(g,h);var p=(0,o.default)(g,f);if(c&&(p.vs=r.default.flatten([c,p.vs,s],!0),t.predecessors(c).length)){var m=t.node(t.predecessors(c)[0]),E=t.node(t.predecessors(s)[0]);r.default.has(p,"barycenter")||(p.barycenter=0,p.weight=0),p.barycenter=(p.barycenter*p.weight+m.order+E.order)/(p.weight+2),p.weight+=2}return p}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,a=n(0),u=(r=a)&&r.__esModule?r:{default:r};function o(e,t,n){for(var r=u.default.zipObject(n,u.default.map(n,function(e,t){return t})),a=u.default.flatten(u.default.map(t,function(t){return u.default.chain(e.outEdges(t)).map(function(t){return{pos:r[t.w],weight:e.edge(t).weight}}).sortBy("pos").value()}),!0),o=1;o0;)t%2&&(n+=f[t+1]),f[t=t-1>>1]+=e.weight;i+=e.weight*n})),i}t.default=function(e,t){for(var n=0,r=1;r=2),d=l.default.buildLayerMatrix(e);var p=(0,o.default)(e,d);po||d>t[f].lim));for(i=f,f=r;(f=e.parent(f))!==i;)u.push(f);return{path:a.concat(u.reverse()),lca:i}}(e,t,a.v,a.w),o=u.path,d=u.lca,f=0,i=o[f],l=!0;n!==a.w;){if(r=e.node(n),l){for(;(i=o[f])!==d&&e.node(i).maxRankf.lim&&(i=f,l=!0);var c=r.default.filter(t.edges(),function(t){return l===E(e,e.node(t.v),i)&&l!==E(e,e.node(t.w),i)});return r.default.minBy(c,function(e){return(0,o.slack)(t,e)})}function m(e,t,n,a){var u=n.v,o=n.w;e.removeEdge(u,o),e.setEdge(a.v,a.w,{}),v(e),s(e,t),function(e,t){var n=r.default.find(e.nodes(),function(e){return!t.node(e).parent}),a=i(e,n);a=a.slice(1),r.default.forEach(a,function(n){var r=e.node(n).parent,a=t.edge(n,r),u=!1;a||(a=t.edge(r,n),u=!0),t.node(n).rank=t.node(r).rank+(u?a.minlen:-a.minlen)})}(e,t)}function E(e,t,n){return n.low<=t.lim&&t.lim<=n.lim}c.initLowLimValues=v,c.initCutValues=s,c.calcCutValue=h,c.leaveEdge=g,c.enterEdge=p,c.exchangeEdges=m,t.default=c},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=n(3),a=o(n(4)),u=o(n(20));function o(e){return e&&e.__esModule?e:{default:e}}var d=r.longestPath;function f(e){(0,u.default)(e)}t.default=function(e){switch(e.graph().ranker){case"network-simplex":f(e);break;case"tight-tree":!function(e){(0,r.longestPath)(e),(0,a.default)(e)}(e);break;case"longest-path":d(e);break;default:f(e)}}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=u(n(0)),a=u(n(1));function u(e){return e&&e.__esModule?e:{default:e}}t.default={run:function(e){e.graph().dummyChains=[],r.default.forEach(e.edges(),function(t){!function(e,t){var n=t.v,r=e.node(n).rank,u=t.w,o=e.node(u).rank,d=t.name,f=e.edge(t),i=f.labelRank;if(o!==r+1){e.removeEdge(t);var l=void 0,c=void 0,s=void 0;for(s=0,++r;r0;--d)if(o=t[d].dequeue()){r=r.concat(f(e,t,n,o,!0));break}}return r}(n.graph,n.buckets,n.zeroIdx);return r.default.flatten(r.default.map(o,function(t){return e.outEdges(t.v,t.w)}),!0)}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=u(n(0)),a=u(n(24));function u(e){return e&&e.__esModule?e:{default:e}}t.default={run:function(e){var t="greedy"===e.graph().acyclicer?(0,a.default)(e,function(e){return function(t){return e.edge(t).weight}}(e)):function(e){var t=[],n={},a={};return r.default.forEach(e.nodes(),function u(o){r.default.has(a,o)||(a[o]=!0,n[o]=!0,r.default.forEach(e.outEdges(o),function(e){r.default.has(n,e.w)?t.push(e):u(e.w)}),delete n[o])}),t}(e);r.default.forEach(t,function(t){var n=e.edge(t);e.removeEdge(t),n.forwardName=t.name,n.reversed=!0,e.setEdge(t.w,t.v,n,r.default.uniqueId("rev"))})},undo:function(e){r.default.forEach(e.edges(),function(t){var n=e.edge(t);if(n.reversed){e.removeEdge(t);var r=n.forwardName;delete n.reversed,delete n.forwardName,e.setEdge(t.w,t.v,n,r)}})}}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=p(n(0)),a=n(2),u=p(n(25)),o=p(n(22)),d=p(n(21)),f=n(1),i=p(f),l=p(n(19)),c=p(n(18)),s=p(n(17)),h=p(n(16)),v=p(n(15)),g=p(n(6));function p(e){return e&&e.__esModule?e:{default:e}}var m=["nodesep","edgesep","ranksep","marginx","marginy"],E={ranksep:50,edgesep:20,nodesep:50,rankdir:"tb"},b=["acyclicer","ranker","rankdir","align"],w=["width","height"],y={width:0,height:0},_=["minlen","weight","width","height","labeloffset"],x={minlen:1,weight:1,width:0,height:0,labeloffset:10,labelpos:"r"},k=["labelpos"];function M(e,t){return r.default.mapValues(r.default.pick(e,t),Number)}function N(e){var t={};return r.default.forEach(e,function(e,n){t[n.toLowerCase()]=e}),t}t.default=function(e,t){var n=t&&t.debugTiming?i.default.time:i.default.notime;n("layout",function(){var t=n(" buildLayoutGraph",function(){return function(e){var t=new a.Graph({multigraph:!0,compound:!0}),n=N(e.graph());return t.setGraph(r.default.merge({},E,M(n,m),r.default.pick(n,b))),r.default.forEach(e.nodes(),function(n){var a=N(e.node(n));t.setNode(n,r.default.defaults(M(a,w),y)),t.setParent(n,e.parent(n))}),r.default.forEach(e.edges(),function(n){var a=N(e.edge(n));t.setEdge(n,r.default.merge({},x,M(a,_),r.default.pick(a,k)))}),t}(e)});n(" runLayout",function(){!function(e,t){t(" makeSpaceForEdgeLabels",function(){!function(e){var t=e.graph();t.ranksep/=2,r.default.forEach(e.edges(),function(n){var r=e.edge(n);r.minlen*=2,"c"!==r.labelpos.toLowerCase()&&("TB"===t.rankdir||"BT"===t.rankdir?r.width+=r.labeloffset:r.height+=r.labeloffset)})}(e)}),t(" removeSelfEdges",function(){!function(e){r.default.forEach(e.edges(),function(t){if(t.v===t.w){var n=e.node(t.v);n.selfEdges||(n.selfEdges=[]),n.selfEdges.push({e:t,label:e.edge(t)}),e.removeEdge(t)}})}(e)}),t(" acyclic",function(){u.default.run(e)}),t(" nestingGraph.run",function(){c.default.run(e)}),t(" rank",function(){(0,d.default)(i.default.asNonCompoundGraph(e))}),t(" injectEdgeLabelProxies",function(){!function(e){r.default.forEach(e.edges(),function(t){var n=e.edge(t);if(n.width&&n.height){var r=e.node(t.v),a=e.node(t.w),u={rank:(a.rank-r.rank)/2+r.rank,e:t};i.default.addDummyNode(e,"edge-proxy",u,"_ep")}})}(e)}),t(" removeEmptyRanks",function(){(0,f.removeEmptyRanks)(e)}),t(" nestingGraph.cleanup",function(){c.default.cleanup(e)}),t(" normalizeRanks",function(){(0,f.normalizeRanks)(e)}),t(" assignRankMinMax",function(){!function(e){var t=0;r.default.forEach(e.nodes(),function(n){var r=e.node(n);r.borderTop&&(r.minRank=e.node(r.borderTop).rank,r.maxRank=e.node(r.borderBottom).rank,t=Math.max(t,r.maxRank))}),e.graph().maxRank=t}(e)}),t(" removeEdgeLabelProxies",function(){!function(e){r.default.forEach(e.nodes(),function(t){var n=e.node(t);"edge-proxy"===n.dummy&&(e.edge(n.e).labelRank=n.rank,e.removeNode(t))})}(e)}),t(" normalize.run",function(){o.default.run(e)}),t(" parentDummyChains",function(){(0,l.default)(e)}),t(" addBorderSegments",function(){(0,s.default)(e)}),t(" order",function(){(0,v.default)(e)}),t(" insertSelfEdges",function(){!function(e){var t=i.default.buildLayerMatrix(e);r.default.forEach(t,function(t){var n=0;r.default.forEach(t,function(t,a){var u=e.node(t);u.order=a+n,r.default.forEach(u.selfEdges,function(t){i.default.addDummyNode(e,"selfedge",{width:t.label.width,height:t.label.height,rank:u.rank,order:a+ ++n,e:t.e,label:t.label},"_se")}),delete u.selfEdges})})}(e)}),t(" adjustCoordinateSystem",function(){h.default.adjust(e)}),t(" position",function(){(0,g.default)(e)}),t(" positionSelfEdges",function(){!function(e){r.default.forEach(e.nodes(),function(t){var n=e.node(t);if("selfedge"===n.dummy){var r=e.node(n.e.v),a=r.x+r.width/2,u=r.y,o=n.x-a,d=r.height/2;e.setEdge(n.e,n.label),e.removeNode(t),n.label.points=[{x:a+2*o/3,y:u-d},{x:a+5*o/6,y:u-d},{x:a+o,y:u},{x:a+5*o/6,y:u+d},{x:a+2*o/3,y:u+d}],n.label.x=n.x,n.label.y=n.y}})}(e)}),t(" removeBorderNodes",function(){!function(e){r.default.forEach(e.nodes(),function(t){if(e.children(t).length){var n=e.node(t),a=e.node(n.borderTop),u=e.node(n.borderBottom),o=e.node(r.default.last(n.borderLeft)),d=e.node(r.default.last(n.borderRight));n.width=Math.abs(d.x-o.x),n.height=Math.abs(u.y-a.y),n.x=o.x+n.width/2,n.y=a.y+n.height/2}}),r.default.forEach(e.nodes(),function(t){"border"===e.node(t).dummy&&e.removeNode(t)})}(e)}),t(" normalize.undo",function(){o.default.undo(e)}),t(" fixupEdgeLabelCoords",function(){!function(e){r.default.forEach(e.edges(),function(t){var n=e.edge(t);if(r.default.has(n,"x"))switch("l"!==n.labelpos&&"r"!==n.labelpos||(n.width-=n.labeloffset),n.labelpos){case"l":n.x-=n.width/2+n.labeloffset;break;case"r":n.x+=n.width/2+n.labeloffset}})}(e)}),t(" undoCoordinateSystem",function(){h.default.undo(e)}),t(" translateGraph",function(){!function(e){var t=Number.POSITIVE_INFINITY,n=0,a=Number.POSITIVE_INFINITY,u=0,o=e.graph(),d=o.marginx||0,f=o.marginy||0;function i(e){var r=e.x,o=e.y,d=e.width,f=e.height;t=Math.min(t,r-d/2),n=Math.max(n,r+d/2),a=Math.min(a,o-f/2),u=Math.max(u,o+f/2)}r.default.forEach(e.nodes(),function(t){i(e.node(t))}),r.default.forEach(e.edges(),function(t){var n=e.edge(t);r.default.has(n,"x")&&i(n)}),t-=d,a-=f,r.default.forEach(e.nodes(),function(n){var r=e.node(n);r.x-=t,r.y-=a}),r.default.forEach(e.edges(),function(n){var u=e.edge(n);r.default.forEach(u.points,function(e){e.x-=t,e.y-=a}),r.default.has(u,"x")&&(u.x-=t),r.default.has(u,"y")&&(u.y-=a)}),o.width=n-t+d,o.height=u-a+f}(e)}),t(" assignNodeIntersects",function(){!function(e){r.default.forEach(e.edges(),function(t){var n=e.edge(t),r=e.node(t.v),a=e.node(t.w),u=null,o=null;n.points?(u=n.points[0],o=n.points[n.points.length-1]):(n.points=[],u=a,o=r),n.points.unshift(i.default.intersectRect(r,u)),n.points.push(i.default.intersectRect(a,o))})}(e)}),t(" reversePoints",function(){!function(e){r.default.forEach(e.edges(),function(t){var n=e.edge(t);n.reversed&&n.points.reverse()})}(e)}),t(" acyclic.undo",function(){u.default.undo(e)})}(t,n)}),n(" updateInputGraph",function(){!function(e,t){r.default.forEach(e.nodes(),function(n){var r=e.node(n),a=t.node(n);r&&(r.x=a.x,r.y=a.y,t.children(n).length&&(r.width=a.width,r.height=a.height))}),r.default.forEach(e.edges(),function(n){var a=e.edge(n),u=t.edge(n);a.points=u.points,r.default.has(u,"x")&&(a.x=u.x,a.y=u.y)}),e.graph().width=t.graph().width,e.graph().height=t.graph().height}(e,t)})})}},function(e,t,n){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r,a=n(26),u=(r=a)&&r.__esModule?r:{default:r};t.default={layout:u.default}}]); -//# sourceMappingURL=dagre-layout.core.js.map - -/***/ }), - -/***/ "./node_modules/escaper/dist/escaper.js": -/*!**********************************************!*\ - !*** ./node_modules/escaper/dist/escaper.js ***! - \**********************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -/*! - * Escaper v2.5.3 - * https://github.com/kobezzza/Escaper - * - * Released under the MIT license - * https://github.com/kobezzza/Escaper/blob/master/LICENSE - * - * Date: Tue, 23 Jan 2018 15:58:45 GMT - */ - -(function (global, factory) { - true ? factory(exports) : - undefined; -}(this, (function (exports) { 'use strict'; - -var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { - return typeof obj; -} : function (obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; -}; - -var Escaper = void 0; -var escaper = Escaper = { - VERSION: [2, 5, 3], - content: [], - cache: {}, - snakeskinRgxp: null, - symbols: null, - replace: replace, - paste: paste -}; - -var stringLiterals = { - '"': true, - '\'': true, - '`': true -}; - -var literals = { - '/': true -}; - -for (var key in stringLiterals) { - if (!stringLiterals.hasOwnProperty(key)) { - break; - } - - literals[key] = true; -} - -var singleComments = { - '//': true, - '//*': true, - '//!': true, - '//#': true, - '//@': true, - '//$': true -}; - -var multComments = { - '/*': true, - '/**': true, - '/*!': true, - '/*#': true, - '/*@': true, - '/*$': true -}; - -var keyArr = []; -var finalMap = {}; - -for (var _key in literals) { - if (!literals.hasOwnProperty(_key)) { - break; - } - - keyArr.push(_key); - finalMap[_key] = true; -} - -for (var _key2 in singleComments) { - if (!singleComments.hasOwnProperty(_key2)) { - break; - } - - keyArr.push(_key2); - finalMap[_key2] = true; -} - -for (var _key3 in multComments) { - if (!multComments.hasOwnProperty(_key3)) { - break; - } - - keyArr.push(_key3); - finalMap[_key3] = true; -} - -var rgxpFlags = []; -var rgxpFlagsMap = { - 'g': true, - 'm': true, - 'i': true, - 'y': true, - 'u': true -}; - -for (var _key4 in rgxpFlagsMap) { - if (!rgxpFlagsMap.hasOwnProperty(_key4)) { - break; - } - - rgxpFlags.push(_key4); -} - -var escapeEndMap = { - '-': true, - '+': true, - '*': true, - '%': true, - '~': true, - '>': true, - '<': true, - '^': true, - ',': true, - ';': true, - '=': true, - '|': true, - '&': true, - '!': true, - '?': true, - ':': true, - '(': true, - '{': true, - '[': true -}; - -var escapeEndWordMap = { - 'return': true, - 'yield': true, - 'await': true, - 'typeof': true, - 'void': true, - 'instanceof': true, - 'delete': true, - 'in': true, - 'new': true, - 'of': true -}; - -/** - * @param {!Object} obj - * @param {!Object} p - * @param {(boolean|number)} val - */ -function mix(obj, p, val) { - for (var _key5 in obj) { - if (!obj.hasOwnProperty(_key5)) { - break; - } - - if (_key5 in p === false) { - p[_key5] = val; - } - } -} - -var symbols = void 0; -var snakeskinRgxp = void 0; - -var uSRgxp = /[^\s/]/; -var wRgxp = /[a-z]/; -var sRgxp = /\s/; -var nRgxp = /[\r\n]/; -var posRgxp = /\${pos}/g; - -var objMap = { - 'object': true, - 'function': true -}; - -/** - * Replaces all found blocks ' ... ', " ... ", ` ... `, / ... /, // ..., /* ... *\/ to - * __ESCAPER_QUOT__number_ in a string and returns a new string - * - * @param {string} str - source string - * @param {(Object|boolean)=} [opt_withCommentsOrParams=false] - parameters: - * - * (if a parameter value is set to -1, then all found matches will be removed from the final string, - * or if the value will be set to true/false they will be included/excluded) - * - * *) @label - template for replacement, e.g. __ESCAPER_QUOT__${pos}_ - * *) @all - replaces all found matches - * *) @comments - replaces all kinds of comments - * *) @strings - replaces all kinds of string literals - * *) @literals - replaces all kinds of string literals and regular expressions - * *) ` - * *) ' - * *) " - * *) / - * *) // - * *) //* - * *) //! - * *) //# - * *) //@ - * *) //$ - * *) /* - * *) /** - * *) /*! - * *) /*# - * *) /*@ - * *) /*$ - * - * OR if the value is boolean, then will be replaced all found comments (true) / literals (false) - * - * @param {Array=} [opt_content=Escaper.content] - array for matches - * @param {?boolean=} [opt_snakeskin] - private parameter for using with Snakeskin - * @return {string} - */ -function replace(str, opt_withCommentsOrParams, opt_content, opt_snakeskin) { - symbols = symbols || Escaper.symbols || 'a-z'; - snakeskinRgxp = snakeskinRgxp || Escaper.snakeskinRgxp || new RegExp('[!$' + symbols + '_]', 'i'); - - var _Escaper = Escaper, - cache = _Escaper.cache, - content = _Escaper.content; - - - var isObj = Boolean(opt_withCommentsOrParams && objMap[typeof opt_withCommentsOrParams === 'undefined' ? 'undefined' : _typeof(opt_withCommentsOrParams)]); - - var p = isObj ? Object(opt_withCommentsOrParams) : {}; - - function mark(pos) { - if (p['@label']) { - return p['@label'].replace(posRgxp, pos); - } - - return '__ESCAPER_QUOT__' + pos + '_'; - } - - var withComments = false; - if (typeof opt_withCommentsOrParams === 'boolean') { - withComments = Boolean(opt_withCommentsOrParams); - } - - if ('@comments' in p) { - mix(multComments, p, p['@comments']); - mix(singleComments, p, p['@comments']); - delete p['@comments']; - } - - if ('@strings' in p) { - mix(stringLiterals, p, p['@strings']); - delete p['@strings']; - } - - if ('@literals' in p) { - mix(literals, p, p['@literals']); - delete p['@literals']; - } - - if ('@all' in p) { - mix(finalMap, p, p['@all']); - delete p['@all']; - } - - var cacheKey = ''; - for (var i = -1; ++i < keyArr.length;) { - var el = keyArr[i]; - - if (multComments[el] || singleComments[el]) { - p[el] = withComments || p[el]; - } else { - p[el] = p[el] || !isObj; - } - - cacheKey += p[el] + ','; - } - - var initStr = str, - stack = opt_content || content; - - if (stack === content && cache[cacheKey] && cache[cacheKey][initStr]) { - return cache[cacheKey][initStr]; - } - - var begin = false, - end = true; - - var escape = false, - comment = false; - - var selectionStart = 0, - block = false; - - var templateVar = 0, - filterStart = false; - - var cut = void 0, - label = void 0; - - var part = '', - rPart = ''; - - for (var _i = -1; ++_i < str.length;) { - var _el = str.charAt(_i); - - var next = str.charAt(_i + 1), - word = str.substr(_i, 2), - extWord = str.substr(_i, 3); - - if (!comment) { - if (!begin) { - if (_el === '/') { - if (singleComments[word] || multComments[word]) { - if (singleComments[extWord] || multComments[extWord]) { - comment = extWord; - } else { - comment = word; - } - } - - if (comment) { - selectionStart = _i; - continue; - } - } - - if (escapeEndMap[_el] || escapeEndWordMap[rPart]) { - end = true; - rPart = ''; - } else if (uSRgxp.test(_el)) { - end = false; - } - - if (wRgxp.test(_el)) { - part += _el; - } else { - rPart = part; - part = ''; - } - - var skip = false; - if (opt_snakeskin) { - if (_el === '|' && snakeskinRgxp.test(next)) { - filterStart = true; - end = false; - skip = true; - } else if (filterStart && sRgxp.test(_el)) { - filterStart = false; - end = true; - skip = true; - } - } - - if (!skip) { - if (escapeEndMap[_el]) { - end = true; - } else if (uSRgxp.test(_el)) { - end = false; - } - } - } - - // [] inside RegExp - if (begin === '/' && !escape) { - if (_el === '[') { - block = true; - } else if (_el === ']') { - block = false; - } - } - - if (!begin && templateVar) { - if (_el === '}') { - templateVar--; - } else if (_el === '{') { - templateVar++; - } - - if (!templateVar) { - _el = '`'; - } - } - - if (begin === '`' && !escape && word === '${') { - _el = '`'; - _i++; - templateVar++; - } - - if (finalMap[_el] && (_el !== '/' || end) && !begin) { - begin = _el; - selectionStart = _i; - } else if (begin && (_el === '\\' || escape)) { - escape = !escape; - } else if (finalMap[_el] && begin === _el && !escape && (begin !== '/' || !block)) { - if (_el === '/') { - for (var j = -1; ++j < rgxpFlags.length;) { - if (rgxpFlagsMap[str.charAt(_i + 1)]) { - _i++; - } - } - } - - begin = false; - end = false; - - if (p[_el]) { - cut = str.substring(selectionStart, _i + 1); - - if (p[_el] === -1) { - label = ''; - } else { - label = mark(stack.length); - stack.push(cut); - } - - str = str.substring(0, selectionStart) + label + str.substring(_i + 1); - _i += label.length - cut.length; - } - } - } else if (nRgxp.test(next) && singleComments[comment] || multComments[_el + str.charAt(_i - 1)] && _i - selectionStart > 2 && multComments[comment]) { - if (p[comment]) { - cut = str.substring(selectionStart, _i + 1); - - if (p[comment] === -1) { - label = ''; - } else { - label = mark(stack.length); - stack.push(cut); - } - - str = str.substring(0, selectionStart) + label + str.substring(_i + 1); - _i += label.length - cut.length; - } - - comment = false; - } - } - - if (stack === content) { - cache[cacheKey] = cache[cacheKey] || {}; - cache[cacheKey][initStr] = str; - } - - return str; -} - -var pasteRgxp = /__ESCAPER_QUOT__(\d+)_/g; - -/** - * Replaces all found blocks __ESCAPER_QUOT__number_ to real content in a string - * and returns a new string - * - * @param {string} str - source string - * @param {Array=} [opt_content=Escaper.content] - array of matches - * @param {RegExp=} [opt_rgxp] - RegExp for searching, e.g. /__ESCAPER_QUOT__(\d+)_/g - * @return {string} - */ -function paste(str, opt_content, opt_rgxp) { - return str.replace(opt_rgxp || pasteRgxp, function (str, pos) { - return (opt_content || Escaper.content)[pos]; - }); -} - -exports['default'] = escaper; -exports.replace = replace; -exports.paste = paste; - -Object.defineProperty(exports, '__esModule', { value: true }); - -}))); - - -/***/ }), - -/***/ "./node_modules/graphlibrary/index.js": -/*!********************************************!*\ - !*** ./node_modules/graphlibrary/index.js ***! - \********************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -module.exports = { - Graph: __webpack_require__(/*! ./lib/graph */ "./node_modules/graphlibrary/lib/graph.js"), - json: __webpack_require__(/*! ./lib/json */ "./node_modules/graphlibrary/lib/json.js"), - alg: __webpack_require__(/*! ./lib/alg */ "./node_modules/graphlibrary/lib/alg/index.js") -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/components.js": -/*!*********************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/components.js ***! - \*********************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = components - -function components (g) { - const visited = {} - const cmpts = [] - let cmpt - - function dfs (v) { - if (_.has(visited, v)) return - visited[v] = true - cmpt.push(v) - _.each(g.successors(v), dfs) - _.each(g.predecessors(v), dfs) - } - - _.each(g.nodes(), function (v) { - cmpt = [] - dfs(v) - if (cmpt.length) { - cmpts.push(cmpt) - } - }) - - return cmpts -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/dfs.js": -/*!**************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/dfs.js ***! - \**************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = dfs - -/* - * A helper that preforms a pre- or post-order traversal on the input graph - * and returns the nodes in the order they were visited. If the graph is - * undirected then this algorithm will navigate using neighbors. If the graph - * is directed then this algorithm will navigate using successors. - * - * Order must be one of "pre" or "post". - */ -function dfs (g, vs, order) { - if (!_.isArray(vs)) { - vs = [vs] - } - - var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g) - - const acc = [] - const visited = {} - _.each(vs, function (v) { - if (!g.hasNode(v)) { - throw new Error('Graph does not have node: ' + v) - } - - doDfs(g, v, order === 'post', visited, navigation, acc) - }) - return acc -} - -function doDfs (g, v, postorder, visited, navigation, acc) { - if (!_.has(visited, v)) { - visited[v] = true - - if (!postorder) { acc.push(v) } - _.each(navigation(v), function (w) { - doDfs(g, w, postorder, visited, navigation, acc) - }) - if (postorder) { acc.push(v) } - } -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/dijkstra-all.js": -/*!***********************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/dijkstra-all.js ***! - \***********************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const dijkstra = __webpack_require__(/*! ./dijkstra */ "./node_modules/graphlibrary/lib/alg/dijkstra.js") -const _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = dijkstraAll - -function dijkstraAll (g, weightFunc, edgeFunc) { - return _.transform(g.nodes(), function (acc, v) { - acc[v] = dijkstra(g, v, weightFunc, edgeFunc) - }, {}) -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/dijkstra.js": -/*!*******************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/dijkstra.js ***! - \*******************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") -const PriorityQueue = __webpack_require__(/*! ../data/priority-queue */ "./node_modules/graphlibrary/lib/data/priority-queue.js") - -module.exports = dijkstra - -var DEFAULT_WEIGHT_FUNC = _.constant(1) - -function dijkstra (g, source, weightFn, edgeFn) { - return runDijkstra(g, String(source), - weightFn || DEFAULT_WEIGHT_FUNC, - edgeFn || function (v) { return g.outEdges(v) }) -} - -function runDijkstra (g, source, weightFn, edgeFn) { - const results = {} - const pq = new PriorityQueue() - let v, vEntry - - var updateNeighbors = function (edge) { - const w = edge.v !== v ? edge.v : edge.w - const wEntry = results[w] - const weight = weightFn(edge) - const distance = vEntry.distance + weight - - if (weight < 0) { - throw new Error('dijkstra does not allow negative edge weights. ' + - 'Bad edge: ' + edge + ' Weight: ' + weight) - } - - if (distance < wEntry.distance) { - wEntry.distance = distance - wEntry.predecessor = v - pq.decrease(w, distance) - } - } - - g.nodes().forEach(function (v) { - var distance = v === source ? 0 : Number.POSITIVE_INFINITY - results[v] = { distance: distance } - pq.add(v, distance) - }) - - while (pq.size() > 0) { - v = pq.removeMin() - vEntry = results[v] - if (vEntry.distance === Number.POSITIVE_INFINITY) { - break - } - - edgeFn(v).forEach(updateNeighbors) - } - - return results -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/find-cycles.js": -/*!**********************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/find-cycles.js ***! - \**********************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") -const tarjan = __webpack_require__(/*! ./tarjan */ "./node_modules/graphlibrary/lib/alg/tarjan.js") - -module.exports = findCycles - -function findCycles (g) { - return _.filter(tarjan(g), function (cmpt) { - return cmpt.length > 1 || (cmpt.length === 1 && g.hasEdge(cmpt[0], cmpt[0])) - }) -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/floyd-warshall.js": -/*!*************************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/floyd-warshall.js ***! - \*************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = floydWarshall - -var DEFAULT_WEIGHT_FUNC = _.constant(1) - -function floydWarshall (g, weightFn, edgeFn) { - return runFloydWarshall(g, - weightFn || DEFAULT_WEIGHT_FUNC, - edgeFn || function (v) { return g.outEdges(v) }) -} - -function runFloydWarshall (g, weightFn, edgeFn) { - const results = {} - const nodes = g.nodes() - - nodes.forEach(function (v) { - results[v] = {} - results[v][v] = { distance: 0 } - nodes.forEach(function (w) { - if (v !== w) { - results[v][w] = { distance: Number.POSITIVE_INFINITY } - } - }) - edgeFn(v).forEach(function (edge) { - const w = edge.v === v ? edge.w : edge.v - const d = weightFn(edge) - results[v][w] = { distance: d, predecessor: v } - }) - }) - - nodes.forEach(function (k) { - var rowK = results[k] - nodes.forEach(function (i) { - var rowI = results[i] - nodes.forEach(function (j) { - var ik = rowI[k] - var kj = rowK[j] - var ij = rowI[j] - var altDistance = ik.distance + kj.distance - if (altDistance < ij.distance) { - ij.distance = altDistance - ij.predecessor = kj.predecessor - } - }) - }) - }) - - return results -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/index.js": -/*!****************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/index.js ***! - \****************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -module.exports = { - components: __webpack_require__(/*! ./components */ "./node_modules/graphlibrary/lib/alg/components.js"), - dijkstra: __webpack_require__(/*! ./dijkstra */ "./node_modules/graphlibrary/lib/alg/dijkstra.js"), - dijkstraAll: __webpack_require__(/*! ./dijkstra-all */ "./node_modules/graphlibrary/lib/alg/dijkstra-all.js"), - findCycles: __webpack_require__(/*! ./find-cycles */ "./node_modules/graphlibrary/lib/alg/find-cycles.js"), - floydWarshall: __webpack_require__(/*! ./floyd-warshall */ "./node_modules/graphlibrary/lib/alg/floyd-warshall.js"), - isAcyclic: __webpack_require__(/*! ./is-acyclic */ "./node_modules/graphlibrary/lib/alg/is-acyclic.js"), - postorder: __webpack_require__(/*! ./postorder */ "./node_modules/graphlibrary/lib/alg/postorder.js"), - preorder: __webpack_require__(/*! ./preorder */ "./node_modules/graphlibrary/lib/alg/preorder.js"), - prim: __webpack_require__(/*! ./prim */ "./node_modules/graphlibrary/lib/alg/prim.js"), - tarjan: __webpack_require__(/*! ./tarjan */ "./node_modules/graphlibrary/lib/alg/tarjan.js"), - topsort: __webpack_require__(/*! ./topsort */ "./node_modules/graphlibrary/lib/alg/topsort.js") -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/is-acyclic.js": -/*!*********************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/is-acyclic.js ***! - \*********************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var topsort = __webpack_require__(/*! ./topsort */ "./node_modules/graphlibrary/lib/alg/topsort.js") - -module.exports = isAcyclic - -function isAcyclic (g) { - try { - topsort(g) - } catch (e) { - if (e instanceof topsort.CycleException) { - return false - } - throw e - } - return true -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/postorder.js": -/*!********************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/postorder.js ***! - \********************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var dfs = __webpack_require__(/*! ./dfs */ "./node_modules/graphlibrary/lib/alg/dfs.js") - -module.exports = postorder - -function postorder (g, vs) { - return dfs(g, vs, 'post') -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/preorder.js": -/*!*******************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/preorder.js ***! - \*******************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var dfs = __webpack_require__(/*! ./dfs */ "./node_modules/graphlibrary/lib/alg/dfs.js") - -module.exports = preorder - -function preorder (g, vs) { - return dfs(g, vs, 'pre') -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/prim.js": -/*!***************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/prim.js ***! - \***************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") -const Graph = __webpack_require__(/*! ../graph */ "./node_modules/graphlibrary/lib/graph.js") -const PriorityQueue = __webpack_require__(/*! ../data/priority-queue */ "./node_modules/graphlibrary/lib/data/priority-queue.js") - -module.exports = prim - -function prim (g, weightFunc) { - const result = new Graph() - const parents = {} - const pq = new PriorityQueue() - let v - - function updateNeighbors (edge) { - const w = edge.v === v ? edge.w : edge.v - const pri = pq.priority(w) - if (pri !== undefined) { - var edgeWeight = weightFunc(edge) - if (edgeWeight < pri) { - parents[w] = v - pq.decrease(w, edgeWeight) - } - } - } - - if (g.nodeCount() === 0) { - return result - } - - _.each(g.nodes(), function (v) { - pq.add(v, Number.POSITIVE_INFINITY) - result.setNode(v) - }) - - // Start from an arbitrary node - pq.decrease(g.nodes()[0], 0) - - var init = false - while (pq.size() > 0) { - v = pq.removeMin() - if (_.has(parents, v)) { - result.setEdge(v, parents[v]) - } else if (init) { - throw new Error('Input graph is not connected: ' + g) - } else { - init = true - } - - g.nodeEdges(v).forEach(updateNeighbors) - } - - return result -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/tarjan.js": -/*!*****************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/tarjan.js ***! - \*****************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -var _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = tarjan - -function tarjan (g) { - let index = 0 - const stack = [] - const visited = {} // node id -> { onStack, lowlink, index } - const results = [] - - function dfs (v) { - var entry = visited[v] = { - onStack: true, - lowlink: index, - index: index++ - } - stack.push(v) - - g.successors(v).forEach(function (w) { - if (!_.has(visited, w)) { - dfs(w) - entry.lowlink = Math.min(entry.lowlink, visited[w].lowlink) - } else if (visited[w].onStack) { - entry.lowlink = Math.min(entry.lowlink, visited[w].index) - } - }) - - if (entry.lowlink === entry.index) { - const cmpt = [] - let w - do { - w = stack.pop() - visited[w].onStack = false - cmpt.push(w) - } while (v !== w) - results.push(cmpt) - } - } - - g.nodes().forEach(function (v) { - if (!_.has(visited, v)) { - dfs(v) - } - }) - - return results -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/alg/topsort.js": -/*!******************************************************!*\ - !*** ./node_modules/graphlibrary/lib/alg/topsort.js ***! - \******************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = topsort -topsort.CycleException = CycleException - -function topsort (g) { - const visited = {} - const stack = {} - const results = [] - - function visit (node) { - if (_.has(stack, node)) { - throw new CycleException() - } - - if (!_.has(visited, node)) { - stack[node] = true - visited[node] = true - _.each(g.predecessors(node), visit) - delete stack[node] - results.push(node) - } - } - - _.each(g.sinks(), visit) - - if (_.size(visited) !== g.nodeCount()) { - throw new CycleException() - } - - return results -} - -function CycleException () {} -CycleException.prototype = new Error() // must be an instance of Error to pass testing - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/data/priority-queue.js": -/*!**************************************************************!*\ - !*** ./node_modules/graphlibrary/lib/data/priority-queue.js ***! - \**************************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ../lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = PriorityQueue - -/** - * A min-priority queue data structure. This algorithm is derived from Cormen, - * et al., "Introduction to Algorithms". The basic idea of a min-priority - * queue is that you can efficiently (in O(1) time) get the smallest key in - * the queue. Adding and removing elements takes O(log n) time. A key can - * have its priority decreased in O(log n) time. - */ -function PriorityQueue () { - this._arr = [] - this._keyIndices = {} -} - -/** - * Returns the number of elements in the queue. Takes `O(1)` time. - */ -PriorityQueue.prototype.size = function () { - return this._arr.length -} - -/** - * Returns the keys that are in the queue. Takes `O(n)` time. - */ -PriorityQueue.prototype.keys = function () { - return this._arr.map(function (x) { return x.key }) -} - -/** - * Returns `true` if **key** is in the queue and `false` if not. - */ -PriorityQueue.prototype.has = function (key) { - return _.has(this._keyIndices, key) -} - -/** - * Returns the priority for **key**. If **key** is not present in the queue - * then this function returns `undefined`. Takes `O(1)` time. - * - * @param {Object} key - */ -PriorityQueue.prototype.priority = function (key) { - var index = this._keyIndices[key] - if (index !== undefined) { - return this._arr[index].priority - } -} - -/** - * Returns the key for the minimum element in this queue. If the queue is - * empty this function throws an Error. Takes `O(1)` time. - */ -PriorityQueue.prototype.min = function () { - if (this.size() === 0) { - throw new Error('Queue underflow') - } - return this._arr[0].key -} - -/** - * Inserts a new key into the priority queue. If the key already exists in - * the queue this function returns `false`; otherwise it will return `true`. - * Takes `O(n)` time. - * - * @param {Object} key the key to add - * @param {Number} priority the initial priority for the key - */ -PriorityQueue.prototype.add = function (key, priority) { - var keyIndices = this._keyIndices - key = String(key) - if (!_.has(keyIndices, key)) { - var arr = this._arr - var index = arr.length - keyIndices[key] = index - arr.push({key: key, priority: priority}) - this._decrease(index) - return true - } - return false -} - -/** - * Removes and returns the smallest key in the queue. Takes `O(log n)` time. - */ -PriorityQueue.prototype.removeMin = function () { - this._swap(0, this._arr.length - 1) - var min = this._arr.pop() - delete this._keyIndices[min.key] - this._heapify(0) - return min.key -} - -/** - * Decreases the priority for **key** to **priority**. If the new priority is - * greater than the previous priority, this function will throw an Error. - * - * @param {Object} key the key for which to raise priority - * @param {Number} priority the new priority for the key - */ -PriorityQueue.prototype.decrease = function (key, priority) { - var index = this._keyIndices[key] - if (priority > this._arr[index].priority) { - throw new Error('New priority is greater than current priority. ' + - 'Key: ' + key + ' Old: ' + this._arr[index].priority + ' New: ' + priority) - } - this._arr[index].priority = priority - this._decrease(index) -} - -PriorityQueue.prototype._heapify = function (i) { - const arr = this._arr - const l = 2 * i - const r = l + 1 - let largest = i - if (l < arr.length) { - largest = arr[l].priority < arr[largest].priority ? l : largest - if (r < arr.length) { - largest = arr[r].priority < arr[largest].priority ? r : largest - } - if (largest !== i) { - this._swap(i, largest) - this._heapify(largest) - } - } -} - -PriorityQueue.prototype._decrease = function (index) { - var arr = this._arr - var priority = arr[index].priority - var parent - while (index !== 0) { - parent = index >> 1 - if (arr[parent].priority < priority) { - break - } - this._swap(index, parent) - index = parent - } -} - -PriorityQueue.prototype._swap = function (i, j) { - var arr = this._arr - var keyIndices = this._keyIndices - var origArrI = arr[i] - var origArrJ = arr[j] - arr[i] = origArrJ - arr[j] = origArrI - keyIndices[origArrJ.key] = i - keyIndices[origArrI.key] = j -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/graph.js": -/*!************************************************!*\ - !*** ./node_modules/graphlibrary/lib/graph.js ***! - \************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ./lodash */ "./node_modules/graphlibrary/lib/lodash.js") - -module.exports = Graph - -const DEFAULT_EDGE_NAME = '\x00' -const GRAPH_NODE = '\x00' -const EDGE_KEY_DELIM = '\x01' - -// Implementation notes: -// -// * Node id query functions should return string ids for the nodes -// * Edge id query functions should return an "edgeObj", edge object, that is -// composed of enough information to uniquely identify an edge: {v, w, name}. -// * Internally we use an "edgeId", a stringified form of the edgeObj, to -// reference edges. This is because we need a performant way to look these -// edges up and, object properties, which have string keys, are the closest -// we're going to get to a performant hashtable in JavaScript. - -function Graph (opts) { - this._isDirected = _.has(opts, 'directed') ? opts.directed : true - this._isMultigraph = _.has(opts, 'multigraph') ? opts.multigraph : false - this._isCompound = _.has(opts, 'compound') ? opts.compound : false - - // Label for the graph itself - this._label = undefined - - // Defaults to be set when creating a new node - this._defaultNodeLabelFn = _.constant(undefined) - - // Defaults to be set when creating a new edge - this._defaultEdgeLabelFn = _.constant(undefined) - - // v -> label - this._nodes = {} - - if (this._isCompound) { - // v -> parent - this._parent = {} - - // v -> children - this._children = {} - this._children[GRAPH_NODE] = {} - } - - // v -> edgeObj - this._in = {} - - // u -> v -> Number - this._preds = {} - - // v -> edgeObj - this._out = {} - - // v -> w -> Number - this._sucs = {} - - // e -> edgeObj - this._edgeObjs = {} - - // e -> label - this._edgeLabels = {} -} - -/* Number of nodes in the graph. Should only be changed by the implementation. */ -Graph.prototype._nodeCount = 0 - -/* Number of edges in the graph. Should only be changed by the implementation. */ -Graph.prototype._edgeCount = 0 - -/* === Graph functions ========= */ - -Graph.prototype.isDirected = function () { - return this._isDirected -} - -Graph.prototype.isMultigraph = function () { - return this._isMultigraph -} - -Graph.prototype.isCompound = function () { - return this._isCompound -} - -Graph.prototype.setGraph = function (label) { - this._label = label - return this -} - -Graph.prototype.graph = function () { - return this._label -} - -/* === Node functions ========== */ - -Graph.prototype.setDefaultNodeLabel = function (newDefault) { - if (!_.isFunction(newDefault)) { - newDefault = _.constant(newDefault) - } - this._defaultNodeLabelFn = newDefault - return this -} - -Graph.prototype.nodeCount = function () { - return this._nodeCount -} - -Graph.prototype.nodes = function () { - return _.keys(this._nodes) -} - -Graph.prototype.sources = function () { - var self = this - return _.filter(this.nodes(), function (v) { - return _.isEmpty(self._in[v]) - }) -} - -Graph.prototype.sinks = function () { - var self = this - return _.filter(this.nodes(), function (v) { - return _.isEmpty(self._out[v]) - }) -} - -Graph.prototype.setNodes = function (vs, value) { - var args = arguments - var self = this - _.each(vs, function (v) { - if (args.length > 1) { - self.setNode(v, value) - } else { - self.setNode(v) - } - }) - return this -} - -Graph.prototype.setNode = function (v, value) { - if (_.has(this._nodes, v)) { - if (arguments.length > 1) { - this._nodes[v] = value - } - return this - } - - this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v) - if (this._isCompound) { - this._parent[v] = GRAPH_NODE - this._children[v] = {} - this._children[GRAPH_NODE][v] = true - } - this._in[v] = {} - this._preds[v] = {} - this._out[v] = {} - this._sucs[v] = {} - ++this._nodeCount - return this -} - -Graph.prototype.node = function (v) { - return this._nodes[v] -} - -Graph.prototype.hasNode = function (v) { - return _.has(this._nodes, v) -} - -Graph.prototype.removeNode = function (v) { - var self = this - if (_.has(this._nodes, v)) { - var removeEdge = function (e) { self.removeEdge(self._edgeObjs[e]) } - delete this._nodes[v] - if (this._isCompound) { - this._removeFromParentsChildList(v) - delete this._parent[v] - _.each(this.children(v), function (child) { - self.setParent(child) - }) - delete this._children[v] - } - _.each(_.keys(this._in[v]), removeEdge) - delete this._in[v] - delete this._preds[v] - _.each(_.keys(this._out[v]), removeEdge) - delete this._out[v] - delete this._sucs[v] - --this._nodeCount - } - return this -} - -Graph.prototype.setParent = function (v, parent) { - if (!this._isCompound) { - throw new Error('Cannot set parent in a non-compound graph') - } - - if (_.isUndefined(parent)) { - parent = GRAPH_NODE - } else { - // Coerce parent to string - parent += '' - for (var ancestor = parent; - !_.isUndefined(ancestor); - ancestor = this.parent(ancestor)) { - if (ancestor === v) { - throw new Error('Setting ' + parent + ' as parent of ' + v + - ' would create a cycle') - } - } - - this.setNode(parent) - } - - this.setNode(v) - this._removeFromParentsChildList(v) - this._parent[v] = parent - this._children[parent][v] = true - return this -} - -Graph.prototype._removeFromParentsChildList = function (v) { - delete this._children[this._parent[v]][v] -} - -Graph.prototype.parent = function (v) { - if (this._isCompound) { - var parent = this._parent[v] - if (parent !== GRAPH_NODE) { - return parent - } - } -} - -Graph.prototype.children = function (v) { - if (_.isUndefined(v)) { - v = GRAPH_NODE - } - - if (this._isCompound) { - var children = this._children[v] - if (children) { - return _.keys(children) - } - } else if (v === GRAPH_NODE) { - return this.nodes() - } else if (this.hasNode(v)) { - return [] - } -} - -Graph.prototype.predecessors = function (v) { - var predsV = this._preds[v] - if (predsV) { - return _.keys(predsV) - } -} - -Graph.prototype.successors = function (v) { - var sucsV = this._sucs[v] - if (sucsV) { - return _.keys(sucsV) - } -} - -Graph.prototype.neighbors = function (v) { - var preds = this.predecessors(v) - if (preds) { - return _.union(preds, this.successors(v)) - } -} - -Graph.prototype.isLeaf = function (v) { - var neighbors - if (this.isDirected()) { - neighbors = this.successors(v) - } else { - neighbors = this.neighbors(v) - } - return neighbors.length === 0 -} - -Graph.prototype.filterNodes = function (filter) { - var copy = new this.constructor({ - directed: this._isDirected, - multigraph: this._isMultigraph, - compound: this._isCompound - }) - - copy.setGraph(this.graph()) - - var self = this - _.each(this._nodes, function (value, v) { - if (filter(v)) { - copy.setNode(v, value) - } - }) - - _.each(this._edgeObjs, function (e) { - if (copy.hasNode(e.v) && copy.hasNode(e.w)) { - copy.setEdge(e, self.edge(e)) - } - }) - - var parents = {} - function findParent (v) { - var parent = self.parent(v) - if (parent === undefined || copy.hasNode(parent)) { - parents[v] = parent - return parent - } else if (parent in parents) { - return parents[parent] - } else { - return findParent(parent) - } - } - - if (this._isCompound) { - _.each(copy.nodes(), function (v) { - copy.setParent(v, findParent(v)) - }) - } - - return copy -} - -/* === Edge functions ========== */ - -Graph.prototype.setDefaultEdgeLabel = function (newDefault) { - if (!_.isFunction(newDefault)) { - newDefault = _.constant(newDefault) - } - this._defaultEdgeLabelFn = newDefault - return this -} - -Graph.prototype.edgeCount = function () { - return this._edgeCount -} - -Graph.prototype.edges = function () { - return _.values(this._edgeObjs) -} - -Graph.prototype.setPath = function (vs, value) { - const self = this - const args = arguments - _.reduce(vs, function (v, w) { - if (args.length > 1) { - self.setEdge(v, w, value) - } else { - self.setEdge(v, w) - } - return w - }) - return this -} - -/* - * setEdge(v, w, [value, [name]]) - * setEdge({ v, w, [name] }, [value]) - */ -Graph.prototype.setEdge = function () { - let v, w, name, value - let valueSpecified = false - const arg0 = arguments[0] - - if (typeof arg0 === 'object' && arg0 !== null && 'v' in arg0) { - v = arg0.v - w = arg0.w - name = arg0.name - if (arguments.length === 2) { - value = arguments[1] - valueSpecified = true - } - } else { - v = arg0 - w = arguments[1] - name = arguments[3] - if (arguments.length > 2) { - value = arguments[2] - valueSpecified = true - } - } - - v = '' + v - w = '' + w - if (!_.isUndefined(name)) { - name = '' + name - } - - var e = edgeArgsToId(this._isDirected, v, w, name) - if (_.has(this._edgeLabels, e)) { - if (valueSpecified) { - this._edgeLabels[e] = value - } - return this - } - - if (!_.isUndefined(name) && !this._isMultigraph) { - throw new Error('Cannot set a named edge when isMultigraph = false') - } - - // It didn't exist, so we need to create it. - // First ensure the nodes exist. - this.setNode(v) - this.setNode(w) - - this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name) - - var edgeObj = edgeArgsToObj(this._isDirected, v, w, name) - // Ensure we add undirected edges in a consistent way. - v = edgeObj.v - w = edgeObj.w - - Object.freeze(edgeObj) - this._edgeObjs[e] = edgeObj - incrementOrInitEntry(this._preds[w], v) - incrementOrInitEntry(this._sucs[v], w) - this._in[w][e] = edgeObj - this._out[v][e] = edgeObj - this._edgeCount++ - return this -} - -Graph.prototype.edge = function (v, w, name) { - var e = (arguments.length === 1 - ? edgeObjToId(this._isDirected, arguments[0]) - : edgeArgsToId(this._isDirected, v, w, name)) - return this._edgeLabels[e] -} - -Graph.prototype.hasEdge = function (v, w, name) { - var e = (arguments.length === 1 - ? edgeObjToId(this._isDirected, arguments[0]) - : edgeArgsToId(this._isDirected, v, w, name)) - return _.has(this._edgeLabels, e) -} - -Graph.prototype.removeEdge = function (v, w, name) { - const e = (arguments.length === 1 - ? edgeObjToId(this._isDirected, arguments[0]) - : edgeArgsToId(this._isDirected, v, w, name)) - const edge = this._edgeObjs[e] - if (edge) { - v = edge.v - w = edge.w - delete this._edgeLabels[e] - delete this._edgeObjs[e] - decrementOrRemoveEntry(this._preds[w], v) - decrementOrRemoveEntry(this._sucs[v], w) - delete this._in[w][e] - delete this._out[v][e] - this._edgeCount-- - } - return this -} - -Graph.prototype.inEdges = function (v, u) { - var inV = this._in[v] - if (inV) { - var edges = _.values(inV) - if (!u) { - return edges - } - return _.filter(edges, function (edge) { return edge.v === u }) - } -} - -Graph.prototype.outEdges = function (v, w) { - var outV = this._out[v] - if (outV) { - var edges = _.values(outV) - if (!w) { - return edges - } - return _.filter(edges, function (edge) { return edge.w === w }) - } -} - -Graph.prototype.nodeEdges = function (v, w) { - var inEdges = this.inEdges(v, w) - if (inEdges) { - return inEdges.concat(this.outEdges(v, w)) - } -} - -function incrementOrInitEntry (map, k) { - if (map[k]) { - map[k]++ - } else { - map[k] = 1 - } -} - -function decrementOrRemoveEntry (map, k) { - if (!--map[k]) { delete map[k] } -} - -function edgeArgsToId (isDirected, v_, w_, name) { - var v = '' + v_ - var w = '' + w_ - if (!isDirected && v > w) { - var tmp = v - v = w - w = tmp - } - return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + - (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name) -} - -function edgeArgsToObj (isDirected, v_, w_, name) { - var v = '' + v_ - var w = '' + w_ - if (!isDirected && v > w) { - var tmp = v - v = w - w = tmp - } - var edgeObj = { v: v, w: w } - if (name) { - edgeObj.name = name - } - return edgeObj -} - -function edgeObjToId (isDirected, edgeObj) { - return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name) -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/json.js": -/*!***********************************************!*\ - !*** ./node_modules/graphlibrary/lib/json.js ***! - \***********************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -const _ = __webpack_require__(/*! ./lodash */ "./node_modules/graphlibrary/lib/lodash.js") -const Graph = __webpack_require__(/*! ./graph */ "./node_modules/graphlibrary/lib/graph.js") - -module.exports = { - write: write, - read: read -} - -function write (g) { - var json = { - options: { - directed: g.isDirected(), - multigraph: g.isMultigraph(), - compound: g.isCompound() - }, - nodes: writeNodes(g), - edges: writeEdges(g) - } - if (!_.isUndefined(g.graph())) { - json.value = _.clone(g.graph()) - } - return json -} - -function writeNodes (g) { - return _.map(g.nodes(), function (v) { - const nodeValue = g.node(v) - const parent = g.parent(v) - const node = { v: v } - if (!_.isUndefined(nodeValue)) { - node.value = nodeValue - } - if (!_.isUndefined(parent)) { - node.parent = parent - } - return node - }) -} - -function writeEdges (g) { - return _.map(g.edges(), function (e) { - const edgeValue = g.edge(e) - const edge = { v: e.v, w: e.w } - if (!_.isUndefined(e.name)) { - edge.name = e.name - } - if (!_.isUndefined(edgeValue)) { - edge.value = edgeValue - } - return edge - }) -} - -function read (json) { - var g = new Graph(json.options).setGraph(json.value) - _.each(json.nodes, function (entry) { - g.setNode(entry.v, entry.value) - if (entry.parent) { - g.setParent(entry.v, entry.parent) - } - }) - _.each(json.edges, function (entry) { - g.setEdge({ v: entry.v, w: entry.w, name: entry.name }, entry.value) - }) - return g -} - - -/***/ }), - -/***/ "./node_modules/graphlibrary/lib/lodash.js": -/*!*************************************************!*\ - !*** ./node_modules/graphlibrary/lib/lodash.js ***! - \*************************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -/* global window */ - -var lodash - -if (true) { - try { - lodash = __webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js") - } catch (e) {} -} - -if (!lodash) { - lodash = window._ -} - -module.exports = lodash - - -/***/ }), - -/***/ "./node_modules/he/he.js": -/*!*******************************!*\ - !*** ./node_modules/he/he.js ***! - \*******************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(module, global) {/*! https://mths.be/he v1.2.0 by @mathias | MIT license */ -;(function(root) { - - // Detect free variables `exports`. - var freeExports = true && exports; - - // Detect free variable `module`. - var freeModule = true && module && - module.exports == freeExports && module; - - // Detect free variable `global`, from Node.js or Browserified code, - // and use it as `root`. - var freeGlobal = typeof global == 'object' && global; - if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) { - root = freeGlobal; - } - - /*--------------------------------------------------------------------------*/ - - // All astral symbols. - var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; - // All ASCII symbols (not just printable ASCII) except those listed in the - // first column of the overrides table. - // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides - var regexAsciiWhitelist = /[\x01-\x7F]/g; - // All BMP symbols that are not ASCII newlines, printable ASCII symbols, or - // code points listed in the first column of the overrides table on - // https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides. - var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g; - - var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g; - var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'}; - - var regexEscape = /["&'<>`]/g; - var escapeMap = { - '"': '"', - '&': '&', - '\'': ''', - '<': '<', - // See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the - // following is not strictly necessary unless it’s part of a tag or an - // unquoted attribute value. We’re only escaping it to support those - // situations, and for XML support. - '>': '>', - // In Internet Explorer ≤ 8, the backtick character can be used - // to break out of (un)quoted attribute values or HTML comments. - // See http://html5sec.org/#102, http://html5sec.org/#108, and - // http://html5sec.org/#133. - '`': '`' - }; - - var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/; - var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; - var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g; - var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'}; - var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'}; - var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'}; - var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111]; - - /*--------------------------------------------------------------------------*/ - - var stringFromCharCode = String.fromCharCode; - - var object = {}; - var hasOwnProperty = object.hasOwnProperty; - var has = function(object, propertyName) { - return hasOwnProperty.call(object, propertyName); - }; - - var contains = function(array, value) { - var index = -1; - var length = array.length; - while (++index < length) { - if (array[index] == value) { - return true; - } - } - return false; - }; - - var merge = function(options, defaults) { - if (!options) { - return defaults; - } - var result = {}; - var key; - for (key in defaults) { - // A `hasOwnProperty` check is not needed here, since only recognized - // option names are used anyway. Any others are ignored. - result[key] = has(options, key) ? options[key] : defaults[key]; - } - return result; - }; - - // Modified version of `ucs2encode`; see https://mths.be/punycode. - var codePointToSymbol = function(codePoint, strict) { - var output = ''; - if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) { - // See issue #4: - // “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is - // greater than 0x10FFFF, then this is a parse error. Return a U+FFFD - // REPLACEMENT CHARACTER.” - if (strict) { - parseError('character reference outside the permissible Unicode range'); - } - return '\uFFFD'; - } - if (has(decodeMapNumeric, codePoint)) { - if (strict) { - parseError('disallowed character reference'); - } - return decodeMapNumeric[codePoint]; - } - if (strict && contains(invalidReferenceCodePoints, codePoint)) { - parseError('disallowed character reference'); - } - if (codePoint > 0xFFFF) { - codePoint -= 0x10000; - output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800); - codePoint = 0xDC00 | codePoint & 0x3FF; - } - output += stringFromCharCode(codePoint); - return output; - }; - - var hexEscape = function(codePoint) { - return '&#x' + codePoint.toString(16).toUpperCase() + ';'; - }; - - var decEscape = function(codePoint) { - return '&#' + codePoint + ';'; - }; - - var parseError = function(message) { - throw Error('Parse error: ' + message); - }; - - /*--------------------------------------------------------------------------*/ - - var encode = function(string, options) { - options = merge(options, encode.options); - var strict = options.strict; - if (strict && regexInvalidRawCodePoint.test(string)) { - parseError('forbidden code point'); - } - var encodeEverything = options.encodeEverything; - var useNamedReferences = options.useNamedReferences; - var allowUnsafeSymbols = options.allowUnsafeSymbols; - var escapeCodePoint = options.decimal ? decEscape : hexEscape; - - var escapeBmpSymbol = function(symbol) { - return escapeCodePoint(symbol.charCodeAt(0)); - }; - - if (encodeEverything) { - // Encode ASCII symbols. - string = string.replace(regexAsciiWhitelist, function(symbol) { - // Use named references if requested & possible. - if (useNamedReferences && has(encodeMap, symbol)) { - return '&' + encodeMap[symbol] + ';'; - } - return escapeBmpSymbol(symbol); - }); - // Shorten a few escapes that represent two symbols, of which at least one - // is within the ASCII range. - if (useNamedReferences) { - string = string - .replace(/>\u20D2/g, '>⃒') - .replace(/<\u20D2/g, '<⃒') - .replace(/fj/g, 'fj'); - } - // Encode non-ASCII symbols. - if (useNamedReferences) { - // Encode non-ASCII symbols that can be replaced with a named reference. - string = string.replace(regexEncodeNonAscii, function(string) { - // Note: there is no need to check `has(encodeMap, string)` here. - return '&' + encodeMap[string] + ';'; - }); - } - // Note: any remaining non-ASCII symbols are handled outside of the `if`. - } else if (useNamedReferences) { - // Apply named character references. - // Encode `<>"'&` using named character references. - if (!allowUnsafeSymbols) { - string = string.replace(regexEscape, function(string) { - return '&' + encodeMap[string] + ';'; // no need to check `has()` here - }); - } - // Shorten escapes that represent two symbols, of which at least one is - // `<>"'&`. - string = string - .replace(/>\u20D2/g, '>⃒') - .replace(/<\u20D2/g, '<⃒'); - // Encode non-ASCII symbols that can be replaced with a named reference. - string = string.replace(regexEncodeNonAscii, function(string) { - // Note: there is no need to check `has(encodeMap, string)` here. - return '&' + encodeMap[string] + ';'; - }); - } else if (!allowUnsafeSymbols) { - // Encode `<>"'&` using hexadecimal escapes, now that they’re not handled - // using named character references. - string = string.replace(regexEscape, escapeBmpSymbol); - } - return string - // Encode astral symbols. - .replace(regexAstralSymbols, function($0) { - // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae - var high = $0.charCodeAt(0); - var low = $0.charCodeAt(1); - var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000; - return escapeCodePoint(codePoint); - }) - // Encode any remaining BMP symbols that are not printable ASCII symbols - // using a hexadecimal escape. - .replace(regexBmpWhitelist, escapeBmpSymbol); - }; - // Expose default options (so they can be overridden globally). - encode.options = { - 'allowUnsafeSymbols': false, - 'encodeEverything': false, - 'strict': false, - 'useNamedReferences': false, - 'decimal' : false - }; - - var decode = function(html, options) { - options = merge(options, decode.options); - var strict = options.strict; - if (strict && regexInvalidEntity.test(html)) { - parseError('malformed character reference'); - } - return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) { - var codePoint; - var semicolon; - var decDigits; - var hexDigits; - var reference; - var next; - - if ($1) { - reference = $1; - // Note: there is no need to check `has(decodeMap, reference)`. - return decodeMap[reference]; - } - - if ($2) { - // Decode named character references without trailing `;`, e.g. `&`. - // This is only a parse error if it gets converted to `&`, or if it is - // followed by `=` in an attribute context. - reference = $2; - next = $3; - if (next && options.isAttributeValue) { - if (strict && next == '=') { - parseError('`&` did not start a character reference'); - } - return $0; - } else { - if (strict) { - parseError( - 'named character reference was not terminated by a semicolon' - ); - } - // Note: there is no need to check `has(decodeMapLegacy, reference)`. - return decodeMapLegacy[reference] + (next || ''); - } - } - - if ($4) { - // Decode decimal escapes, e.g. `𝌆`. - decDigits = $4; - semicolon = $5; - if (strict && !semicolon) { - parseError('character reference was not terminated by a semicolon'); - } - codePoint = parseInt(decDigits, 10); - return codePointToSymbol(codePoint, strict); - } - - if ($6) { - // Decode hexadecimal escapes, e.g. `𝌆`. - hexDigits = $6; - semicolon = $7; - if (strict && !semicolon) { - parseError('character reference was not terminated by a semicolon'); - } - codePoint = parseInt(hexDigits, 16); - return codePointToSymbol(codePoint, strict); - } - - // If we’re still here, `if ($7)` is implied; it’s an ambiguous - // ampersand for sure. https://mths.be/notes/ambiguous-ampersands - if (strict) { - parseError( - 'named character reference was not terminated by a semicolon' - ); - } - return $0; - }); - }; - // Expose default options (so they can be overridden globally). - decode.options = { - 'isAttributeValue': false, - 'strict': false - }; - - var escape = function(string) { - return string.replace(regexEscape, function($0) { - // Note: there is no need to check `has(escapeMap, $0)` here. - return escapeMap[$0]; - }); - }; - - /*--------------------------------------------------------------------------*/ - - var he = { - 'version': '1.2.0', - 'encode': encode, - 'decode': decode, - 'escape': escape, - 'unescape': decode - }; - - // Some AMD build optimizers, like r.js, check for specific condition patterns - // like the following: - if ( - typeof define == 'function' && - typeof define.amd == 'object' && - define.amd - ) { - define(function() { - return he; - }); - } else if (freeExports && !freeExports.nodeType) { - if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+ - freeModule.exports = he; - } else { // in Narwhal or RingoJS v0.7.0- - for (var key in he) { - has(he, key) && (freeExports[key] = he[key]); - } - } - } else { // in Rhino or a web browser - root.he = he; - } - -}(this)); - -/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/module.js */ "./node_modules/webpack/buildin/module.js")(module), __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js"))) - -/***/ }), - -/***/ "./node_modules/is-regexp/index.js": -/*!*****************************************!*\ - !*** ./node_modules/is-regexp/index.js ***! - \*****************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -"use strict"; - -module.exports = function (re) { - return Object.prototype.toString.call(re) === '[object RegExp]'; -}; - - -/***/ }), - -/***/ "./node_modules/lodash/lodash.js": -/*!***************************************!*\ - !*** ./node_modules/lodash/lodash.js ***! - \***************************************/ -/*! no static exports found */ -/***/ (function(module, exports, __webpack_require__) { - -/* WEBPACK VAR INJECTION */(function(global, module) {/** - * @license - * Lodash - * Copyright OpenJS Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - */ -;(function() { - - /** Used as a safe reference for `undefined` in pre-ES5 environments. */ - var undefined; - - /** Used as the semantic version number. */ - var VERSION = '4.17.13'; - - /** Used as the size to enable large array optimizations. */ - var LARGE_ARRAY_SIZE = 200; - - /** Error message constants. */ - var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.', - FUNC_ERROR_TEXT = 'Expected a function'; - - /** Used to stand-in for `undefined` hash values. */ - var HASH_UNDEFINED = '__lodash_hash_undefined__'; - - /** Used as the maximum memoize cache size. */ - var MAX_MEMOIZE_SIZE = 500; - - /** Used as the internal argument placeholder. */ - var PLACEHOLDER = '__lodash_placeholder__'; - - /** Used to compose bitmasks for cloning. */ - var CLONE_DEEP_FLAG = 1, - CLONE_FLAT_FLAG = 2, - CLONE_SYMBOLS_FLAG = 4; - - /** Used to compose bitmasks for value comparisons. */ - var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - - /** Used to compose bitmasks for function metadata. */ - var WRAP_BIND_FLAG = 1, - WRAP_BIND_KEY_FLAG = 2, - WRAP_CURRY_BOUND_FLAG = 4, - WRAP_CURRY_FLAG = 8, - WRAP_CURRY_RIGHT_FLAG = 16, - WRAP_PARTIAL_FLAG = 32, - WRAP_PARTIAL_RIGHT_FLAG = 64, - WRAP_ARY_FLAG = 128, - WRAP_REARG_FLAG = 256, - WRAP_FLIP_FLAG = 512; - - /** Used as default options for `_.truncate`. */ - var DEFAULT_TRUNC_LENGTH = 30, - DEFAULT_TRUNC_OMISSION = '...'; - - /** Used to detect hot functions by number of calls within a span of milliseconds. */ - var HOT_COUNT = 800, - HOT_SPAN = 16; - - /** Used to indicate the type of lazy iteratees. */ - var LAZY_FILTER_FLAG = 1, - LAZY_MAP_FLAG = 2, - LAZY_WHILE_FLAG = 3; - - /** Used as references for various `Number` constants. */ - var INFINITY = 1 / 0, - MAX_SAFE_INTEGER = 9007199254740991, - MAX_INTEGER = 1.7976931348623157e+308, - NAN = 0 / 0; - - /** Used as references for the maximum length and index of an array. */ - var MAX_ARRAY_LENGTH = 4294967295, - MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, - HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1; - - /** Used to associate wrap methods with their bit flags. */ - var wrapFlags = [ - ['ary', WRAP_ARY_FLAG], - ['bind', WRAP_BIND_FLAG], - ['bindKey', WRAP_BIND_KEY_FLAG], - ['curry', WRAP_CURRY_FLAG], - ['curryRight', WRAP_CURRY_RIGHT_FLAG], - ['flip', WRAP_FLIP_FLAG], - ['partial', WRAP_PARTIAL_FLAG], - ['partialRight', WRAP_PARTIAL_RIGHT_FLAG], - ['rearg', WRAP_REARG_FLAG] - ]; - - /** `Object#toString` result references. */ - var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - asyncTag = '[object AsyncFunction]', - boolTag = '[object Boolean]', - dateTag = '[object Date]', - domExcTag = '[object DOMException]', - errorTag = '[object Error]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - mapTag = '[object Map]', - numberTag = '[object Number]', - nullTag = '[object Null]', - objectTag = '[object Object]', - promiseTag = '[object Promise]', - proxyTag = '[object Proxy]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]', - undefinedTag = '[object Undefined]', - weakMapTag = '[object WeakMap]', - weakSetTag = '[object WeakSet]'; - - var arrayBufferTag = '[object ArrayBuffer]', - dataViewTag = '[object DataView]', - float32Tag = '[object Float32Array]', - float64Tag = '[object Float64Array]', - int8Tag = '[object Int8Array]', - int16Tag = '[object Int16Array]', - int32Tag = '[object Int32Array]', - uint8Tag = '[object Uint8Array]', - uint8ClampedTag = '[object Uint8ClampedArray]', - uint16Tag = '[object Uint16Array]', - uint32Tag = '[object Uint32Array]'; - - /** Used to match empty string literals in compiled template source. */ - var reEmptyStringLeading = /\b__p \+= '';/g, - reEmptyStringMiddle = /\b(__p \+=) '' \+/g, - reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g; - - /** Used to match HTML entities and HTML characters. */ - var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, - reUnescapedHtml = /[&<>"']/g, - reHasEscapedHtml = RegExp(reEscapedHtml.source), - reHasUnescapedHtml = RegExp(reUnescapedHtml.source); - - /** Used to match template delimiters. */ - var reEscape = /<%-([\s\S]+?)%>/g, - reEvaluate = /<%([\s\S]+?)%>/g, - reInterpolate = /<%=([\s\S]+?)%>/g; - - /** Used to match property names within property paths. */ - var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/, - rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; - - /** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). - */ - var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, - reHasRegExpChar = RegExp(reRegExpChar.source); - - /** Used to match leading and trailing whitespace. */ - var reTrim = /^\s+|\s+$/g, - reTrimStart = /^\s+/, - reTrimEnd = /\s+$/; - - /** Used to match wrap detail comments. */ - var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, - reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, - reSplitDetails = /,? & /; - - /** Used to match words composed of alphanumeric characters. */ - var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; - - /** Used to match backslashes in property paths. */ - var reEscapeChar = /\\(\\)?/g; - - /** - * Used to match - * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components). - */ - var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g; - - /** Used to match `RegExp` flags from their coerced string values. */ - var reFlags = /\w*$/; - - /** Used to detect bad signed hexadecimal string values. */ - var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; - - /** Used to detect binary string values. */ - var reIsBinary = /^0b[01]+$/i; - - /** Used to detect host constructors (Safari). */ - var reIsHostCtor = /^\[object .+?Constructor\]$/; - - /** Used to detect octal string values. */ - var reIsOctal = /^0o[0-7]+$/i; - - /** Used to detect unsigned integer values. */ - var reIsUint = /^(?:0|[1-9]\d*)$/; - - /** Used to match Latin Unicode letters (excluding mathematical operators). */ - var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g; - - /** Used to ensure capturing order of template delimiters. */ - var reNoMatch = /($^)/; - - /** Used to match unescaped characters in compiled string literals. */ - var reUnescapedString = /['\n\r\u2028\u2029\\]/g; - - /** Used to compose unicode character classes. */ - var rsAstralRange = '\\ud800-\\udfff', - rsComboMarksRange = '\\u0300-\\u036f', - reComboHalfMarksRange = '\\ufe20-\\ufe2f', - rsComboSymbolsRange = '\\u20d0-\\u20ff', - rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, - rsDingbatRange = '\\u2700-\\u27bf', - rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff', - rsMathOpRange = '\\xac\\xb1\\xd7\\xf7', - rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf', - rsPunctuationRange = '\\u2000-\\u206f', - rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000', - rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde', - rsVarRange = '\\ufe0e\\ufe0f', - rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange; - - /** Used to compose unicode capture groups. */ - var rsApos = "['\u2019]", - rsAstral = '[' + rsAstralRange + ']', - rsBreak = '[' + rsBreakRange + ']', - rsCombo = '[' + rsComboRange + ']', - rsDigits = '\\d+', - rsDingbat = '[' + rsDingbatRange + ']', - rsLower = '[' + rsLowerRange + ']', - rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']', - rsFitz = '\\ud83c[\\udffb-\\udfff]', - rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', - rsNonAstral = '[^' + rsAstralRange + ']', - rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', - rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', - rsUpper = '[' + rsUpperRange + ']', - rsZWJ = '\\u200d'; - - /** Used to compose unicode regexes. */ - var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')', - rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')', - rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?', - rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?', - reOptMod = rsModifier + '?', - rsOptVar = '[' + rsVarRange + ']?', - rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', - rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])', - rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])', - rsSeq = rsOptVar + reOptMod + rsOptJoin, - rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq, - rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; - - /** Used to match apostrophes. */ - var reApos = RegExp(rsApos, 'g'); - - /** - * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and - * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols). - */ - var reComboMark = RegExp(rsCombo, 'g'); - - /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ - var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); - - /** Used to match complex or compound words. */ - var reUnicodeWord = RegExp([ - rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')', - rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')', - rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower, - rsUpper + '+' + rsOptContrUpper, - rsOrdUpper, - rsOrdLower, - rsDigits, - rsEmoji - ].join('|'), 'g'); - - /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */ - var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']'); - - /** Used to detect strings that need a more robust regexp to match words. */ - var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/; - - /** Used to assign default `context` object properties. */ - var contextProps = [ - 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array', - 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object', - 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array', - 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap', - '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout' - ]; - - /** Used to make template sourceURLs easier to identify. */ - var templateCounter = -1; - - /** Used to identify `toStringTag` values of typed arrays. */ - var typedArrayTags = {}; - typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = - typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = - typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = - typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = - typedArrayTags[uint32Tag] = true; - typedArrayTags[argsTag] = typedArrayTags[arrayTag] = - typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = - typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = - typedArrayTags[errorTag] = typedArrayTags[funcTag] = - typedArrayTags[mapTag] = typedArrayTags[numberTag] = - typedArrayTags[objectTag] = typedArrayTags[regexpTag] = - typedArrayTags[setTag] = typedArrayTags[stringTag] = - typedArrayTags[weakMapTag] = false; - - /** Used to identify `toStringTag` values supported by `_.clone`. */ - var cloneableTags = {}; - cloneableTags[argsTag] = cloneableTags[arrayTag] = - cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = - cloneableTags[boolTag] = cloneableTags[dateTag] = - cloneableTags[float32Tag] = cloneableTags[float64Tag] = - cloneableTags[int8Tag] = cloneableTags[int16Tag] = - cloneableTags[int32Tag] = cloneableTags[mapTag] = - cloneableTags[numberTag] = cloneableTags[objectTag] = - cloneableTags[regexpTag] = cloneableTags[setTag] = - cloneableTags[stringTag] = cloneableTags[symbolTag] = - cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = - cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; - cloneableTags[errorTag] = cloneableTags[funcTag] = - cloneableTags[weakMapTag] = false; - - /** Used to map Latin Unicode letters to basic Latin letters. */ - var deburredLetters = { - // Latin-1 Supplement block. - '\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A', - '\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a', - '\xc7': 'C', '\xe7': 'c', - '\xd0': 'D', '\xf0': 'd', - '\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E', - '\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e', - '\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I', - '\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i', - '\xd1': 'N', '\xf1': 'n', - '\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O', - '\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o', - '\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U', - '\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u', - '\xdd': 'Y', '\xfd': 'y', '\xff': 'y', - '\xc6': 'Ae', '\xe6': 'ae', - '\xde': 'Th', '\xfe': 'th', - '\xdf': 'ss', - // Latin Extended-A block. - '\u0100': 'A', '\u0102': 'A', '\u0104': 'A', - '\u0101': 'a', '\u0103': 'a', '\u0105': 'a', - '\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C', - '\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c', - '\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd', - '\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E', - '\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e', - '\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G', - '\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g', - '\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h', - '\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I', - '\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i', - '\u0134': 'J', '\u0135': 'j', - '\u0136': 'K', '\u0137': 'k', '\u0138': 'k', - '\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L', - '\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l', - '\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N', - '\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n', - '\u014c': 'O', '\u014e': 'O', '\u0150': 'O', - '\u014d': 'o', '\u014f': 'o', '\u0151': 'o', - '\u0154': 'R', '\u0156': 'R', '\u0158': 'R', - '\u0155': 'r', '\u0157': 'r', '\u0159': 'r', - '\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S', - '\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's', - '\u0162': 'T', '\u0164': 'T', '\u0166': 'T', - '\u0163': 't', '\u0165': 't', '\u0167': 't', - '\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U', - '\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u', - '\u0174': 'W', '\u0175': 'w', - '\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y', - '\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z', - '\u017a': 'z', '\u017c': 'z', '\u017e': 'z', - '\u0132': 'IJ', '\u0133': 'ij', - '\u0152': 'Oe', '\u0153': 'oe', - '\u0149': "'n", '\u017f': 's' - }; - - /** Used to map characters to HTML entities. */ - var htmlEscapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - "'": ''' - }; - - /** Used to map HTML entities to characters. */ - var htmlUnescapes = { - '&': '&', - '<': '<', - '>': '>', - '"': '"', - ''': "'" - }; - - /** Used to escape characters for inclusion in compiled string literals. */ - var stringEscapes = { - '\\': '\\', - "'": "'", - '\n': 'n', - '\r': 'r', - '\u2028': 'u2028', - '\u2029': 'u2029' - }; - - /** Built-in method references without a dependency on `root`. */ - var freeParseFloat = parseFloat, - freeParseInt = parseInt; - - /** Detect free variable `global` from Node.js. */ - var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; - - /** Detect free variable `self`. */ - var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - - /** Used as a reference to the global object. */ - var root = freeGlobal || freeSelf || Function('return this')(); - - /** Detect free variable `exports`. */ - var freeExports = true && exports && !exports.nodeType && exports; - - /** Detect free variable `module`. */ - var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; - - /** Detect the popular CommonJS extension `module.exports`. */ - var moduleExports = freeModule && freeModule.exports === freeExports; - - /** Detect free variable `process` from Node.js. */ - var freeProcess = moduleExports && freeGlobal.process; - - /** Used to access faster Node.js helpers. */ - var nodeUtil = (function() { - try { - // Use `util.types` for Node.js 10+. - var types = freeModule && freeModule.require && freeModule.require('util').types; - - if (types) { - return types; - } - - // Legacy `process.binding('util')` for Node.js < 10. - return freeProcess && freeProcess.binding && freeProcess.binding('util'); - } catch (e) {} - }()); - - /* Node.js helper references. */ - var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, - nodeIsDate = nodeUtil && nodeUtil.isDate, - nodeIsMap = nodeUtil && nodeUtil.isMap, - nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, - nodeIsSet = nodeUtil && nodeUtil.isSet, - nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; - - /*--------------------------------------------------------------------------*/ - - /** - * A faster alternative to `Function#apply`, this function invokes `func` - * with the `this` binding of `thisArg` and the arguments of `args`. - * - * @private - * @param {Function} func The function to invoke. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} args The arguments to invoke `func` with. - * @returns {*} Returns the result of `func`. - */ - function apply(func, thisArg, args) { - switch (args.length) { - case 0: return func.call(thisArg); - case 1: return func.call(thisArg, args[0]); - case 2: return func.call(thisArg, args[0], args[1]); - case 3: return func.call(thisArg, args[0], args[1], args[2]); - } - return func.apply(thisArg, args); - } - - /** - * A specialized version of `baseAggregator` for arrays. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform keys. - * @param {Object} accumulator The initial aggregated object. - * @returns {Function} Returns `accumulator`. - */ - function arrayAggregator(array, setter, iteratee, accumulator) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - var value = array[index]; - setter(accumulator, value, iteratee(value), array); - } - return accumulator; - } - - /** - * A specialized version of `_.forEach` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. - */ - function arrayEach(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (iteratee(array[index], index, array) === false) { - break; - } - } - return array; - } - - /** - * A specialized version of `_.forEachRight` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. - */ - function arrayEachRight(array, iteratee) { - var length = array == null ? 0 : array.length; - - while (length--) { - if (iteratee(array[length], length, array) === false) { - break; - } - } - return array; - } - - /** - * A specialized version of `_.every` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false`. - */ - function arrayEvery(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (!predicate(array[index], index, array)) { - return false; - } - } - return true; - } - - /** - * A specialized version of `_.filter` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ - function arrayFilter(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (predicate(value, index, array)) { - result[resIndex++] = value; - } - } - return result; - } - - /** - * A specialized version of `_.includes` for arrays without support for - * specifying an index to search from. - * - * @private - * @param {Array} [array] The array to inspect. - * @param {*} target The value to search for. - * @returns {boolean} Returns `true` if `target` is found, else `false`. - */ - function arrayIncludes(array, value) { - var length = array == null ? 0 : array.length; - return !!length && baseIndexOf(array, value, 0) > -1; - } - - /** - * This function is like `arrayIncludes` except that it accepts a comparator. - * - * @private - * @param {Array} [array] The array to inspect. - * @param {*} target The value to search for. - * @param {Function} comparator The comparator invoked per element. - * @returns {boolean} Returns `true` if `target` is found, else `false`. - */ - function arrayIncludesWith(array, value, comparator) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (comparator(value, array[index])) { - return true; - } - } - return false; - } - - /** - * A specialized version of `_.map` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ - function arrayMap(array, iteratee) { - var index = -1, - length = array == null ? 0 : array.length, - result = Array(length); - - while (++index < length) { - result[index] = iteratee(array[index], index, array); - } - return result; - } - - /** - * Appends the elements of `values` to `array`. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. - */ - function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length; - - while (++index < length) { - array[offset + index] = values[index]; - } - return array; - } - - /** - * A specialized version of `_.reduce` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @param {boolean} [initAccum] Specify using the first element of `array` as - * the initial value. - * @returns {*} Returns the accumulated value. - */ - function arrayReduce(array, iteratee, accumulator, initAccum) { - var index = -1, - length = array == null ? 0 : array.length; - - if (initAccum && length) { - accumulator = array[++index]; - } - while (++index < length) { - accumulator = iteratee(accumulator, array[index], index, array); - } - return accumulator; - } - - /** - * A specialized version of `_.reduceRight` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @param {boolean} [initAccum] Specify using the last element of `array` as - * the initial value. - * @returns {*} Returns the accumulated value. - */ - function arrayReduceRight(array, iteratee, accumulator, initAccum) { - var length = array == null ? 0 : array.length; - if (initAccum && length) { - accumulator = array[--length]; - } - while (length--) { - accumulator = iteratee(accumulator, array[length], length, array); - } - return accumulator; - } - - /** - * A specialized version of `_.some` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ - function arraySome(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (predicate(array[index], index, array)) { - return true; - } - } - return false; - } - - /** - * Gets the size of an ASCII `string`. - * - * @private - * @param {string} string The string inspect. - * @returns {number} Returns the string size. - */ - var asciiSize = baseProperty('length'); - - /** - * Converts an ASCII `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function asciiToArray(string) { - return string.split(''); - } - - /** - * Splits an ASCII `string` into an array of its words. - * - * @private - * @param {string} The string to inspect. - * @returns {Array} Returns the words of `string`. - */ - function asciiWords(string) { - return string.match(reAsciiWord) || []; - } - - /** - * The base implementation of methods like `_.findKey` and `_.findLastKey`, - * without support for iteratee shorthands, which iterates over `collection` - * using `eachFunc`. - * - * @private - * @param {Array|Object} collection The collection to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {Function} eachFunc The function to iterate over `collection`. - * @returns {*} Returns the found element or its key, else `undefined`. - */ - function baseFindKey(collection, predicate, eachFunc) { - var result; - eachFunc(collection, function(value, key, collection) { - if (predicate(value, key, collection)) { - result = key; - return false; - } - }); - return result; - } - - /** - * The base implementation of `_.findIndex` and `_.findLastIndex` without - * support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} predicate The function invoked per iteration. - * @param {number} fromIndex The index to search from. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseFindIndex(array, predicate, fromIndex, fromRight) { - var length = array.length, - index = fromIndex + (fromRight ? 1 : -1); - - while ((fromRight ? index-- : ++index < length)) { - if (predicate(array[index], index, array)) { - return index; - } - } - return -1; - } - - /** - * The base implementation of `_.indexOf` without `fromIndex` bounds checks. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseIndexOf(array, value, fromIndex) { - return value === value - ? strictIndexOf(array, value, fromIndex) - : baseFindIndex(array, baseIsNaN, fromIndex); - } - - /** - * This function is like `baseIndexOf` except that it accepts a comparator. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @param {Function} comparator The comparator invoked per element. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function baseIndexOfWith(array, value, fromIndex, comparator) { - var index = fromIndex - 1, - length = array.length; - - while (++index < length) { - if (comparator(array[index], value)) { - return index; - } - } - return -1; - } - - /** - * The base implementation of `_.isNaN` without support for number objects. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. - */ - function baseIsNaN(value) { - return value !== value; - } - - /** - * The base implementation of `_.mean` and `_.meanBy` without support for - * iteratee shorthands. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {number} Returns the mean. - */ - function baseMean(array, iteratee) { - var length = array == null ? 0 : array.length; - return length ? (baseSum(array, iteratee) / length) : NAN; - } - - /** - * The base implementation of `_.property` without support for deep paths. - * - * @private - * @param {string} key The key of the property to get. - * @returns {Function} Returns the new accessor function. - */ - function baseProperty(key) { - return function(object) { - return object == null ? undefined : object[key]; - }; - } - - /** - * The base implementation of `_.propertyOf` without support for deep paths. - * - * @private - * @param {Object} object The object to query. - * @returns {Function} Returns the new accessor function. - */ - function basePropertyOf(object) { - return function(key) { - return object == null ? undefined : object[key]; - }; - } - - /** - * The base implementation of `_.reduce` and `_.reduceRight`, without support - * for iteratee shorthands, which iterates over `collection` using `eachFunc`. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {*} accumulator The initial value. - * @param {boolean} initAccum Specify using the first or last element of - * `collection` as the initial value. - * @param {Function} eachFunc The function to iterate over `collection`. - * @returns {*} Returns the accumulated value. - */ - function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) { - eachFunc(collection, function(value, index, collection) { - accumulator = initAccum - ? (initAccum = false, value) - : iteratee(accumulator, value, index, collection); - }); - return accumulator; - } - - /** - * The base implementation of `_.sortBy` which uses `comparer` to define the - * sort order of `array` and replaces criteria objects with their corresponding - * values. - * - * @private - * @param {Array} array The array to sort. - * @param {Function} comparer The function to define sort order. - * @returns {Array} Returns `array`. - */ - function baseSortBy(array, comparer) { - var length = array.length; - - array.sort(comparer); - while (length--) { - array[length] = array[length].value; - } - return array; - } - - /** - * The base implementation of `_.sum` and `_.sumBy` without support for - * iteratee shorthands. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {number} Returns the sum. - */ - function baseSum(array, iteratee) { - var result, - index = -1, - length = array.length; - - while (++index < length) { - var current = iteratee(array[index]); - if (current !== undefined) { - result = result === undefined ? current : (result + current); - } - } - return result; - } - - /** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. - * - * @private - * @param {number} n The number of times to invoke `iteratee`. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. - */ - function baseTimes(n, iteratee) { - var index = -1, - result = Array(n); - - while (++index < n) { - result[index] = iteratee(index); - } - return result; - } - - /** - * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array - * of key-value pairs for `object` corresponding to the property names of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the key-value pairs. - */ - function baseToPairs(object, props) { - return arrayMap(props, function(key) { - return [key, object[key]]; - }); - } - - /** - * The base implementation of `_.unary` without support for storing metadata. - * - * @private - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - */ - function baseUnary(func) { - return function(value) { - return func(value); - }; - } - - /** - * The base implementation of `_.values` and `_.valuesIn` which creates an - * array of `object` property values corresponding to the property names - * of `props`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} props The property names to get values for. - * @returns {Object} Returns the array of property values. - */ - function baseValues(object, props) { - return arrayMap(props, function(key) { - return object[key]; - }); - } - - /** - * Checks if a `cache` value for `key` exists. - * - * @private - * @param {Object} cache The cache to query. - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function cacheHas(cache, key) { - return cache.has(key); - } - - /** - * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol - * that is not found in the character symbols. - * - * @private - * @param {Array} strSymbols The string symbols to inspect. - * @param {Array} chrSymbols The character symbols to find. - * @returns {number} Returns the index of the first unmatched string symbol. - */ - function charsStartIndex(strSymbols, chrSymbols) { - var index = -1, - length = strSymbols.length; - - while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} - return index; - } - - /** - * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol - * that is not found in the character symbols. - * - * @private - * @param {Array} strSymbols The string symbols to inspect. - * @param {Array} chrSymbols The character symbols to find. - * @returns {number} Returns the index of the last unmatched string symbol. - */ - function charsEndIndex(strSymbols, chrSymbols) { - var index = strSymbols.length; - - while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {} - return index; - } - - /** - * Gets the number of `placeholder` occurrences in `array`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} placeholder The placeholder to search for. - * @returns {number} Returns the placeholder count. - */ - function countHolders(array, placeholder) { - var length = array.length, - result = 0; - - while (length--) { - if (array[length] === placeholder) { - ++result; - } - } - return result; - } - - /** - * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A - * letters to basic Latin letters. - * - * @private - * @param {string} letter The matched letter to deburr. - * @returns {string} Returns the deburred letter. - */ - var deburrLetter = basePropertyOf(deburredLetters); - - /** - * Used by `_.escape` to convert characters to HTML entities. - * - * @private - * @param {string} chr The matched character to escape. - * @returns {string} Returns the escaped character. - */ - var escapeHtmlChar = basePropertyOf(htmlEscapes); - - /** - * Used by `_.template` to escape characters for inclusion in compiled string literals. - * - * @private - * @param {string} chr The matched character to escape. - * @returns {string} Returns the escaped character. - */ - function escapeStringChar(chr) { - return '\\' + stringEscapes[chr]; - } - - /** - * Gets the value at `key` of `object`. - * - * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ - function getValue(object, key) { - return object == null ? undefined : object[key]; - } - - /** - * Checks if `string` contains Unicode symbols. - * - * @private - * @param {string} string The string to inspect. - * @returns {boolean} Returns `true` if a symbol is found, else `false`. - */ - function hasUnicode(string) { - return reHasUnicode.test(string); - } - - /** - * Checks if `string` contains a word composed of Unicode symbols. - * - * @private - * @param {string} string The string to inspect. - * @returns {boolean} Returns `true` if a word is found, else `false`. - */ - function hasUnicodeWord(string) { - return reHasUnicodeWord.test(string); - } - - /** - * Converts `iterator` to an array. - * - * @private - * @param {Object} iterator The iterator to convert. - * @returns {Array} Returns the converted array. - */ - function iteratorToArray(iterator) { - var data, - result = []; - - while (!(data = iterator.next()).done) { - result.push(data.value); - } - return result; - } - - /** - * Converts `map` to its key-value pairs. - * - * @private - * @param {Object} map The map to convert. - * @returns {Array} Returns the key-value pairs. - */ - function mapToArray(map) { - var index = -1, - result = Array(map.size); - - map.forEach(function(value, key) { - result[++index] = [key, value]; - }); - return result; - } - - /** - * Creates a unary function that invokes `func` with its argument transformed. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. - */ - function overArg(func, transform) { - return function(arg) { - return func(transform(arg)); - }; - } - - /** - * Replaces all `placeholder` elements in `array` with an internal placeholder - * and returns an array of their indexes. - * - * @private - * @param {Array} array The array to modify. - * @param {*} placeholder The placeholder to replace. - * @returns {Array} Returns the new array of placeholder indexes. - */ - function replaceHolders(array, placeholder) { - var index = -1, - length = array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value === placeholder || value === PLACEHOLDER) { - array[index] = PLACEHOLDER; - result[resIndex++] = index; - } - } - return result; - } - - /** - * Converts `set` to an array of its values. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the values. - */ - function setToArray(set) { - var index = -1, - result = Array(set.size); - - set.forEach(function(value) { - result[++index] = value; - }); - return result; - } - - /** - * Converts `set` to its value-value pairs. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the value-value pairs. - */ - function setToPairs(set) { - var index = -1, - result = Array(set.size); - - set.forEach(function(value) { - result[++index] = [value, value]; - }); - return result; - } - - /** - * A specialized version of `_.indexOf` which performs strict equality - * comparisons of values, i.e. `===`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function strictIndexOf(array, value, fromIndex) { - var index = fromIndex - 1, - length = array.length; - - while (++index < length) { - if (array[index] === value) { - return index; - } - } - return -1; - } - - /** - * A specialized version of `_.lastIndexOf` which performs strict equality - * comparisons of values, i.e. `===`. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} fromIndex The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function strictLastIndexOf(array, value, fromIndex) { - var index = fromIndex + 1; - while (index--) { - if (array[index] === value) { - return index; - } - } - return index; - } - - /** - * Gets the number of symbols in `string`. - * - * @private - * @param {string} string The string to inspect. - * @returns {number} Returns the string size. - */ - function stringSize(string) { - return hasUnicode(string) - ? unicodeSize(string) - : asciiSize(string); - } - - /** - * Converts `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function stringToArray(string) { - return hasUnicode(string) - ? unicodeToArray(string) - : asciiToArray(string); - } - - /** - * Used by `_.unescape` to convert HTML entities to characters. - * - * @private - * @param {string} chr The matched character to unescape. - * @returns {string} Returns the unescaped character. - */ - var unescapeHtmlChar = basePropertyOf(htmlUnescapes); - - /** - * Gets the size of a Unicode `string`. - * - * @private - * @param {string} string The string inspect. - * @returns {number} Returns the string size. - */ - function unicodeSize(string) { - var result = reUnicode.lastIndex = 0; - while (reUnicode.test(string)) { - ++result; - } - return result; - } - - /** - * Converts a Unicode `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function unicodeToArray(string) { - return string.match(reUnicode) || []; - } - - /** - * Splits a Unicode `string` into an array of its words. - * - * @private - * @param {string} The string to inspect. - * @returns {Array} Returns the words of `string`. - */ - function unicodeWords(string) { - return string.match(reUnicodeWord) || []; - } - - /*--------------------------------------------------------------------------*/ - - /** - * Create a new pristine `lodash` function using the `context` object. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Util - * @param {Object} [context=root] The context object. - * @returns {Function} Returns a new `lodash` function. - * @example - * - * _.mixin({ 'foo': _.constant('foo') }); - * - * var lodash = _.runInContext(); - * lodash.mixin({ 'bar': lodash.constant('bar') }); - * - * _.isFunction(_.foo); - * // => true - * _.isFunction(_.bar); - * // => false - * - * lodash.isFunction(lodash.foo); - * // => false - * lodash.isFunction(lodash.bar); - * // => true - * - * // Create a suped-up `defer` in Node.js. - * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer; - */ - var runInContext = (function runInContext(context) { - context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps)); - - /** Built-in constructor references. */ - var Array = context.Array, - Date = context.Date, - Error = context.Error, - Function = context.Function, - Math = context.Math, - Object = context.Object, - RegExp = context.RegExp, - String = context.String, - TypeError = context.TypeError; - - /** Used for built-in method references. */ - var arrayProto = Array.prototype, - funcProto = Function.prototype, - objectProto = Object.prototype; - - /** Used to detect overreaching core-js shims. */ - var coreJsData = context['__core-js_shared__']; - - /** Used to resolve the decompiled source of functions. */ - var funcToString = funcProto.toString; - - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; - - /** Used to generate unique IDs. */ - var idCounter = 0; - - /** Used to detect methods masquerading as native. */ - var maskSrcKey = (function() { - var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); - return uid ? ('Symbol(src)_1.' + uid) : ''; - }()); - - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ - var nativeObjectToString = objectProto.toString; - - /** Used to infer the `Object` constructor. */ - var objectCtorString = funcToString.call(Object); - - /** Used to restore the original `_` reference in `_.noConflict`. */ - var oldDash = root._; - - /** Used to detect if a method is native. */ - var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' - ); - - /** Built-in value references. */ - var Buffer = moduleExports ? context.Buffer : undefined, - Symbol = context.Symbol, - Uint8Array = context.Uint8Array, - allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined, - getPrototype = overArg(Object.getPrototypeOf, Object), - objectCreate = Object.create, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - splice = arrayProto.splice, - spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined, - symIterator = Symbol ? Symbol.iterator : undefined, - symToStringTag = Symbol ? Symbol.toStringTag : undefined; - - var defineProperty = (function() { - try { - var func = getNative(Object, 'defineProperty'); - func({}, '', {}); - return func; - } catch (e) {} - }()); - - /** Mocked built-ins. */ - var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, - ctxNow = Date && Date.now !== root.Date.now && Date.now, - ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout; - - /* Built-in method references for those with the same name as other `lodash` methods. */ - var nativeCeil = Math.ceil, - nativeFloor = Math.floor, - nativeGetSymbols = Object.getOwnPropertySymbols, - nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, - nativeIsFinite = context.isFinite, - nativeJoin = arrayProto.join, - nativeKeys = overArg(Object.keys, Object), - nativeMax = Math.max, - nativeMin = Math.min, - nativeNow = Date.now, - nativeParseInt = context.parseInt, - nativeRandom = Math.random, - nativeReverse = arrayProto.reverse; - - /* Built-in method references that are verified to be native. */ - var DataView = getNative(context, 'DataView'), - Map = getNative(context, 'Map'), - Promise = getNative(context, 'Promise'), - Set = getNative(context, 'Set'), - WeakMap = getNative(context, 'WeakMap'), - nativeCreate = getNative(Object, 'create'); - - /** Used to store function metadata. */ - var metaMap = WeakMap && new WeakMap; - - /** Used to lookup unminified function names. */ - var realNames = {}; - - /** Used to detect maps, sets, and weakmaps. */ - var dataViewCtorString = toSource(DataView), - mapCtorString = toSource(Map), - promiseCtorString = toSource(Promise), - setCtorString = toSource(Set), - weakMapCtorString = toSource(WeakMap); - - /** Used to convert symbols to primitives and strings. */ - var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined, - symbolToString = symbolProto ? symbolProto.toString : undefined; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` object which wraps `value` to enable implicit method - * chain sequences. Methods that operate on and return arrays, collections, - * and functions can be chained together. Methods that retrieve a single value - * or may return a primitive value will automatically end the chain sequence - * and return the unwrapped value. Otherwise, the value must be unwrapped - * with `_#value`. - * - * Explicit chain sequences, which must be unwrapped with `_#value`, may be - * enabled using `_.chain`. - * - * The execution of chained methods is lazy, that is, it's deferred until - * `_#value` is implicitly or explicitly called. - * - * Lazy evaluation allows several methods to support shortcut fusion. - * Shortcut fusion is an optimization to merge iteratee calls; this avoids - * the creation of intermediate arrays and can greatly reduce the number of - * iteratee executions. Sections of a chain sequence qualify for shortcut - * fusion if the section is applied to an array and iteratees accept only - * one argument. The heuristic for whether a section qualifies for shortcut - * fusion is subject to change. - * - * Chaining is supported in custom builds as long as the `_#value` method is - * directly or indirectly included in the build. - * - * In addition to lodash methods, wrappers have `Array` and `String` methods. - * - * The wrapper `Array` methods are: - * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift` - * - * The wrapper `String` methods are: - * `replace` and `split` - * - * The wrapper methods that support shortcut fusion are: - * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`, - * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`, - * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray` - * - * The chainable wrapper methods are: - * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`, - * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`, - * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`, - * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`, - * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`, - * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`, - * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`, - * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`, - * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`, - * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`, - * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`, - * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`, - * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`, - * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`, - * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`, - * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`, - * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`, - * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`, - * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`, - * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`, - * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`, - * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`, - * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`, - * `zipObject`, `zipObjectDeep`, and `zipWith` - * - * The wrapper methods that are **not** chainable by default are: - * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`, - * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`, - * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`, - * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`, - * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`, - * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`, - * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`, - * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`, - * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`, - * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`, - * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`, - * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`, - * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`, - * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`, - * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`, - * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`, - * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`, - * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`, - * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`, - * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`, - * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`, - * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`, - * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`, - * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`, - * `upperFirst`, `value`, and `words` - * - * @name _ - * @constructor - * @category Seq - * @param {*} value The value to wrap in a `lodash` instance. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * function square(n) { - * return n * n; - * } - * - * var wrapped = _([1, 2, 3]); - * - * // Returns an unwrapped value. - * wrapped.reduce(_.add); - * // => 6 - * - * // Returns a wrapped value. - * var squares = wrapped.map(square); - * - * _.isArray(squares); - * // => false - * - * _.isArray(squares.value()); - * // => true - */ - function lodash(value) { - if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) { - if (value instanceof LodashWrapper) { - return value; - } - if (hasOwnProperty.call(value, '__wrapped__')) { - return wrapperClone(value); - } - } - return new LodashWrapper(value); - } - - /** - * The base implementation of `_.create` without support for assigning - * properties to the created object. - * - * @private - * @param {Object} proto The object to inherit from. - * @returns {Object} Returns the new object. - */ - var baseCreate = (function() { - function object() {} - return function(proto) { - if (!isObject(proto)) { - return {}; - } - if (objectCreate) { - return objectCreate(proto); - } - object.prototype = proto; - var result = new object; - object.prototype = undefined; - return result; - }; - }()); - - /** - * The function whose prototype chain sequence wrappers inherit from. - * - * @private - */ - function baseLodash() { - // No operation performed. - } - - /** - * The base constructor for creating `lodash` wrapper objects. - * - * @private - * @param {*} value The value to wrap. - * @param {boolean} [chainAll] Enable explicit method chain sequences. - */ - function LodashWrapper(value, chainAll) { - this.__wrapped__ = value; - this.__actions__ = []; - this.__chain__ = !!chainAll; - this.__index__ = 0; - this.__values__ = undefined; - } - - /** - * By default, the template delimiters used by lodash are like those in - * embedded Ruby (ERB) as well as ES2015 template strings. Change the - * following template settings to use alternative delimiters. - * - * @static - * @memberOf _ - * @type {Object} - */ - lodash.templateSettings = { - - /** - * Used to detect `data` property values to be HTML-escaped. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - 'escape': reEscape, - - /** - * Used to detect code to be evaluated. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - 'evaluate': reEvaluate, - - /** - * Used to detect `data` property values to inject. - * - * @memberOf _.templateSettings - * @type {RegExp} - */ - 'interpolate': reInterpolate, - - /** - * Used to reference the data object in the template text. - * - * @memberOf _.templateSettings - * @type {string} - */ - 'variable': '', - - /** - * Used to import variables into the compiled template. - * - * @memberOf _.templateSettings - * @type {Object} - */ - 'imports': { - - /** - * A reference to the `lodash` function. - * - * @memberOf _.templateSettings.imports - * @type {Function} - */ - '_': lodash - } - }; - - // Ensure wrappers are instances of `baseLodash`. - lodash.prototype = baseLodash.prototype; - lodash.prototype.constructor = lodash; - - LodashWrapper.prototype = baseCreate(baseLodash.prototype); - LodashWrapper.prototype.constructor = LodashWrapper; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. - * - * @private - * @constructor - * @param {*} value The value to wrap. - */ - function LazyWrapper(value) { - this.__wrapped__ = value; - this.__actions__ = []; - this.__dir__ = 1; - this.__filtered__ = false; - this.__iteratees__ = []; - this.__takeCount__ = MAX_ARRAY_LENGTH; - this.__views__ = []; - } - - /** - * Creates a clone of the lazy wrapper object. - * - * @private - * @name clone - * @memberOf LazyWrapper - * @returns {Object} Returns the cloned `LazyWrapper` object. - */ - function lazyClone() { - var result = new LazyWrapper(this.__wrapped__); - result.__actions__ = copyArray(this.__actions__); - result.__dir__ = this.__dir__; - result.__filtered__ = this.__filtered__; - result.__iteratees__ = copyArray(this.__iteratees__); - result.__takeCount__ = this.__takeCount__; - result.__views__ = copyArray(this.__views__); - return result; - } - - /** - * Reverses the direction of lazy iteration. - * - * @private - * @name reverse - * @memberOf LazyWrapper - * @returns {Object} Returns the new reversed `LazyWrapper` object. - */ - function lazyReverse() { - if (this.__filtered__) { - var result = new LazyWrapper(this); - result.__dir__ = -1; - result.__filtered__ = true; - } else { - result = this.clone(); - result.__dir__ *= -1; - } - return result; - } - - /** - * Extracts the unwrapped value from its lazy wrapper. - * - * @private - * @name value - * @memberOf LazyWrapper - * @returns {*} Returns the unwrapped value. - */ - function lazyValue() { - var array = this.__wrapped__.value(), - dir = this.__dir__, - isArr = isArray(array), - isRight = dir < 0, - arrLength = isArr ? array.length : 0, - view = getView(0, arrLength, this.__views__), - start = view.start, - end = view.end, - length = end - start, - index = isRight ? end : (start - 1), - iteratees = this.__iteratees__, - iterLength = iteratees.length, - resIndex = 0, - takeCount = nativeMin(length, this.__takeCount__); - - if (!isArr || (!isRight && arrLength == length && takeCount == length)) { - return baseWrapperValue(array, this.__actions__); - } - var result = []; - - outer: - while (length-- && resIndex < takeCount) { - index += dir; - - var iterIndex = -1, - value = array[index]; - - while (++iterIndex < iterLength) { - var data = iteratees[iterIndex], - iteratee = data.iteratee, - type = data.type, - computed = iteratee(value); - - if (type == LAZY_MAP_FLAG) { - value = computed; - } else if (!computed) { - if (type == LAZY_FILTER_FLAG) { - continue outer; - } else { - break outer; - } - } - } - result[resIndex++] = value; - } - return result; - } - - // Ensure `LazyWrapper` is an instance of `baseLodash`. - LazyWrapper.prototype = baseCreate(baseLodash.prototype); - LazyWrapper.prototype.constructor = LazyWrapper; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function Hash(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } - - /** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ - function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; - this.size = 0; - } - - /** - * Removes `key` and its value from the hash. - * - * @private - * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function hashDelete(key) { - var result = this.has(key) && delete this.__data__[key]; - this.size -= result ? 1 : 0; - return result; - } - - /** - * Gets the hash value for `key`. - * - * @private - * @name get - * @memberOf Hash - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function hashGet(key) { - var data = this.__data__; - if (nativeCreate) { - var result = data[key]; - return result === HASH_UNDEFINED ? undefined : result; - } - return hasOwnProperty.call(data, key) ? data[key] : undefined; - } - - /** - * Checks if a hash value for `key` exists. - * - * @private - * @name has - * @memberOf Hash - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function hashHas(key) { - var data = this.__data__; - return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); - } - - /** - * Sets the hash `key` to `value`. - * - * @private - * @name set - * @memberOf Hash - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. - */ - function hashSet(key, value) { - var data = this.__data__; - this.size += this.has(key) ? 0 : 1; - data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; - return this; - } - - // Add methods to `Hash`. - Hash.prototype.clear = hashClear; - Hash.prototype['delete'] = hashDelete; - Hash.prototype.get = hashGet; - Hash.prototype.has = hashHas; - Hash.prototype.set = hashSet; - - /*------------------------------------------------------------------------*/ - - /** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function ListCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } - - /** - * Removes all key-value entries from the list cache. - * - * @private - * @name clear - * @memberOf ListCache - */ - function listCacheClear() { - this.__data__ = []; - this.size = 0; - } - - /** - * Removes `key` and its value from the list cache. - * - * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - return false; - } - var lastIndex = data.length - 1; - if (index == lastIndex) { - data.pop(); - } else { - splice.call(data, index, 1); - } - --this.size; - return true; - } - - /** - * Gets the list cache value for `key`. - * - * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - return index < 0 ? undefined : data[index][1]; - } - - /** - * Checks if a list cache value for `key` exists. - * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1; - } - - /** - * Sets the list cache `key` to `value`. - * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. - */ - function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - ++this.size; - data.push([key, value]); - } else { - data[index][1] = value; - } - return this; - } - - // Add methods to `ListCache`. - ListCache.prototype.clear = listCacheClear; - ListCache.prototype['delete'] = listCacheDelete; - ListCache.prototype.get = listCacheGet; - ListCache.prototype.has = listCacheHas; - ListCache.prototype.set = listCacheSet; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function MapCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } - - /** - * Removes all key-value entries from the map. - * - * @private - * @name clear - * @memberOf MapCache - */ - function mapCacheClear() { - this.size = 0; - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; - } - - /** - * Removes `key` and its value from the map. - * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function mapCacheDelete(key) { - var result = getMapData(this, key)['delete'](key); - this.size -= result ? 1 : 0; - return result; - } - - /** - * Gets the map value for `key`. - * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function mapCacheGet(key) { - return getMapData(this, key).get(key); - } - - /** - * Checks if a map value for `key` exists. - * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function mapCacheHas(key) { - return getMapData(this, key).has(key); - } - - /** - * Sets the map `key` to `value`. - * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. - */ - function mapCacheSet(key, value) { - var data = getMapData(this, key), - size = data.size; - - data.set(key, value); - this.size += data.size == size ? 0 : 1; - return this; - } - - // Add methods to `MapCache`. - MapCache.prototype.clear = mapCacheClear; - MapCache.prototype['delete'] = mapCacheDelete; - MapCache.prototype.get = mapCacheGet; - MapCache.prototype.has = mapCacheHas; - MapCache.prototype.set = mapCacheSet; - - /*------------------------------------------------------------------------*/ - - /** - * - * Creates an array cache object to store unique values. - * - * @private - * @constructor - * @param {Array} [values] The values to cache. - */ - function SetCache(values) { - var index = -1, - length = values == null ? 0 : values.length; - - this.__data__ = new MapCache; - while (++index < length) { - this.add(values[index]); - } - } - - /** - * Adds `value` to the array cache. - * - * @private - * @name add - * @memberOf SetCache - * @alias push - * @param {*} value The value to cache. - * @returns {Object} Returns the cache instance. - */ - function setCacheAdd(value) { - this.__data__.set(value, HASH_UNDEFINED); - return this; - } - - /** - * Checks if `value` is in the array cache. - * - * @private - * @name has - * @memberOf SetCache - * @param {*} value The value to search for. - * @returns {number} Returns `true` if `value` is found, else `false`. - */ - function setCacheHas(value) { - return this.__data__.has(value); - } - - // Add methods to `SetCache`. - SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; - SetCache.prototype.has = setCacheHas; - - /*------------------------------------------------------------------------*/ - - /** - * Creates a stack cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ - function Stack(entries) { - var data = this.__data__ = new ListCache(entries); - this.size = data.size; - } - - /** - * Removes all key-value entries from the stack. - * - * @private - * @name clear - * @memberOf Stack - */ - function stackClear() { - this.__data__ = new ListCache; - this.size = 0; - } - - /** - * Removes `key` and its value from the stack. - * - * @private - * @name delete - * @memberOf Stack - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ - function stackDelete(key) { - var data = this.__data__, - result = data['delete'](key); - - this.size = data.size; - return result; - } - - /** - * Gets the stack value for `key`. - * - * @private - * @name get - * @memberOf Stack - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ - function stackGet(key) { - return this.__data__.get(key); - } - - /** - * Checks if a stack value for `key` exists. - * - * @private - * @name has - * @memberOf Stack - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ - function stackHas(key) { - return this.__data__.has(key); - } - - /** - * Sets the stack `key` to `value`. - * - * @private - * @name set - * @memberOf Stack - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the stack cache instance. - */ - function stackSet(key, value) { - var data = this.__data__; - if (data instanceof ListCache) { - var pairs = data.__data__; - if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { - pairs.push([key, value]); - this.size = ++data.size; - return this; - } - data = this.__data__ = new MapCache(pairs); - } - data.set(key, value); - this.size = data.size; - return this; - } - - // Add methods to `Stack`. - Stack.prototype.clear = stackClear; - Stack.prototype['delete'] = stackDelete; - Stack.prototype.get = stackGet; - Stack.prototype.has = stackHas; - Stack.prototype.set = stackSet; - - /*------------------------------------------------------------------------*/ - - /** - * Creates an array of the enumerable property names of the array-like `value`. - * - * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. - */ - function arrayLikeKeys(value, inherited) { - var isArr = isArray(value), - isArg = !isArr && isArguments(value), - isBuff = !isArr && !isArg && isBuffer(value), - isType = !isArr && !isArg && !isBuff && isTypedArray(value), - skipIndexes = isArr || isArg || isBuff || isType, - result = skipIndexes ? baseTimes(value.length, String) : [], - length = result.length; - - for (var key in value) { - if ((inherited || hasOwnProperty.call(value, key)) && - !(skipIndexes && ( - // Safari 9 has enumerable `arguments.length` in strict mode. - key == 'length' || - // Node.js 0.10 has enumerable non-index properties on buffers. - (isBuff && (key == 'offset' || key == 'parent')) || - // PhantomJS 2 has enumerable non-index properties on typed arrays. - (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || - // Skip index properties. - isIndex(key, length) - ))) { - result.push(key); - } - } - return result; - } - - /** - * A specialized version of `_.sample` for arrays. - * - * @private - * @param {Array} array The array to sample. - * @returns {*} Returns the random element. - */ - function arraySample(array) { - var length = array.length; - return length ? array[baseRandom(0, length - 1)] : undefined; - } - - /** - * A specialized version of `_.sampleSize` for arrays. - * - * @private - * @param {Array} array The array to sample. - * @param {number} n The number of elements to sample. - * @returns {Array} Returns the random elements. - */ - function arraySampleSize(array, n) { - return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); - } - - /** - * A specialized version of `_.shuffle` for arrays. - * - * @private - * @param {Array} array The array to shuffle. - * @returns {Array} Returns the new shuffled array. - */ - function arrayShuffle(array) { - return shuffleSelf(copyArray(array)); - } - - /** - * This function is like `assignValue` except that it doesn't assign - * `undefined` values. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function assignMergeValue(object, key, value) { - if ((value !== undefined && !eq(object[key], value)) || - (value === undefined && !(key in object))) { - baseAssignValue(object, key, value); - } - } - - /** - * Assigns `value` to `key` of `object` if the existing value is not equivalent - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function assignValue(object, key, value) { - var objValue = object[key]; - if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || - (value === undefined && !(key in object))) { - baseAssignValue(object, key, value); - } - } - - /** - * Gets the index at which the `key` is found in `array` of key-value pairs. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - */ - function assocIndexOf(array, key) { - var length = array.length; - while (length--) { - if (eq(array[length][0], key)) { - return length; - } - } - return -1; - } - - /** - * Aggregates elements of `collection` on `accumulator` with keys transformed - * by `iteratee` and values set by `setter`. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform keys. - * @param {Object} accumulator The initial aggregated object. - * @returns {Function} Returns `accumulator`. - */ - function baseAggregator(collection, setter, iteratee, accumulator) { - baseEach(collection, function(value, key, collection) { - setter(accumulator, value, iteratee(value), collection); - }); - return accumulator; - } - - /** - * The base implementation of `_.assign` without support for multiple sources - * or `customizer` functions. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. - */ - function baseAssign(object, source) { - return object && copyObject(source, keys(source), object); - } - - /** - * The base implementation of `_.assignIn` without support for multiple sources - * or `customizer` functions. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. - */ - function baseAssignIn(object, source) { - return object && copyObject(source, keysIn(source), object); - } - - /** - * The base implementation of `assignValue` and `assignMergeValue` without - * value checks. - * - * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. - */ - function baseAssignValue(object, key, value) { - if (key == '__proto__' && defineProperty) { - defineProperty(object, key, { - 'configurable': true, - 'enumerable': true, - 'value': value, - 'writable': true - }); - } else { - object[key] = value; - } - } - - /** - * The base implementation of `_.at` without support for individual paths. - * - * @private - * @param {Object} object The object to iterate over. - * @param {string[]} paths The property paths to pick. - * @returns {Array} Returns the picked elements. - */ - function baseAt(object, paths) { - var index = -1, - length = paths.length, - result = Array(length), - skip = object == null; - - while (++index < length) { - result[index] = skip ? undefined : get(object, paths[index]); - } - return result; - } - - /** - * The base implementation of `_.clamp` which doesn't coerce arguments. - * - * @private - * @param {number} number The number to clamp. - * @param {number} [lower] The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the clamped number. - */ - function baseClamp(number, lower, upper) { - if (number === number) { - if (upper !== undefined) { - number = number <= upper ? number : upper; - } - if (lower !== undefined) { - number = number >= lower ? number : lower; - } - } - return number; - } - - /** - * The base implementation of `_.clone` and `_.cloneDeep` which tracks - * traversed objects. - * - * @private - * @param {*} value The value to clone. - * @param {boolean} bitmask The bitmask flags. - * 1 - Deep clone - * 2 - Flatten inherited properties - * 4 - Clone symbols - * @param {Function} [customizer] The function to customize cloning. - * @param {string} [key] The key of `value`. - * @param {Object} [object] The parent object of `value`. - * @param {Object} [stack] Tracks traversed objects and their clone counterparts. - * @returns {*} Returns the cloned value. - */ - function baseClone(value, bitmask, customizer, key, object, stack) { - var result, - isDeep = bitmask & CLONE_DEEP_FLAG, - isFlat = bitmask & CLONE_FLAT_FLAG, - isFull = bitmask & CLONE_SYMBOLS_FLAG; - - if (customizer) { - result = object ? customizer(value, key, object, stack) : customizer(value); - } - if (result !== undefined) { - return result; - } - if (!isObject(value)) { - return value; - } - var isArr = isArray(value); - if (isArr) { - result = initCloneArray(value); - if (!isDeep) { - return copyArray(value, result); - } - } else { - var tag = getTag(value), - isFunc = tag == funcTag || tag == genTag; - - if (isBuffer(value)) { - return cloneBuffer(value, isDeep); - } - if (tag == objectTag || tag == argsTag || (isFunc && !object)) { - result = (isFlat || isFunc) ? {} : initCloneObject(value); - if (!isDeep) { - return isFlat - ? copySymbolsIn(value, baseAssignIn(result, value)) - : copySymbols(value, baseAssign(result, value)); - } - } else { - if (!cloneableTags[tag]) { - return object ? value : {}; - } - result = initCloneByTag(value, tag, isDeep); - } - } - // Check for circular references and return its corresponding clone. - stack || (stack = new Stack); - var stacked = stack.get(value); - if (stacked) { - return stacked; - } - stack.set(value, result); - - if (isSet(value)) { - value.forEach(function(subValue) { - result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); - }); - } else if (isMap(value)) { - value.forEach(function(subValue, key) { - result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); - }); - } - - var keysFunc = isFull - ? (isFlat ? getAllKeysIn : getAllKeys) - : (isFlat ? keysIn : keys); - - var props = isArr ? undefined : keysFunc(value); - arrayEach(props || value, function(subValue, key) { - if (props) { - key = subValue; - subValue = value[key]; - } - // Recursively populate clone (susceptible to call stack limits). - assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); - }); - return result; - } - - /** - * The base implementation of `_.conforms` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property predicates to conform to. - * @returns {Function} Returns the new spec function. - */ - function baseConforms(source) { - var props = keys(source); - return function(object) { - return baseConformsTo(object, source, props); - }; - } - - /** - * The base implementation of `_.conformsTo` which accepts `props` to check. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property predicates to conform to. - * @returns {boolean} Returns `true` if `object` conforms, else `false`. - */ - function baseConformsTo(object, source, props) { - var length = props.length; - if (object == null) { - return !length; - } - object = Object(object); - while (length--) { - var key = props[length], - predicate = source[key], - value = object[key]; - - if ((value === undefined && !(key in object)) || !predicate(value)) { - return false; - } - } - return true; - } - - /** - * The base implementation of `_.delay` and `_.defer` which accepts `args` - * to provide to `func`. - * - * @private - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @param {Array} args The arguments to provide to `func`. - * @returns {number|Object} Returns the timer id or timeout object. - */ - function baseDelay(func, wait, args) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - return setTimeout(function() { func.apply(undefined, args); }, wait); - } - - /** - * The base implementation of methods like `_.difference` without support - * for excluding multiple arrays or iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Array} values The values to exclude. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - */ - function baseDifference(array, values, iteratee, comparator) { - var index = -1, - includes = arrayIncludes, - isCommon = true, - length = array.length, - result = [], - valuesLength = values.length; - - if (!length) { - return result; - } - if (iteratee) { - values = arrayMap(values, baseUnary(iteratee)); - } - if (comparator) { - includes = arrayIncludesWith; - isCommon = false; - } - else if (values.length >= LARGE_ARRAY_SIZE) { - includes = cacheHas; - isCommon = false; - values = new SetCache(values); - } - outer: - while (++index < length) { - var value = array[index], - computed = iteratee == null ? value : iteratee(value); - - value = (comparator || value !== 0) ? value : 0; - if (isCommon && computed === computed) { - var valuesIndex = valuesLength; - while (valuesIndex--) { - if (values[valuesIndex] === computed) { - continue outer; - } - } - result.push(value); - } - else if (!includes(values, computed, comparator)) { - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.forEach` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ - var baseEach = createBaseEach(baseForOwn); - - /** - * The base implementation of `_.forEachRight` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - */ - var baseEachRight = createBaseEach(baseForOwnRight, true); - - /** - * The base implementation of `_.every` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false` - */ - function baseEvery(collection, predicate) { - var result = true; - baseEach(collection, function(value, index, collection) { - result = !!predicate(value, index, collection); - return result; - }); - return result; - } - - /** - * The base implementation of methods like `_.max` and `_.min` which accepts a - * `comparator` to determine the extremum value. - * - * @private - * @param {Array} array The array to iterate over. - * @param {Function} iteratee The iteratee invoked per iteration. - * @param {Function} comparator The comparator used to compare values. - * @returns {*} Returns the extremum value. - */ - function baseExtremum(array, iteratee, comparator) { - var index = -1, - length = array.length; - - while (++index < length) { - var value = array[index], - current = iteratee(value); - - if (current != null && (computed === undefined - ? (current === current && !isSymbol(current)) - : comparator(current, computed) - )) { - var computed = current, - result = value; - } - } - return result; - } - - /** - * The base implementation of `_.fill` without an iteratee call guard. - * - * @private - * @param {Array} array The array to fill. - * @param {*} value The value to fill `array` with. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns `array`. - */ - function baseFill(array, value, start, end) { - var length = array.length; - - start = toInteger(start); - if (start < 0) { - start = -start > length ? 0 : (length + start); - } - end = (end === undefined || end > length) ? length : toInteger(end); - if (end < 0) { - end += length; - } - end = start > end ? 0 : toLength(end); - while (start < end) { - array[start++] = value; - } - return array; - } - - /** - * The base implementation of `_.filter` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ - function baseFilter(collection, predicate) { - var result = []; - baseEach(collection, function(value, index, collection) { - if (predicate(value, index, collection)) { - result.push(value); - } - }); - return result; - } - - /** - * The base implementation of `_.flatten` with support for restricting flattening. - * - * @private - * @param {Array} array The array to flatten. - * @param {number} depth The maximum recursion depth. - * @param {boolean} [predicate=isFlattenable] The function invoked per iteration. - * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks. - * @param {Array} [result=[]] The initial result value. - * @returns {Array} Returns the new flattened array. - */ - function baseFlatten(array, depth, predicate, isStrict, result) { - var index = -1, - length = array.length; - - predicate || (predicate = isFlattenable); - result || (result = []); - - while (++index < length) { - var value = array[index]; - if (depth > 0 && predicate(value)) { - if (depth > 1) { - // Recursively flatten arrays (susceptible to call stack limits). - baseFlatten(value, depth - 1, predicate, isStrict, result); - } else { - arrayPush(result, value); - } - } else if (!isStrict) { - result[result.length] = value; - } - } - return result; - } - - /** - * The base implementation of `baseForOwn` which iterates over `object` - * properties returned by `keysFunc` and invokes `iteratee` for each property. - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ - var baseFor = createBaseFor(); - - /** - * This function is like `baseFor` except that it iterates over properties - * in the opposite order. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @param {Function} keysFunc The function to get the keys of `object`. - * @returns {Object} Returns `object`. - */ - var baseForRight = createBaseFor(true); - - /** - * The base implementation of `_.forOwn` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ - function baseForOwn(object, iteratee) { - return object && baseFor(object, iteratee, keys); - } - - /** - * The base implementation of `_.forOwnRight` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `object`. - */ - function baseForOwnRight(object, iteratee) { - return object && baseForRight(object, iteratee, keys); - } - - /** - * The base implementation of `_.functions` which creates an array of - * `object` function property names filtered from `props`. - * - * @private - * @param {Object} object The object to inspect. - * @param {Array} props The property names to filter. - * @returns {Array} Returns the function names. - */ - function baseFunctions(object, props) { - return arrayFilter(props, function(key) { - return isFunction(object[key]); - }); - } - - /** - * The base implementation of `_.get` without support for default values. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. - */ - function baseGet(object, path) { - path = castPath(path, object); - - var index = 0, - length = path.length; - - while (object != null && index < length) { - object = object[toKey(path[index++])]; - } - return (index && index == length) ? object : undefined; - } - - /** - * The base implementation of `getAllKeys` and `getAllKeysIn` which uses - * `keysFunc` and `symbolsFunc` to get the enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Function} keysFunc The function to get the keys of `object`. - * @param {Function} symbolsFunc The function to get the symbols of `object`. - * @returns {Array} Returns the array of property names and symbols. - */ - function baseGetAllKeys(object, keysFunc, symbolsFunc) { - var result = keysFunc(object); - return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); - } - - /** - * The base implementation of `getTag` without fallbacks for buggy environments. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ - function baseGetTag(value) { - if (value == null) { - return value === undefined ? undefinedTag : nullTag; - } - return (symToStringTag && symToStringTag in Object(value)) - ? getRawTag(value) - : objectToString(value); - } - - /** - * The base implementation of `_.gt` which doesn't coerce arguments. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than `other`, - * else `false`. - */ - function baseGt(value, other) { - return value > other; - } - - /** - * The base implementation of `_.has` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ - function baseHas(object, key) { - return object != null && hasOwnProperty.call(object, key); - } - - /** - * The base implementation of `_.hasIn` without support for deep paths. - * - * @private - * @param {Object} [object] The object to query. - * @param {Array|string} key The key to check. - * @returns {boolean} Returns `true` if `key` exists, else `false`. - */ - function baseHasIn(object, key) { - return object != null && key in Object(object); - } - - /** - * The base implementation of `_.inRange` which doesn't coerce arguments. - * - * @private - * @param {number} number The number to check. - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @returns {boolean} Returns `true` if `number` is in the range, else `false`. - */ - function baseInRange(number, start, end) { - return number >= nativeMin(start, end) && number < nativeMax(start, end); - } - - /** - * The base implementation of methods like `_.intersection`, without support - * for iteratee shorthands, that accepts an array of arrays to inspect. - * - * @private - * @param {Array} arrays The arrays to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of shared values. - */ - function baseIntersection(arrays, iteratee, comparator) { - var includes = comparator ? arrayIncludesWith : arrayIncludes, - length = arrays[0].length, - othLength = arrays.length, - othIndex = othLength, - caches = Array(othLength), - maxLength = Infinity, - result = []; - - while (othIndex--) { - var array = arrays[othIndex]; - if (othIndex && iteratee) { - array = arrayMap(array, baseUnary(iteratee)); - } - maxLength = nativeMin(array.length, maxLength); - caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120)) - ? new SetCache(othIndex && array) - : undefined; - } - array = arrays[0]; - - var index = -1, - seen = caches[0]; - - outer: - while (++index < length && result.length < maxLength) { - var value = array[index], - computed = iteratee ? iteratee(value) : value; - - value = (comparator || value !== 0) ? value : 0; - if (!(seen - ? cacheHas(seen, computed) - : includes(result, computed, comparator) - )) { - othIndex = othLength; - while (--othIndex) { - var cache = caches[othIndex]; - if (!(cache - ? cacheHas(cache, computed) - : includes(arrays[othIndex], computed, comparator)) - ) { - continue outer; - } - } - if (seen) { - seen.push(computed); - } - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.invert` and `_.invertBy` which inverts - * `object` with values transformed by `iteratee` and set by `setter`. - * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} setter The function to set `accumulator` values. - * @param {Function} iteratee The iteratee to transform values. - * @param {Object} accumulator The initial inverted object. - * @returns {Function} Returns `accumulator`. - */ - function baseInverter(object, setter, iteratee, accumulator) { - baseForOwn(object, function(value, key, object) { - setter(accumulator, iteratee(value), key, object); - }); - return accumulator; - } - - /** - * The base implementation of `_.invoke` without support for individual - * method arguments. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the method to invoke. - * @param {Array} args The arguments to invoke the method with. - * @returns {*} Returns the result of the invoked method. - */ - function baseInvoke(object, path, args) { - path = castPath(path, object); - object = parent(object, path); - var func = object == null ? object : object[toKey(last(path))]; - return func == null ? undefined : apply(func, object, args); - } - - /** - * The base implementation of `_.isArguments`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - */ - function baseIsArguments(value) { - return isObjectLike(value) && baseGetTag(value) == argsTag; - } - - /** - * The base implementation of `_.isArrayBuffer` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. - */ - function baseIsArrayBuffer(value) { - return isObjectLike(value) && baseGetTag(value) == arrayBufferTag; - } - - /** - * The base implementation of `_.isDate` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a date object, else `false`. - */ - function baseIsDate(value) { - return isObjectLike(value) && baseGetTag(value) == dateTag; - } - - /** - * The base implementation of `_.isEqual` which supports partial comparisons - * and tracks traversed objects. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {boolean} bitmask The bitmask flags. - * 1 - Unordered comparison - * 2 - Partial comparison - * @param {Function} [customizer] The function to customize comparisons. - * @param {Object} [stack] Tracks traversed `value` and `other` objects. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - */ - function baseIsEqual(value, other, bitmask, customizer, stack) { - if (value === other) { - return true; - } - if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { - return value !== value && other !== other; - } - return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); - } - - /** - * A specialized version of `baseIsEqual` for arrays and objects which performs - * deep comparisons and tracks traversed objects enabling objects with circular - * references to be compared. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} [stack] Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { - var objIsArr = isArray(object), - othIsArr = isArray(other), - objTag = objIsArr ? arrayTag : getTag(object), - othTag = othIsArr ? arrayTag : getTag(other); - - objTag = objTag == argsTag ? objectTag : objTag; - othTag = othTag == argsTag ? objectTag : othTag; - - var objIsObj = objTag == objectTag, - othIsObj = othTag == objectTag, - isSameTag = objTag == othTag; - - if (isSameTag && isBuffer(object)) { - if (!isBuffer(other)) { - return false; - } - objIsArr = true; - objIsObj = false; - } - if (isSameTag && !objIsObj) { - stack || (stack = new Stack); - return (objIsArr || isTypedArray(object)) - ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) - : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); - } - if (!(bitmask & COMPARE_PARTIAL_FLAG)) { - var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), - othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); - - if (objIsWrapped || othIsWrapped) { - var objUnwrapped = objIsWrapped ? object.value() : object, - othUnwrapped = othIsWrapped ? other.value() : other; - - stack || (stack = new Stack); - return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); - } - } - if (!isSameTag) { - return false; - } - stack || (stack = new Stack); - return equalObjects(object, other, bitmask, customizer, equalFunc, stack); - } - - /** - * The base implementation of `_.isMap` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a map, else `false`. - */ - function baseIsMap(value) { - return isObjectLike(value) && getTag(value) == mapTag; - } - - /** - * The base implementation of `_.isMatch` without support for iteratee shorthands. - * - * @private - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Array} matchData The property names, values, and compare flags to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - */ - function baseIsMatch(object, source, matchData, customizer) { - var index = matchData.length, - length = index, - noCustomizer = !customizer; - - if (object == null) { - return !length; - } - object = Object(object); - while (index--) { - var data = matchData[index]; - if ((noCustomizer && data[2]) - ? data[1] !== object[data[0]] - : !(data[0] in object) - ) { - return false; - } - } - while (++index < length) { - data = matchData[index]; - var key = data[0], - objValue = object[key], - srcValue = data[1]; - - if (noCustomizer && data[2]) { - if (objValue === undefined && !(key in object)) { - return false; - } - } else { - var stack = new Stack; - if (customizer) { - var result = customizer(objValue, srcValue, key, object, source, stack); - } - if (!(result === undefined - ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) - : result - )) { - return false; - } - } - } - return true; - } - - /** - * The base implementation of `_.isNative` without bad shim checks. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - */ - function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false; - } - var pattern = isFunction(value) ? reIsNative : reIsHostCtor; - return pattern.test(toSource(value)); - } - - /** - * The base implementation of `_.isRegExp` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. - */ - function baseIsRegExp(value) { - return isObjectLike(value) && baseGetTag(value) == regexpTag; - } - - /** - * The base implementation of `_.isSet` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a set, else `false`. - */ - function baseIsSet(value) { - return isObjectLike(value) && getTag(value) == setTag; - } - - /** - * The base implementation of `_.isTypedArray` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - */ - function baseIsTypedArray(value) { - return isObjectLike(value) && - isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; - } - - /** - * The base implementation of `_.iteratee`. - * - * @private - * @param {*} [value=_.identity] The value to convert to an iteratee. - * @returns {Function} Returns the iteratee. - */ - function baseIteratee(value) { - // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9. - // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details. - if (typeof value == 'function') { - return value; - } - if (value == null) { - return identity; - } - if (typeof value == 'object') { - return isArray(value) - ? baseMatchesProperty(value[0], value[1]) - : baseMatches(value); - } - return property(value); - } - - /** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object); - } - var result = []; - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != 'constructor') { - result.push(key); - } - } - return result; - } - - /** - * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeysIn(object) { - if (!isObject(object)) { - return nativeKeysIn(object); - } - var isProto = isPrototype(object), - result = []; - - for (var key in object) { - if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { - result.push(key); - } - } - return result; - } - - /** - * The base implementation of `_.lt` which doesn't coerce arguments. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than `other`, - * else `false`. - */ - function baseLt(value, other) { - return value < other; - } - - /** - * The base implementation of `_.map` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - */ - function baseMap(collection, iteratee) { - var index = -1, - result = isArrayLike(collection) ? Array(collection.length) : []; - - baseEach(collection, function(value, key, collection) { - result[++index] = iteratee(value, key, collection); - }); - return result; - } - - /** - * The base implementation of `_.matches` which doesn't clone `source`. - * - * @private - * @param {Object} source The object of property values to match. - * @returns {Function} Returns the new spec function. - */ - function baseMatches(source) { - var matchData = getMatchData(source); - if (matchData.length == 1 && matchData[0][2]) { - return matchesStrictComparable(matchData[0][0], matchData[0][1]); - } - return function(object) { - return object === source || baseIsMatch(object, source, matchData); - }; - } - - /** - * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. - * - * @private - * @param {string} path The path of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ - function baseMatchesProperty(path, srcValue) { - if (isKey(path) && isStrictComparable(srcValue)) { - return matchesStrictComparable(toKey(path), srcValue); - } - return function(object) { - var objValue = get(object, path); - return (objValue === undefined && objValue === srcValue) - ? hasIn(object, path) - : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG); - }; - } - - /** - * The base implementation of `_.merge` without support for multiple sources. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @param {number} srcIndex The index of `source`. - * @param {Function} [customizer] The function to customize merged values. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - */ - function baseMerge(object, source, srcIndex, customizer, stack) { - if (object === source) { - return; - } - baseFor(source, function(srcValue, key) { - stack || (stack = new Stack); - if (isObject(srcValue)) { - baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); - } - else { - var newValue = customizer - ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) - : undefined; - - if (newValue === undefined) { - newValue = srcValue; - } - assignMergeValue(object, key, newValue); - } - }, keysIn); - } - - /** - * A specialized version of `baseMerge` for arrays and objects which performs - * deep merges and tracks traversed objects enabling objects with circular - * references to be merged. - * - * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @param {string} key The key of the value to merge. - * @param {number} srcIndex The index of `source`. - * @param {Function} mergeFunc The function to merge values. - * @param {Function} [customizer] The function to customize assigned values. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - */ - function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { - var objValue = safeGet(object, key), - srcValue = safeGet(source, key), - stacked = stack.get(srcValue); - - if (stacked) { - assignMergeValue(object, key, stacked); - return; - } - var newValue = customizer - ? customizer(objValue, srcValue, (key + ''), object, source, stack) - : undefined; - - var isCommon = newValue === undefined; - - if (isCommon) { - var isArr = isArray(srcValue), - isBuff = !isArr && isBuffer(srcValue), - isTyped = !isArr && !isBuff && isTypedArray(srcValue); - - newValue = srcValue; - if (isArr || isBuff || isTyped) { - if (isArray(objValue)) { - newValue = objValue; - } - else if (isArrayLikeObject(objValue)) { - newValue = copyArray(objValue); - } - else if (isBuff) { - isCommon = false; - newValue = cloneBuffer(srcValue, true); - } - else if (isTyped) { - isCommon = false; - newValue = cloneTypedArray(srcValue, true); - } - else { - newValue = []; - } - } - else if (isPlainObject(srcValue) || isArguments(srcValue)) { - newValue = objValue; - if (isArguments(objValue)) { - newValue = toPlainObject(objValue); - } - else if (!isObject(objValue) || isFunction(objValue)) { - newValue = initCloneObject(srcValue); - } - } - else { - isCommon = false; - } - } - if (isCommon) { - // Recursively merge objects and arrays (susceptible to call stack limits). - stack.set(srcValue, newValue); - mergeFunc(newValue, srcValue, srcIndex, customizer, stack); - stack['delete'](srcValue); - } - assignMergeValue(object, key, newValue); - } - - /** - * The base implementation of `_.nth` which doesn't coerce arguments. - * - * @private - * @param {Array} array The array to query. - * @param {number} n The index of the element to return. - * @returns {*} Returns the nth element of `array`. - */ - function baseNth(array, n) { - var length = array.length; - if (!length) { - return; - } - n += n < 0 ? length : 0; - return isIndex(n, length) ? array[n] : undefined; - } - - /** - * The base implementation of `_.orderBy` without param guards. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by. - * @param {string[]} orders The sort orders of `iteratees`. - * @returns {Array} Returns the new sorted array. - */ - function baseOrderBy(collection, iteratees, orders) { - var index = -1; - iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee())); - - var result = baseMap(collection, function(value, key, collection) { - var criteria = arrayMap(iteratees, function(iteratee) { - return iteratee(value); - }); - return { 'criteria': criteria, 'index': ++index, 'value': value }; - }); - - return baseSortBy(result, function(object, other) { - return compareMultiple(object, other, orders); - }); - } - - /** - * The base implementation of `_.pick` without support for individual - * property identifiers. - * - * @private - * @param {Object} object The source object. - * @param {string[]} paths The property paths to pick. - * @returns {Object} Returns the new object. - */ - function basePick(object, paths) { - return basePickBy(object, paths, function(value, path) { - return hasIn(object, path); - }); - } - - /** - * The base implementation of `_.pickBy` without support for iteratee shorthands. - * - * @private - * @param {Object} object The source object. - * @param {string[]} paths The property paths to pick. - * @param {Function} predicate The function invoked per property. - * @returns {Object} Returns the new object. - */ - function basePickBy(object, paths, predicate) { - var index = -1, - length = paths.length, - result = {}; - - while (++index < length) { - var path = paths[index], - value = baseGet(object, path); - - if (predicate(value, path)) { - baseSet(result, castPath(path, object), value); - } - } - return result; - } - - /** - * A specialized version of `baseProperty` which supports deep paths. - * - * @private - * @param {Array|string} path The path of the property to get. - * @returns {Function} Returns the new accessor function. - */ - function basePropertyDeep(path) { - return function(object) { - return baseGet(object, path); - }; - } - - /** - * The base implementation of `_.pullAllBy` without support for iteratee - * shorthands. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns `array`. - */ - function basePullAll(array, values, iteratee, comparator) { - var indexOf = comparator ? baseIndexOfWith : baseIndexOf, - index = -1, - length = values.length, - seen = array; - - if (array === values) { - values = copyArray(values); - } - if (iteratee) { - seen = arrayMap(array, baseUnary(iteratee)); - } - while (++index < length) { - var fromIndex = 0, - value = values[index], - computed = iteratee ? iteratee(value) : value; - - while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) { - if (seen !== array) { - splice.call(seen, fromIndex, 1); - } - splice.call(array, fromIndex, 1); - } - } - return array; - } - - /** - * The base implementation of `_.pullAt` without support for individual - * indexes or capturing the removed elements. - * - * @private - * @param {Array} array The array to modify. - * @param {number[]} indexes The indexes of elements to remove. - * @returns {Array} Returns `array`. - */ - function basePullAt(array, indexes) { - var length = array ? indexes.length : 0, - lastIndex = length - 1; - - while (length--) { - var index = indexes[length]; - if (length == lastIndex || index !== previous) { - var previous = index; - if (isIndex(index)) { - splice.call(array, index, 1); - } else { - baseUnset(array, index); - } - } - } - return array; - } - - /** - * The base implementation of `_.random` without support for returning - * floating-point numbers. - * - * @private - * @param {number} lower The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the random number. - */ - function baseRandom(lower, upper) { - return lower + nativeFloor(nativeRandom() * (upper - lower + 1)); - } - - /** - * The base implementation of `_.range` and `_.rangeRight` which doesn't - * coerce arguments. - * - * @private - * @param {number} start The start of the range. - * @param {number} end The end of the range. - * @param {number} step The value to increment or decrement by. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the range of numbers. - */ - function baseRange(start, end, step, fromRight) { - var index = -1, - length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), - result = Array(length); - - while (length--) { - result[fromRight ? length : ++index] = start; - start += step; - } - return result; - } - - /** - * The base implementation of `_.repeat` which doesn't coerce arguments. - * - * @private - * @param {string} string The string to repeat. - * @param {number} n The number of times to repeat the string. - * @returns {string} Returns the repeated string. - */ - function baseRepeat(string, n) { - var result = ''; - if (!string || n < 1 || n > MAX_SAFE_INTEGER) { - return result; - } - // Leverage the exponentiation by squaring algorithm for a faster repeat. - // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details. - do { - if (n % 2) { - result += string; - } - n = nativeFloor(n / 2); - if (n) { - string += string; - } - } while (n); - - return result; - } - - /** - * The base implementation of `_.rest` which doesn't validate or coerce arguments. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. - */ - function baseRest(func, start) { - return setToString(overRest(func, start, identity), func + ''); - } - - /** - * The base implementation of `_.sample`. - * - * @private - * @param {Array|Object} collection The collection to sample. - * @returns {*} Returns the random element. - */ - function baseSample(collection) { - return arraySample(values(collection)); - } - - /** - * The base implementation of `_.sampleSize` without param guards. - * - * @private - * @param {Array|Object} collection The collection to sample. - * @param {number} n The number of elements to sample. - * @returns {Array} Returns the random elements. - */ - function baseSampleSize(collection, n) { - var array = values(collection); - return shuffleSelf(array, baseClamp(n, 0, array.length)); - } - - /** - * The base implementation of `_.set`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @param {Function} [customizer] The function to customize path creation. - * @returns {Object} Returns `object`. - */ - function baseSet(object, path, value, customizer) { - if (!isObject(object)) { - return object; - } - path = castPath(path, object); - - var index = -1, - length = path.length, - lastIndex = length - 1, - nested = object; - - while (nested != null && ++index < length) { - var key = toKey(path[index]), - newValue = value; - - if (index != lastIndex) { - var objValue = nested[key]; - newValue = customizer ? customizer(objValue, key, nested) : undefined; - if (newValue === undefined) { - newValue = isObject(objValue) - ? objValue - : (isIndex(path[index + 1]) ? [] : {}); - } - } - assignValue(nested, key, newValue); - nested = nested[key]; - } - return object; - } - - /** - * The base implementation of `setData` without support for hot loop shorting. - * - * @private - * @param {Function} func The function to associate metadata with. - * @param {*} data The metadata. - * @returns {Function} Returns `func`. - */ - var baseSetData = !metaMap ? identity : function(func, data) { - metaMap.set(func, data); - return func; - }; - - /** - * The base implementation of `setToString` without support for hot loop shorting. - * - * @private - * @param {Function} func The function to modify. - * @param {Function} string The `toString` result. - * @returns {Function} Returns `func`. - */ - var baseSetToString = !defineProperty ? identity : function(func, string) { - return defineProperty(func, 'toString', { - 'configurable': true, - 'enumerable': false, - 'value': constant(string), - 'writable': true - }); - }; - - /** - * The base implementation of `_.shuffle`. - * - * @private - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - */ - function baseShuffle(collection) { - return shuffleSelf(values(collection)); - } - - /** - * The base implementation of `_.slice` without an iteratee call guard. - * - * @private - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ - function baseSlice(array, start, end) { - var index = -1, - length = array.length; - - if (start < 0) { - start = -start > length ? 0 : (length + start); - } - end = end > length ? length : end; - if (end < 0) { - end += length; - } - length = start > end ? 0 : ((end - start) >>> 0); - start >>>= 0; - - var result = Array(length); - while (++index < length) { - result[index] = array[index + start]; - } - return result; - } - - /** - * The base implementation of `_.some` without support for iteratee shorthands. - * - * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ - function baseSome(collection, predicate) { - var result; - - baseEach(collection, function(value, index, collection) { - result = predicate(value, index, collection); - return !result; - }); - return !!result; - } - - /** - * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which - * performs a binary search of `array` to determine the index at which `value` - * should be inserted into `array` in order to maintain its sort order. - * - * @private - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {boolean} [retHighest] Specify returning the highest qualified index. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - */ - function baseSortedIndex(array, value, retHighest) { - var low = 0, - high = array == null ? low : array.length; - - if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) { - while (low < high) { - var mid = (low + high) >>> 1, - computed = array[mid]; - - if (computed !== null && !isSymbol(computed) && - (retHighest ? (computed <= value) : (computed < value))) { - low = mid + 1; - } else { - high = mid; - } - } - return high; - } - return baseSortedIndexBy(array, value, identity, retHighest); - } - - /** - * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` - * which invokes `iteratee` for `value` and each element of `array` to compute - * their sort ranking. The iteratee is invoked with one argument; (value). - * - * @private - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} iteratee The iteratee invoked per element. - * @param {boolean} [retHighest] Specify returning the highest qualified index. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - */ - function baseSortedIndexBy(array, value, iteratee, retHighest) { - value = iteratee(value); - - var low = 0, - high = array == null ? 0 : array.length, - valIsNaN = value !== value, - valIsNull = value === null, - valIsSymbol = isSymbol(value), - valIsUndefined = value === undefined; - - while (low < high) { - var mid = nativeFloor((low + high) / 2), - computed = iteratee(array[mid]), - othIsDefined = computed !== undefined, - othIsNull = computed === null, - othIsReflexive = computed === computed, - othIsSymbol = isSymbol(computed); - - if (valIsNaN) { - var setLow = retHighest || othIsReflexive; - } else if (valIsUndefined) { - setLow = othIsReflexive && (retHighest || othIsDefined); - } else if (valIsNull) { - setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull); - } else if (valIsSymbol) { - setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol); - } else if (othIsNull || othIsSymbol) { - setLow = false; - } else { - setLow = retHighest ? (computed <= value) : (computed < value); - } - if (setLow) { - low = mid + 1; - } else { - high = mid; - } - } - return nativeMin(high, MAX_ARRAY_INDEX); - } - - /** - * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without - * support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - */ - function baseSortedUniq(array, iteratee) { - var index = -1, - length = array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index], - computed = iteratee ? iteratee(value) : value; - - if (!index || !eq(computed, seen)) { - var seen = computed; - result[resIndex++] = value === 0 ? 0 : value; - } - } - return result; - } - - /** - * The base implementation of `_.toNumber` which doesn't ensure correct - * conversions of binary, hexadecimal, or octal string values. - * - * @private - * @param {*} value The value to process. - * @returns {number} Returns the number. - */ - function baseToNumber(value) { - if (typeof value == 'number') { - return value; - } - if (isSymbol(value)) { - return NAN; - } - return +value; - } - - /** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. - * - * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. - */ - function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == 'string') { - return value; - } - if (isArray(value)) { - // Recursively convert values (susceptible to call stack limits). - return arrayMap(value, baseToString) + ''; - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : ''; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; - } - - /** - * The base implementation of `_.uniqBy` without support for iteratee shorthands. - * - * @private - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new duplicate free array. - */ - function baseUniq(array, iteratee, comparator) { - var index = -1, - includes = arrayIncludes, - length = array.length, - isCommon = true, - result = [], - seen = result; - - if (comparator) { - isCommon = false; - includes = arrayIncludesWith; - } - else if (length >= LARGE_ARRAY_SIZE) { - var set = iteratee ? null : createSet(array); - if (set) { - return setToArray(set); - } - isCommon = false; - includes = cacheHas; - seen = new SetCache; - } - else { - seen = iteratee ? [] : result; - } - outer: - while (++index < length) { - var value = array[index], - computed = iteratee ? iteratee(value) : value; - - value = (comparator || value !== 0) ? value : 0; - if (isCommon && computed === computed) { - var seenIndex = seen.length; - while (seenIndex--) { - if (seen[seenIndex] === computed) { - continue outer; - } - } - if (iteratee) { - seen.push(computed); - } - result.push(value); - } - else if (!includes(seen, computed, comparator)) { - if (seen !== result) { - seen.push(computed); - } - result.push(value); - } - } - return result; - } - - /** - * The base implementation of `_.unset`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The property path to unset. - * @returns {boolean} Returns `true` if the property is deleted, else `false`. - */ - function baseUnset(object, path) { - path = castPath(path, object); - object = parent(object, path); - return object == null || delete object[toKey(last(path))]; - } - - /** - * The base implementation of `_.update`. - * - * @private - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to update. - * @param {Function} updater The function to produce the updated value. - * @param {Function} [customizer] The function to customize path creation. - * @returns {Object} Returns `object`. - */ - function baseUpdate(object, path, updater, customizer) { - return baseSet(object, path, updater(baseGet(object, path)), customizer); - } - - /** - * The base implementation of methods like `_.dropWhile` and `_.takeWhile` - * without support for iteratee shorthands. - * - * @private - * @param {Array} array The array to query. - * @param {Function} predicate The function invoked per iteration. - * @param {boolean} [isDrop] Specify dropping elements instead of taking them. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Array} Returns the slice of `array`. - */ - function baseWhile(array, predicate, isDrop, fromRight) { - var length = array.length, - index = fromRight ? length : -1; - - while ((fromRight ? index-- : ++index < length) && - predicate(array[index], index, array)) {} - - return isDrop - ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length)) - : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index)); - } - - /** - * The base implementation of `wrapperValue` which returns the result of - * performing a sequence of actions on the unwrapped `value`, where each - * successive action is supplied the return value of the previous. - * - * @private - * @param {*} value The unwrapped value. - * @param {Array} actions Actions to perform to resolve the unwrapped value. - * @returns {*} Returns the resolved value. - */ - function baseWrapperValue(value, actions) { - var result = value; - if (result instanceof LazyWrapper) { - result = result.value(); - } - return arrayReduce(actions, function(result, action) { - return action.func.apply(action.thisArg, arrayPush([result], action.args)); - }, result); - } - - /** - * The base implementation of methods like `_.xor`, without support for - * iteratee shorthands, that accepts an array of arrays to inspect. - * - * @private - * @param {Array} arrays The arrays to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of values. - */ - function baseXor(arrays, iteratee, comparator) { - var length = arrays.length; - if (length < 2) { - return length ? baseUniq(arrays[0]) : []; - } - var index = -1, - result = Array(length); - - while (++index < length) { - var array = arrays[index], - othIndex = -1; - - while (++othIndex < length) { - if (othIndex != index) { - result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator); - } - } - } - return baseUniq(baseFlatten(result, 1), iteratee, comparator); - } - - /** - * This base implementation of `_.zipObject` which assigns values using `assignFunc`. - * - * @private - * @param {Array} props The property identifiers. - * @param {Array} values The property values. - * @param {Function} assignFunc The function to assign values. - * @returns {Object} Returns the new object. - */ - function baseZipObject(props, values, assignFunc) { - var index = -1, - length = props.length, - valsLength = values.length, - result = {}; - - while (++index < length) { - var value = index < valsLength ? values[index] : undefined; - assignFunc(result, props[index], value); - } - return result; - } - - /** - * Casts `value` to an empty array if it's not an array like object. - * - * @private - * @param {*} value The value to inspect. - * @returns {Array|Object} Returns the cast array-like object. - */ - function castArrayLikeObject(value) { - return isArrayLikeObject(value) ? value : []; - } - - /** - * Casts `value` to `identity` if it's not a function. - * - * @private - * @param {*} value The value to inspect. - * @returns {Function} Returns cast function. - */ - function castFunction(value) { - return typeof value == 'function' ? value : identity; - } - - /** - * Casts `value` to a path array if it's not one. - * - * @private - * @param {*} value The value to inspect. - * @param {Object} [object] The object to query keys on. - * @returns {Array} Returns the cast property path array. - */ - function castPath(value, object) { - if (isArray(value)) { - return value; - } - return isKey(value, object) ? [value] : stringToPath(toString(value)); - } - - /** - * A `baseRest` alias which can be replaced with `identity` by module - * replacement plugins. - * - * @private - * @type {Function} - * @param {Function} func The function to apply a rest parameter to. - * @returns {Function} Returns the new function. - */ - var castRest = baseRest; - - /** - * Casts `array` to a slice if it's needed. - * - * @private - * @param {Array} array The array to inspect. - * @param {number} start The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the cast slice. - */ - function castSlice(array, start, end) { - var length = array.length; - end = end === undefined ? length : end; - return (!start && end >= length) ? array : baseSlice(array, start, end); - } - - /** - * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout). - * - * @private - * @param {number|Object} id The timer id or timeout object of the timer to clear. - */ - var clearTimeout = ctxClearTimeout || function(id) { - return root.clearTimeout(id); - }; - - /** - * Creates a clone of `buffer`. - * - * @private - * @param {Buffer} buffer The buffer to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Buffer} Returns the cloned buffer. - */ - function cloneBuffer(buffer, isDeep) { - if (isDeep) { - return buffer.slice(); - } - var length = buffer.length, - result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); - - buffer.copy(result); - return result; - } - - /** - * Creates a clone of `arrayBuffer`. - * - * @private - * @param {ArrayBuffer} arrayBuffer The array buffer to clone. - * @returns {ArrayBuffer} Returns the cloned array buffer. - */ - function cloneArrayBuffer(arrayBuffer) { - var result = new arrayBuffer.constructor(arrayBuffer.byteLength); - new Uint8Array(result).set(new Uint8Array(arrayBuffer)); - return result; - } - - /** - * Creates a clone of `dataView`. - * - * @private - * @param {Object} dataView The data view to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned data view. - */ - function cloneDataView(dataView, isDeep) { - var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer; - return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); - } - - /** - * Creates a clone of `regexp`. - * - * @private - * @param {Object} regexp The regexp to clone. - * @returns {Object} Returns the cloned regexp. - */ - function cloneRegExp(regexp) { - var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); - result.lastIndex = regexp.lastIndex; - return result; - } - - /** - * Creates a clone of the `symbol` object. - * - * @private - * @param {Object} symbol The symbol object to clone. - * @returns {Object} Returns the cloned symbol object. - */ - function cloneSymbol(symbol) { - return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; - } - - /** - * Creates a clone of `typedArray`. - * - * @private - * @param {Object} typedArray The typed array to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned typed array. - */ - function cloneTypedArray(typedArray, isDeep) { - var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; - return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); - } - - /** - * Compares values to sort them in ascending order. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {number} Returns the sort order indicator for `value`. - */ - function compareAscending(value, other) { - if (value !== other) { - var valIsDefined = value !== undefined, - valIsNull = value === null, - valIsReflexive = value === value, - valIsSymbol = isSymbol(value); - - var othIsDefined = other !== undefined, - othIsNull = other === null, - othIsReflexive = other === other, - othIsSymbol = isSymbol(other); - - if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) || - (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) || - (valIsNull && othIsDefined && othIsReflexive) || - (!valIsDefined && othIsReflexive) || - !valIsReflexive) { - return 1; - } - if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) || - (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) || - (othIsNull && valIsDefined && valIsReflexive) || - (!othIsDefined && valIsReflexive) || - !othIsReflexive) { - return -1; - } - } - return 0; - } - - /** - * Used by `_.orderBy` to compare multiple properties of a value to another - * and stable sort them. - * - * If `orders` is unspecified, all values are sorted in ascending order. Otherwise, - * specify an order of "desc" for descending or "asc" for ascending sort order - * of corresponding values. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {boolean[]|string[]} orders The order to sort by for each property. - * @returns {number} Returns the sort order indicator for `object`. - */ - function compareMultiple(object, other, orders) { - var index = -1, - objCriteria = object.criteria, - othCriteria = other.criteria, - length = objCriteria.length, - ordersLength = orders.length; - - while (++index < length) { - var result = compareAscending(objCriteria[index], othCriteria[index]); - if (result) { - if (index >= ordersLength) { - return result; - } - var order = orders[index]; - return result * (order == 'desc' ? -1 : 1); - } - } - // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications - // that causes it, under certain circumstances, to provide the same value for - // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247 - // for more details. - // - // This also ensures a stable sort in V8 and other engines. - // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details. - return object.index - other.index; - } - - /** - * Creates an array that is the composition of partially applied arguments, - * placeholders, and provided arguments into a single array of arguments. - * - * @private - * @param {Array} args The provided arguments. - * @param {Array} partials The arguments to prepend to those provided. - * @param {Array} holders The `partials` placeholder indexes. - * @params {boolean} [isCurried] Specify composing for a curried function. - * @returns {Array} Returns the new array of composed arguments. - */ - function composeArgs(args, partials, holders, isCurried) { - var argsIndex = -1, - argsLength = args.length, - holdersLength = holders.length, - leftIndex = -1, - leftLength = partials.length, - rangeLength = nativeMax(argsLength - holdersLength, 0), - result = Array(leftLength + rangeLength), - isUncurried = !isCurried; - - while (++leftIndex < leftLength) { - result[leftIndex] = partials[leftIndex]; - } - while (++argsIndex < holdersLength) { - if (isUncurried || argsIndex < argsLength) { - result[holders[argsIndex]] = args[argsIndex]; - } - } - while (rangeLength--) { - result[leftIndex++] = args[argsIndex++]; - } - return result; - } - - /** - * This function is like `composeArgs` except that the arguments composition - * is tailored for `_.partialRight`. - * - * @private - * @param {Array} args The provided arguments. - * @param {Array} partials The arguments to append to those provided. - * @param {Array} holders The `partials` placeholder indexes. - * @params {boolean} [isCurried] Specify composing for a curried function. - * @returns {Array} Returns the new array of composed arguments. - */ - function composeArgsRight(args, partials, holders, isCurried) { - var argsIndex = -1, - argsLength = args.length, - holdersIndex = -1, - holdersLength = holders.length, - rightIndex = -1, - rightLength = partials.length, - rangeLength = nativeMax(argsLength - holdersLength, 0), - result = Array(rangeLength + rightLength), - isUncurried = !isCurried; - - while (++argsIndex < rangeLength) { - result[argsIndex] = args[argsIndex]; - } - var offset = argsIndex; - while (++rightIndex < rightLength) { - result[offset + rightIndex] = partials[rightIndex]; - } - while (++holdersIndex < holdersLength) { - if (isUncurried || argsIndex < argsLength) { - result[offset + holders[holdersIndex]] = args[argsIndex++]; - } - } - return result; - } - - /** - * Copies the values of `source` to `array`. - * - * @private - * @param {Array} source The array to copy values from. - * @param {Array} [array=[]] The array to copy values to. - * @returns {Array} Returns `array`. - */ - function copyArray(source, array) { - var index = -1, - length = source.length; - - array || (array = Array(length)); - while (++index < length) { - array[index] = source[index]; - } - return array; - } - - /** - * Copies properties of `source` to `object`. - * - * @private - * @param {Object} source The object to copy properties from. - * @param {Array} props The property identifiers to copy. - * @param {Object} [object={}] The object to copy properties to. - * @param {Function} [customizer] The function to customize copied values. - * @returns {Object} Returns `object`. - */ - function copyObject(source, props, object, customizer) { - var isNew = !object; - object || (object = {}); - - var index = -1, - length = props.length; - - while (++index < length) { - var key = props[index]; - - var newValue = customizer - ? customizer(object[key], source[key], key, object, source) - : undefined; - - if (newValue === undefined) { - newValue = source[key]; - } - if (isNew) { - baseAssignValue(object, key, newValue); - } else { - assignValue(object, key, newValue); - } - } - return object; - } - - /** - * Copies own symbols of `source` to `object`. - * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `object`. - */ - function copySymbols(source, object) { - return copyObject(source, getSymbols(source), object); - } - - /** - * Copies own and inherited symbols of `source` to `object`. - * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `object`. - */ - function copySymbolsIn(source, object) { - return copyObject(source, getSymbolsIn(source), object); - } - - /** - * Creates a function like `_.groupBy`. - * - * @private - * @param {Function} setter The function to set accumulator values. - * @param {Function} [initializer] The accumulator object initializer. - * @returns {Function} Returns the new aggregator function. - */ - function createAggregator(setter, initializer) { - return function(collection, iteratee) { - var func = isArray(collection) ? arrayAggregator : baseAggregator, - accumulator = initializer ? initializer() : {}; - - return func(collection, setter, getIteratee(iteratee, 2), accumulator); - }; - } - - /** - * Creates a function like `_.assign`. - * - * @private - * @param {Function} assigner The function to assign values. - * @returns {Function} Returns the new assigner function. - */ - function createAssigner(assigner) { - return baseRest(function(object, sources) { - var index = -1, - length = sources.length, - customizer = length > 1 ? sources[length - 1] : undefined, - guard = length > 2 ? sources[2] : undefined; - - customizer = (assigner.length > 3 && typeof customizer == 'function') - ? (length--, customizer) - : undefined; - - if (guard && isIterateeCall(sources[0], sources[1], guard)) { - customizer = length < 3 ? undefined : customizer; - length = 1; - } - object = Object(object); - while (++index < length) { - var source = sources[index]; - if (source) { - assigner(object, source, index, customizer); - } - } - return object; - }); - } - - /** - * Creates a `baseEach` or `baseEachRight` function. - * - * @private - * @param {Function} eachFunc The function to iterate over a collection. - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ - function createBaseEach(eachFunc, fromRight) { - return function(collection, iteratee) { - if (collection == null) { - return collection; - } - if (!isArrayLike(collection)) { - return eachFunc(collection, iteratee); - } - var length = collection.length, - index = fromRight ? length : -1, - iterable = Object(collection); - - while ((fromRight ? index-- : ++index < length)) { - if (iteratee(iterable[index], index, iterable) === false) { - break; - } - } - return collection; - }; - } - - /** - * Creates a base function for methods like `_.forIn` and `_.forOwn`. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new base function. - */ - function createBaseFor(fromRight) { - return function(object, iteratee, keysFunc) { - var index = -1, - iterable = Object(object), - props = keysFunc(object), - length = props.length; - - while (length--) { - var key = props[fromRight ? length : ++index]; - if (iteratee(iterable[key], key, iterable) === false) { - break; - } - } - return object; - }; - } - - /** - * Creates a function that wraps `func` to invoke it with the optional `this` - * binding of `thisArg`. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} [thisArg] The `this` binding of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createBind(func, bitmask, thisArg) { - var isBind = bitmask & WRAP_BIND_FLAG, - Ctor = createCtor(func); - - function wrapper() { - var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; - return fn.apply(isBind ? thisArg : this, arguments); - } - return wrapper; - } - - /** - * Creates a function like `_.lowerFirst`. - * - * @private - * @param {string} methodName The name of the `String` case method to use. - * @returns {Function} Returns the new case function. - */ - function createCaseFirst(methodName) { - return function(string) { - string = toString(string); - - var strSymbols = hasUnicode(string) - ? stringToArray(string) - : undefined; - - var chr = strSymbols - ? strSymbols[0] - : string.charAt(0); - - var trailing = strSymbols - ? castSlice(strSymbols, 1).join('') - : string.slice(1); - - return chr[methodName]() + trailing; - }; - } - - /** - * Creates a function like `_.camelCase`. - * - * @private - * @param {Function} callback The function to combine each word. - * @returns {Function} Returns the new compounder function. - */ - function createCompounder(callback) { - return function(string) { - return arrayReduce(words(deburr(string).replace(reApos, '')), callback, ''); - }; - } - - /** - * Creates a function that produces an instance of `Ctor` regardless of - * whether it was invoked as part of a `new` expression or by `call` or `apply`. - * - * @private - * @param {Function} Ctor The constructor to wrap. - * @returns {Function} Returns the new wrapped function. - */ - function createCtor(Ctor) { - return function() { - // Use a `switch` statement to work with class constructors. See - // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist - // for more details. - var args = arguments; - switch (args.length) { - case 0: return new Ctor; - case 1: return new Ctor(args[0]); - case 2: return new Ctor(args[0], args[1]); - case 3: return new Ctor(args[0], args[1], args[2]); - case 4: return new Ctor(args[0], args[1], args[2], args[3]); - case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]); - case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]); - case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]); - } - var thisBinding = baseCreate(Ctor.prototype), - result = Ctor.apply(thisBinding, args); - - // Mimic the constructor's `return` behavior. - // See https://es5.github.io/#x13.2.2 for more details. - return isObject(result) ? result : thisBinding; - }; - } - - /** - * Creates a function that wraps `func` to enable currying. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {number} arity The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createCurry(func, bitmask, arity) { - var Ctor = createCtor(func); - - function wrapper() { - var length = arguments.length, - args = Array(length), - index = length, - placeholder = getHolder(wrapper); - - while (index--) { - args[index] = arguments[index]; - } - var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder) - ? [] - : replaceHolders(args, placeholder); - - length -= holders.length; - if (length < arity) { - return createRecurry( - func, bitmask, createHybrid, wrapper.placeholder, undefined, - args, holders, undefined, undefined, arity - length); - } - var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; - return apply(fn, this, args); - } - return wrapper; - } - - /** - * Creates a `_.find` or `_.findLast` function. - * - * @private - * @param {Function} findIndexFunc The function to find the collection index. - * @returns {Function} Returns the new find function. - */ - function createFind(findIndexFunc) { - return function(collection, predicate, fromIndex) { - var iterable = Object(collection); - if (!isArrayLike(collection)) { - var iteratee = getIteratee(predicate, 3); - collection = keys(collection); - predicate = function(key) { return iteratee(iterable[key], key, iterable); }; - } - var index = findIndexFunc(collection, predicate, fromIndex); - return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined; - }; - } - - /** - * Creates a `_.flow` or `_.flowRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new flow function. - */ - function createFlow(fromRight) { - return flatRest(function(funcs) { - var length = funcs.length, - index = length, - prereq = LodashWrapper.prototype.thru; - - if (fromRight) { - funcs.reverse(); - } - while (index--) { - var func = funcs[index]; - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - if (prereq && !wrapper && getFuncName(func) == 'wrapper') { - var wrapper = new LodashWrapper([], true); - } - } - index = wrapper ? index : length; - while (++index < length) { - func = funcs[index]; - - var funcName = getFuncName(func), - data = funcName == 'wrapper' ? getData(func) : undefined; - - if (data && isLaziable(data[0]) && - data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && - !data[4].length && data[9] == 1 - ) { - wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]); - } else { - wrapper = (func.length == 1 && isLaziable(func)) - ? wrapper[funcName]() - : wrapper.thru(func); - } - } - return function() { - var args = arguments, - value = args[0]; - - if (wrapper && args.length == 1 && isArray(value)) { - return wrapper.plant(value).value(); - } - var index = 0, - result = length ? funcs[index].apply(this, args) : value; - - while (++index < length) { - result = funcs[index].call(this, result); - } - return result; - }; - }); - } - - /** - * Creates a function that wraps `func` to invoke it with optional `this` - * binding of `thisArg`, partial application, and currying. - * - * @private - * @param {Function|string} func The function or method name to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to prepend to those provided to - * the new function. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [partialsRight] The arguments to append to those provided - * to the new function. - * @param {Array} [holdersRight] The `partialsRight` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) { - var isAry = bitmask & WRAP_ARY_FLAG, - isBind = bitmask & WRAP_BIND_FLAG, - isBindKey = bitmask & WRAP_BIND_KEY_FLAG, - isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), - isFlip = bitmask & WRAP_FLIP_FLAG, - Ctor = isBindKey ? undefined : createCtor(func); - - function wrapper() { - var length = arguments.length, - args = Array(length), - index = length; - - while (index--) { - args[index] = arguments[index]; - } - if (isCurried) { - var placeholder = getHolder(wrapper), - holdersCount = countHolders(args, placeholder); - } - if (partials) { - args = composeArgs(args, partials, holders, isCurried); - } - if (partialsRight) { - args = composeArgsRight(args, partialsRight, holdersRight, isCurried); - } - length -= holdersCount; - if (isCurried && length < arity) { - var newHolders = replaceHolders(args, placeholder); - return createRecurry( - func, bitmask, createHybrid, wrapper.placeholder, thisArg, - args, newHolders, argPos, ary, arity - length - ); - } - var thisBinding = isBind ? thisArg : this, - fn = isBindKey ? thisBinding[func] : func; - - length = args.length; - if (argPos) { - args = reorder(args, argPos); - } else if (isFlip && length > 1) { - args.reverse(); - } - if (isAry && ary < length) { - args.length = ary; - } - if (this && this !== root && this instanceof wrapper) { - fn = Ctor || createCtor(fn); - } - return fn.apply(thisBinding, args); - } - return wrapper; - } - - /** - * Creates a function like `_.invertBy`. - * - * @private - * @param {Function} setter The function to set accumulator values. - * @param {Function} toIteratee The function to resolve iteratees. - * @returns {Function} Returns the new inverter function. - */ - function createInverter(setter, toIteratee) { - return function(object, iteratee) { - return baseInverter(object, setter, toIteratee(iteratee), {}); - }; - } - - /** - * Creates a function that performs a mathematical operation on two values. - * - * @private - * @param {Function} operator The function to perform the operation. - * @param {number} [defaultValue] The value used for `undefined` arguments. - * @returns {Function} Returns the new mathematical operation function. - */ - function createMathOperation(operator, defaultValue) { - return function(value, other) { - var result; - if (value === undefined && other === undefined) { - return defaultValue; - } - if (value !== undefined) { - result = value; - } - if (other !== undefined) { - if (result === undefined) { - return other; - } - if (typeof value == 'string' || typeof other == 'string') { - value = baseToString(value); - other = baseToString(other); - } else { - value = baseToNumber(value); - other = baseToNumber(other); - } - result = operator(value, other); - } - return result; - }; - } - - /** - * Creates a function like `_.over`. - * - * @private - * @param {Function} arrayFunc The function to iterate over iteratees. - * @returns {Function} Returns the new over function. - */ - function createOver(arrayFunc) { - return flatRest(function(iteratees) { - iteratees = arrayMap(iteratees, baseUnary(getIteratee())); - return baseRest(function(args) { - var thisArg = this; - return arrayFunc(iteratees, function(iteratee) { - return apply(iteratee, thisArg, args); - }); - }); - }); - } - - /** - * Creates the padding for `string` based on `length`. The `chars` string - * is truncated if the number of characters exceeds `length`. - * - * @private - * @param {number} length The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padding for `string`. - */ - function createPadding(length, chars) { - chars = chars === undefined ? ' ' : baseToString(chars); - - var charsLength = chars.length; - if (charsLength < 2) { - return charsLength ? baseRepeat(chars, length) : chars; - } - var result = baseRepeat(chars, nativeCeil(length / stringSize(chars))); - return hasUnicode(chars) - ? castSlice(stringToArray(result), 0, length).join('') - : result.slice(0, length); - } - - /** - * Creates a function that wraps `func` to invoke it with the `this` binding - * of `thisArg` and `partials` prepended to the arguments it receives. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {*} thisArg The `this` binding of `func`. - * @param {Array} partials The arguments to prepend to those provided to - * the new function. - * @returns {Function} Returns the new wrapped function. - */ - function createPartial(func, bitmask, thisArg, partials) { - var isBind = bitmask & WRAP_BIND_FLAG, - Ctor = createCtor(func); - - function wrapper() { - var argsIndex = -1, - argsLength = arguments.length, - leftIndex = -1, - leftLength = partials.length, - args = Array(leftLength + argsLength), - fn = (this && this !== root && this instanceof wrapper) ? Ctor : func; - - while (++leftIndex < leftLength) { - args[leftIndex] = partials[leftIndex]; - } - while (argsLength--) { - args[leftIndex++] = arguments[++argsIndex]; - } - return apply(fn, isBind ? thisArg : this, args); - } - return wrapper; - } - - /** - * Creates a `_.range` or `_.rangeRight` function. - * - * @private - * @param {boolean} [fromRight] Specify iterating from right to left. - * @returns {Function} Returns the new range function. - */ - function createRange(fromRight) { - return function(start, end, step) { - if (step && typeof step != 'number' && isIterateeCall(start, end, step)) { - end = step = undefined; - } - // Ensure the sign of `-0` is preserved. - start = toFinite(start); - if (end === undefined) { - end = start; - start = 0; - } else { - end = toFinite(end); - } - step = step === undefined ? (start < end ? 1 : -1) : toFinite(step); - return baseRange(start, end, step, fromRight); - }; - } - - /** - * Creates a function that performs a relational operation on two values. - * - * @private - * @param {Function} operator The function to perform the operation. - * @returns {Function} Returns the new relational operation function. - */ - function createRelationalOperation(operator) { - return function(value, other) { - if (!(typeof value == 'string' && typeof other == 'string')) { - value = toNumber(value); - other = toNumber(other); - } - return operator(value, other); - }; - } - - /** - * Creates a function that wraps `func` to continue currying. - * - * @private - * @param {Function} func The function to wrap. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @param {Function} wrapFunc The function to create the `func` wrapper. - * @param {*} placeholder The placeholder value. - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to prepend to those provided to - * the new function. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) { - var isCurry = bitmask & WRAP_CURRY_FLAG, - newHolders = isCurry ? holders : undefined, - newHoldersRight = isCurry ? undefined : holders, - newPartials = isCurry ? partials : undefined, - newPartialsRight = isCurry ? undefined : partials; - - bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG); - bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG); - - if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) { - bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG); - } - var newData = [ - func, bitmask, thisArg, newPartials, newHolders, newPartialsRight, - newHoldersRight, argPos, ary, arity - ]; - - var result = wrapFunc.apply(undefined, newData); - if (isLaziable(func)) { - setData(result, newData); - } - result.placeholder = placeholder; - return setWrapToString(result, func, bitmask); - } - - /** - * Creates a function like `_.round`. - * - * @private - * @param {string} methodName The name of the `Math` method to use when rounding. - * @returns {Function} Returns the new round function. - */ - function createRound(methodName) { - var func = Math[methodName]; - return function(number, precision) { - number = toNumber(number); - precision = precision == null ? 0 : nativeMin(toInteger(precision), 292); - if (precision && nativeIsFinite(number)) { - // Shift with exponential notation to avoid floating-point issues. - // See [MDN](https://mdn.io/round#Examples) for more details. - var pair = (toString(number) + 'e').split('e'), - value = func(pair[0] + 'e' + (+pair[1] + precision)); - - pair = (toString(value) + 'e').split('e'); - return +(pair[0] + 'e' + (+pair[1] - precision)); - } - return func(number); - }; - } - - /** - * Creates a set object of `values`. - * - * @private - * @param {Array} values The values to add to the set. - * @returns {Object} Returns the new set. - */ - var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) { - return new Set(values); - }; - - /** - * Creates a `_.toPairs` or `_.toPairsIn` function. - * - * @private - * @param {Function} keysFunc The function to get the keys of a given object. - * @returns {Function} Returns the new pairs function. - */ - function createToPairs(keysFunc) { - return function(object) { - var tag = getTag(object); - if (tag == mapTag) { - return mapToArray(object); - } - if (tag == setTag) { - return setToPairs(object); - } - return baseToPairs(object, keysFunc(object)); - }; - } - - /** - * Creates a function that either curries or invokes `func` with optional - * `this` binding and partially applied arguments. - * - * @private - * @param {Function|string} func The function or method name to wrap. - * @param {number} bitmask The bitmask flags. - * 1 - `_.bind` - * 2 - `_.bindKey` - * 4 - `_.curry` or `_.curryRight` of a bound function - * 8 - `_.curry` - * 16 - `_.curryRight` - * 32 - `_.partial` - * 64 - `_.partialRight` - * 128 - `_.rearg` - * 256 - `_.ary` - * 512 - `_.flip` - * @param {*} [thisArg] The `this` binding of `func`. - * @param {Array} [partials] The arguments to be partially applied. - * @param {Array} [holders] The `partials` placeholder indexes. - * @param {Array} [argPos] The argument positions of the new function. - * @param {number} [ary] The arity cap of `func`. - * @param {number} [arity] The arity of `func`. - * @returns {Function} Returns the new wrapped function. - */ - function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) { - var isBindKey = bitmask & WRAP_BIND_KEY_FLAG; - if (!isBindKey && typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - var length = partials ? partials.length : 0; - if (!length) { - bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG); - partials = holders = undefined; - } - ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0); - arity = arity === undefined ? arity : toInteger(arity); - length -= holders ? holders.length : 0; - - if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) { - var partialsRight = partials, - holdersRight = holders; - - partials = holders = undefined; - } - var data = isBindKey ? undefined : getData(func); - - var newData = [ - func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, - argPos, ary, arity - ]; - - if (data) { - mergeData(newData, data); - } - func = newData[0]; - bitmask = newData[1]; - thisArg = newData[2]; - partials = newData[3]; - holders = newData[4]; - arity = newData[9] = newData[9] === undefined - ? (isBindKey ? 0 : func.length) - : nativeMax(newData[9] - length, 0); - - if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) { - bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG); - } - if (!bitmask || bitmask == WRAP_BIND_FLAG) { - var result = createBind(func, bitmask, thisArg); - } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) { - result = createCurry(func, bitmask, arity); - } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) { - result = createPartial(func, bitmask, thisArg, partials); - } else { - result = createHybrid.apply(undefined, newData); - } - var setter = data ? baseSetData : setData; - return setWrapToString(setter(result, newData), func, bitmask); - } - - /** - * Used by `_.defaults` to customize its `_.assignIn` use to assign properties - * of source objects to the destination object for all destination properties - * that resolve to `undefined`. - * - * @private - * @param {*} objValue The destination value. - * @param {*} srcValue The source value. - * @param {string} key The key of the property to assign. - * @param {Object} object The parent object of `objValue`. - * @returns {*} Returns the value to assign. - */ - function customDefaultsAssignIn(objValue, srcValue, key, object) { - if (objValue === undefined || - (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) { - return srcValue; - } - return objValue; - } - - /** - * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source - * objects into destination objects that are passed thru. - * - * @private - * @param {*} objValue The destination value. - * @param {*} srcValue The source value. - * @param {string} key The key of the property to merge. - * @param {Object} object The parent object of `objValue`. - * @param {Object} source The parent object of `srcValue`. - * @param {Object} [stack] Tracks traversed source values and their merged - * counterparts. - * @returns {*} Returns the value to assign. - */ - function customDefaultsMerge(objValue, srcValue, key, object, source, stack) { - if (isObject(objValue) && isObject(srcValue)) { - // Recursively merge objects and arrays (susceptible to call stack limits). - stack.set(srcValue, objValue); - baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack); - stack['delete'](srcValue); - } - return objValue; - } - - /** - * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain - * objects. - * - * @private - * @param {*} value The value to inspect. - * @param {string} key The key of the property to inspect. - * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. - */ - function customOmitClone(value) { - return isPlainObject(value) ? undefined : value; - } - - /** - * A specialized version of `baseIsEqualDeep` for arrays with support for - * partial deep comparisons. - * - * @private - * @param {Array} array The array to compare. - * @param {Array} other The other array to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `array` and `other` objects. - * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. - */ - function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - arrLength = array.length, - othLength = other.length; - - if (arrLength != othLength && !(isPartial && othLength > arrLength)) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(array); - if (stacked && stack.get(other)) { - return stacked == other; - } - var index = -1, - result = true, - seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; - - stack.set(array, other); - stack.set(other, array); - - // Ignore non-index properties. - while (++index < arrLength) { - var arrValue = array[index], - othValue = other[index]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, arrValue, index, other, array, stack) - : customizer(arrValue, othValue, index, array, other, stack); - } - if (compared !== undefined) { - if (compared) { - continue; - } - result = false; - break; - } - // Recursively compare arrays (susceptible to call stack limits). - if (seen) { - if (!arraySome(other, function(othValue, othIndex) { - if (!cacheHas(seen, othIndex) && - (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { - return seen.push(othIndex); - } - })) { - result = false; - break; - } - } else if (!( - arrValue === othValue || - equalFunc(arrValue, othValue, bitmask, customizer, stack) - )) { - result = false; - break; - } - } - stack['delete'](array); - stack['delete'](other); - return result; - } - - /** - * A specialized version of `baseIsEqualDeep` for comparing objects of - * the same `toStringTag`. - * - * **Note:** This function only supports comparing values with tags of - * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {string} tag The `toStringTag` of the objects to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { - switch (tag) { - case dataViewTag: - if ((object.byteLength != other.byteLength) || - (object.byteOffset != other.byteOffset)) { - return false; - } - object = object.buffer; - other = other.buffer; - - case arrayBufferTag: - if ((object.byteLength != other.byteLength) || - !equalFunc(new Uint8Array(object), new Uint8Array(other))) { - return false; - } - return true; - - case boolTag: - case dateTag: - case numberTag: - // Coerce booleans to `1` or `0` and dates to milliseconds. - // Invalid dates are coerced to `NaN`. - return eq(+object, +other); - - case errorTag: - return object.name == other.name && object.message == other.message; - - case regexpTag: - case stringTag: - // Coerce regexes to strings and treat strings, primitives and objects, - // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring - // for more details. - return object == (other + ''); - - case mapTag: - var convert = mapToArray; - - case setTag: - var isPartial = bitmask & COMPARE_PARTIAL_FLAG; - convert || (convert = setToArray); - - if (object.size != other.size && !isPartial) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked) { - return stacked == other; - } - bitmask |= COMPARE_UNORDERED_FLAG; - - // Recursively compare objects (susceptible to call stack limits). - stack.set(object, other); - var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); - stack['delete'](object); - return result; - - case symbolTag: - if (symbolValueOf) { - return symbolValueOf.call(object) == symbolValueOf.call(other); - } - } - return false; - } - - /** - * A specialized version of `baseIsEqualDeep` for objects with support for - * partial deep comparisons. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - objProps = getAllKeys(object), - objLength = objProps.length, - othProps = getAllKeys(other), - othLength = othProps.length; - - if (objLength != othLength && !isPartial) { - return false; - } - var index = objLength; - while (index--) { - var key = objProps[index]; - if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { - return false; - } - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked && stack.get(other)) { - return stacked == other; - } - var result = true; - stack.set(object, other); - stack.set(other, object); - - var skipCtor = isPartial; - while (++index < objLength) { - key = objProps[index]; - var objValue = object[key], - othValue = other[key]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, objValue, key, other, object, stack) - : customizer(objValue, othValue, key, object, other, stack); - } - // Recursively compare objects (susceptible to call stack limits). - if (!(compared === undefined - ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) - : compared - )) { - result = false; - break; - } - skipCtor || (skipCtor = key == 'constructor'); - } - if (result && !skipCtor) { - var objCtor = object.constructor, - othCtor = other.constructor; - - // Non `Object` object instances with different constructors are not equal. - if (objCtor != othCtor && - ('constructor' in object && 'constructor' in other) && - !(typeof objCtor == 'function' && objCtor instanceof objCtor && - typeof othCtor == 'function' && othCtor instanceof othCtor)) { - result = false; - } - } - stack['delete'](object); - stack['delete'](other); - return result; - } - - /** - * A specialized version of `baseRest` which flattens the rest array. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @returns {Function} Returns the new function. - */ - function flatRest(func) { - return setToString(overRest(func, undefined, flatten), func + ''); - } - - /** - * Creates an array of own enumerable property names and symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ - function getAllKeys(object) { - return baseGetAllKeys(object, keys, getSymbols); - } - - /** - * Creates an array of own and inherited enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ - function getAllKeysIn(object) { - return baseGetAllKeys(object, keysIn, getSymbolsIn); - } - - /** - * Gets metadata for `func`. - * - * @private - * @param {Function} func The function to query. - * @returns {*} Returns the metadata for `func`. - */ - var getData = !metaMap ? noop : function(func) { - return metaMap.get(func); - }; - - /** - * Gets the name of `func`. - * - * @private - * @param {Function} func The function to query. - * @returns {string} Returns the function name. - */ - function getFuncName(func) { - var result = (func.name + ''), - array = realNames[result], - length = hasOwnProperty.call(realNames, result) ? array.length : 0; - - while (length--) { - var data = array[length], - otherFunc = data.func; - if (otherFunc == null || otherFunc == func) { - return data.name; - } - } - return result; - } - - /** - * Gets the argument placeholder value for `func`. - * - * @private - * @param {Function} func The function to inspect. - * @returns {*} Returns the placeholder value. - */ - function getHolder(func) { - var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func; - return object.placeholder; - } - - /** - * Gets the appropriate "iteratee" function. If `_.iteratee` is customized, - * this function returns the custom method, otherwise it returns `baseIteratee`. - * If arguments are provided, the chosen function is invoked with them and - * its result is returned. - * - * @private - * @param {*} [value] The value to convert to an iteratee. - * @param {number} [arity] The arity of the created iteratee. - * @returns {Function} Returns the chosen function or its result. - */ - function getIteratee() { - var result = lodash.iteratee || iteratee; - result = result === iteratee ? baseIteratee : result; - return arguments.length ? result(arguments[0], arguments[1]) : result; - } - - /** - * Gets the data for `map`. - * - * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. - */ - function getMapData(map, key) { - var data = map.__data__; - return isKeyable(key) - ? data[typeof key == 'string' ? 'string' : 'hash'] - : data.map; - } - - /** - * Gets the property names, values, and compare flags of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the match data of `object`. - */ - function getMatchData(object) { - var result = keys(object), - length = result.length; - - while (length--) { - var key = result[length], - value = object[key]; - - result[length] = [key, value, isStrictComparable(value)]; - } - return result; - } - - /** - * Gets the native function at `key` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. - */ - function getNative(object, key) { - var value = getValue(object, key); - return baseIsNative(value) ? value : undefined; - } - - /** - * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the raw `toStringTag`. - */ - function getRawTag(value) { - var isOwn = hasOwnProperty.call(value, symToStringTag), - tag = value[symToStringTag]; - - try { - value[symToStringTag] = undefined; - var unmasked = true; - } catch (e) {} - - var result = nativeObjectToString.call(value); - if (unmasked) { - if (isOwn) { - value[symToStringTag] = tag; - } else { - delete value[symToStringTag]; - } - } - return result; - } - - /** - * Creates an array of the own enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ - var getSymbols = !nativeGetSymbols ? stubArray : function(object) { - if (object == null) { - return []; - } - object = Object(object); - return arrayFilter(nativeGetSymbols(object), function(symbol) { - return propertyIsEnumerable.call(object, symbol); - }); - }; - - /** - * Creates an array of the own and inherited enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ - var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) { - var result = []; - while (object) { - arrayPush(result, getSymbols(object)); - object = getPrototype(object); - } - return result; - }; - - /** - * Gets the `toStringTag` of `value`. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ - var getTag = baseGetTag; - - // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. - if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || - (Map && getTag(new Map) != mapTag) || - (Promise && getTag(Promise.resolve()) != promiseTag) || - (Set && getTag(new Set) != setTag) || - (WeakMap && getTag(new WeakMap) != weakMapTag)) { - getTag = function(value) { - var result = baseGetTag(value), - Ctor = result == objectTag ? value.constructor : undefined, - ctorString = Ctor ? toSource(Ctor) : ''; - - if (ctorString) { - switch (ctorString) { - case dataViewCtorString: return dataViewTag; - case mapCtorString: return mapTag; - case promiseCtorString: return promiseTag; - case setCtorString: return setTag; - case weakMapCtorString: return weakMapTag; - } - } - return result; - }; - } - - /** - * Gets the view, applying any `transforms` to the `start` and `end` positions. - * - * @private - * @param {number} start The start of the view. - * @param {number} end The end of the view. - * @param {Array} transforms The transformations to apply to the view. - * @returns {Object} Returns an object containing the `start` and `end` - * positions of the view. - */ - function getView(start, end, transforms) { - var index = -1, - length = transforms.length; - - while (++index < length) { - var data = transforms[index], - size = data.size; - - switch (data.type) { - case 'drop': start += size; break; - case 'dropRight': end -= size; break; - case 'take': end = nativeMin(end, start + size); break; - case 'takeRight': start = nativeMax(start, end - size); break; - } - } - return { 'start': start, 'end': end }; - } - - /** - * Extracts wrapper details from the `source` body comment. - * - * @private - * @param {string} source The source to inspect. - * @returns {Array} Returns the wrapper details. - */ - function getWrapDetails(source) { - var match = source.match(reWrapDetails); - return match ? match[1].split(reSplitDetails) : []; - } - - /** - * Checks if `path` exists on `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @param {Function} hasFunc The function to check properties. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - */ - function hasPath(object, path, hasFunc) { - path = castPath(path, object); - - var index = -1, - length = path.length, - result = false; - - while (++index < length) { - var key = toKey(path[index]); - if (!(result = object != null && hasFunc(object, key))) { - break; - } - object = object[key]; - } - if (result || ++index != length) { - return result; - } - length = object == null ? 0 : object.length; - return !!length && isLength(length) && isIndex(key, length) && - (isArray(object) || isArguments(object)); - } - - /** - * Initializes an array clone. - * - * @private - * @param {Array} array The array to clone. - * @returns {Array} Returns the initialized clone. - */ - function initCloneArray(array) { - var length = array.length, - result = new array.constructor(length); - - // Add properties assigned by `RegExp#exec`. - if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { - result.index = array.index; - result.input = array.input; - } - return result; - } - - /** - * Initializes an object clone. - * - * @private - * @param {Object} object The object to clone. - * @returns {Object} Returns the initialized clone. - */ - function initCloneObject(object) { - return (typeof object.constructor == 'function' && !isPrototype(object)) - ? baseCreate(getPrototype(object)) - : {}; - } - - /** - * Initializes an object clone based on its `toStringTag`. - * - * **Note:** This function only supports cloning values with tags of - * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. - * - * @private - * @param {Object} object The object to clone. - * @param {string} tag The `toStringTag` of the object to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the initialized clone. - */ - function initCloneByTag(object, tag, isDeep) { - var Ctor = object.constructor; - switch (tag) { - case arrayBufferTag: - return cloneArrayBuffer(object); - - case boolTag: - case dateTag: - return new Ctor(+object); - - case dataViewTag: - return cloneDataView(object, isDeep); - - case float32Tag: case float64Tag: - case int8Tag: case int16Tag: case int32Tag: - case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag: - return cloneTypedArray(object, isDeep); - - case mapTag: - return new Ctor; - - case numberTag: - case stringTag: - return new Ctor(object); - - case regexpTag: - return cloneRegExp(object); - - case setTag: - return new Ctor; - - case symbolTag: - return cloneSymbol(object); - } - } - - /** - * Inserts wrapper `details` in a comment at the top of the `source` body. - * - * @private - * @param {string} source The source to modify. - * @returns {Array} details The details to insert. - * @returns {string} Returns the modified source. - */ - function insertWrapDetails(source, details) { - var length = details.length; - if (!length) { - return source; - } - var lastIndex = length - 1; - details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex]; - details = details.join(length > 2 ? ', ' : ' '); - return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n'); - } - - /** - * Checks if `value` is a flattenable `arguments` object or array. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is flattenable, else `false`. - */ - function isFlattenable(value) { - return isArray(value) || isArguments(value) || - !!(spreadableSymbol && value && value[spreadableSymbol]); - } - - /** - * Checks if `value` is a valid array-like index. - * - * @private - * @param {*} value The value to check. - * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. - * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. - */ - function isIndex(value, length) { - var type = typeof value; - length = length == null ? MAX_SAFE_INTEGER : length; - - return !!length && - (type == 'number' || - (type != 'symbol' && reIsUint.test(value))) && - (value > -1 && value % 1 == 0 && value < length); - } - - /** - * Checks if the given arguments are from an iteratee call. - * - * @private - * @param {*} value The potential iteratee value argument. - * @param {*} index The potential iteratee index or key argument. - * @param {*} object The potential iteratee object argument. - * @returns {boolean} Returns `true` if the arguments are from an iteratee call, - * else `false`. - */ - function isIterateeCall(value, index, object) { - if (!isObject(object)) { - return false; - } - var type = typeof index; - if (type == 'number' - ? (isArrayLike(object) && isIndex(index, object.length)) - : (type == 'string' && index in object) - ) { - return eq(object[index], value); - } - return false; - } - - /** - * Checks if `value` is a property name and not a property path. - * - * @private - * @param {*} value The value to check. - * @param {Object} [object] The object to query keys on. - * @returns {boolean} Returns `true` if `value` is a property name, else `false`. - */ - function isKey(value, object) { - if (isArray(value)) { - return false; - } - var type = typeof value; - if (type == 'number' || type == 'symbol' || type == 'boolean' || - value == null || isSymbol(value)) { - return true; - } - return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || - (object != null && value in Object(object)); - } - - /** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ - function isKeyable(value) { - var type = typeof value; - return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') - ? (value !== '__proto__') - : (value === null); - } - - /** - * Checks if `func` has a lazy counterpart. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` has a lazy counterpart, - * else `false`. - */ - function isLaziable(func) { - var funcName = getFuncName(func), - other = lodash[funcName]; - - if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) { - return false; - } - if (func === other) { - return true; - } - var data = getData(other); - return !!data && func === data[0]; - } - - /** - * Checks if `func` has its source masked. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. - */ - function isMasked(func) { - return !!maskSrcKey && (maskSrcKey in func); - } - - /** - * Checks if `func` is capable of being masked. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `func` is maskable, else `false`. - */ - var isMaskable = coreJsData ? isFunction : stubFalse; - - /** - * Checks if `value` is likely a prototype object. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. - */ - function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; - - return value === proto; - } - - /** - * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` if suitable for strict - * equality comparisons, else `false`. - */ - function isStrictComparable(value) { - return value === value && !isObject(value); - } - - /** - * A specialized version of `matchesProperty` for source values suitable - * for strict equality comparisons, i.e. `===`. - * - * @private - * @param {string} key The key of the property to get. - * @param {*} srcValue The value to match. - * @returns {Function} Returns the new spec function. - */ - function matchesStrictComparable(key, srcValue) { - return function(object) { - if (object == null) { - return false; - } - return object[key] === srcValue && - (srcValue !== undefined || (key in Object(object))); - }; - } - - /** - * A specialized version of `_.memoize` which clears the memoized function's - * cache when it exceeds `MAX_MEMOIZE_SIZE`. - * - * @private - * @param {Function} func The function to have its output memoized. - * @returns {Function} Returns the new memoized function. - */ - function memoizeCapped(func) { - var result = memoize(func, function(key) { - if (cache.size === MAX_MEMOIZE_SIZE) { - cache.clear(); - } - return key; - }); - - var cache = result.cache; - return result; - } - - /** - * Merges the function metadata of `source` into `data`. - * - * Merging metadata reduces the number of wrappers used to invoke a function. - * This is possible because methods like `_.bind`, `_.curry`, and `_.partial` - * may be applied regardless of execution order. Methods like `_.ary` and - * `_.rearg` modify function arguments, making the order in which they are - * executed important, preventing the merging of metadata. However, we make - * an exception for a safe combined case where curried functions have `_.ary` - * and or `_.rearg` applied. - * - * @private - * @param {Array} data The destination metadata. - * @param {Array} source The source metadata. - * @returns {Array} Returns `data`. - */ - function mergeData(data, source) { - var bitmask = data[1], - srcBitmask = source[1], - newBitmask = bitmask | srcBitmask, - isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG); - - var isCombo = - ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) || - ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) || - ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG)); - - // Exit early if metadata can't be merged. - if (!(isCommon || isCombo)) { - return data; - } - // Use source `thisArg` if available. - if (srcBitmask & WRAP_BIND_FLAG) { - data[2] = source[2]; - // Set when currying a bound function. - newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG; - } - // Compose partial arguments. - var value = source[3]; - if (value) { - var partials = data[3]; - data[3] = partials ? composeArgs(partials, value, source[4]) : value; - data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4]; - } - // Compose partial right arguments. - value = source[5]; - if (value) { - partials = data[5]; - data[5] = partials ? composeArgsRight(partials, value, source[6]) : value; - data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6]; - } - // Use source `argPos` if available. - value = source[7]; - if (value) { - data[7] = value; - } - // Use source `ary` if it's smaller. - if (srcBitmask & WRAP_ARY_FLAG) { - data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]); - } - // Use source `arity` if one is not provided. - if (data[9] == null) { - data[9] = source[9]; - } - // Use source `func` and merge bitmasks. - data[0] = source[0]; - data[1] = newBitmask; - - return data; - } - - /** - * This function is like - * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * except that it includes inherited enumerable properties. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function nativeKeysIn(object) { - var result = []; - if (object != null) { - for (var key in Object(object)) { - result.push(key); - } - } - return result; - } - - /** - * Converts `value` to a string using `Object.prototype.toString`. - * - * @private - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - */ - function objectToString(value) { - return nativeObjectToString.call(value); - } - - /** - * A specialized version of `baseRest` which transforms the rest array. - * - * @private - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @param {Function} transform The rest array transform. - * @returns {Function} Returns the new function. - */ - function overRest(func, start, transform) { - start = nativeMax(start === undefined ? (func.length - 1) : start, 0); - return function() { - var args = arguments, - index = -1, - length = nativeMax(args.length - start, 0), - array = Array(length); - - while (++index < length) { - array[index] = args[start + index]; - } - index = -1; - var otherArgs = Array(start + 1); - while (++index < start) { - otherArgs[index] = args[index]; - } - otherArgs[start] = transform(array); - return apply(func, this, otherArgs); - }; - } - - /** - * Gets the parent value at `path` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Array} path The path to get the parent value of. - * @returns {*} Returns the parent value. - */ - function parent(object, path) { - return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1)); - } - - /** - * Reorder `array` according to the specified indexes where the element at - * the first index is assigned as the first element, the element at - * the second index is assigned as the second element, and so on. - * - * @private - * @param {Array} array The array to reorder. - * @param {Array} indexes The arranged array indexes. - * @returns {Array} Returns `array`. - */ - function reorder(array, indexes) { - var arrLength = array.length, - length = nativeMin(indexes.length, arrLength), - oldArray = copyArray(array); - - while (length--) { - var index = indexes[length]; - array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined; - } - return array; - } - - /** - * Gets the value at `key`, unless `key` is "__proto__" or "constructor". - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ - function safeGet(object, key) { - if (key === 'constructor' && typeof object[key] === 'function') { - return; - } - - if (key == '__proto__') { - return; - } - - return object[key]; - } - - /** - * Sets metadata for `func`. - * - * **Note:** If this function becomes hot, i.e. is invoked a lot in a short - * period of time, it will trip its breaker and transition to an identity - * function to avoid garbage collection pauses in V8. See - * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070) - * for more details. - * - * @private - * @param {Function} func The function to associate metadata with. - * @param {*} data The metadata. - * @returns {Function} Returns `func`. - */ - var setData = shortOut(baseSetData); - - /** - * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout). - * - * @private - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @returns {number|Object} Returns the timer id or timeout object. - */ - var setTimeout = ctxSetTimeout || function(func, wait) { - return root.setTimeout(func, wait); - }; - - /** - * Sets the `toString` method of `func` to return `string`. - * - * @private - * @param {Function} func The function to modify. - * @param {Function} string The `toString` result. - * @returns {Function} Returns `func`. - */ - var setToString = shortOut(baseSetToString); - - /** - * Sets the `toString` method of `wrapper` to mimic the source of `reference` - * with wrapper details in a comment at the top of the source body. - * - * @private - * @param {Function} wrapper The function to modify. - * @param {Function} reference The reference function. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @returns {Function} Returns `wrapper`. - */ - function setWrapToString(wrapper, reference, bitmask) { - var source = (reference + ''); - return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask))); - } - - /** - * Creates a function that'll short out and invoke `identity` instead - * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` - * milliseconds. - * - * @private - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new shortable function. - */ - function shortOut(func) { - var count = 0, - lastCalled = 0; - - return function() { - var stamp = nativeNow(), - remaining = HOT_SPAN - (stamp - lastCalled); - - lastCalled = stamp; - if (remaining > 0) { - if (++count >= HOT_COUNT) { - return arguments[0]; - } - } else { - count = 0; - } - return func.apply(undefined, arguments); - }; - } - - /** - * A specialized version of `_.shuffle` which mutates and sets the size of `array`. - * - * @private - * @param {Array} array The array to shuffle. - * @param {number} [size=array.length] The size of `array`. - * @returns {Array} Returns `array`. - */ - function shuffleSelf(array, size) { - var index = -1, - length = array.length, - lastIndex = length - 1; - - size = size === undefined ? length : size; - while (++index < size) { - var rand = baseRandom(index, lastIndex), - value = array[rand]; - - array[rand] = array[index]; - array[index] = value; - } - array.length = size; - return array; - } - - /** - * Converts `string` to a property path array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. - */ - var stringToPath = memoizeCapped(function(string) { - var result = []; - if (string.charCodeAt(0) === 46 /* . */) { - result.push(''); - } - string.replace(rePropName, function(match, number, quote, subString) { - result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); - }); - return result; - }); - - /** - * Converts `value` to a string key if it's not a string or symbol. - * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. - */ - function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; - } - - /** - * Converts `func` to its source code. - * - * @private - * @param {Function} func The function to convert. - * @returns {string} Returns the source code. - */ - function toSource(func) { - if (func != null) { - try { - return funcToString.call(func); - } catch (e) {} - try { - return (func + ''); - } catch (e) {} - } - return ''; - } - - /** - * Updates wrapper `details` based on `bitmask` flags. - * - * @private - * @returns {Array} details The details to modify. - * @param {number} bitmask The bitmask flags. See `createWrap` for more details. - * @returns {Array} Returns `details`. - */ - function updateWrapDetails(details, bitmask) { - arrayEach(wrapFlags, function(pair) { - var value = '_.' + pair[0]; - if ((bitmask & pair[1]) && !arrayIncludes(details, value)) { - details.push(value); - } - }); - return details.sort(); - } - - /** - * Creates a clone of `wrapper`. - * - * @private - * @param {Object} wrapper The wrapper to clone. - * @returns {Object} Returns the cloned wrapper. - */ - function wrapperClone(wrapper) { - if (wrapper instanceof LazyWrapper) { - return wrapper.clone(); - } - var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__); - result.__actions__ = copyArray(wrapper.__actions__); - result.__index__ = wrapper.__index__; - result.__values__ = wrapper.__values__; - return result; - } - - /*------------------------------------------------------------------------*/ - - /** - * Creates an array of elements split into groups the length of `size`. - * If `array` can't be split evenly, the final chunk will be the remaining - * elements. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to process. - * @param {number} [size=1] The length of each chunk - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the new array of chunks. - * @example - * - * _.chunk(['a', 'b', 'c', 'd'], 2); - * // => [['a', 'b'], ['c', 'd']] - * - * _.chunk(['a', 'b', 'c', 'd'], 3); - * // => [['a', 'b', 'c'], ['d']] - */ - function chunk(array, size, guard) { - if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) { - size = 1; - } else { - size = nativeMax(toInteger(size), 0); - } - var length = array == null ? 0 : array.length; - if (!length || size < 1) { - return []; - } - var index = 0, - resIndex = 0, - result = Array(nativeCeil(length / size)); - - while (index < length) { - result[resIndex++] = baseSlice(array, index, (index += size)); - } - return result; - } - - /** - * Creates an array with all falsey values removed. The values `false`, `null`, - * `0`, `""`, `undefined`, and `NaN` are falsey. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to compact. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.compact([0, 1, false, 2, '', 3]); - * // => [1, 2, 3] - */ - function compact(array) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (value) { - result[resIndex++] = value; - } - } - return result; - } - - /** - * Creates a new array concatenating `array` with any additional arrays - * and/or values. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to concatenate. - * @param {...*} [values] The values to concatenate. - * @returns {Array} Returns the new concatenated array. - * @example - * - * var array = [1]; - * var other = _.concat(array, 2, [3], [[4]]); - * - * console.log(other); - * // => [1, 2, 3, [4]] - * - * console.log(array); - * // => [1] - */ - function concat() { - var length = arguments.length; - if (!length) { - return []; - } - var args = Array(length - 1), - array = arguments[0], - index = length; - - while (index--) { - args[index - 1] = arguments[index]; - } - return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1)); - } - - /** - * Creates an array of `array` values not included in the other given arrays - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. The order and references of result values are - * determined by the first array. - * - * **Note:** Unlike `_.pullAll`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @returns {Array} Returns the new array of filtered values. - * @see _.without, _.xor - * @example - * - * _.difference([2, 1], [2, 3]); - * // => [1] - */ - var difference = baseRest(function(array, values) { - return isArrayLikeObject(array) - ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) - : []; - }); - - /** - * This method is like `_.difference` except that it accepts `iteratee` which - * is invoked for each element of `array` and `values` to generate the criterion - * by which they're compared. The order and references of result values are - * determined by the first array. The iteratee is invoked with one argument: - * (value). - * - * **Note:** Unlike `_.pullAllBy`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [1.2] - * - * // The `_.property` iteratee shorthand. - * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'); - * // => [{ 'x': 2 }] - */ - var differenceBy = baseRest(function(array, values) { - var iteratee = last(values); - if (isArrayLikeObject(iteratee)) { - iteratee = undefined; - } - return isArrayLikeObject(array) - ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)) - : []; - }); - - /** - * This method is like `_.difference` except that it accepts `comparator` - * which is invoked to compare elements of `array` to `values`. The order and - * references of result values are determined by the first array. The comparator - * is invoked with two arguments: (arrVal, othVal). - * - * **Note:** Unlike `_.pullAllWith`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...Array} [values] The values to exclude. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * - * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual); - * // => [{ 'x': 2, 'y': 1 }] - */ - var differenceWith = baseRest(function(array, values) { - var comparator = last(values); - if (isArrayLikeObject(comparator)) { - comparator = undefined; - } - return isArrayLikeObject(array) - ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator) - : []; - }); - - /** - * Creates a slice of `array` with `n` elements dropped from the beginning. - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to drop. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.drop([1, 2, 3]); - * // => [2, 3] - * - * _.drop([1, 2, 3], 2); - * // => [3] - * - * _.drop([1, 2, 3], 5); - * // => [] - * - * _.drop([1, 2, 3], 0); - * // => [1, 2, 3] - */ - function drop(array, n, guard) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - return baseSlice(array, n < 0 ? 0 : n, length); - } - - /** - * Creates a slice of `array` with `n` elements dropped from the end. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to drop. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.dropRight([1, 2, 3]); - * // => [1, 2] - * - * _.dropRight([1, 2, 3], 2); - * // => [1] - * - * _.dropRight([1, 2, 3], 5); - * // => [] - * - * _.dropRight([1, 2, 3], 0); - * // => [1, 2, 3] - */ - function dropRight(array, n, guard) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - n = length - n; - return baseSlice(array, 0, n < 0 ? 0 : n); - } - - /** - * Creates a slice of `array` excluding elements dropped from the end. - * Elements are dropped until `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.dropRightWhile(users, function(o) { return !o.active; }); - * // => objects for ['barney'] - * - * // The `_.matches` iteratee shorthand. - * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false }); - * // => objects for ['barney', 'fred'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.dropRightWhile(users, ['active', false]); - * // => objects for ['barney'] - * - * // The `_.property` iteratee shorthand. - * _.dropRightWhile(users, 'active'); - * // => objects for ['barney', 'fred', 'pebbles'] - */ - function dropRightWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3), true, true) - : []; - } - - /** - * Creates a slice of `array` excluding elements dropped from the beginning. - * Elements are dropped until `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.dropWhile(users, function(o) { return !o.active; }); - * // => objects for ['pebbles'] - * - * // The `_.matches` iteratee shorthand. - * _.dropWhile(users, { 'user': 'barney', 'active': false }); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.dropWhile(users, ['active', false]); - * // => objects for ['pebbles'] - * - * // The `_.property` iteratee shorthand. - * _.dropWhile(users, 'active'); - * // => objects for ['barney', 'fred', 'pebbles'] - */ - function dropWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3), true) - : []; - } - - /** - * Fills elements of `array` with `value` from `start` up to, but not - * including, `end`. - * - * **Note:** This method mutates `array`. - * - * @static - * @memberOf _ - * @since 3.2.0 - * @category Array - * @param {Array} array The array to fill. - * @param {*} value The value to fill `array` with. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns `array`. - * @example - * - * var array = [1, 2, 3]; - * - * _.fill(array, 'a'); - * console.log(array); - * // => ['a', 'a', 'a'] - * - * _.fill(Array(3), 2); - * // => [2, 2, 2] - * - * _.fill([4, 6, 8, 10], '*', 1, 3); - * // => [4, '*', '*', 10] - */ - function fill(array, value, start, end) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - if (start && typeof start != 'number' && isIterateeCall(array, value, start)) { - start = 0; - end = length; - } - return baseFill(array, value, start, end); - } - - /** - * This method is like `_.find` except that it returns the index of the first - * element `predicate` returns truthy for instead of the element itself. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=0] The index to search from. - * @returns {number} Returns the index of the found element, else `-1`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.findIndex(users, function(o) { return o.user == 'barney'; }); - * // => 0 - * - * // The `_.matches` iteratee shorthand. - * _.findIndex(users, { 'user': 'fred', 'active': false }); - * // => 1 - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findIndex(users, ['active', false]); - * // => 0 - * - * // The `_.property` iteratee shorthand. - * _.findIndex(users, 'active'); - * // => 2 - */ - function findIndex(array, predicate, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = fromIndex == null ? 0 : toInteger(fromIndex); - if (index < 0) { - index = nativeMax(length + index, 0); - } - return baseFindIndex(array, getIteratee(predicate, 3), index); - } - - /** - * This method is like `_.findIndex` except that it iterates over elements - * of `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=array.length-1] The index to search from. - * @returns {number} Returns the index of the found element, else `-1`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; }); - * // => 2 - * - * // The `_.matches` iteratee shorthand. - * _.findLastIndex(users, { 'user': 'barney', 'active': true }); - * // => 0 - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findLastIndex(users, ['active', false]); - * // => 2 - * - * // The `_.property` iteratee shorthand. - * _.findLastIndex(users, 'active'); - * // => 0 - */ - function findLastIndex(array, predicate, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = length - 1; - if (fromIndex !== undefined) { - index = toInteger(fromIndex); - index = fromIndex < 0 - ? nativeMax(length + index, 0) - : nativeMin(index, length - 1); - } - return baseFindIndex(array, getIteratee(predicate, 3), index, true); - } - - /** - * Flattens `array` a single level deep. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to flatten. - * @returns {Array} Returns the new flattened array. - * @example - * - * _.flatten([1, [2, [3, [4]], 5]]); - * // => [1, 2, [3, [4]], 5] - */ - function flatten(array) { - var length = array == null ? 0 : array.length; - return length ? baseFlatten(array, 1) : []; - } - - /** - * Recursively flattens `array`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to flatten. - * @returns {Array} Returns the new flattened array. - * @example - * - * _.flattenDeep([1, [2, [3, [4]], 5]]); - * // => [1, 2, 3, 4, 5] - */ - function flattenDeep(array) { - var length = array == null ? 0 : array.length; - return length ? baseFlatten(array, INFINITY) : []; - } - - /** - * Recursively flatten `array` up to `depth` times. - * - * @static - * @memberOf _ - * @since 4.4.0 - * @category Array - * @param {Array} array The array to flatten. - * @param {number} [depth=1] The maximum recursion depth. - * @returns {Array} Returns the new flattened array. - * @example - * - * var array = [1, [2, [3, [4]], 5]]; - * - * _.flattenDepth(array, 1); - * // => [1, 2, [3, [4]], 5] - * - * _.flattenDepth(array, 2); - * // => [1, 2, 3, [4], 5] - */ - function flattenDepth(array, depth) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - depth = depth === undefined ? 1 : toInteger(depth); - return baseFlatten(array, depth); - } - - /** - * The inverse of `_.toPairs`; this method returns an object composed - * from key-value `pairs`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} pairs The key-value pairs. - * @returns {Object} Returns the new object. - * @example - * - * _.fromPairs([['a', 1], ['b', 2]]); - * // => { 'a': 1, 'b': 2 } - */ - function fromPairs(pairs) { - var index = -1, - length = pairs == null ? 0 : pairs.length, - result = {}; - - while (++index < length) { - var pair = pairs[index]; - result[pair[0]] = pair[1]; - } - return result; - } - - /** - * Gets the first element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @alias first - * @category Array - * @param {Array} array The array to query. - * @returns {*} Returns the first element of `array`. - * @example - * - * _.head([1, 2, 3]); - * // => 1 - * - * _.head([]); - * // => undefined - */ - function head(array) { - return (array && array.length) ? array[0] : undefined; - } - - /** - * Gets the index at which the first occurrence of `value` is found in `array` - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. If `fromIndex` is negative, it's used as the - * offset from the end of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.indexOf([1, 2, 1, 2], 2); - * // => 1 - * - * // Search from the `fromIndex`. - * _.indexOf([1, 2, 1, 2], 2, 2); - * // => 3 - */ - function indexOf(array, value, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = fromIndex == null ? 0 : toInteger(fromIndex); - if (index < 0) { - index = nativeMax(length + index, 0); - } - return baseIndexOf(array, value, index); - } - - /** - * Gets all but the last element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.initial([1, 2, 3]); - * // => [1, 2] - */ - function initial(array) { - var length = array == null ? 0 : array.length; - return length ? baseSlice(array, 0, -1) : []; - } - - /** - * Creates an array of unique values that are included in all given arrays - * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. The order and references of result values are - * determined by the first array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * _.intersection([2, 1], [2, 3]); - * // => [2] - */ - var intersection = baseRest(function(arrays) { - var mapped = arrayMap(arrays, castArrayLikeObject); - return (mapped.length && mapped[0] === arrays[0]) - ? baseIntersection(mapped) - : []; - }); - - /** - * This method is like `_.intersection` except that it accepts `iteratee` - * which is invoked for each element of each `arrays` to generate the criterion - * by which they're compared. The order and references of result values are - * determined by the first array. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [2.1] - * - * // The `_.property` iteratee shorthand. - * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }] - */ - var intersectionBy = baseRest(function(arrays) { - var iteratee = last(arrays), - mapped = arrayMap(arrays, castArrayLikeObject); - - if (iteratee === last(mapped)) { - iteratee = undefined; - } else { - mapped.pop(); - } - return (mapped.length && mapped[0] === arrays[0]) - ? baseIntersection(mapped, getIteratee(iteratee, 2)) - : []; - }); - - /** - * This method is like `_.intersection` except that it accepts `comparator` - * which is invoked to compare elements of `arrays`. The order and references - * of result values are determined by the first array. The comparator is - * invoked with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of intersecting values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.intersectionWith(objects, others, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }] - */ - var intersectionWith = baseRest(function(arrays) { - var comparator = last(arrays), - mapped = arrayMap(arrays, castArrayLikeObject); - - comparator = typeof comparator == 'function' ? comparator : undefined; - if (comparator) { - mapped.pop(); - } - return (mapped.length && mapped[0] === arrays[0]) - ? baseIntersection(mapped, undefined, comparator) - : []; - }); - - /** - * Converts all elements in `array` into a string separated by `separator`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to convert. - * @param {string} [separator=','] The element separator. - * @returns {string} Returns the joined string. - * @example - * - * _.join(['a', 'b', 'c'], '~'); - * // => 'a~b~c' - */ - function join(array, separator) { - return array == null ? '' : nativeJoin.call(array, separator); - } - - /** - * Gets the last element of `array`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @returns {*} Returns the last element of `array`. - * @example - * - * _.last([1, 2, 3]); - * // => 3 - */ - function last(array) { - var length = array == null ? 0 : array.length; - return length ? array[length - 1] : undefined; - } - - /** - * This method is like `_.indexOf` except that it iterates over elements of - * `array` from right to left. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=array.length-1] The index to search from. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.lastIndexOf([1, 2, 1, 2], 2); - * // => 3 - * - * // Search from the `fromIndex`. - * _.lastIndexOf([1, 2, 1, 2], 2, 2); - * // => 1 - */ - function lastIndexOf(array, value, fromIndex) { - var length = array == null ? 0 : array.length; - if (!length) { - return -1; - } - var index = length; - if (fromIndex !== undefined) { - index = toInteger(fromIndex); - index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1); - } - return value === value - ? strictLastIndexOf(array, value, index) - : baseFindIndex(array, baseIsNaN, index, true); - } - - /** - * Gets the element at index `n` of `array`. If `n` is negative, the nth - * element from the end is returned. - * - * @static - * @memberOf _ - * @since 4.11.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=0] The index of the element to return. - * @returns {*} Returns the nth element of `array`. - * @example - * - * var array = ['a', 'b', 'c', 'd']; - * - * _.nth(array, 1); - * // => 'b' - * - * _.nth(array, -2); - * // => 'c'; - */ - function nth(array, n) { - return (array && array.length) ? baseNth(array, toInteger(n)) : undefined; - } - - /** - * Removes all given values from `array` using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove` - * to remove elements from an array by predicate. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {...*} [values] The values to remove. - * @returns {Array} Returns `array`. - * @example - * - * var array = ['a', 'b', 'c', 'a', 'b', 'c']; - * - * _.pull(array, 'a', 'c'); - * console.log(array); - * // => ['b', 'b'] - */ - var pull = baseRest(pullAll); - - /** - * This method is like `_.pull` except that it accepts an array of values to remove. - * - * **Note:** Unlike `_.difference`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @returns {Array} Returns `array`. - * @example - * - * var array = ['a', 'b', 'c', 'a', 'b', 'c']; - * - * _.pullAll(array, ['a', 'c']); - * console.log(array); - * // => ['b', 'b'] - */ - function pullAll(array, values) { - return (array && array.length && values && values.length) - ? basePullAll(array, values) - : array; - } - - /** - * This method is like `_.pullAll` except that it accepts `iteratee` which is - * invoked for each element of `array` and `values` to generate the criterion - * by which they're compared. The iteratee is invoked with one argument: (value). - * - * **Note:** Unlike `_.differenceBy`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns `array`. - * @example - * - * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }]; - * - * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x'); - * console.log(array); - * // => [{ 'x': 2 }] - */ - function pullAllBy(array, values, iteratee) { - return (array && array.length && values && values.length) - ? basePullAll(array, values, getIteratee(iteratee, 2)) - : array; - } - - /** - * This method is like `_.pullAll` except that it accepts `comparator` which - * is invoked to compare elements of `array` to `values`. The comparator is - * invoked with two arguments: (arrVal, othVal). - * - * **Note:** Unlike `_.differenceWith`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Array} values The values to remove. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns `array`. - * @example - * - * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }]; - * - * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); - * console.log(array); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }] - */ - function pullAllWith(array, values, comparator) { - return (array && array.length && values && values.length) - ? basePullAll(array, values, undefined, comparator) - : array; - } - - /** - * Removes elements from `array` corresponding to `indexes` and returns an - * array of removed elements. - * - * **Note:** Unlike `_.at`, this method mutates `array`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {...(number|number[])} [indexes] The indexes of elements to remove. - * @returns {Array} Returns the new array of removed elements. - * @example - * - * var array = ['a', 'b', 'c', 'd']; - * var pulled = _.pullAt(array, [1, 3]); - * - * console.log(array); - * // => ['a', 'c'] - * - * console.log(pulled); - * // => ['b', 'd'] - */ - var pullAt = flatRest(function(array, indexes) { - var length = array == null ? 0 : array.length, - result = baseAt(array, indexes); - - basePullAt(array, arrayMap(indexes, function(index) { - return isIndex(index, length) ? +index : index; - }).sort(compareAscending)); - - return result; - }); - - /** - * Removes all elements from `array` that `predicate` returns truthy for - * and returns an array of the removed elements. The predicate is invoked - * with three arguments: (value, index, array). - * - * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` - * to pull elements from an array by value. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Array - * @param {Array} array The array to modify. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new array of removed elements. - * @example - * - * var array = [1, 2, 3, 4]; - * var evens = _.remove(array, function(n) { - * return n % 2 == 0; - * }); - * - * console.log(array); - * // => [1, 3] - * - * console.log(evens); - * // => [2, 4] - */ - function remove(array, predicate) { - var result = []; - if (!(array && array.length)) { - return result; - } - var index = -1, - indexes = [], - length = array.length; - - predicate = getIteratee(predicate, 3); - while (++index < length) { - var value = array[index]; - if (predicate(value, index, array)) { - result.push(value); - indexes.push(index); - } - } - basePullAt(array, indexes); - return result; - } - - /** - * Reverses `array` so that the first element becomes the last, the second - * element becomes the second to last, and so on. - * - * **Note:** This method mutates `array` and is based on - * [`Array#reverse`](https://mdn.io/Array/reverse). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to modify. - * @returns {Array} Returns `array`. - * @example - * - * var array = [1, 2, 3]; - * - * _.reverse(array); - * // => [3, 2, 1] - * - * console.log(array); - * // => [3, 2, 1] - */ - function reverse(array) { - return array == null ? array : nativeReverse.call(array); - } - - /** - * Creates a slice of `array` from `start` up to, but not including, `end`. - * - * **Note:** This method is used instead of - * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are - * returned. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to slice. - * @param {number} [start=0] The start position. - * @param {number} [end=array.length] The end position. - * @returns {Array} Returns the slice of `array`. - */ - function slice(array, start, end) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - if (end && typeof end != 'number' && isIterateeCall(array, start, end)) { - start = 0; - end = length; - } - else { - start = start == null ? 0 : toInteger(start); - end = end === undefined ? length : toInteger(end); - } - return baseSlice(array, start, end); - } - - /** - * Uses a binary search to determine the lowest index at which `value` - * should be inserted into `array` in order to maintain its sort order. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * _.sortedIndex([30, 50], 40); - * // => 1 - */ - function sortedIndex(array, value) { - return baseSortedIndex(array, value); - } - - /** - * This method is like `_.sortedIndex` except that it accepts `iteratee` - * which is invoked for `value` and each element of `array` to compute their - * sort ranking. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * var objects = [{ 'x': 4 }, { 'x': 5 }]; - * - * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); - * // => 0 - * - * // The `_.property` iteratee shorthand. - * _.sortedIndexBy(objects, { 'x': 4 }, 'x'); - * // => 0 - */ - function sortedIndexBy(array, value, iteratee) { - return baseSortedIndexBy(array, value, getIteratee(iteratee, 2)); - } - - /** - * This method is like `_.indexOf` except that it performs a binary - * search on a sorted `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.sortedIndexOf([4, 5, 5, 5, 6], 5); - * // => 1 - */ - function sortedIndexOf(array, value) { - var length = array == null ? 0 : array.length; - if (length) { - var index = baseSortedIndex(array, value); - if (index < length && eq(array[index], value)) { - return index; - } - } - return -1; - } - - /** - * This method is like `_.sortedIndex` except that it returns the highest - * index at which `value` should be inserted into `array` in order to - * maintain its sort order. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * _.sortedLastIndex([4, 5, 5, 5, 6], 5); - * // => 4 - */ - function sortedLastIndex(array, value) { - return baseSortedIndex(array, value, true); - } - - /** - * This method is like `_.sortedLastIndex` except that it accepts `iteratee` - * which is invoked for `value` and each element of `array` to compute their - * sort ranking. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The sorted array to inspect. - * @param {*} value The value to evaluate. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {number} Returns the index at which `value` should be inserted - * into `array`. - * @example - * - * var objects = [{ 'x': 4 }, { 'x': 5 }]; - * - * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; }); - * // => 1 - * - * // The `_.property` iteratee shorthand. - * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x'); - * // => 1 - */ - function sortedLastIndexBy(array, value, iteratee) { - return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true); - } - - /** - * This method is like `_.lastIndexOf` except that it performs a binary - * search on a sorted `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {*} value The value to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - * @example - * - * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5); - * // => 3 - */ - function sortedLastIndexOf(array, value) { - var length = array == null ? 0 : array.length; - if (length) { - var index = baseSortedIndex(array, value, true) - 1; - if (eq(array[index], value)) { - return index; - } - } - return -1; - } - - /** - * This method is like `_.uniq` except that it's designed and optimized - * for sorted arrays. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.sortedUniq([1, 1, 2]); - * // => [1, 2] - */ - function sortedUniq(array) { - return (array && array.length) - ? baseSortedUniq(array) - : []; - } - - /** - * This method is like `_.uniqBy` except that it's designed and optimized - * for sorted arrays. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [iteratee] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); - * // => [1.1, 2.3] - */ - function sortedUniqBy(array, iteratee) { - return (array && array.length) - ? baseSortedUniq(array, getIteratee(iteratee, 2)) - : []; - } - - /** - * Gets all but the first element of `array`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to query. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.tail([1, 2, 3]); - * // => [2, 3] - */ - function tail(array) { - var length = array == null ? 0 : array.length; - return length ? baseSlice(array, 1, length) : []; - } - - /** - * Creates a slice of `array` with `n` elements taken from the beginning. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to take. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.take([1, 2, 3]); - * // => [1] - * - * _.take([1, 2, 3], 2); - * // => [1, 2] - * - * _.take([1, 2, 3], 5); - * // => [1, 2, 3] - * - * _.take([1, 2, 3], 0); - * // => [] - */ - function take(array, n, guard) { - if (!(array && array.length)) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - return baseSlice(array, 0, n < 0 ? 0 : n); - } - - /** - * Creates a slice of `array` with `n` elements taken from the end. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {number} [n=1] The number of elements to take. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the slice of `array`. - * @example - * - * _.takeRight([1, 2, 3]); - * // => [3] - * - * _.takeRight([1, 2, 3], 2); - * // => [2, 3] - * - * _.takeRight([1, 2, 3], 5); - * // => [1, 2, 3] - * - * _.takeRight([1, 2, 3], 0); - * // => [] - */ - function takeRight(array, n, guard) { - var length = array == null ? 0 : array.length; - if (!length) { - return []; - } - n = (guard || n === undefined) ? 1 : toInteger(n); - n = length - n; - return baseSlice(array, n < 0 ? 0 : n, length); - } - - /** - * Creates a slice of `array` with elements taken from the end. Elements are - * taken until `predicate` returns falsey. The predicate is invoked with - * three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': false } - * ]; - * - * _.takeRightWhile(users, function(o) { return !o.active; }); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.matches` iteratee shorthand. - * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false }); - * // => objects for ['pebbles'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.takeRightWhile(users, ['active', false]); - * // => objects for ['fred', 'pebbles'] - * - * // The `_.property` iteratee shorthand. - * _.takeRightWhile(users, 'active'); - * // => [] - */ - function takeRightWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3), false, true) - : []; - } - - /** - * Creates a slice of `array` with elements taken from the beginning. Elements - * are taken until `predicate` returns falsey. The predicate is invoked with - * three arguments: (value, index, array). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Array - * @param {Array} array The array to query. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the slice of `array`. - * @example - * - * var users = [ - * { 'user': 'barney', 'active': false }, - * { 'user': 'fred', 'active': false }, - * { 'user': 'pebbles', 'active': true } - * ]; - * - * _.takeWhile(users, function(o) { return !o.active; }); - * // => objects for ['barney', 'fred'] - * - * // The `_.matches` iteratee shorthand. - * _.takeWhile(users, { 'user': 'barney', 'active': false }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.takeWhile(users, ['active', false]); - * // => objects for ['barney', 'fred'] - * - * // The `_.property` iteratee shorthand. - * _.takeWhile(users, 'active'); - * // => [] - */ - function takeWhile(array, predicate) { - return (array && array.length) - ? baseWhile(array, getIteratee(predicate, 3)) - : []; - } - - /** - * Creates an array of unique values, in order, from all given arrays using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of combined values. - * @example - * - * _.union([2], [1, 2]); - * // => [2, 1] - */ - var union = baseRest(function(arrays) { - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true)); - }); - - /** - * This method is like `_.union` except that it accepts `iteratee` which is - * invoked for each element of each `arrays` to generate the criterion by - * which uniqueness is computed. Result values are chosen from the first - * array in which the value occurs. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of combined values. - * @example - * - * _.unionBy([2.1], [1.2, 2.3], Math.floor); - * // => [2.1, 1.2] - * - * // The `_.property` iteratee shorthand. - * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - var unionBy = baseRest(function(arrays) { - var iteratee = last(arrays); - if (isArrayLikeObject(iteratee)) { - iteratee = undefined; - } - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2)); - }); - - /** - * This method is like `_.union` except that it accepts `comparator` which - * is invoked to compare elements of `arrays`. Result values are chosen from - * the first array in which the value occurs. The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of combined values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.unionWith(objects, others, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] - */ - var unionWith = baseRest(function(arrays) { - var comparator = last(arrays); - comparator = typeof comparator == 'function' ? comparator : undefined; - return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator); - }); - - /** - * Creates a duplicate-free version of an array, using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons, in which only the first occurrence of each element - * is kept. The order of result values is determined by the order they occur - * in the array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.uniq([2, 1, 2]); - * // => [2, 1] - */ - function uniq(array) { - return (array && array.length) ? baseUniq(array) : []; - } - - /** - * This method is like `_.uniq` except that it accepts `iteratee` which is - * invoked for each element in `array` to generate the criterion by which - * uniqueness is computed. The order of result values is determined by the - * order they occur in the array. The iteratee is invoked with one argument: - * (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * _.uniqBy([2.1, 1.2, 2.3], Math.floor); - * // => [2.1, 1.2] - * - * // The `_.property` iteratee shorthand. - * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 1 }, { 'x': 2 }] - */ - function uniqBy(array, iteratee) { - return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : []; - } - - /** - * This method is like `_.uniq` except that it accepts `comparator` which - * is invoked to compare elements of `array`. The order of result values is - * determined by the order they occur in the array.The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new duplicate free array. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.uniqWith(objects, _.isEqual); - * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }] - */ - function uniqWith(array, comparator) { - comparator = typeof comparator == 'function' ? comparator : undefined; - return (array && array.length) ? baseUniq(array, undefined, comparator) : []; - } - - /** - * This method is like `_.zip` except that it accepts an array of grouped - * elements and creates an array regrouping the elements to their pre-zip - * configuration. - * - * @static - * @memberOf _ - * @since 1.2.0 - * @category Array - * @param {Array} array The array of grouped elements to process. - * @returns {Array} Returns the new array of regrouped elements. - * @example - * - * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]); - * // => [['a', 1, true], ['b', 2, false]] - * - * _.unzip(zipped); - * // => [['a', 'b'], [1, 2], [true, false]] - */ - function unzip(array) { - if (!(array && array.length)) { - return []; - } - var length = 0; - array = arrayFilter(array, function(group) { - if (isArrayLikeObject(group)) { - length = nativeMax(group.length, length); - return true; - } - }); - return baseTimes(length, function(index) { - return arrayMap(array, baseProperty(index)); - }); - } - - /** - * This method is like `_.unzip` except that it accepts `iteratee` to specify - * how regrouped values should be combined. The iteratee is invoked with the - * elements of each group: (...group). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Array - * @param {Array} array The array of grouped elements to process. - * @param {Function} [iteratee=_.identity] The function to combine - * regrouped values. - * @returns {Array} Returns the new array of regrouped elements. - * @example - * - * var zipped = _.zip([1, 2], [10, 20], [100, 200]); - * // => [[1, 10, 100], [2, 20, 200]] - * - * _.unzipWith(zipped, _.add); - * // => [3, 30, 300] - */ - function unzipWith(array, iteratee) { - if (!(array && array.length)) { - return []; - } - var result = unzip(array); - if (iteratee == null) { - return result; - } - return arrayMap(result, function(group) { - return apply(iteratee, undefined, group); - }); - } - - /** - * Creates an array excluding all given values using - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * for equality comparisons. - * - * **Note:** Unlike `_.pull`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {Array} array The array to inspect. - * @param {...*} [values] The values to exclude. - * @returns {Array} Returns the new array of filtered values. - * @see _.difference, _.xor - * @example - * - * _.without([2, 1, 2, 3], 1, 2); - * // => [3] - */ - var without = baseRest(function(array, values) { - return isArrayLikeObject(array) - ? baseDifference(array, values) - : []; - }); - - /** - * Creates an array of unique values that is the - * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference) - * of the given arrays. The order of result values is determined by the order - * they occur in the arrays. - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @returns {Array} Returns the new array of filtered values. - * @see _.difference, _.without - * @example - * - * _.xor([2, 1], [2, 3]); - * // => [1, 3] - */ - var xor = baseRest(function(arrays) { - return baseXor(arrayFilter(arrays, isArrayLikeObject)); - }); - - /** - * This method is like `_.xor` except that it accepts `iteratee` which is - * invoked for each element of each `arrays` to generate the criterion by - * which by which they're compared. The order of result values is determined - * by the order they occur in the arrays. The iteratee is invoked with one - * argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); - * // => [1.2, 3.4] - * - * // The `_.property` iteratee shorthand. - * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x'); - * // => [{ 'x': 2 }] - */ - var xorBy = baseRest(function(arrays) { - var iteratee = last(arrays); - if (isArrayLikeObject(iteratee)) { - iteratee = undefined; - } - return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2)); - }); - - /** - * This method is like `_.xor` except that it accepts `comparator` which is - * invoked to compare elements of `arrays`. The order of result values is - * determined by the order they occur in the arrays. The comparator is invoked - * with two arguments: (arrVal, othVal). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Array - * @param {...Array} [arrays] The arrays to inspect. - * @param {Function} [comparator] The comparator invoked per element. - * @returns {Array} Returns the new array of filtered values. - * @example - * - * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]; - * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]; - * - * _.xorWith(objects, others, _.isEqual); - * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }] - */ - var xorWith = baseRest(function(arrays) { - var comparator = last(arrays); - comparator = typeof comparator == 'function' ? comparator : undefined; - return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator); - }); - - /** - * Creates an array of grouped elements, the first of which contains the - * first elements of the given arrays, the second of which contains the - * second elements of the given arrays, and so on. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Array - * @param {...Array} [arrays] The arrays to process. - * @returns {Array} Returns the new array of grouped elements. - * @example - * - * _.zip(['a', 'b'], [1, 2], [true, false]); - * // => [['a', 1, true], ['b', 2, false]] - */ - var zip = baseRest(unzip); - - /** - * This method is like `_.fromPairs` except that it accepts two arrays, - * one of property identifiers and one of corresponding values. - * - * @static - * @memberOf _ - * @since 0.4.0 - * @category Array - * @param {Array} [props=[]] The property identifiers. - * @param {Array} [values=[]] The property values. - * @returns {Object} Returns the new object. - * @example - * - * _.zipObject(['a', 'b'], [1, 2]); - * // => { 'a': 1, 'b': 2 } - */ - function zipObject(props, values) { - return baseZipObject(props || [], values || [], assignValue); - } - - /** - * This method is like `_.zipObject` except that it supports property paths. - * - * @static - * @memberOf _ - * @since 4.1.0 - * @category Array - * @param {Array} [props=[]] The property identifiers. - * @param {Array} [values=[]] The property values. - * @returns {Object} Returns the new object. - * @example - * - * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]); - * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } } - */ - function zipObjectDeep(props, values) { - return baseZipObject(props || [], values || [], baseSet); - } - - /** - * This method is like `_.zip` except that it accepts `iteratee` to specify - * how grouped values should be combined. The iteratee is invoked with the - * elements of each group: (...group). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Array - * @param {...Array} [arrays] The arrays to process. - * @param {Function} [iteratee=_.identity] The function to combine - * grouped values. - * @returns {Array} Returns the new array of grouped elements. - * @example - * - * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) { - * return a + b + c; - * }); - * // => [111, 222] - */ - var zipWith = baseRest(function(arrays) { - var length = arrays.length, - iteratee = length > 1 ? arrays[length - 1] : undefined; - - iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined; - return unzipWith(arrays, iteratee); - }); - - /*------------------------------------------------------------------------*/ - - /** - * Creates a `lodash` wrapper instance that wraps `value` with explicit method - * chain sequences enabled. The result of such sequences must be unwrapped - * with `_#value`. - * - * @static - * @memberOf _ - * @since 1.3.0 - * @category Seq - * @param {*} value The value to wrap. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'pebbles', 'age': 1 } - * ]; - * - * var youngest = _ - * .chain(users) - * .sortBy('age') - * .map(function(o) { - * return o.user + ' is ' + o.age; - * }) - * .head() - * .value(); - * // => 'pebbles is 1' - */ - function chain(value) { - var result = lodash(value); - result.__chain__ = true; - return result; - } - - /** - * This method invokes `interceptor` and returns `value`. The interceptor - * is invoked with one argument; (value). The purpose of this method is to - * "tap into" a method chain sequence in order to modify intermediate results. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @param {*} value The value to provide to `interceptor`. - * @param {Function} interceptor The function to invoke. - * @returns {*} Returns `value`. - * @example - * - * _([1, 2, 3]) - * .tap(function(array) { - * // Mutate input array. - * array.pop(); - * }) - * .reverse() - * .value(); - * // => [2, 1] - */ - function tap(value, interceptor) { - interceptor(value); - return value; - } - - /** - * This method is like `_.tap` except that it returns the result of `interceptor`. - * The purpose of this method is to "pass thru" values replacing intermediate - * results in a method chain sequence. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Seq - * @param {*} value The value to provide to `interceptor`. - * @param {Function} interceptor The function to invoke. - * @returns {*} Returns the result of `interceptor`. - * @example - * - * _(' abc ') - * .chain() - * .trim() - * .thru(function(value) { - * return [value]; - * }) - * .value(); - * // => ['abc'] - */ - function thru(value, interceptor) { - return interceptor(value); - } - - /** - * This method is the wrapper version of `_.at`. - * - * @name at - * @memberOf _ - * @since 1.0.0 - * @category Seq - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - * - * _(object).at(['a[0].b.c', 'a[1]']).value(); - * // => [3, 4] - */ - var wrapperAt = flatRest(function(paths) { - var length = paths.length, - start = length ? paths[0] : 0, - value = this.__wrapped__, - interceptor = function(object) { return baseAt(object, paths); }; - - if (length > 1 || this.__actions__.length || - !(value instanceof LazyWrapper) || !isIndex(start)) { - return this.thru(interceptor); - } - value = value.slice(start, +start + (length ? 1 : 0)); - value.__actions__.push({ - 'func': thru, - 'args': [interceptor], - 'thisArg': undefined - }); - return new LodashWrapper(value, this.__chain__).thru(function(array) { - if (length && !array.length) { - array.push(undefined); - } - return array; - }); - }); - - /** - * Creates a `lodash` wrapper instance with explicit method chain sequences enabled. - * - * @name chain - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 } - * ]; - * - * // A sequence without explicit chaining. - * _(users).head(); - * // => { 'user': 'barney', 'age': 36 } - * - * // A sequence with explicit chaining. - * _(users) - * .chain() - * .head() - * .pick('user') - * .value(); - * // => { 'user': 'barney' } - */ - function wrapperChain() { - return chain(this); - } - - /** - * Executes the chain sequence and returns the wrapped result. - * - * @name commit - * @memberOf _ - * @since 3.2.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var array = [1, 2]; - * var wrapped = _(array).push(3); - * - * console.log(array); - * // => [1, 2] - * - * wrapped = wrapped.commit(); - * console.log(array); - * // => [1, 2, 3] - * - * wrapped.last(); - * // => 3 - * - * console.log(array); - * // => [1, 2, 3] - */ - function wrapperCommit() { - return new LodashWrapper(this.value(), this.__chain__); - } - - /** - * Gets the next value on a wrapped object following the - * [iterator protocol](https://mdn.io/iteration_protocols#iterator). - * - * @name next - * @memberOf _ - * @since 4.0.0 - * @category Seq - * @returns {Object} Returns the next iterator value. - * @example - * - * var wrapped = _([1, 2]); - * - * wrapped.next(); - * // => { 'done': false, 'value': 1 } - * - * wrapped.next(); - * // => { 'done': false, 'value': 2 } - * - * wrapped.next(); - * // => { 'done': true, 'value': undefined } - */ - function wrapperNext() { - if (this.__values__ === undefined) { - this.__values__ = toArray(this.value()); - } - var done = this.__index__ >= this.__values__.length, - value = done ? undefined : this.__values__[this.__index__++]; - - return { 'done': done, 'value': value }; - } - - /** - * Enables the wrapper to be iterable. - * - * @name Symbol.iterator - * @memberOf _ - * @since 4.0.0 - * @category Seq - * @returns {Object} Returns the wrapper object. - * @example - * - * var wrapped = _([1, 2]); - * - * wrapped[Symbol.iterator]() === wrapped; - * // => true - * - * Array.from(wrapped); - * // => [1, 2] - */ - function wrapperToIterator() { - return this; - } - - /** - * Creates a clone of the chain sequence planting `value` as the wrapped value. - * - * @name plant - * @memberOf _ - * @since 3.2.0 - * @category Seq - * @param {*} value The value to plant. - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * function square(n) { - * return n * n; - * } - * - * var wrapped = _([1, 2]).map(square); - * var other = wrapped.plant([3, 4]); - * - * other.value(); - * // => [9, 16] - * - * wrapped.value(); - * // => [1, 4] - */ - function wrapperPlant(value) { - var result, - parent = this; - - while (parent instanceof baseLodash) { - var clone = wrapperClone(parent); - clone.__index__ = 0; - clone.__values__ = undefined; - if (result) { - previous.__wrapped__ = clone; - } else { - result = clone; - } - var previous = clone; - parent = parent.__wrapped__; - } - previous.__wrapped__ = value; - return result; - } - - /** - * This method is the wrapper version of `_.reverse`. - * - * **Note:** This method mutates the wrapped array. - * - * @name reverse - * @memberOf _ - * @since 0.1.0 - * @category Seq - * @returns {Object} Returns the new `lodash` wrapper instance. - * @example - * - * var array = [1, 2, 3]; - * - * _(array).reverse().value() - * // => [3, 2, 1] - * - * console.log(array); - * // => [3, 2, 1] - */ - function wrapperReverse() { - var value = this.__wrapped__; - if (value instanceof LazyWrapper) { - var wrapped = value; - if (this.__actions__.length) { - wrapped = new LazyWrapper(this); - } - wrapped = wrapped.reverse(); - wrapped.__actions__.push({ - 'func': thru, - 'args': [reverse], - 'thisArg': undefined - }); - return new LodashWrapper(wrapped, this.__chain__); - } - return this.thru(reverse); - } - - /** - * Executes the chain sequence to resolve the unwrapped value. - * - * @name value - * @memberOf _ - * @since 0.1.0 - * @alias toJSON, valueOf - * @category Seq - * @returns {*} Returns the resolved unwrapped value. - * @example - * - * _([1, 2, 3]).value(); - * // => [1, 2, 3] - */ - function wrapperValue() { - return baseWrapperValue(this.__wrapped__, this.__actions__); - } - - /*------------------------------------------------------------------------*/ - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The corresponding value of - * each key is the number of times the key was returned by `iteratee`. The - * iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.countBy([6.1, 4.2, 6.3], Math.floor); - * // => { '4': 1, '6': 2 } - * - * // The `_.property` iteratee shorthand. - * _.countBy(['one', 'two', 'three'], 'length'); - * // => { '3': 2, '5': 1 } - */ - var countBy = createAggregator(function(result, value, key) { - if (hasOwnProperty.call(result, key)) { - ++result[key]; - } else { - baseAssignValue(result, key, 1); - } - }); - - /** - * Checks if `predicate` returns truthy for **all** elements of `collection`. - * Iteration is stopped once `predicate` returns falsey. The predicate is - * invoked with three arguments: (value, index|key, collection). - * - * **Note:** This method returns `true` for - * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because - * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of - * elements of empty collections. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {boolean} Returns `true` if all elements pass the predicate check, - * else `false`. - * @example - * - * _.every([true, 1, null, 'yes'], Boolean); - * // => false - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': false } - * ]; - * - * // The `_.matches` iteratee shorthand. - * _.every(users, { 'user': 'barney', 'active': false }); - * // => false - * - * // The `_.matchesProperty` iteratee shorthand. - * _.every(users, ['active', false]); - * // => true - * - * // The `_.property` iteratee shorthand. - * _.every(users, 'active'); - * // => false - */ - function every(collection, predicate, guard) { - var func = isArray(collection) ? arrayEvery : baseEvery; - if (guard && isIterateeCall(collection, predicate, guard)) { - predicate = undefined; - } - return func(collection, getIteratee(predicate, 3)); - } - - /** - * Iterates over elements of `collection`, returning an array of all elements - * `predicate` returns truthy for. The predicate is invoked with three - * arguments: (value, index|key, collection). - * - * **Note:** Unlike `_.remove`, this method returns a new array. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - * @see _.reject - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': true }, - * { 'user': 'fred', 'age': 40, 'active': false } - * ]; - * - * _.filter(users, function(o) { return !o.active; }); - * // => objects for ['fred'] - * - * // The `_.matches` iteratee shorthand. - * _.filter(users, { 'age': 36, 'active': true }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.filter(users, ['active', false]); - * // => objects for ['fred'] - * - * // The `_.property` iteratee shorthand. - * _.filter(users, 'active'); - * // => objects for ['barney'] - */ - function filter(collection, predicate) { - var func = isArray(collection) ? arrayFilter : baseFilter; - return func(collection, getIteratee(predicate, 3)); - } - - /** - * Iterates over elements of `collection`, returning the first element - * `predicate` returns truthy for. The predicate is invoked with three - * arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=0] The index to search from. - * @returns {*} Returns the matched element, else `undefined`. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': true }, - * { 'user': 'fred', 'age': 40, 'active': false }, - * { 'user': 'pebbles', 'age': 1, 'active': true } - * ]; - * - * _.find(users, function(o) { return o.age < 40; }); - * // => object for 'barney' - * - * // The `_.matches` iteratee shorthand. - * _.find(users, { 'age': 1, 'active': true }); - * // => object for 'pebbles' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.find(users, ['active', false]); - * // => object for 'fred' - * - * // The `_.property` iteratee shorthand. - * _.find(users, 'active'); - * // => object for 'barney' - */ - var find = createFind(findIndex); - - /** - * This method is like `_.find` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Collection - * @param {Array|Object} collection The collection to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param {number} [fromIndex=collection.length-1] The index to search from. - * @returns {*} Returns the matched element, else `undefined`. - * @example - * - * _.findLast([1, 2, 3, 4], function(n) { - * return n % 2 == 1; - * }); - * // => 3 - */ - var findLast = createFind(findLastIndex); - - /** - * Creates a flattened array of values by running each element in `collection` - * thru `iteratee` and flattening the mapped results. The iteratee is invoked - * with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [n, n]; - * } - * - * _.flatMap([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ - function flatMap(collection, iteratee) { - return baseFlatten(map(collection, iteratee), 1); - } - - /** - * This method is like `_.flatMap` except that it recursively flattens the - * mapped results. - * - * @static - * @memberOf _ - * @since 4.7.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [[[n, n]]]; - * } - * - * _.flatMapDeep([1, 2], duplicate); - * // => [1, 1, 2, 2] - */ - function flatMapDeep(collection, iteratee) { - return baseFlatten(map(collection, iteratee), INFINITY); - } - - /** - * This method is like `_.flatMap` except that it recursively flattens the - * mapped results up to `depth` times. - * - * @static - * @memberOf _ - * @since 4.7.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {number} [depth=1] The maximum recursion depth. - * @returns {Array} Returns the new flattened array. - * @example - * - * function duplicate(n) { - * return [[[n, n]]]; - * } - * - * _.flatMapDepth([1, 2], duplicate, 2); - * // => [[1, 1], [2, 2]] - */ - function flatMapDepth(collection, iteratee, depth) { - depth = depth === undefined ? 1 : toInteger(depth); - return baseFlatten(map(collection, iteratee), depth); - } - - /** - * Iterates over elements of `collection` and invokes `iteratee` for each element. - * The iteratee is invoked with three arguments: (value, index|key, collection). - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * **Note:** As with other "Collections" methods, objects with a "length" - * property are iterated like arrays. To avoid this behavior use `_.forIn` - * or `_.forOwn` for object iteration. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @alias each - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - * @see _.forEachRight - * @example - * - * _.forEach([1, 2], function(value) { - * console.log(value); - * }); - * // => Logs `1` then `2`. - * - * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a' then 'b' (iteration order is not guaranteed). - */ - function forEach(collection, iteratee) { - var func = isArray(collection) ? arrayEach : baseEach; - return func(collection, getIteratee(iteratee, 3)); - } - - /** - * This method is like `_.forEach` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @alias eachRight - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. - * @see _.forEach - * @example - * - * _.forEachRight([1, 2], function(value) { - * console.log(value); - * }); - * // => Logs `2` then `1`. - */ - function forEachRight(collection, iteratee) { - var func = isArray(collection) ? arrayEachRight : baseEachRight; - return func(collection, getIteratee(iteratee, 3)); - } - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The order of grouped values - * is determined by the order they occur in `collection`. The corresponding - * value of each key is an array of elements responsible for generating the - * key. The iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * _.groupBy([6.1, 4.2, 6.3], Math.floor); - * // => { '4': [4.2], '6': [6.1, 6.3] } - * - * // The `_.property` iteratee shorthand. - * _.groupBy(['one', 'two', 'three'], 'length'); - * // => { '3': ['one', 'two'], '5': ['three'] } - */ - var groupBy = createAggregator(function(result, value, key) { - if (hasOwnProperty.call(result, key)) { - result[key].push(value); - } else { - baseAssignValue(result, key, [value]); - } - }); - - /** - * Checks if `value` is in `collection`. If `collection` is a string, it's - * checked for a substring of `value`, otherwise - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * is used for equality comparisons. If `fromIndex` is negative, it's used as - * the offset from the end of `collection`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. - * @param {*} value The value to search for. - * @param {number} [fromIndex=0] The index to search from. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {boolean} Returns `true` if `value` is found, else `false`. - * @example - * - * _.includes([1, 2, 3], 1); - * // => true - * - * _.includes([1, 2, 3], 1, 2); - * // => false - * - * _.includes({ 'a': 1, 'b': 2 }, 1); - * // => true - * - * _.includes('abcd', 'bc'); - * // => true - */ - function includes(collection, value, fromIndex, guard) { - collection = isArrayLike(collection) ? collection : values(collection); - fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0; - - var length = collection.length; - if (fromIndex < 0) { - fromIndex = nativeMax(length + fromIndex, 0); - } - return isString(collection) - ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1) - : (!!length && baseIndexOf(collection, value, fromIndex) > -1); - } - - /** - * Invokes the method at `path` of each element in `collection`, returning - * an array of the results of each invoked method. Any additional arguments - * are provided to each invoked method. If `path` is a function, it's invoked - * for, and `this` bound to, each element in `collection`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Array|Function|string} path The path of the method to invoke or - * the function invoked per iteration. - * @param {...*} [args] The arguments to invoke each method with. - * @returns {Array} Returns the array of results. - * @example - * - * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); - * // => [[1, 5, 7], [1, 2, 3]] - * - * _.invokeMap([123, 456], String.prototype.split, ''); - * // => [['1', '2', '3'], ['4', '5', '6']] - */ - var invokeMap = baseRest(function(collection, path, args) { - var index = -1, - isFunc = typeof path == 'function', - result = isArrayLike(collection) ? Array(collection.length) : []; - - baseEach(collection, function(value) { - result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args); - }); - return result; - }); - - /** - * Creates an object composed of keys generated from the results of running - * each element of `collection` thru `iteratee`. The corresponding value of - * each key is the last element responsible for generating the key. The - * iteratee is invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The iteratee to transform keys. - * @returns {Object} Returns the composed aggregate object. - * @example - * - * var array = [ - * { 'dir': 'left', 'code': 97 }, - * { 'dir': 'right', 'code': 100 } - * ]; - * - * _.keyBy(array, function(o) { - * return String.fromCharCode(o.code); - * }); - * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } } - * - * _.keyBy(array, 'dir'); - * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } } - */ - var keyBy = createAggregator(function(result, value, key) { - baseAssignValue(result, key, value); - }); - - /** - * Creates an array of values by running each element in `collection` thru - * `iteratee`. The iteratee is invoked with three arguments: - * (value, index|key, collection). - * - * Many lodash methods are guarded to work as iteratees for methods like - * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. - * - * The guarded methods are: - * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, - * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, - * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, - * `template`, `trim`, `trimEnd`, `trimStart`, and `words` - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new mapped array. - * @example - * - * function square(n) { - * return n * n; - * } - * - * _.map([4, 8], square); - * // => [16, 64] - * - * _.map({ 'a': 4, 'b': 8 }, square); - * // => [16, 64] (iteration order is not guaranteed) - * - * var users = [ - * { 'user': 'barney' }, - * { 'user': 'fred' } - * ]; - * - * // The `_.property` iteratee shorthand. - * _.map(users, 'user'); - * // => ['barney', 'fred'] - */ - function map(collection, iteratee) { - var func = isArray(collection) ? arrayMap : baseMap; - return func(collection, getIteratee(iteratee, 3)); - } - - /** - * This method is like `_.sortBy` except that it allows specifying the sort - * orders of the iteratees to sort by. If `orders` is unspecified, all values - * are sorted in ascending order. Otherwise, specify an order of "desc" for - * descending or "asc" for ascending sort order of corresponding values. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] - * The iteratees to sort by. - * @param {string[]} [orders] The sort orders of `iteratees`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. - * @returns {Array} Returns the new sorted array. - * @example - * - * var users = [ - * { 'user': 'fred', 'age': 48 }, - * { 'user': 'barney', 'age': 34 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'barney', 'age': 36 } - * ]; - * - * // Sort by `user` in ascending order and by `age` in descending order. - * _.orderBy(users, ['user', 'age'], ['asc', 'desc']); - * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] - */ - function orderBy(collection, iteratees, orders, guard) { - if (collection == null) { - return []; - } - if (!isArray(iteratees)) { - iteratees = iteratees == null ? [] : [iteratees]; - } - orders = guard ? undefined : orders; - if (!isArray(orders)) { - orders = orders == null ? [] : [orders]; - } - return baseOrderBy(collection, iteratees, orders); - } - - /** - * Creates an array of elements split into two groups, the first of which - * contains elements `predicate` returns truthy for, the second of which - * contains elements `predicate` returns falsey for. The predicate is - * invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the array of grouped elements. - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': true }, - * { 'user': 'pebbles', 'age': 1, 'active': false } - * ]; - * - * _.partition(users, function(o) { return o.active; }); - * // => objects for [['fred'], ['barney', 'pebbles']] - * - * // The `_.matches` iteratee shorthand. - * _.partition(users, { 'age': 1, 'active': false }); - * // => objects for [['pebbles'], ['barney', 'fred']] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.partition(users, ['active', false]); - * // => objects for [['barney', 'pebbles'], ['fred']] - * - * // The `_.property` iteratee shorthand. - * _.partition(users, 'active'); - * // => objects for [['fred'], ['barney', 'pebbles']] - */ - var partition = createAggregator(function(result, value, key) { - result[key ? 0 : 1].push(value); - }, function() { return [[], []]; }); - - /** - * Reduces `collection` to a value which is the accumulated result of running - * each element in `collection` thru `iteratee`, where each successive - * invocation is supplied the return value of the previous. If `accumulator` - * is not given, the first element of `collection` is used as the initial - * value. The iteratee is invoked with four arguments: - * (accumulator, value, index|key, collection). - * - * Many lodash methods are guarded to work as iteratees for methods like - * `_.reduce`, `_.reduceRight`, and `_.transform`. - * - * The guarded methods are: - * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, - * and `sortBy` - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @returns {*} Returns the accumulated value. - * @see _.reduceRight - * @example - * - * _.reduce([1, 2], function(sum, n) { - * return sum + n; - * }, 0); - * // => 3 - * - * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { - * (result[value] || (result[value] = [])).push(key); - * return result; - * }, {}); - * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed) - */ - function reduce(collection, iteratee, accumulator) { - var func = isArray(collection) ? arrayReduce : baseReduce, - initAccum = arguments.length < 3; - - return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach); - } - - /** - * This method is like `_.reduce` except that it iterates over elements of - * `collection` from right to left. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The initial value. - * @returns {*} Returns the accumulated value. - * @see _.reduce - * @example - * - * var array = [[0, 1], [2, 3], [4, 5]]; - * - * _.reduceRight(array, function(flattened, other) { - * return flattened.concat(other); - * }, []); - * // => [4, 5, 2, 3, 0, 1] - */ - function reduceRight(collection, iteratee, accumulator) { - var func = isArray(collection) ? arrayReduceRight : baseReduce, - initAccum = arguments.length < 3; - - return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight); - } - - /** - * The opposite of `_.filter`; this method returns the elements of `collection` - * that `predicate` does **not** return truthy for. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - * @see _.filter - * @example - * - * var users = [ - * { 'user': 'barney', 'age': 36, 'active': false }, - * { 'user': 'fred', 'age': 40, 'active': true } - * ]; - * - * _.reject(users, function(o) { return !o.active; }); - * // => objects for ['fred'] - * - * // The `_.matches` iteratee shorthand. - * _.reject(users, { 'age': 40, 'active': true }); - * // => objects for ['barney'] - * - * // The `_.matchesProperty` iteratee shorthand. - * _.reject(users, ['active', false]); - * // => objects for ['fred'] - * - * // The `_.property` iteratee shorthand. - * _.reject(users, 'active'); - * // => objects for ['barney'] - */ - function reject(collection, predicate) { - var func = isArray(collection) ? arrayFilter : baseFilter; - return func(collection, negate(getIteratee(predicate, 3))); - } - - /** - * Gets a random element from `collection`. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Collection - * @param {Array|Object} collection The collection to sample. - * @returns {*} Returns the random element. - * @example - * - * _.sample([1, 2, 3, 4]); - * // => 2 - */ - function sample(collection) { - var func = isArray(collection) ? arraySample : baseSample; - return func(collection); - } - - /** - * Gets `n` random elements at unique keys from `collection` up to the - * size of `collection`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Collection - * @param {Array|Object} collection The collection to sample. - * @param {number} [n=1] The number of elements to sample. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Array} Returns the random elements. - * @example - * - * _.sampleSize([1, 2, 3], 2); - * // => [3, 1] - * - * _.sampleSize([1, 2, 3], 4); - * // => [2, 3, 1] - */ - function sampleSize(collection, n, guard) { - if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) { - n = 1; - } else { - n = toInteger(n); - } - var func = isArray(collection) ? arraySampleSize : baseSampleSize; - return func(collection, n); - } - - /** - * Creates an array of shuffled values, using a version of the - * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to shuffle. - * @returns {Array} Returns the new shuffled array. - * @example - * - * _.shuffle([1, 2, 3, 4]); - * // => [4, 1, 3, 2] - */ - function shuffle(collection) { - var func = isArray(collection) ? arrayShuffle : baseShuffle; - return func(collection); - } - - /** - * Gets the size of `collection` by returning its length for array-like - * values or the number of own enumerable string keyed properties for objects. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object|string} collection The collection to inspect. - * @returns {number} Returns the collection size. - * @example - * - * _.size([1, 2, 3]); - * // => 3 - * - * _.size({ 'a': 1, 'b': 2 }); - * // => 2 - * - * _.size('pebbles'); - * // => 7 - */ - function size(collection) { - if (collection == null) { - return 0; - } - if (isArrayLike(collection)) { - return isString(collection) ? stringSize(collection) : collection.length; - } - var tag = getTag(collection); - if (tag == mapTag || tag == setTag) { - return collection.size; - } - return baseKeys(collection).length; - } - - /** - * Checks if `predicate` returns truthy for **any** element of `collection`. - * Iteration is stopped once `predicate` returns truthy. The predicate is - * invoked with three arguments: (value, index|key, collection). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - * @example - * - * _.some([null, 0, 'yes', false], Boolean); - * // => true - * - * var users = [ - * { 'user': 'barney', 'active': true }, - * { 'user': 'fred', 'active': false } - * ]; - * - * // The `_.matches` iteratee shorthand. - * _.some(users, { 'user': 'barney', 'active': false }); - * // => false - * - * // The `_.matchesProperty` iteratee shorthand. - * _.some(users, ['active', false]); - * // => true - * - * // The `_.property` iteratee shorthand. - * _.some(users, 'active'); - * // => true - */ - function some(collection, predicate, guard) { - var func = isArray(collection) ? arraySome : baseSome; - if (guard && isIterateeCall(collection, predicate, guard)) { - predicate = undefined; - } - return func(collection, getIteratee(predicate, 3)); - } - - /** - * Creates an array of elements, sorted in ascending order by the results of - * running each element in a collection thru each iteratee. This method - * performs a stable sort, that is, it preserves the original sort order of - * equal elements. The iteratees are invoked with one argument: (value). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Collection - * @param {Array|Object} collection The collection to iterate over. - * @param {...(Function|Function[])} [iteratees=[_.identity]] - * The iteratees to sort by. - * @returns {Array} Returns the new sorted array. - * @example - * - * var users = [ - * { 'user': 'fred', 'age': 48 }, - * { 'user': 'barney', 'age': 36 }, - * { 'user': 'fred', 'age': 40 }, - * { 'user': 'barney', 'age': 34 } - * ]; - * - * _.sortBy(users, [function(o) { return o.user; }]); - * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]] - * - * _.sortBy(users, ['user', 'age']); - * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]] - */ - var sortBy = baseRest(function(collection, iteratees) { - if (collection == null) { - return []; - } - var length = iteratees.length; - if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) { - iteratees = []; - } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) { - iteratees = [iteratees[0]]; - } - return baseOrderBy(collection, baseFlatten(iteratees, 1), []); - }); - - /*------------------------------------------------------------------------*/ - - /** - * Gets the timestamp of the number of milliseconds that have elapsed since - * the Unix epoch (1 January 1970 00:00:00 UTC). - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Date - * @returns {number} Returns the timestamp. - * @example - * - * _.defer(function(stamp) { - * console.log(_.now() - stamp); - * }, _.now()); - * // => Logs the number of milliseconds it took for the deferred invocation. - */ - var now = ctxNow || function() { - return root.Date.now(); - }; - - /*------------------------------------------------------------------------*/ - - /** - * The opposite of `_.before`; this method creates a function that invokes - * `func` once it's called `n` or more times. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {number} n The number of calls before `func` is invoked. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var saves = ['profile', 'settings']; - * - * var done = _.after(saves.length, function() { - * console.log('done saving!'); - * }); - * - * _.forEach(saves, function(type) { - * asyncSave({ 'type': type, 'complete': done }); - * }); - * // => Logs 'done saving!' after the two async saves have completed. - */ - function after(n, func) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - n = toInteger(n); - return function() { - if (--n < 1) { - return func.apply(this, arguments); - } - }; - } - - /** - * Creates a function that invokes `func`, with up to `n` arguments, - * ignoring any additional arguments. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to cap arguments for. - * @param {number} [n=func.length] The arity cap. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new capped function. - * @example - * - * _.map(['6', '8', '10'], _.ary(parseInt, 1)); - * // => [6, 8, 10] - */ - function ary(func, n, guard) { - n = guard ? undefined : n; - n = (func && n == null) ? func.length : n; - return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n); - } - - /** - * Creates a function that invokes `func`, with the `this` binding and arguments - * of the created function, while it's called less than `n` times. Subsequent - * calls to the created function return the result of the last `func` invocation. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {number} n The number of calls at which `func` is no longer invoked. - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * jQuery(element).on('click', _.before(5, addContactToList)); - * // => Allows adding up to 4 contacts to the list. - */ - function before(n, func) { - var result; - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - n = toInteger(n); - return function() { - if (--n > 0) { - result = func.apply(this, arguments); - } - if (n <= 1) { - func = undefined; - } - return result; - }; - } - - /** - * Creates a function that invokes `func` with the `this` binding of `thisArg` - * and `partials` prepended to the arguments it receives. - * - * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds, - * may be used as a placeholder for partially applied arguments. - * - * **Note:** Unlike native `Function#bind`, this method doesn't set the "length" - * property of bound functions. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to bind. - * @param {*} thisArg The `this` binding of `func`. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * function greet(greeting, punctuation) { - * return greeting + ' ' + this.user + punctuation; - * } - * - * var object = { 'user': 'fred' }; - * - * var bound = _.bind(greet, object, 'hi'); - * bound('!'); - * // => 'hi fred!' - * - * // Bound with placeholders. - * var bound = _.bind(greet, object, _, '!'); - * bound('hi'); - * // => 'hi fred!' - */ - var bind = baseRest(function(func, thisArg, partials) { - var bitmask = WRAP_BIND_FLAG; - if (partials.length) { - var holders = replaceHolders(partials, getHolder(bind)); - bitmask |= WRAP_PARTIAL_FLAG; - } - return createWrap(func, bitmask, thisArg, partials, holders); - }); - - /** - * Creates a function that invokes the method at `object[key]` with `partials` - * prepended to the arguments it receives. - * - * This method differs from `_.bind` by allowing bound functions to reference - * methods that may be redefined or don't yet exist. See - * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) - * for more details. - * - * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * @static - * @memberOf _ - * @since 0.10.0 - * @category Function - * @param {Object} object The object to invoke the method on. - * @param {string} key The key of the method. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new bound function. - * @example - * - * var object = { - * 'user': 'fred', - * 'greet': function(greeting, punctuation) { - * return greeting + ' ' + this.user + punctuation; - * } - * }; - * - * var bound = _.bindKey(object, 'greet', 'hi'); - * bound('!'); - * // => 'hi fred!' - * - * object.greet = function(greeting, punctuation) { - * return greeting + 'ya ' + this.user + punctuation; - * }; - * - * bound('!'); - * // => 'hiya fred!' - * - * // Bound with placeholders. - * var bound = _.bindKey(object, 'greet', _, '!'); - * bound('hi'); - * // => 'hiya fred!' - */ - var bindKey = baseRest(function(object, key, partials) { - var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG; - if (partials.length) { - var holders = replaceHolders(partials, getHolder(bindKey)); - bitmask |= WRAP_PARTIAL_FLAG; - } - return createWrap(key, bitmask, object, partials, holders); - }); - - /** - * Creates a function that accepts arguments of `func` and either invokes - * `func` returning its result, if at least `arity` number of arguments have - * been provided, or returns a function that accepts the remaining `func` - * arguments, and so on. The arity of `func` may be specified if `func.length` - * is not sufficient. - * - * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, - * may be used as a placeholder for provided arguments. - * - * **Note:** This method doesn't set the "length" property of curried functions. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Function - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new curried function. - * @example - * - * var abc = function(a, b, c) { - * return [a, b, c]; - * }; - * - * var curried = _.curry(abc); - * - * curried(1)(2)(3); - * // => [1, 2, 3] - * - * curried(1, 2)(3); - * // => [1, 2, 3] - * - * curried(1, 2, 3); - * // => [1, 2, 3] - * - * // Curried with placeholders. - * curried(1)(_, 3)(2); - * // => [1, 2, 3] - */ - function curry(func, arity, guard) { - arity = guard ? undefined : arity; - var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity); - result.placeholder = curry.placeholder; - return result; - } - - /** - * This method is like `_.curry` except that arguments are applied to `func` - * in the manner of `_.partialRight` instead of `_.partial`. - * - * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for provided arguments. - * - * **Note:** This method doesn't set the "length" property of curried functions. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to curry. - * @param {number} [arity=func.length] The arity of `func`. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the new curried function. - * @example - * - * var abc = function(a, b, c) { - * return [a, b, c]; - * }; - * - * var curried = _.curryRight(abc); - * - * curried(3)(2)(1); - * // => [1, 2, 3] - * - * curried(2, 3)(1); - * // => [1, 2, 3] - * - * curried(1, 2, 3); - * // => [1, 2, 3] - * - * // Curried with placeholders. - * curried(3)(1, _)(2); - * // => [1, 2, 3] - */ - function curryRight(func, arity, guard) { - arity = guard ? undefined : arity; - var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity); - result.placeholder = curryRight.placeholder; - return result; - } - - /** - * Creates a debounced function that delays invoking `func` until after `wait` - * milliseconds have elapsed since the last time the debounced function was - * invoked. The debounced function comes with a `cancel` method to cancel - * delayed `func` invocations and a `flush` method to immediately invoke them. - * Provide `options` to indicate whether `func` should be invoked on the - * leading and/or trailing edge of the `wait` timeout. The `func` is invoked - * with the last arguments provided to the debounced function. Subsequent - * calls to the debounced function return the result of the last `func` - * invocation. - * - * **Note:** If `leading` and `trailing` options are `true`, `func` is - * invoked on the trailing edge of the timeout only if the debounced function - * is invoked more than once during the `wait` timeout. - * - * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred - * until to the next tick, similar to `setTimeout` with a timeout of `0`. - * - * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) - * for details over the differences between `_.debounce` and `_.throttle`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to debounce. - * @param {number} [wait=0] The number of milliseconds to delay. - * @param {Object} [options={}] The options object. - * @param {boolean} [options.leading=false] - * Specify invoking on the leading edge of the timeout. - * @param {number} [options.maxWait] - * The maximum time `func` is allowed to be delayed before it's invoked. - * @param {boolean} [options.trailing=true] - * Specify invoking on the trailing edge of the timeout. - * @returns {Function} Returns the new debounced function. - * @example - * - * // Avoid costly calculations while the window size is in flux. - * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); - * - * // Invoke `sendMail` when clicked, debouncing subsequent calls. - * jQuery(element).on('click', _.debounce(sendMail, 300, { - * 'leading': true, - * 'trailing': false - * })); - * - * // Ensure `batchLog` is invoked once after 1 second of debounced calls. - * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); - * var source = new EventSource('/stream'); - * jQuery(source).on('message', debounced); - * - * // Cancel the trailing debounced invocation. - * jQuery(window).on('popstate', debounced.cancel); - */ - function debounce(func, wait, options) { - var lastArgs, - lastThis, - maxWait, - result, - timerId, - lastCallTime, - lastInvokeTime = 0, - leading = false, - maxing = false, - trailing = true; - - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - wait = toNumber(wait) || 0; - if (isObject(options)) { - leading = !!options.leading; - maxing = 'maxWait' in options; - maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; - trailing = 'trailing' in options ? !!options.trailing : trailing; - } - - function invokeFunc(time) { - var args = lastArgs, - thisArg = lastThis; - - lastArgs = lastThis = undefined; - lastInvokeTime = time; - result = func.apply(thisArg, args); - return result; - } - - function leadingEdge(time) { - // Reset any `maxWait` timer. - lastInvokeTime = time; - // Start the timer for the trailing edge. - timerId = setTimeout(timerExpired, wait); - // Invoke the leading edge. - return leading ? invokeFunc(time) : result; - } - - function remainingWait(time) { - var timeSinceLastCall = time - lastCallTime, - timeSinceLastInvoke = time - lastInvokeTime, - timeWaiting = wait - timeSinceLastCall; - - return maxing - ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) - : timeWaiting; - } - - function shouldInvoke(time) { - var timeSinceLastCall = time - lastCallTime, - timeSinceLastInvoke = time - lastInvokeTime; - - // Either this is the first call, activity has stopped and we're at the - // trailing edge, the system time has gone backwards and we're treating - // it as the trailing edge, or we've hit the `maxWait` limit. - return (lastCallTime === undefined || (timeSinceLastCall >= wait) || - (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); - } - - function timerExpired() { - var time = now(); - if (shouldInvoke(time)) { - return trailingEdge(time); - } - // Restart the timer. - timerId = setTimeout(timerExpired, remainingWait(time)); - } - - function trailingEdge(time) { - timerId = undefined; - - // Only invoke if we have `lastArgs` which means `func` has been - // debounced at least once. - if (trailing && lastArgs) { - return invokeFunc(time); - } - lastArgs = lastThis = undefined; - return result; - } - - function cancel() { - if (timerId !== undefined) { - clearTimeout(timerId); - } - lastInvokeTime = 0; - lastArgs = lastCallTime = lastThis = timerId = undefined; - } - - function flush() { - return timerId === undefined ? result : trailingEdge(now()); - } - - function debounced() { - var time = now(), - isInvoking = shouldInvoke(time); - - lastArgs = arguments; - lastThis = this; - lastCallTime = time; - - if (isInvoking) { - if (timerId === undefined) { - return leadingEdge(lastCallTime); - } - if (maxing) { - // Handle invocations in a tight loop. - clearTimeout(timerId); - timerId = setTimeout(timerExpired, wait); - return invokeFunc(lastCallTime); - } - } - if (timerId === undefined) { - timerId = setTimeout(timerExpired, wait); - } - return result; - } - debounced.cancel = cancel; - debounced.flush = flush; - return debounced; - } - - /** - * Defers invoking the `func` until the current call stack has cleared. Any - * additional arguments are provided to `func` when it's invoked. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to defer. - * @param {...*} [args] The arguments to invoke `func` with. - * @returns {number} Returns the timer id. - * @example - * - * _.defer(function(text) { - * console.log(text); - * }, 'deferred'); - * // => Logs 'deferred' after one millisecond. - */ - var defer = baseRest(function(func, args) { - return baseDelay(func, 1, args); - }); - - /** - * Invokes `func` after `wait` milliseconds. Any additional arguments are - * provided to `func` when it's invoked. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to delay. - * @param {number} wait The number of milliseconds to delay invocation. - * @param {...*} [args] The arguments to invoke `func` with. - * @returns {number} Returns the timer id. - * @example - * - * _.delay(function(text) { - * console.log(text); - * }, 1000, 'later'); - * // => Logs 'later' after one second. - */ - var delay = baseRest(function(func, wait, args) { - return baseDelay(func, toNumber(wait) || 0, args); - }); - - /** - * Creates a function that invokes `func` with arguments reversed. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to flip arguments for. - * @returns {Function} Returns the new flipped function. - * @example - * - * var flipped = _.flip(function() { - * return _.toArray(arguments); - * }); - * - * flipped('a', 'b', 'c', 'd'); - * // => ['d', 'c', 'b', 'a'] - */ - function flip(func) { - return createWrap(func, WRAP_FLIP_FLAG); - } - - /** - * Creates a function that memoizes the result of `func`. If `resolver` is - * provided, it determines the cache key for storing the result based on the - * arguments provided to the memoized function. By default, the first argument - * provided to the memoized function is used as the map cache key. The `func` - * is invoked with the `this` binding of the memoized function. - * - * **Note:** The cache is exposed as the `cache` property on the memoized - * function. Its creation may be customized by replacing the `_.memoize.Cache` - * constructor with one whose instances implement the - * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) - * method interface of `clear`, `delete`, `get`, `has`, and `set`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] The function to resolve the cache key. - * @returns {Function} Returns the new memoized function. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * var other = { 'c': 3, 'd': 4 }; - * - * var values = _.memoize(_.values); - * values(object); - * // => [1, 2] - * - * values(other); - * // => [3, 4] - * - * object.a = 2; - * values(object); - * // => [1, 2] - * - * // Modify the result cache. - * values.cache.set(object, ['a', 'b']); - * values(object); - * // => ['a', 'b'] - * - * // Replace `_.memoize.Cache`. - * _.memoize.Cache = WeakMap; - */ - function memoize(func, resolver) { - if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { - throw new TypeError(FUNC_ERROR_TEXT); - } - var memoized = function() { - var args = arguments, - key = resolver ? resolver.apply(this, args) : args[0], - cache = memoized.cache; - - if (cache.has(key)) { - return cache.get(key); - } - var result = func.apply(this, args); - memoized.cache = cache.set(key, result) || cache; - return result; - }; - memoized.cache = new (memoize.Cache || MapCache); - return memoized; - } - - // Expose `MapCache`. - memoize.Cache = MapCache; - - /** - * Creates a function that negates the result of the predicate `func`. The - * `func` predicate is invoked with the `this` binding and arguments of the - * created function. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} predicate The predicate to negate. - * @returns {Function} Returns the new negated function. - * @example - * - * function isEven(n) { - * return n % 2 == 0; - * } - * - * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven)); - * // => [1, 3, 5] - */ - function negate(predicate) { - if (typeof predicate != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - return function() { - var args = arguments; - switch (args.length) { - case 0: return !predicate.call(this); - case 1: return !predicate.call(this, args[0]); - case 2: return !predicate.call(this, args[0], args[1]); - case 3: return !predicate.call(this, args[0], args[1], args[2]); - } - return !predicate.apply(this, args); - }; - } - - /** - * Creates a function that is restricted to invoking `func` once. Repeat calls - * to the function return the value of the first invocation. The `func` is - * invoked with the `this` binding and arguments of the created function. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to restrict. - * @returns {Function} Returns the new restricted function. - * @example - * - * var initialize = _.once(createApplication); - * initialize(); - * initialize(); - * // => `createApplication` is invoked once - */ - function once(func) { - return before(2, func); - } - - /** - * Creates a function that invokes `func` with its arguments transformed. - * - * @static - * @since 4.0.0 - * @memberOf _ - * @category Function - * @param {Function} func The function to wrap. - * @param {...(Function|Function[])} [transforms=[_.identity]] - * The argument transforms. - * @returns {Function} Returns the new function. - * @example - * - * function doubled(n) { - * return n * 2; - * } - * - * function square(n) { - * return n * n; - * } - * - * var func = _.overArgs(function(x, y) { - * return [x, y]; - * }, [square, doubled]); - * - * func(9, 3); - * // => [81, 6] - * - * func(10, 5); - * // => [100, 10] - */ - var overArgs = castRest(function(func, transforms) { - transforms = (transforms.length == 1 && isArray(transforms[0])) - ? arrayMap(transforms[0], baseUnary(getIteratee())) - : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee())); - - var funcsLength = transforms.length; - return baseRest(function(args) { - var index = -1, - length = nativeMin(args.length, funcsLength); - - while (++index < length) { - args[index] = transforms[index].call(this, args[index]); - } - return apply(func, this, args); - }); - }); - - /** - * Creates a function that invokes `func` with `partials` prepended to the - * arguments it receives. This method is like `_.bind` except it does **not** - * alter the `this` binding. - * - * The `_.partial.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * **Note:** This method doesn't set the "length" property of partially - * applied functions. - * - * @static - * @memberOf _ - * @since 0.2.0 - * @category Function - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * function greet(greeting, name) { - * return greeting + ' ' + name; - * } - * - * var sayHelloTo = _.partial(greet, 'hello'); - * sayHelloTo('fred'); - * // => 'hello fred' - * - * // Partially applied with placeholders. - * var greetFred = _.partial(greet, _, 'fred'); - * greetFred('hi'); - * // => 'hi fred' - */ - var partial = baseRest(function(func, partials) { - var holders = replaceHolders(partials, getHolder(partial)); - return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders); - }); - - /** - * This method is like `_.partial` except that partially applied arguments - * are appended to the arguments it receives. - * - * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic - * builds, may be used as a placeholder for partially applied arguments. - * - * **Note:** This method doesn't set the "length" property of partially - * applied functions. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Function - * @param {Function} func The function to partially apply arguments to. - * @param {...*} [partials] The arguments to be partially applied. - * @returns {Function} Returns the new partially applied function. - * @example - * - * function greet(greeting, name) { - * return greeting + ' ' + name; - * } - * - * var greetFred = _.partialRight(greet, 'fred'); - * greetFred('hi'); - * // => 'hi fred' - * - * // Partially applied with placeholders. - * var sayHelloTo = _.partialRight(greet, 'hello', _); - * sayHelloTo('fred'); - * // => 'hello fred' - */ - var partialRight = baseRest(function(func, partials) { - var holders = replaceHolders(partials, getHolder(partialRight)); - return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders); - }); - - /** - * Creates a function that invokes `func` with arguments arranged according - * to the specified `indexes` where the argument value at the first index is - * provided as the first argument, the argument value at the second index is - * provided as the second argument, and so on. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Function - * @param {Function} func The function to rearrange arguments for. - * @param {...(number|number[])} indexes The arranged argument indexes. - * @returns {Function} Returns the new function. - * @example - * - * var rearged = _.rearg(function(a, b, c) { - * return [a, b, c]; - * }, [2, 0, 1]); - * - * rearged('b', 'c', 'a') - * // => ['a', 'b', 'c'] - */ - var rearg = flatRest(function(func, indexes) { - return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes); - }); - - /** - * Creates a function that invokes `func` with the `this` binding of the - * created function and arguments from `start` and beyond provided as - * an array. - * - * **Note:** This method is based on the - * [rest parameter](https://mdn.io/rest_parameters). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to apply a rest parameter to. - * @param {number} [start=func.length-1] The start position of the rest parameter. - * @returns {Function} Returns the new function. - * @example - * - * var say = _.rest(function(what, names) { - * return what + ' ' + _.initial(names).join(', ') + - * (_.size(names) > 1 ? ', & ' : '') + _.last(names); - * }); - * - * say('hello', 'fred', 'barney', 'pebbles'); - * // => 'hello fred, barney, & pebbles' - */ - function rest(func, start) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - start = start === undefined ? start : toInteger(start); - return baseRest(func, start); - } - - /** - * Creates a function that invokes `func` with the `this` binding of the - * create function and an array of arguments much like - * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). - * - * **Note:** This method is based on the - * [spread operator](https://mdn.io/spread_operator). - * - * @static - * @memberOf _ - * @since 3.2.0 - * @category Function - * @param {Function} func The function to spread arguments over. - * @param {number} [start=0] The start position of the spread. - * @returns {Function} Returns the new function. - * @example - * - * var say = _.spread(function(who, what) { - * return who + ' says ' + what; - * }); - * - * say(['fred', 'hello']); - * // => 'fred says hello' - * - * var numbers = Promise.all([ - * Promise.resolve(40), - * Promise.resolve(36) - * ]); - * - * numbers.then(_.spread(function(x, y) { - * return x + y; - * })); - * // => a Promise of 76 - */ - function spread(func, start) { - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - start = start == null ? 0 : nativeMax(toInteger(start), 0); - return baseRest(function(args) { - var array = args[start], - otherArgs = castSlice(args, 0, start); - - if (array) { - arrayPush(otherArgs, array); - } - return apply(func, this, otherArgs); - }); - } - - /** - * Creates a throttled function that only invokes `func` at most once per - * every `wait` milliseconds. The throttled function comes with a `cancel` - * method to cancel delayed `func` invocations and a `flush` method to - * immediately invoke them. Provide `options` to indicate whether `func` - * should be invoked on the leading and/or trailing edge of the `wait` - * timeout. The `func` is invoked with the last arguments provided to the - * throttled function. Subsequent calls to the throttled function return the - * result of the last `func` invocation. - * - * **Note:** If `leading` and `trailing` options are `true`, `func` is - * invoked on the trailing edge of the timeout only if the throttled function - * is invoked more than once during the `wait` timeout. - * - * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred - * until to the next tick, similar to `setTimeout` with a timeout of `0`. - * - * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) - * for details over the differences between `_.throttle` and `_.debounce`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to throttle. - * @param {number} [wait=0] The number of milliseconds to throttle invocations to. - * @param {Object} [options={}] The options object. - * @param {boolean} [options.leading=true] - * Specify invoking on the leading edge of the timeout. - * @param {boolean} [options.trailing=true] - * Specify invoking on the trailing edge of the timeout. - * @returns {Function} Returns the new throttled function. - * @example - * - * // Avoid excessively updating the position while scrolling. - * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); - * - * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. - * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); - * jQuery(element).on('click', throttled); - * - * // Cancel the trailing throttled invocation. - * jQuery(window).on('popstate', throttled.cancel); - */ - function throttle(func, wait, options) { - var leading = true, - trailing = true; - - if (typeof func != 'function') { - throw new TypeError(FUNC_ERROR_TEXT); - } - if (isObject(options)) { - leading = 'leading' in options ? !!options.leading : leading; - trailing = 'trailing' in options ? !!options.trailing : trailing; - } - return debounce(func, wait, { - 'leading': leading, - 'maxWait': wait, - 'trailing': trailing - }); - } - - /** - * Creates a function that accepts up to one argument, ignoring any - * additional arguments. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Function - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - * @example - * - * _.map(['6', '8', '10'], _.unary(parseInt)); - * // => [6, 8, 10] - */ - function unary(func) { - return ary(func, 1); - } - - /** - * Creates a function that provides `value` to `wrapper` as its first - * argument. Any additional arguments provided to the function are appended - * to those provided to the `wrapper`. The wrapper is invoked with the `this` - * binding of the created function. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {*} value The value to wrap. - * @param {Function} [wrapper=identity] The wrapper function. - * @returns {Function} Returns the new function. - * @example - * - * var p = _.wrap(_.escape, function(func, text) { - * return '

' + func(text) + '

'; - * }); - * - * p('fred, barney, & pebbles'); - * // => '

fred, barney, & pebbles

' - */ - function wrap(value, wrapper) { - return partial(castFunction(wrapper), value); - } - - /*------------------------------------------------------------------------*/ - - /** - * Casts `value` as an array if it's not one. - * - * @static - * @memberOf _ - * @since 4.4.0 - * @category Lang - * @param {*} value The value to inspect. - * @returns {Array} Returns the cast array. - * @example - * - * _.castArray(1); - * // => [1] - * - * _.castArray({ 'a': 1 }); - * // => [{ 'a': 1 }] - * - * _.castArray('abc'); - * // => ['abc'] - * - * _.castArray(null); - * // => [null] - * - * _.castArray(undefined); - * // => [undefined] - * - * _.castArray(); - * // => [] - * - * var array = [1, 2, 3]; - * console.log(_.castArray(array) === array); - * // => true - */ - function castArray() { - if (!arguments.length) { - return []; - } - var value = arguments[0]; - return isArray(value) ? value : [value]; - } - - /** - * Creates a shallow clone of `value`. - * - * **Note:** This method is loosely based on the - * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) - * and supports cloning arrays, array buffers, booleans, date objects, maps, - * numbers, `Object` objects, regexes, sets, strings, symbols, and typed - * arrays. The own enumerable properties of `arguments` objects are cloned - * as plain objects. An empty object is returned for uncloneable values such - * as error objects, functions, DOM nodes, and WeakMaps. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to clone. - * @returns {*} Returns the cloned value. - * @see _.cloneDeep - * @example - * - * var objects = [{ 'a': 1 }, { 'b': 2 }]; - * - * var shallow = _.clone(objects); - * console.log(shallow[0] === objects[0]); - * // => true - */ - function clone(value) { - return baseClone(value, CLONE_SYMBOLS_FLAG); - } - - /** - * This method is like `_.clone` except that it accepts `customizer` which - * is invoked to produce the cloned value. If `customizer` returns `undefined`, - * cloning is handled by the method instead. The `customizer` is invoked with - * up to four arguments; (value [, index|key, object, stack]). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to clone. - * @param {Function} [customizer] The function to customize cloning. - * @returns {*} Returns the cloned value. - * @see _.cloneDeepWith - * @example - * - * function customizer(value) { - * if (_.isElement(value)) { - * return value.cloneNode(false); - * } - * } - * - * var el = _.cloneWith(document.body, customizer); - * - * console.log(el === document.body); - * // => false - * console.log(el.nodeName); - * // => 'BODY' - * console.log(el.childNodes.length); - * // => 0 - */ - function cloneWith(value, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return baseClone(value, CLONE_SYMBOLS_FLAG, customizer); - } - - /** - * This method is like `_.clone` except that it recursively clones `value`. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Lang - * @param {*} value The value to recursively clone. - * @returns {*} Returns the deep cloned value. - * @see _.clone - * @example - * - * var objects = [{ 'a': 1 }, { 'b': 2 }]; - * - * var deep = _.cloneDeep(objects); - * console.log(deep[0] === objects[0]); - * // => false - */ - function cloneDeep(value) { - return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG); - } - - /** - * This method is like `_.cloneWith` except that it recursively clones `value`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to recursively clone. - * @param {Function} [customizer] The function to customize cloning. - * @returns {*} Returns the deep cloned value. - * @see _.cloneWith - * @example - * - * function customizer(value) { - * if (_.isElement(value)) { - * return value.cloneNode(true); - * } - * } - * - * var el = _.cloneDeepWith(document.body, customizer); - * - * console.log(el === document.body); - * // => false - * console.log(el.nodeName); - * // => 'BODY' - * console.log(el.childNodes.length); - * // => 20 - */ - function cloneDeepWith(value, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer); - } - - /** - * Checks if `object` conforms to `source` by invoking the predicate - * properties of `source` with the corresponding property values of `object`. - * - * **Note:** This method is equivalent to `_.conforms` when `source` is - * partially applied. - * - * @static - * @memberOf _ - * @since 4.14.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property predicates to conform to. - * @returns {boolean} Returns `true` if `object` conforms, else `false`. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * - * _.conformsTo(object, { 'b': function(n) { return n > 1; } }); - * // => true - * - * _.conformsTo(object, { 'b': function(n) { return n > 2; } }); - * // => false - */ - function conformsTo(object, source) { - return source == null || baseConformsTo(object, source, keys(source)); - } - - /** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true - * - * _.eq('a', Object('a')); - * // => false - * - * _.eq(NaN, NaN); - * // => true - */ - function eq(value, other) { - return value === other || (value !== value && other !== other); - } - - /** - * Checks if `value` is greater than `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than `other`, - * else `false`. - * @see _.lt - * @example - * - * _.gt(3, 1); - * // => true - * - * _.gt(3, 3); - * // => false - * - * _.gt(1, 3); - * // => false - */ - var gt = createRelationalOperation(baseGt); - - /** - * Checks if `value` is greater than or equal to `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is greater than or equal to - * `other`, else `false`. - * @see _.lte - * @example - * - * _.gte(3, 1); - * // => true - * - * _.gte(3, 3); - * // => true - * - * _.gte(1, 3); - * // => false - */ - var gte = createRelationalOperation(function(value, other) { - return value >= other; - }); - - /** - * Checks if `value` is likely an `arguments` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. - * @example - * - * _.isArguments(function() { return arguments; }()); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ - var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { - return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && - !propertyIsEnumerable.call(value, 'callee'); - }; - - /** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false - * - * _.isArray('abc'); - * // => false - * - * _.isArray(_.noop); - * // => false - */ - var isArray = Array.isArray; - - /** - * Checks if `value` is classified as an `ArrayBuffer` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`. - * @example - * - * _.isArrayBuffer(new ArrayBuffer(2)); - * // => true - * - * _.isArrayBuffer(new Array(2)); - * // => false - */ - var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer; - - /** - * Checks if `value` is array-like. A value is considered array-like if it's - * not a function and has a `value.length` that's an integer greater than or - * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is array-like, else `false`. - * @example - * - * _.isArrayLike([1, 2, 3]); - * // => true - * - * _.isArrayLike(document.body.children); - * // => true - * - * _.isArrayLike('abc'); - * // => true - * - * _.isArrayLike(_.noop); - * // => false - */ - function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value); - } - - /** - * This method is like `_.isArrayLike` except that it also checks if `value` - * is an object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array-like object, - * else `false`. - * @example - * - * _.isArrayLikeObject([1, 2, 3]); - * // => true - * - * _.isArrayLikeObject(document.body.children); - * // => true - * - * _.isArrayLikeObject('abc'); - * // => false - * - * _.isArrayLikeObject(_.noop); - * // => false - */ - function isArrayLikeObject(value) { - return isObjectLike(value) && isArrayLike(value); - } - - /** - * Checks if `value` is classified as a boolean primitive or object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a boolean, else `false`. - * @example - * - * _.isBoolean(false); - * // => true - * - * _.isBoolean(null); - * // => false - */ - function isBoolean(value) { - return value === true || value === false || - (isObjectLike(value) && baseGetTag(value) == boolTag); - } - - /** - * Checks if `value` is a buffer. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. - * @example - * - * _.isBuffer(new Buffer(2)); - * // => true - * - * _.isBuffer(new Uint8Array(2)); - * // => false - */ - var isBuffer = nativeIsBuffer || stubFalse; - - /** - * Checks if `value` is classified as a `Date` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a date object, else `false`. - * @example - * - * _.isDate(new Date); - * // => true - * - * _.isDate('Mon April 23 2012'); - * // => false - */ - var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate; - - /** - * Checks if `value` is likely a DOM element. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`. - * @example - * - * _.isElement(document.body); - * // => true - * - * _.isElement(''); - * // => false - */ - function isElement(value) { - return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value); - } - - /** - * Checks if `value` is an empty object, collection, map, or set. - * - * Objects are considered empty if they have no own enumerable string keyed - * properties. - * - * Array-like values such as `arguments` objects, arrays, buffers, strings, or - * jQuery-like collections are considered empty if they have a `length` of `0`. - * Similarly, maps and sets are considered empty if they have a `size` of `0`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is empty, else `false`. - * @example - * - * _.isEmpty(null); - * // => true - * - * _.isEmpty(true); - * // => true - * - * _.isEmpty(1); - * // => true - * - * _.isEmpty([1, 2, 3]); - * // => false - * - * _.isEmpty({ 'a': 1 }); - * // => false - */ - function isEmpty(value) { - if (value == null) { - return true; - } - if (isArrayLike(value) && - (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || - isBuffer(value) || isTypedArray(value) || isArguments(value))) { - return !value.length; - } - var tag = getTag(value); - if (tag == mapTag || tag == setTag) { - return !value.size; - } - if (isPrototype(value)) { - return !baseKeys(value).length; - } - for (var key in value) { - if (hasOwnProperty.call(value, key)) { - return false; - } - } - return true; - } - - /** - * Performs a deep comparison between two values to determine if they are - * equivalent. - * - * **Note:** This method supports comparing arrays, array buffers, booleans, - * date objects, error objects, maps, numbers, `Object` objects, regexes, - * sets, strings, symbols, and typed arrays. `Object` objects are compared - * by their own, not inherited, enumerable properties. Functions and DOM - * nodes are compared by strict equality, i.e. `===`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.isEqual(object, other); - * // => true - * - * object === other; - * // => false - */ - function isEqual(value, other) { - return baseIsEqual(value, other); - } - - /** - * This method is like `_.isEqual` except that it accepts `customizer` which - * is invoked to compare values. If `customizer` returns `undefined`, comparisons - * are handled by the method instead. The `customizer` is invoked with up to - * six arguments: (objValue, othValue [, index|key, object, other, stack]). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * function isGreeting(value) { - * return /^h(?:i|ello)$/.test(value); - * } - * - * function customizer(objValue, othValue) { - * if (isGreeting(objValue) && isGreeting(othValue)) { - * return true; - * } - * } - * - * var array = ['hello', 'goodbye']; - * var other = ['hi', 'goodbye']; - * - * _.isEqualWith(array, other, customizer); - * // => true - */ - function isEqualWith(value, other, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - var result = customizer ? customizer(value, other) : undefined; - return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result; - } - - /** - * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, - * `SyntaxError`, `TypeError`, or `URIError` object. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an error object, else `false`. - * @example - * - * _.isError(new Error); - * // => true - * - * _.isError(Error); - * // => false - */ - function isError(value) { - if (!isObjectLike(value)) { - return false; - } - var tag = baseGetTag(value); - return tag == errorTag || tag == domExcTag || - (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value)); - } - - /** - * Checks if `value` is a finite primitive number. - * - * **Note:** This method is based on - * [`Number.isFinite`](https://mdn.io/Number/isFinite). - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a finite number, else `false`. - * @example - * - * _.isFinite(3); - * // => true - * - * _.isFinite(Number.MIN_VALUE); - * // => true - * - * _.isFinite(Infinity); - * // => false - * - * _.isFinite('3'); - * // => false - */ - function isFinite(value) { - return typeof value == 'number' && nativeIsFinite(value); - } - - /** - * Checks if `value` is classified as a `Function` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false - */ - function isFunction(value) { - if (!isObject(value)) { - return false; - } - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 9 which returns 'object' for typed arrays and other constructors. - var tag = baseGetTag(value); - return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; - } - - /** - * Checks if `value` is an integer. - * - * **Note:** This method is based on - * [`Number.isInteger`](https://mdn.io/Number/isInteger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an integer, else `false`. - * @example - * - * _.isInteger(3); - * // => true - * - * _.isInteger(Number.MIN_VALUE); - * // => false - * - * _.isInteger(Infinity); - * // => false - * - * _.isInteger('3'); - * // => false - */ - function isInteger(value) { - return typeof value == 'number' && value == toInteger(value); - } - - /** - * Checks if `value` is a valid array-like length. - * - * **Note:** This method is loosely based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. - * @example - * - * _.isLength(3); - * // => true - * - * _.isLength(Number.MIN_VALUE); - * // => false - * - * _.isLength(Infinity); - * // => false - * - * _.isLength('3'); - * // => false - */ - function isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; - } - - /** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true - * - * _.isObject(null); - * // => false - */ - function isObject(value) { - var type = typeof value; - return value != null && (type == 'object' || type == 'function'); - } - - /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example - * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); - * // => true - * - * _.isObjectLike(_.noop); - * // => false - * - * _.isObjectLike(null); - * // => false - */ - function isObjectLike(value) { - return value != null && typeof value == 'object'; - } - - /** - * Checks if `value` is classified as a `Map` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a map, else `false`. - * @example - * - * _.isMap(new Map); - * // => true - * - * _.isMap(new WeakMap); - * // => false - */ - var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap; - - /** - * Performs a partial deep comparison between `object` and `source` to - * determine if `object` contains equivalent property values. - * - * **Note:** This method is equivalent to `_.matches` when `source` is - * partially applied. - * - * Partial comparisons will match empty array and empty object `source` - * values against any array or object value, respectively. See `_.isEqual` - * for a list of supported value comparisons. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * - * _.isMatch(object, { 'b': 2 }); - * // => true - * - * _.isMatch(object, { 'b': 1 }); - * // => false - */ - function isMatch(object, source) { - return object === source || baseIsMatch(object, source, getMatchData(source)); - } - - /** - * This method is like `_.isMatch` except that it accepts `customizer` which - * is invoked to compare values. If `customizer` returns `undefined`, comparisons - * are handled by the method instead. The `customizer` is invoked with five - * arguments: (objValue, srcValue, index|key, object, source). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {Object} object The object to inspect. - * @param {Object} source The object of property values to match. - * @param {Function} [customizer] The function to customize comparisons. - * @returns {boolean} Returns `true` if `object` is a match, else `false`. - * @example - * - * function isGreeting(value) { - * return /^h(?:i|ello)$/.test(value); - * } - * - * function customizer(objValue, srcValue) { - * if (isGreeting(objValue) && isGreeting(srcValue)) { - * return true; - * } - * } - * - * var object = { 'greeting': 'hello' }; - * var source = { 'greeting': 'hi' }; - * - * _.isMatchWith(object, source, customizer); - * // => true - */ - function isMatchWith(object, source, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return baseIsMatch(object, source, getMatchData(source), customizer); - } - - /** - * Checks if `value` is `NaN`. - * - * **Note:** This method is based on - * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as - * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for - * `undefined` and other non-number values. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`. - * @example - * - * _.isNaN(NaN); - * // => true - * - * _.isNaN(new Number(NaN)); - * // => true - * - * isNaN(undefined); - * // => true - * - * _.isNaN(undefined); - * // => false - */ - function isNaN(value) { - // An `NaN` primitive is the only value that is not equal to itself. - // Perform the `toStringTag` check first to avoid errors with some - // ActiveX objects in IE. - return isNumber(value) && value != +value; - } - - /** - * Checks if `value` is a pristine native function. - * - * **Note:** This method can't reliably detect native functions in the presence - * of the core-js package because core-js circumvents this kind of detection. - * Despite multiple requests, the core-js maintainer has made it clear: any - * attempt to fix the detection will be obstructed. As a result, we're left - * with little choice but to throw an error. Unfortunately, this also affects - * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), - * which rely on core-js. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - * @example - * - * _.isNative(Array.prototype.push); - * // => true - * - * _.isNative(_); - * // => false - */ - function isNative(value) { - if (isMaskable(value)) { - throw new Error(CORE_ERROR_TEXT); - } - return baseIsNative(value); - } - - /** - * Checks if `value` is `null`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `null`, else `false`. - * @example - * - * _.isNull(null); - * // => true - * - * _.isNull(void 0); - * // => false - */ - function isNull(value) { - return value === null; - } - - /** - * Checks if `value` is `null` or `undefined`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is nullish, else `false`. - * @example - * - * _.isNil(null); - * // => true - * - * _.isNil(void 0); - * // => true - * - * _.isNil(NaN); - * // => false - */ - function isNil(value) { - return value == null; - } - - /** - * Checks if `value` is classified as a `Number` primitive or object. - * - * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are - * classified as numbers, use the `_.isFinite` method. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a number, else `false`. - * @example - * - * _.isNumber(3); - * // => true - * - * _.isNumber(Number.MIN_VALUE); - * // => true - * - * _.isNumber(Infinity); - * // => true - * - * _.isNumber('3'); - * // => false - */ - function isNumber(value) { - return typeof value == 'number' || - (isObjectLike(value) && baseGetTag(value) == numberTag); - } - - /** - * Checks if `value` is a plain object, that is, an object created by the - * `Object` constructor or one with a `[[Prototype]]` of `null`. - * - * @static - * @memberOf _ - * @since 0.8.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * _.isPlainObject(new Foo); - * // => false - * - * _.isPlainObject([1, 2, 3]); - * // => false - * - * _.isPlainObject({ 'x': 0, 'y': 0 }); - * // => true - * - * _.isPlainObject(Object.create(null)); - * // => true - */ - function isPlainObject(value) { - if (!isObjectLike(value) || baseGetTag(value) != objectTag) { - return false; - } - var proto = getPrototype(value); - if (proto === null) { - return true; - } - var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor; - return typeof Ctor == 'function' && Ctor instanceof Ctor && - funcToString.call(Ctor) == objectCtorString; - } - - /** - * Checks if `value` is classified as a `RegExp` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a regexp, else `false`. - * @example - * - * _.isRegExp(/abc/); - * // => true - * - * _.isRegExp('/abc/'); - * // => false - */ - var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp; - - /** - * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 - * double precision number which isn't the result of a rounded unsafe integer. - * - * **Note:** This method is based on - * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`. - * @example - * - * _.isSafeInteger(3); - * // => true - * - * _.isSafeInteger(Number.MIN_VALUE); - * // => false - * - * _.isSafeInteger(Infinity); - * // => false - * - * _.isSafeInteger('3'); - * // => false - */ - function isSafeInteger(value) { - return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER; - } - - /** - * Checks if `value` is classified as a `Set` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a set, else `false`. - * @example - * - * _.isSet(new Set); - * // => true - * - * _.isSet(new WeakSet); - * // => false - */ - var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet; - - /** - * Checks if `value` is classified as a `String` primitive or object. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a string, else `false`. - * @example - * - * _.isString('abc'); - * // => true - * - * _.isString(1); - * // => false - */ - function isString(value) { - return typeof value == 'string' || - (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); - } - - /** - * Checks if `value` is classified as a `Symbol` primitive or object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. - * @example - * - * _.isSymbol(Symbol.iterator); - * // => true - * - * _.isSymbol('abc'); - * // => false - */ - function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && baseGetTag(value) == symbolTag); - } - - /** - * Checks if `value` is classified as a typed array. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - * @example - * - * _.isTypedArray(new Uint8Array); - * // => true - * - * _.isTypedArray([]); - * // => false - */ - var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; - - /** - * Checks if `value` is `undefined`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`. - * @example - * - * _.isUndefined(void 0); - * // => true - * - * _.isUndefined(null); - * // => false - */ - function isUndefined(value) { - return value === undefined; - } - - /** - * Checks if `value` is classified as a `WeakMap` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a weak map, else `false`. - * @example - * - * _.isWeakMap(new WeakMap); - * // => true - * - * _.isWeakMap(new Map); - * // => false - */ - function isWeakMap(value) { - return isObjectLike(value) && getTag(value) == weakMapTag; - } - - /** - * Checks if `value` is classified as a `WeakSet` object. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a weak set, else `false`. - * @example - * - * _.isWeakSet(new WeakSet); - * // => true - * - * _.isWeakSet(new Set); - * // => false - */ - function isWeakSet(value) { - return isObjectLike(value) && baseGetTag(value) == weakSetTag; - } - - /** - * Checks if `value` is less than `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than `other`, - * else `false`. - * @see _.gt - * @example - * - * _.lt(1, 3); - * // => true - * - * _.lt(3, 3); - * // => false - * - * _.lt(3, 1); - * // => false - */ - var lt = createRelationalOperation(baseLt); - - /** - * Checks if `value` is less than or equal to `other`. - * - * @static - * @memberOf _ - * @since 3.9.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if `value` is less than or equal to - * `other`, else `false`. - * @see _.gte - * @example - * - * _.lte(1, 3); - * // => true - * - * _.lte(3, 3); - * // => true - * - * _.lte(3, 1); - * // => false - */ - var lte = createRelationalOperation(function(value, other) { - return value <= other; - }); - - /** - * Converts `value` to an array. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Lang - * @param {*} value The value to convert. - * @returns {Array} Returns the converted array. - * @example - * - * _.toArray({ 'a': 1, 'b': 2 }); - * // => [1, 2] - * - * _.toArray('abc'); - * // => ['a', 'b', 'c'] - * - * _.toArray(1); - * // => [] - * - * _.toArray(null); - * // => [] - */ - function toArray(value) { - if (!value) { - return []; - } - if (isArrayLike(value)) { - return isString(value) ? stringToArray(value) : copyArray(value); - } - if (symIterator && value[symIterator]) { - return iteratorToArray(value[symIterator]()); - } - var tag = getTag(value), - func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values); - - return func(value); - } - - /** - * Converts `value` to a finite number. - * - * @static - * @memberOf _ - * @since 4.12.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted number. - * @example - * - * _.toFinite(3.2); - * // => 3.2 - * - * _.toFinite(Number.MIN_VALUE); - * // => 5e-324 - * - * _.toFinite(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toFinite('3.2'); - * // => 3.2 - */ - function toFinite(value) { - if (!value) { - return value === 0 ? value : 0; - } - value = toNumber(value); - if (value === INFINITY || value === -INFINITY) { - var sign = (value < 0 ? -1 : 1); - return sign * MAX_INTEGER; - } - return value === value ? value : 0; - } - - /** - * Converts `value` to an integer. - * - * **Note:** This method is loosely based on - * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toInteger(3.2); - * // => 3 - * - * _.toInteger(Number.MIN_VALUE); - * // => 0 - * - * _.toInteger(Infinity); - * // => 1.7976931348623157e+308 - * - * _.toInteger('3.2'); - * // => 3 - */ - function toInteger(value) { - var result = toFinite(value), - remainder = result % 1; - - return result === result ? (remainder ? result - remainder : result) : 0; - } - - /** - * Converts `value` to an integer suitable for use as the length of an - * array-like object. - * - * **Note:** This method is based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toLength(3.2); - * // => 3 - * - * _.toLength(Number.MIN_VALUE); - * // => 0 - * - * _.toLength(Infinity); - * // => 4294967295 - * - * _.toLength('3.2'); - * // => 3 - */ - function toLength(value) { - return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0; - } - - /** - * Converts `value` to a number. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to process. - * @returns {number} Returns the number. - * @example - * - * _.toNumber(3.2); - * // => 3.2 - * - * _.toNumber(Number.MIN_VALUE); - * // => 5e-324 - * - * _.toNumber(Infinity); - * // => Infinity - * - * _.toNumber('3.2'); - * // => 3.2 - */ - function toNumber(value) { - if (typeof value == 'number') { - return value; - } - if (isSymbol(value)) { - return NAN; - } - if (isObject(value)) { - var other = typeof value.valueOf == 'function' ? value.valueOf() : value; - value = isObject(other) ? (other + '') : other; - } - if (typeof value != 'string') { - return value === 0 ? value : +value; - } - value = value.replace(reTrim, ''); - var isBinary = reIsBinary.test(value); - return (isBinary || reIsOctal.test(value)) - ? freeParseInt(value.slice(2), isBinary ? 2 : 8) - : (reIsBadHex.test(value) ? NAN : +value); - } - - /** - * Converts `value` to a plain object flattening inherited enumerable string - * keyed properties of `value` to own properties of the plain object. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {Object} Returns the converted plain object. - * @example - * - * function Foo() { - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.assign({ 'a': 1 }, new Foo); - * // => { 'a': 1, 'b': 2 } - * - * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); - * // => { 'a': 1, 'b': 2, 'c': 3 } - */ - function toPlainObject(value) { - return copyObject(value, keysIn(value)); - } - - /** - * Converts `value` to a safe integer. A safe integer can be compared and - * represented correctly. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {number} Returns the converted integer. - * @example - * - * _.toSafeInteger(3.2); - * // => 3 - * - * _.toSafeInteger(Number.MIN_VALUE); - * // => 0 - * - * _.toSafeInteger(Infinity); - * // => 9007199254740991 - * - * _.toSafeInteger('3.2'); - * // => 3 - */ - function toSafeInteger(value) { - return value - ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) - : (value === 0 ? value : 0); - } - - /** - * Converts `value` to a string. An empty string is returned for `null` - * and `undefined` values. The sign of `-0` is preserved. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.toString(null); - * // => '' - * - * _.toString(-0); - * // => '-0' - * - * _.toString([1, 2, 3]); - * // => '1,2,3' - */ - function toString(value) { - return value == null ? '' : baseToString(value); - } - - /*------------------------------------------------------------------------*/ - - /** - * Assigns own enumerable string keyed properties of source objects to the - * destination object. Source objects are applied from left to right. - * Subsequent sources overwrite property assignments of previous sources. - * - * **Note:** This method mutates `object` and is loosely based on - * [`Object.assign`](https://mdn.io/Object/assign). - * - * @static - * @memberOf _ - * @since 0.10.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.assignIn - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * function Bar() { - * this.c = 3; - * } - * - * Foo.prototype.b = 2; - * Bar.prototype.d = 4; - * - * _.assign({ 'a': 0 }, new Foo, new Bar); - * // => { 'a': 1, 'c': 3 } - */ - var assign = createAssigner(function(object, source) { - if (isPrototype(source) || isArrayLike(source)) { - copyObject(source, keys(source), object); - return; - } - for (var key in source) { - if (hasOwnProperty.call(source, key)) { - assignValue(object, key, source[key]); - } - } - }); - - /** - * This method is like `_.assign` except that it iterates over own and - * inherited source properties. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias extend - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.assign - * @example - * - * function Foo() { - * this.a = 1; - * } - * - * function Bar() { - * this.c = 3; - * } - * - * Foo.prototype.b = 2; - * Bar.prototype.d = 4; - * - * _.assignIn({ 'a': 0 }, new Foo, new Bar); - * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 } - */ - var assignIn = createAssigner(function(object, source) { - copyObject(source, keysIn(source), object); - }); - - /** - * This method is like `_.assignIn` except that it accepts `customizer` - * which is invoked to produce the assigned values. If `customizer` returns - * `undefined`, assignment is handled by the method instead. The `customizer` - * is invoked with five arguments: (objValue, srcValue, key, object, source). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias extendWith - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @see _.assignWith - * @example - * - * function customizer(objValue, srcValue) { - * return _.isUndefined(objValue) ? srcValue : objValue; - * } - * - * var defaults = _.partialRight(_.assignInWith, customizer); - * - * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var assignInWith = createAssigner(function(object, source, srcIndex, customizer) { - copyObject(source, keysIn(source), object, customizer); - }); - - /** - * This method is like `_.assign` except that it accepts `customizer` - * which is invoked to produce the assigned values. If `customizer` returns - * `undefined`, assignment is handled by the method instead. The `customizer` - * is invoked with five arguments: (objValue, srcValue, key, object, source). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @see _.assignInWith - * @example - * - * function customizer(objValue, srcValue) { - * return _.isUndefined(objValue) ? srcValue : objValue; - * } - * - * var defaults = _.partialRight(_.assignWith, customizer); - * - * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var assignWith = createAssigner(function(object, source, srcIndex, customizer) { - copyObject(source, keys(source), object, customizer); - }); - - /** - * Creates an array of values corresponding to `paths` of `object`. - * - * @static - * @memberOf _ - * @since 1.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Array} Returns the picked values. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] }; - * - * _.at(object, ['a[0].b.c', 'a[1]']); - * // => [3, 4] - */ - var at = flatRest(baseAt); - - /** - * Creates an object that inherits from the `prototype` object. If a - * `properties` object is given, its own enumerable string keyed properties - * are assigned to the created object. - * - * @static - * @memberOf _ - * @since 2.3.0 - * @category Object - * @param {Object} prototype The object to inherit from. - * @param {Object} [properties] The properties to assign to the object. - * @returns {Object} Returns the new object. - * @example - * - * function Shape() { - * this.x = 0; - * this.y = 0; - * } - * - * function Circle() { - * Shape.call(this); - * } - * - * Circle.prototype = _.create(Shape.prototype, { - * 'constructor': Circle - * }); - * - * var circle = new Circle; - * circle instanceof Circle; - * // => true - * - * circle instanceof Shape; - * // => true - */ - function create(prototype, properties) { - var result = baseCreate(prototype); - return properties == null ? result : baseAssign(result, properties); - } - - /** - * Assigns own and inherited enumerable string keyed properties of source - * objects to the destination object for all destination properties that - * resolve to `undefined`. Source objects are applied from left to right. - * Once a property is set, additional values of the same property are ignored. - * - * **Note:** This method mutates `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.defaultsDeep - * @example - * - * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); - * // => { 'a': 1, 'b': 2 } - */ - var defaults = baseRest(function(object, sources) { - object = Object(object); - - var index = -1; - var length = sources.length; - var guard = length > 2 ? sources[2] : undefined; - - if (guard && isIterateeCall(sources[0], sources[1], guard)) { - length = 1; - } - - while (++index < length) { - var source = sources[index]; - var props = keysIn(source); - var propsIndex = -1; - var propsLength = props.length; - - while (++propsIndex < propsLength) { - var key = props[propsIndex]; - var value = object[key]; - - if (value === undefined || - (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) { - object[key] = source[key]; - } - } - } - - return object; - }); - - /** - * This method is like `_.defaults` except that it recursively assigns - * default properties. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 3.10.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @see _.defaults - * @example - * - * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); - * // => { 'a': { 'b': 2, 'c': 3 } } - */ - var defaultsDeep = baseRest(function(args) { - args.push(undefined, customDefaultsMerge); - return apply(mergeWith, undefined, args); - }); - - /** - * This method is like `_.find` except that it returns the key of the first - * element `predicate` returns truthy for instead of the element itself. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category Object - * @param {Object} object The object to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {string|undefined} Returns the key of the matched element, - * else `undefined`. - * @example - * - * var users = { - * 'barney': { 'age': 36, 'active': true }, - * 'fred': { 'age': 40, 'active': false }, - * 'pebbles': { 'age': 1, 'active': true } - * }; - * - * _.findKey(users, function(o) { return o.age < 40; }); - * // => 'barney' (iteration order is not guaranteed) - * - * // The `_.matches` iteratee shorthand. - * _.findKey(users, { 'age': 1, 'active': true }); - * // => 'pebbles' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findKey(users, ['active', false]); - * // => 'fred' - * - * // The `_.property` iteratee shorthand. - * _.findKey(users, 'active'); - * // => 'barney' - */ - function findKey(object, predicate) { - return baseFindKey(object, getIteratee(predicate, 3), baseForOwn); - } - - /** - * This method is like `_.findKey` except that it iterates over elements of - * a collection in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to inspect. - * @param {Function} [predicate=_.identity] The function invoked per iteration. - * @returns {string|undefined} Returns the key of the matched element, - * else `undefined`. - * @example - * - * var users = { - * 'barney': { 'age': 36, 'active': true }, - * 'fred': { 'age': 40, 'active': false }, - * 'pebbles': { 'age': 1, 'active': true } - * }; - * - * _.findLastKey(users, function(o) { return o.age < 40; }); - * // => returns 'pebbles' assuming `_.findKey` returns 'barney' - * - * // The `_.matches` iteratee shorthand. - * _.findLastKey(users, { 'age': 36, 'active': true }); - * // => 'barney' - * - * // The `_.matchesProperty` iteratee shorthand. - * _.findLastKey(users, ['active', false]); - * // => 'fred' - * - * // The `_.property` iteratee shorthand. - * _.findLastKey(users, 'active'); - * // => 'pebbles' - */ - function findLastKey(object, predicate) { - return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight); - } - - /** - * Iterates over own and inherited enumerable string keyed properties of an - * object and invokes `iteratee` for each property. The iteratee is invoked - * with three arguments: (value, key, object). Iteratee functions may exit - * iteration early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 0.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forInRight - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forIn(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed). - */ - function forIn(object, iteratee) { - return object == null - ? object - : baseFor(object, getIteratee(iteratee, 3), keysIn); - } - - /** - * This method is like `_.forIn` except that it iterates over properties of - * `object` in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forIn - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forInRight(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'. - */ - function forInRight(object, iteratee) { - return object == null - ? object - : baseForRight(object, getIteratee(iteratee, 3), keysIn); - } - - /** - * Iterates over own enumerable string keyed properties of an object and - * invokes `iteratee` for each property. The iteratee is invoked with three - * arguments: (value, key, object). Iteratee functions may exit iteration - * early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 0.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forOwnRight - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forOwn(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'a' then 'b' (iteration order is not guaranteed). - */ - function forOwn(object, iteratee) { - return object && baseForOwn(object, getIteratee(iteratee, 3)); - } - - /** - * This method is like `_.forOwn` except that it iterates over properties of - * `object` in the opposite order. - * - * @static - * @memberOf _ - * @since 2.0.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns `object`. - * @see _.forOwn - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.forOwnRight(new Foo, function(value, key) { - * console.log(key); - * }); - * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'. - */ - function forOwnRight(object, iteratee) { - return object && baseForOwnRight(object, getIteratee(iteratee, 3)); - } - - /** - * Creates an array of function property names from own enumerable properties - * of `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to inspect. - * @returns {Array} Returns the function names. - * @see _.functionsIn - * @example - * - * function Foo() { - * this.a = _.constant('a'); - * this.b = _.constant('b'); - * } - * - * Foo.prototype.c = _.constant('c'); - * - * _.functions(new Foo); - * // => ['a', 'b'] - */ - function functions(object) { - return object == null ? [] : baseFunctions(object, keys(object)); - } - - /** - * Creates an array of function property names from own and inherited - * enumerable properties of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to inspect. - * @returns {Array} Returns the function names. - * @see _.functions - * @example - * - * function Foo() { - * this.a = _.constant('a'); - * this.b = _.constant('b'); - * } - * - * Foo.prototype.c = _.constant('c'); - * - * _.functionsIn(new Foo); - * // => ['a', 'b', 'c'] - */ - function functionsIn(object) { - return object == null ? [] : baseFunctions(object, keysIn(object)); - } - - /** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is returned in its place. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.get(object, 'a[0].b.c'); - * // => 3 - * - * _.get(object, ['a', '0', 'b', 'c']); - * // => 3 - * - * _.get(object, 'a.b.c', 'default'); - * // => 'default' - */ - function get(object, path, defaultValue) { - var result = object == null ? undefined : baseGet(object, path); - return result === undefined ? defaultValue : result; - } - - /** - * Checks if `path` is a direct property of `object`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = { 'a': { 'b': 2 } }; - * var other = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.has(object, 'a'); - * // => true - * - * _.has(object, 'a.b'); - * // => true - * - * _.has(object, ['a', 'b']); - * // => true - * - * _.has(other, 'a'); - * // => false - */ - function has(object, path) { - return object != null && hasPath(object, path, baseHas); - } - - /** - * Checks if `path` is a direct or inherited property of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path to check. - * @returns {boolean} Returns `true` if `path` exists, else `false`. - * @example - * - * var object = _.create({ 'a': _.create({ 'b': 2 }) }); - * - * _.hasIn(object, 'a'); - * // => true - * - * _.hasIn(object, 'a.b'); - * // => true - * - * _.hasIn(object, ['a', 'b']); - * // => true - * - * _.hasIn(object, 'b'); - * // => false - */ - function hasIn(object, path) { - return object != null && hasPath(object, path, baseHasIn); - } - - /** - * Creates an object composed of the inverted keys and values of `object`. - * If `object` contains duplicate values, subsequent values overwrite - * property assignments of previous values. - * - * @static - * @memberOf _ - * @since 0.7.0 - * @category Object - * @param {Object} object The object to invert. - * @returns {Object} Returns the new inverted object. - * @example - * - * var object = { 'a': 1, 'b': 2, 'c': 1 }; - * - * _.invert(object); - * // => { '1': 'c', '2': 'b' } - */ - var invert = createInverter(function(result, value, key) { - if (value != null && - typeof value.toString != 'function') { - value = nativeObjectToString.call(value); - } - - result[value] = key; - }, constant(identity)); - - /** - * This method is like `_.invert` except that the inverted object is generated - * from the results of running each element of `object` thru `iteratee`. The - * corresponding inverted value of each inverted key is an array of keys - * responsible for generating the inverted value. The iteratee is invoked - * with one argument: (value). - * - * @static - * @memberOf _ - * @since 4.1.0 - * @category Object - * @param {Object} object The object to invert. - * @param {Function} [iteratee=_.identity] The iteratee invoked per element. - * @returns {Object} Returns the new inverted object. - * @example - * - * var object = { 'a': 1, 'b': 2, 'c': 1 }; - * - * _.invertBy(object); - * // => { '1': ['a', 'c'], '2': ['b'] } - * - * _.invertBy(object, function(value) { - * return 'group' + value; - * }); - * // => { 'group1': ['a', 'c'], 'group2': ['b'] } - */ - var invertBy = createInverter(function(result, value, key) { - if (value != null && - typeof value.toString != 'function') { - value = nativeObjectToString.call(value); - } - - if (hasOwnProperty.call(result, value)) { - result[value].push(key); - } else { - result[value] = [key]; - } - }, getIteratee); - - /** - * Invokes the method at `path` of `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the method to invoke. - * @param {...*} [args] The arguments to invoke the method with. - * @returns {*} Returns the result of the invoked method. - * @example - * - * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] }; - * - * _.invoke(object, 'a[0].b.c.slice', 1, 3); - * // => [2, 3] - */ - var invoke = baseRest(baseInvoke); - - /** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) - * - * _.keys('hi'); - * // => ['0', '1'] - */ - function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); - } - - /** - * Creates an array of the own and inherited enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keysIn(new Foo); - * // => ['a', 'b', 'c'] (iteration order is not guaranteed) - */ - function keysIn(object) { - return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); - } - - /** - * The opposite of `_.mapValues`; this method creates an object with the - * same values as `object` and keys generated by running each own enumerable - * string keyed property of `object` thru `iteratee`. The iteratee is invoked - * with three arguments: (value, key, object). - * - * @static - * @memberOf _ - * @since 3.8.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns the new mapped object. - * @see _.mapValues - * @example - * - * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) { - * return key + value; - * }); - * // => { 'a1': 1, 'b2': 2 } - */ - function mapKeys(object, iteratee) { - var result = {}; - iteratee = getIteratee(iteratee, 3); - - baseForOwn(object, function(value, key, object) { - baseAssignValue(result, iteratee(value, key, object), value); - }); - return result; - } - - /** - * Creates an object with the same keys as `object` and values generated - * by running each own enumerable string keyed property of `object` thru - * `iteratee`. The iteratee is invoked with three arguments: - * (value, key, object). - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @returns {Object} Returns the new mapped object. - * @see _.mapKeys - * @example - * - * var users = { - * 'fred': { 'user': 'fred', 'age': 40 }, - * 'pebbles': { 'user': 'pebbles', 'age': 1 } - * }; - * - * _.mapValues(users, function(o) { return o.age; }); - * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) - * - * // The `_.property` iteratee shorthand. - * _.mapValues(users, 'age'); - * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed) - */ - function mapValues(object, iteratee) { - var result = {}; - iteratee = getIteratee(iteratee, 3); - - baseForOwn(object, function(value, key, object) { - baseAssignValue(result, key, iteratee(value, key, object)); - }); - return result; - } - - /** - * This method is like `_.assign` except that it recursively merges own and - * inherited enumerable string keyed properties of source objects into the - * destination object. Source properties that resolve to `undefined` are - * skipped if a destination value exists. Array and plain object properties - * are merged recursively. Other objects and value types are overridden by - * assignment. Source objects are applied from left to right. Subsequent - * sources overwrite property assignments of previous sources. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 0.5.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} [sources] The source objects. - * @returns {Object} Returns `object`. - * @example - * - * var object = { - * 'a': [{ 'b': 2 }, { 'd': 4 }] - * }; - * - * var other = { - * 'a': [{ 'c': 3 }, { 'e': 5 }] - * }; - * - * _.merge(object, other); - * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] } - */ - var merge = createAssigner(function(object, source, srcIndex) { - baseMerge(object, source, srcIndex); - }); - - /** - * This method is like `_.merge` except that it accepts `customizer` which - * is invoked to produce the merged values of the destination and source - * properties. If `customizer` returns `undefined`, merging is handled by the - * method instead. The `customizer` is invoked with six arguments: - * (objValue, srcValue, key, object, source, stack). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The destination object. - * @param {...Object} sources The source objects. - * @param {Function} customizer The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * function customizer(objValue, srcValue) { - * if (_.isArray(objValue)) { - * return objValue.concat(srcValue); - * } - * } - * - * var object = { 'a': [1], 'b': [2] }; - * var other = { 'a': [3], 'b': [4] }; - * - * _.mergeWith(object, other, customizer); - * // => { 'a': [1, 3], 'b': [2, 4] } - */ - var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { - baseMerge(object, source, srcIndex, customizer); - }); - - /** - * The opposite of `_.pick`; this method creates an object composed of the - * own and inherited enumerable property paths of `object` that are not omitted. - * - * **Note:** This method is considerably slower than `_.pick`. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [paths] The property paths to omit. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.omit(object, ['a', 'c']); - * // => { 'b': '2' } - */ - var omit = flatRest(function(object, paths) { - var result = {}; - if (object == null) { - return result; - } - var isDeep = false; - paths = arrayMap(paths, function(path) { - path = castPath(path, object); - isDeep || (isDeep = path.length > 1); - return path; - }); - copyObject(object, getAllKeysIn(object), result); - if (isDeep) { - result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone); - } - var length = paths.length; - while (length--) { - baseUnset(result, paths[length]); - } - return result; - }); - - /** - * The opposite of `_.pickBy`; this method creates an object composed of - * the own and inherited enumerable string keyed properties of `object` that - * `predicate` doesn't return truthy for. The predicate is invoked with two - * arguments: (value, key). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The source object. - * @param {Function} [predicate=_.identity] The function invoked per property. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.omitBy(object, _.isNumber); - * // => { 'b': '2' } - */ - function omitBy(object, predicate) { - return pickBy(object, negate(getIteratee(predicate))); - } - - /** - * Creates an object composed of the picked `object` properties. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The source object. - * @param {...(string|string[])} [paths] The property paths to pick. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.pick(object, ['a', 'c']); - * // => { 'a': 1, 'c': 3 } - */ - var pick = flatRest(function(object, paths) { - return object == null ? {} : basePick(object, paths); - }); - - /** - * Creates an object composed of the `object` properties `predicate` returns - * truthy for. The predicate is invoked with two arguments: (value, key). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The source object. - * @param {Function} [predicate=_.identity] The function invoked per property. - * @returns {Object} Returns the new object. - * @example - * - * var object = { 'a': 1, 'b': '2', 'c': 3 }; - * - * _.pickBy(object, _.isNumber); - * // => { 'a': 1, 'c': 3 } - */ - function pickBy(object, predicate) { - if (object == null) { - return {}; - } - var props = arrayMap(getAllKeysIn(object), function(prop) { - return [prop]; - }); - predicate = getIteratee(predicate); - return basePickBy(object, props, function(value, path) { - return predicate(value, path[0]); - }); - } - - /** - * This method is like `_.get` except that if the resolved value is a - * function it's invoked with the `this` binding of its parent object and - * its result is returned. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to resolve. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] }; - * - * _.result(object, 'a[0].b.c1'); - * // => 3 - * - * _.result(object, 'a[0].b.c2'); - * // => 4 - * - * _.result(object, 'a[0].b.c3', 'default'); - * // => 'default' - * - * _.result(object, 'a[0].b.c3', _.constant('default')); - * // => 'default' - */ - function result(object, path, defaultValue) { - path = castPath(path, object); - - var index = -1, - length = path.length; - - // Ensure the loop is entered when path is empty. - if (!length) { - length = 1; - object = undefined; - } - while (++index < length) { - var value = object == null ? undefined : object[toKey(path[index])]; - if (value === undefined) { - index = length; - value = defaultValue; - } - object = isFunction(value) ? value.call(object) : value; - } - return object; - } - - /** - * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, - * it's created. Arrays are created for missing index properties while objects - * are created for all other missing properties. Use `_.setWith` to customize - * `path` creation. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @returns {Object} Returns `object`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.set(object, 'a[0].b.c', 4); - * console.log(object.a[0].b.c); - * // => 4 - * - * _.set(object, ['x', '0', 'y', 'z'], 5); - * console.log(object.x[0].y.z); - * // => 5 - */ - function set(object, path, value) { - return object == null ? object : baseSet(object, path, value); - } - - /** - * This method is like `_.set` except that it accepts `customizer` which is - * invoked to produce the objects of `path`. If `customizer` returns `undefined` - * path creation is handled by the method instead. The `customizer` is invoked - * with three arguments: (nsValue, key, nsObject). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {*} value The value to set. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * var object = {}; - * - * _.setWith(object, '[0][1]', 'a', Object); - * // => { '0': { '1': 'a' } } - */ - function setWith(object, path, value, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return object == null ? object : baseSet(object, path, value, customizer); - } - - /** - * Creates an array of own enumerable string keyed-value pairs for `object` - * which can be consumed by `_.fromPairs`. If `object` is a map or set, its - * entries are returned. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias entries - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the key-value pairs. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.toPairs(new Foo); - * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed) - */ - var toPairs = createToPairs(keys); - - /** - * Creates an array of own and inherited enumerable string keyed-value pairs - * for `object` which can be consumed by `_.fromPairs`. If `object` is a map - * or set, its entries are returned. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @alias entriesIn - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the key-value pairs. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.toPairsIn(new Foo); - * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed) - */ - var toPairsIn = createToPairs(keysIn); - - /** - * An alternative to `_.reduce`; this method transforms `object` to a new - * `accumulator` object which is the result of running each of its own - * enumerable string keyed properties thru `iteratee`, with each invocation - * potentially mutating the `accumulator` object. If `accumulator` is not - * provided, a new object with the same `[[Prototype]]` will be used. The - * iteratee is invoked with four arguments: (accumulator, value, key, object). - * Iteratee functions may exit iteration early by explicitly returning `false`. - * - * @static - * @memberOf _ - * @since 1.3.0 - * @category Object - * @param {Object} object The object to iterate over. - * @param {Function} [iteratee=_.identity] The function invoked per iteration. - * @param {*} [accumulator] The custom accumulator value. - * @returns {*} Returns the accumulated value. - * @example - * - * _.transform([2, 3, 4], function(result, n) { - * result.push(n *= n); - * return n % 2 == 0; - * }, []); - * // => [4, 9] - * - * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) { - * (result[value] || (result[value] = [])).push(key); - * }, {}); - * // => { '1': ['a', 'c'], '2': ['b'] } - */ - function transform(object, iteratee, accumulator) { - var isArr = isArray(object), - isArrLike = isArr || isBuffer(object) || isTypedArray(object); - - iteratee = getIteratee(iteratee, 4); - if (accumulator == null) { - var Ctor = object && object.constructor; - if (isArrLike) { - accumulator = isArr ? new Ctor : []; - } - else if (isObject(object)) { - accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {}; - } - else { - accumulator = {}; - } - } - (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) { - return iteratee(accumulator, value, index, object); - }); - return accumulator; - } - - /** - * Removes the property at `path` of `object`. - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to unset. - * @returns {boolean} Returns `true` if the property is deleted, else `false`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 7 } }] }; - * _.unset(object, 'a[0].b.c'); - * // => true - * - * console.log(object); - * // => { 'a': [{ 'b': {} }] }; - * - * _.unset(object, ['a', '0', 'b', 'c']); - * // => true - * - * console.log(object); - * // => { 'a': [{ 'b': {} }] }; - */ - function unset(object, path) { - return object == null ? true : baseUnset(object, path); - } - - /** - * This method is like `_.set` except that accepts `updater` to produce the - * value to set. Use `_.updateWith` to customize `path` creation. The `updater` - * is invoked with one argument: (value). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {Function} updater The function to produce the updated value. - * @returns {Object} Returns `object`. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.update(object, 'a[0].b.c', function(n) { return n * n; }); - * console.log(object.a[0].b.c); - * // => 9 - * - * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; }); - * console.log(object.x[0].y.z); - * // => 0 - */ - function update(object, path, updater) { - return object == null ? object : baseUpdate(object, path, castFunction(updater)); - } - - /** - * This method is like `_.update` except that it accepts `customizer` which is - * invoked to produce the objects of `path`. If `customizer` returns `undefined` - * path creation is handled by the method instead. The `customizer` is invoked - * with three arguments: (nsValue, key, nsObject). - * - * **Note:** This method mutates `object`. - * - * @static - * @memberOf _ - * @since 4.6.0 - * @category Object - * @param {Object} object The object to modify. - * @param {Array|string} path The path of the property to set. - * @param {Function} updater The function to produce the updated value. - * @param {Function} [customizer] The function to customize assigned values. - * @returns {Object} Returns `object`. - * @example - * - * var object = {}; - * - * _.updateWith(object, '[0][1]', _.constant('a'), Object); - * // => { '0': { '1': 'a' } } - */ - function updateWith(object, path, updater, customizer) { - customizer = typeof customizer == 'function' ? customizer : undefined; - return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer); - } - - /** - * Creates an array of the own enumerable string keyed property values of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.values(new Foo); - * // => [1, 2] (iteration order is not guaranteed) - * - * _.values('hi'); - * // => ['h', 'i'] - */ - function values(object) { - return object == null ? [] : baseValues(object, keys(object)); - } - - /** - * Creates an array of the own and inherited enumerable string keyed property - * values of `object`. - * - * **Note:** Non-object values are coerced to objects. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property values. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.valuesIn(new Foo); - * // => [1, 2, 3] (iteration order is not guaranteed) - */ - function valuesIn(object) { - return object == null ? [] : baseValues(object, keysIn(object)); - } - - /*------------------------------------------------------------------------*/ - - /** - * Clamps `number` within the inclusive `lower` and `upper` bounds. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Number - * @param {number} number The number to clamp. - * @param {number} [lower] The lower bound. - * @param {number} upper The upper bound. - * @returns {number} Returns the clamped number. - * @example - * - * _.clamp(-10, -5, 5); - * // => -5 - * - * _.clamp(10, -5, 5); - * // => 5 - */ - function clamp(number, lower, upper) { - if (upper === undefined) { - upper = lower; - lower = undefined; - } - if (upper !== undefined) { - upper = toNumber(upper); - upper = upper === upper ? upper : 0; - } - if (lower !== undefined) { - lower = toNumber(lower); - lower = lower === lower ? lower : 0; - } - return baseClamp(toNumber(number), lower, upper); - } - - /** - * Checks if `n` is between `start` and up to, but not including, `end`. If - * `end` is not specified, it's set to `start` with `start` then set to `0`. - * If `start` is greater than `end` the params are swapped to support - * negative ranges. - * - * @static - * @memberOf _ - * @since 3.3.0 - * @category Number - * @param {number} number The number to check. - * @param {number} [start=0] The start of the range. - * @param {number} end The end of the range. - * @returns {boolean} Returns `true` if `number` is in the range, else `false`. - * @see _.range, _.rangeRight - * @example - * - * _.inRange(3, 2, 4); - * // => true - * - * _.inRange(4, 8); - * // => true - * - * _.inRange(4, 2); - * // => false - * - * _.inRange(2, 2); - * // => false - * - * _.inRange(1.2, 2); - * // => true - * - * _.inRange(5.2, 4); - * // => false - * - * _.inRange(-3, -2, -6); - * // => true - */ - function inRange(number, start, end) { - start = toFinite(start); - if (end === undefined) { - end = start; - start = 0; - } else { - end = toFinite(end); - } - number = toNumber(number); - return baseInRange(number, start, end); - } - - /** - * Produces a random number between the inclusive `lower` and `upper` bounds. - * If only one argument is provided a number between `0` and the given number - * is returned. If `floating` is `true`, or either `lower` or `upper` are - * floats, a floating-point number is returned instead of an integer. - * - * **Note:** JavaScript follows the IEEE-754 standard for resolving - * floating-point values which can produce unexpected results. - * - * @static - * @memberOf _ - * @since 0.7.0 - * @category Number - * @param {number} [lower=0] The lower bound. - * @param {number} [upper=1] The upper bound. - * @param {boolean} [floating] Specify returning a floating-point number. - * @returns {number} Returns the random number. - * @example - * - * _.random(0, 5); - * // => an integer between 0 and 5 - * - * _.random(5); - * // => also an integer between 0 and 5 - * - * _.random(5, true); - * // => a floating-point number between 0 and 5 - * - * _.random(1.2, 5.2); - * // => a floating-point number between 1.2 and 5.2 - */ - function random(lower, upper, floating) { - if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) { - upper = floating = undefined; - } - if (floating === undefined) { - if (typeof upper == 'boolean') { - floating = upper; - upper = undefined; - } - else if (typeof lower == 'boolean') { - floating = lower; - lower = undefined; - } - } - if (lower === undefined && upper === undefined) { - lower = 0; - upper = 1; - } - else { - lower = toFinite(lower); - if (upper === undefined) { - upper = lower; - lower = 0; - } else { - upper = toFinite(upper); - } - } - if (lower > upper) { - var temp = lower; - lower = upper; - upper = temp; - } - if (floating || lower % 1 || upper % 1) { - var rand = nativeRandom(); - return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper); - } - return baseRandom(lower, upper); - } - - /*------------------------------------------------------------------------*/ - - /** - * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the camel cased string. - * @example - * - * _.camelCase('Foo Bar'); - * // => 'fooBar' - * - * _.camelCase('--foo-bar--'); - * // => 'fooBar' - * - * _.camelCase('__FOO_BAR__'); - * // => 'fooBar' - */ - var camelCase = createCompounder(function(result, word, index) { - word = word.toLowerCase(); - return result + (index ? capitalize(word) : word); - }); - - /** - * Converts the first character of `string` to upper case and the remaining - * to lower case. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to capitalize. - * @returns {string} Returns the capitalized string. - * @example - * - * _.capitalize('FRED'); - * // => 'Fred' - */ - function capitalize(string) { - return upperFirst(toString(string).toLowerCase()); - } - - /** - * Deburrs `string` by converting - * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) - * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) - * letters to basic Latin letters and removing - * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to deburr. - * @returns {string} Returns the deburred string. - * @example - * - * _.deburr('déjà vu'); - * // => 'deja vu' - */ - function deburr(string) { - string = toString(string); - return string && string.replace(reLatin, deburrLetter).replace(reComboMark, ''); - } - - /** - * Checks if `string` ends with the given target string. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to inspect. - * @param {string} [target] The string to search for. - * @param {number} [position=string.length] The position to search up to. - * @returns {boolean} Returns `true` if `string` ends with `target`, - * else `false`. - * @example - * - * _.endsWith('abc', 'c'); - * // => true - * - * _.endsWith('abc', 'b'); - * // => false - * - * _.endsWith('abc', 'b', 2); - * // => true - */ - function endsWith(string, target, position) { - string = toString(string); - target = baseToString(target); - - var length = string.length; - position = position === undefined - ? length - : baseClamp(toInteger(position), 0, length); - - var end = position; - position -= target.length; - return position >= 0 && string.slice(position, end) == target; - } - - /** - * Converts the characters "&", "<", ">", '"', and "'" in `string` to their - * corresponding HTML entities. - * - * **Note:** No other characters are escaped. To escape additional - * characters use a third-party library like [_he_](https://mths.be/he). - * - * Though the ">" character is escaped for symmetry, characters like - * ">" and "/" don't need escaping in HTML and have no special meaning - * unless they're part of a tag or unquoted attribute value. See - * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) - * (under "semi-related fun fact") for more details. - * - * When working with HTML you should always - * [quote attribute values](http://wonko.com/post/html-escaping) to reduce - * XSS vectors. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category String - * @param {string} [string=''] The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escape('fred, barney, & pebbles'); - * // => 'fred, barney, & pebbles' - */ - function escape(string) { - string = toString(string); - return (string && reHasUnescapedHtml.test(string)) - ? string.replace(reUnescapedHtml, escapeHtmlChar) - : string; - } - - /** - * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", - * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to escape. - * @returns {string} Returns the escaped string. - * @example - * - * _.escapeRegExp('[lodash](https://lodash.com/)'); - * // => '\[lodash\]\(https://lodash\.com/\)' - */ - function escapeRegExp(string) { - string = toString(string); - return (string && reHasRegExpChar.test(string)) - ? string.replace(reRegExpChar, '\\$&') - : string; - } - - /** - * Converts `string` to - * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the kebab cased string. - * @example - * - * _.kebabCase('Foo Bar'); - * // => 'foo-bar' - * - * _.kebabCase('fooBar'); - * // => 'foo-bar' - * - * _.kebabCase('__FOO_BAR__'); - * // => 'foo-bar' - */ - var kebabCase = createCompounder(function(result, word, index) { - return result + (index ? '-' : '') + word.toLowerCase(); - }); - - /** - * Converts `string`, as space separated words, to lower case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the lower cased string. - * @example - * - * _.lowerCase('--Foo-Bar--'); - * // => 'foo bar' - * - * _.lowerCase('fooBar'); - * // => 'foo bar' - * - * _.lowerCase('__FOO_BAR__'); - * // => 'foo bar' - */ - var lowerCase = createCompounder(function(result, word, index) { - return result + (index ? ' ' : '') + word.toLowerCase(); - }); - - /** - * Converts the first character of `string` to lower case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.lowerFirst('Fred'); - * // => 'fred' - * - * _.lowerFirst('FRED'); - * // => 'fRED' - */ - var lowerFirst = createCaseFirst('toLowerCase'); - - /** - * Pads `string` on the left and right sides if it's shorter than `length`. - * Padding characters are truncated if they can't be evenly divided by `length`. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.pad('abc', 8); - * // => ' abc ' - * - * _.pad('abc', 8, '_-'); - * // => '_-abc_-_' - * - * _.pad('abc', 3); - * // => 'abc' - */ - function pad(string, length, chars) { - string = toString(string); - length = toInteger(length); - - var strLength = length ? stringSize(string) : 0; - if (!length || strLength >= length) { - return string; - } - var mid = (length - strLength) / 2; - return ( - createPadding(nativeFloor(mid), chars) + - string + - createPadding(nativeCeil(mid), chars) - ); - } - - /** - * Pads `string` on the right side if it's shorter than `length`. Padding - * characters are truncated if they exceed `length`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.padEnd('abc', 6); - * // => 'abc ' - * - * _.padEnd('abc', 6, '_-'); - * // => 'abc_-_' - * - * _.padEnd('abc', 3); - * // => 'abc' - */ - function padEnd(string, length, chars) { - string = toString(string); - length = toInteger(length); - - var strLength = length ? stringSize(string) : 0; - return (length && strLength < length) - ? (string + createPadding(length - strLength, chars)) - : string; - } - - /** - * Pads `string` on the left side if it's shorter than `length`. Padding - * characters are truncated if they exceed `length`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to pad. - * @param {number} [length=0] The padding length. - * @param {string} [chars=' '] The string used as padding. - * @returns {string} Returns the padded string. - * @example - * - * _.padStart('abc', 6); - * // => ' abc' - * - * _.padStart('abc', 6, '_-'); - * // => '_-_abc' - * - * _.padStart('abc', 3); - * // => 'abc' - */ - function padStart(string, length, chars) { - string = toString(string); - length = toInteger(length); - - var strLength = length ? stringSize(string) : 0; - return (length && strLength < length) - ? (createPadding(length - strLength, chars) + string) - : string; - } - - /** - * Converts `string` to an integer of the specified radix. If `radix` is - * `undefined` or `0`, a `radix` of `10` is used unless `value` is a - * hexadecimal, in which case a `radix` of `16` is used. - * - * **Note:** This method aligns with the - * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. - * - * @static - * @memberOf _ - * @since 1.1.0 - * @category String - * @param {string} string The string to convert. - * @param {number} [radix=10] The radix to interpret `value` by. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {number} Returns the converted integer. - * @example - * - * _.parseInt('08'); - * // => 8 - * - * _.map(['6', '08', '10'], _.parseInt); - * // => [6, 8, 10] - */ - function parseInt(string, radix, guard) { - if (guard || radix == null) { - radix = 0; - } else if (radix) { - radix = +radix; - } - return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0); - } - - /** - * Repeats the given string `n` times. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to repeat. - * @param {number} [n=1] The number of times to repeat the string. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {string} Returns the repeated string. - * @example - * - * _.repeat('*', 3); - * // => '***' - * - * _.repeat('abc', 2); - * // => 'abcabc' - * - * _.repeat('abc', 0); - * // => '' - */ - function repeat(string, n, guard) { - if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) { - n = 1; - } else { - n = toInteger(n); - } - return baseRepeat(toString(string), n); - } - - /** - * Replaces matches for `pattern` in `string` with `replacement`. - * - * **Note:** This method is based on - * [`String#replace`](https://mdn.io/String/replace). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to modify. - * @param {RegExp|string} pattern The pattern to replace. - * @param {Function|string} replacement The match replacement. - * @returns {string} Returns the modified string. - * @example - * - * _.replace('Hi Fred', 'Fred', 'Barney'); - * // => 'Hi Barney' - */ - function replace() { - var args = arguments, - string = toString(args[0]); - - return args.length < 3 ? string : string.replace(args[1], args[2]); - } - - /** - * Converts `string` to - * [snake case](https://en.wikipedia.org/wiki/Snake_case). - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the snake cased string. - * @example - * - * _.snakeCase('Foo Bar'); - * // => 'foo_bar' - * - * _.snakeCase('fooBar'); - * // => 'foo_bar' - * - * _.snakeCase('--FOO-BAR--'); - * // => 'foo_bar' - */ - var snakeCase = createCompounder(function(result, word, index) { - return result + (index ? '_' : '') + word.toLowerCase(); - }); - - /** - * Splits `string` by `separator`. - * - * **Note:** This method is based on - * [`String#split`](https://mdn.io/String/split). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to split. - * @param {RegExp|string} separator The separator pattern to split by. - * @param {number} [limit] The length to truncate results to. - * @returns {Array} Returns the string segments. - * @example - * - * _.split('a-b-c', '-', 2); - * // => ['a', 'b'] - */ - function split(string, separator, limit) { - if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) { - separator = limit = undefined; - } - limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0; - if (!limit) { - return []; - } - string = toString(string); - if (string && ( - typeof separator == 'string' || - (separator != null && !isRegExp(separator)) - )) { - separator = baseToString(separator); - if (!separator && hasUnicode(string)) { - return castSlice(stringToArray(string), 0, limit); - } - } - return string.split(separator, limit); - } - - /** - * Converts `string` to - * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage). - * - * @static - * @memberOf _ - * @since 3.1.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the start cased string. - * @example - * - * _.startCase('--foo-bar--'); - * // => 'Foo Bar' - * - * _.startCase('fooBar'); - * // => 'Foo Bar' - * - * _.startCase('__FOO_BAR__'); - * // => 'FOO BAR' - */ - var startCase = createCompounder(function(result, word, index) { - return result + (index ? ' ' : '') + upperFirst(word); - }); - - /** - * Checks if `string` starts with the given target string. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category String - * @param {string} [string=''] The string to inspect. - * @param {string} [target] The string to search for. - * @param {number} [position=0] The position to search from. - * @returns {boolean} Returns `true` if `string` starts with `target`, - * else `false`. - * @example - * - * _.startsWith('abc', 'a'); - * // => true - * - * _.startsWith('abc', 'b'); - * // => false - * - * _.startsWith('abc', 'b', 1); - * // => true - */ - function startsWith(string, target, position) { - string = toString(string); - position = position == null - ? 0 - : baseClamp(toInteger(position), 0, string.length); - - target = baseToString(target); - return string.slice(position, position + target.length) == target; - } - - /** - * Creates a compiled template function that can interpolate data properties - * in "interpolate" delimiters, HTML-escape interpolated data properties in - * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data - * properties may be accessed as free variables in the template. If a setting - * object is given, it takes precedence over `_.templateSettings` values. - * - * **Note:** In the development build `_.template` utilizes - * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) - * for easier debugging. - * - * For more information on precompiling templates see - * [lodash's custom builds documentation](https://lodash.com/custom-builds). - * - * For more information on Chrome extension sandboxes see - * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category String - * @param {string} [string=''] The template string. - * @param {Object} [options={}] The options object. - * @param {RegExp} [options.escape=_.templateSettings.escape] - * The HTML "escape" delimiter. - * @param {RegExp} [options.evaluate=_.templateSettings.evaluate] - * The "evaluate" delimiter. - * @param {Object} [options.imports=_.templateSettings.imports] - * An object to import into the template as free variables. - * @param {RegExp} [options.interpolate=_.templateSettings.interpolate] - * The "interpolate" delimiter. - * @param {string} [options.sourceURL='lodash.templateSources[n]'] - * The sourceURL of the compiled template. - * @param {string} [options.variable='obj'] - * The data object variable name. - * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`. - * @returns {Function} Returns the compiled template function. - * @example - * - * // Use the "interpolate" delimiter to create a compiled template. - * var compiled = _.template('hello <%= user %>!'); - * compiled({ 'user': 'fred' }); - * // => 'hello fred!' - * - * // Use the HTML "escape" delimiter to escape data property values. - * var compiled = _.template('<%- value %>'); - * compiled({ 'value': ' - - -Status Legend: - -- 🛑 **Bare** - Very incomplete at this time. - - **Implementors:** This is far from ready for you. -- ⚠️ **Rough** -- work in progress, heavy changes coming, as we put in place key functionality. - - **Implementors:** This will be ready for you soon. -- 🔁 **Refining** - Key functionality is there, some small things expected to change. Some big things may change. - - **Implementors:** Almost ready for you. You can start building these parts, but beware there may be changes still. -- ✅ **Stable** - Mostly complete, minor things expected to change, no major changes expected. - - **Implementors:** Ready for you. You can build these parts. - -*Note that the status relates to the state of the spec either written out either in english or in code. The goal is for the spec to eventually be fleshed out in both language-sets.* - -[Show / Hide ] status indicators - - -{{< incTocMap "/docs/systems" 2 "colorful" >}} - - -# Overview Diagram - -TODO: - -- cleanup / reorganize - - this diagram is accurate, and helps lots to navigate, but it's still a bit confusing - - the arrows and lines make it a bit hard to follow. We should have a much cleaner version (maybe based on [C4](https://c4model.com)) -- reflect addition of Token system - - move data_transfers into Token - -{{< diagram src="../diagrams/overview1/overview.dot.svg" title="Protocol Overview Diagram" >}} - -# Protocol Flow Diagram -- deals on chain - -{{< diagram src="../diagrams/sequence/full-deals-on-chain.mmd.svg" title="Protocol Sequence Diagram - Deals on Chain" >}} - -# Parameter Calculation Dependency Graph - -This is a diagram of the model for parameter calculation. This is made with [orient](https://github.com/filecoin-project/orient), our tool for modeling and solving for constraints. - -{{< diagram src="../diagrams/orient/filecoin.dot.svg" title="Parameter Calculation Dependency Graph" >}} - diff --git a/src/intro/changelog/_index.md b/src/intro/changelog/_index.md deleted file mode 100644 index ff2598e43..000000000 --- a/src/intro/changelog/_index.md +++ /dev/null @@ -1,115 +0,0 @@ ---- -menuTitle: "Change Log" -title: "Change Log - Version History" ---- - -# v1.1 - 2019-10-30 - `c3f6a6dd` - -- **Deals on chain** - - Storage Deals - - Full `StorageMarketActor` logic: - - client and miner balances: deposits, locking, charges, and withdrawls - - collateral slashing - - Full `StorageMinerActor` logic: - - sector states, state transitions, state accounting, power accounting - - DeclareFaults + RecoverSectors flow - - `CommitSector` flow - - `SubmitElectionPost` or `SubmitSurprisePoSt` flow - - Sector proving, faults, recovery, and expiry - - `OnMissedSurprisePost` flow - - Fault sectors, drop power, expiry, and more - - `StoragePowerActor` - - power accounting based on `StorageMinerActor` state changes - - Collaterals: deposit, locking, withdrawal - - Slashing collaerals - - Interactive-Post - - `StorageMinerActor`: `PrecommitSector` and `CommitSector` - - Surprise-Post - - Challenge flow through `CronActor -> StoragePowerActor -> StorageMiner` -- **Virtual Machine** - - Extracted VM system out of blockchain - - Addresses - - Actors - - Separation of code and state - - Messages - - Method invocation representation - - Runtime - - Slimmed down interface - - Safer state Acquire, Release, Commit flow - - Exit codes - - Full invocation flow - - Safer recursive context construction - - Error levels and handling - - Detecting and handling out of gas errors - - Interpreter - - `ApplyMessage` - - `{Deduct,Deposit} -> Transfer` - safer - - Gas accounting - - VM system actors - - `InitActor` basic flow, plug into Runtime - - `CronActor` full flow, static registry - - `AccountActor` basic flow -- **Data Transfer** - - Full Data Transfer flows - - push, pull, 1-RTT pull - - protocol, data structures, interface - - diagrams -- **blockchain/ChainSync:** - - first version of ChainSync protocol description - - Includes protocol state machine description - - Network bootstrap -- connectivity and state - - Progressive Block Validation - - Progressive Block Propagation -- **Other** - - Spec section status indicators - - Changelog - -# v1.0 - 2019-10-07 - `583b1d06` - -- **Full spec reorganization** -- **Tooling** - - added a build system to compile tools - - added diagraming tools (dot, mermaid, etc) - - added dependency installation - - added Orient to calculate protocol parameters -- **Content** - - **filecoin_nodes** - - types - an overview of different filecoin node types - - repository - local data-structure storage - - network interface - connecting to libp2p - - clock - a wall clock - - **files & data** - - file - basic representation of data - - piece - representation of data to store in filecoin - - **blockchain** - - blocks - basic blockchain data structures (block, tipset, chain, etc) - - storage power consensus - basic algorithms and crypto artifacts for SPC - - `StoragePowerActor` basics - - **token** - - skeleton of sections - - **storage mining** - - storage miner: module that controls and coordinates storage mining - - sector: unit of storage, sealing, crypto artifacts, etc. - - sector index: accounting sectors and metadata - - storage proving: seals, posts, and more - - **market** - - deals: storage market deal basics - - storage market: `StorageMarketActor` basics - - **orient** - - orient models for proofs and block sizes - - **libraries** - - filcrypto - sealing, PoRep, PoSt algorithms - - ipld - cids, ipldstores - - libp2p - host/node representation - - ipfs - graphsync and bitswap - - multiformats - multihash, multiaddr - - **diagrams** - - system overview - - full protocol mermaid flow - - -# pre v1.0 - -- Extensive write up of the filecoin protocol - visible [here](https://github.com/filecoin-project/specs/tree/prevspec) -- See full changelog: https://github.com/filecoin-project/specs/commits/prevspec - diff --git a/src/intro/concepts.md b/src/intro/concepts.md deleted file mode 100644 index 4e9feb90d..000000000 --- a/src/intro/concepts.md +++ /dev/null @@ -1,39 +0,0 @@ ---- -title: "Key Concepts" ---- - -For clarity, we refer the following types of entities to describe implementations of the Filecoin protocol: - -- **_Data structures_** are collections of semantically-tagged data members (e.g., structs, interfaces, or enums). - -- **_Functions_** are computational procedures that do not depend on external state (i.e., mathematical functions, - or programming language functions that do not refer to global variables). - -- **_Components_** are sets of functionality that are intended to be represented as single software units - in the implementation structure. - Depending on the choice of language and the particular component, this might - correspond to a single software module, - a thread or process running some main loop, a disk-backed database, or a variety of other design choices. - For example, the {{}} is a component: it could be implemented - as a process or thread running a single specified main loop, which waits for network messages - and responds accordingly by recording and/or forwarding block data. - -- **_APIs_** are messages that can be sent to components. - A client's view of a given sub-protocol, such as a request to a miner node's - {{}} component to store files in the storage market, - may require the execution of a series of APIs. - -- **_Nodes_** are complete software and hardware systems that interact with the protocol. - A node might be constantly running several of the above _components_, participating in several _subsystems_, - and exposing _APIs_ locally and/or over the network, - depending on the node configuration. - The term _full node_ refers to a system that runs all of the above components, and supports all of the APIs detailed in the spec. - -- **_Subsystems_** are conceptual divisions of the entire Filecoin protocol, either in terms of complete protocols - (such as the {{}} or {{}}), or in terms of functionality - (such as the {{}}). They do not necessarily correspond to any particular node or software component. - -- **_Actors_** are virtual entities embodied in the state of the Filecoin VM. - Protocol actors are analogous to participants in smart contracts; - an actor carries a FIL currency balance and can interact with other actors - via the operations of the VM, but does not necessarily correspond to any particular node or software component. diff --git a/src/intro/filecoin_vm.md b/src/intro/filecoin_vm.md deleted file mode 100644 index c88942f8a..000000000 --- a/src/intro/filecoin_vm.md +++ /dev/null @@ -1,15 +0,0 @@ ---- -title: "Filecoin VM" ---- - -The majority of Filecoin's user facing functionality (payments, storage market, power table, etc) is managed through the Filecoin Virtual Machine (Filecoin VM). The network generates a series of blocks, and agrees which 'chain' of blocks is the correct one. Each block contains a series of state transitions called `messages`, and a checkpoint of the current `global state` after the application of those `messages`. - -The `global state` here consists of a set of `actors`, each with their own private `state`. - -An `actor` is the Filecoin equivalent of Ethereum's smart contracts, it is essentially an 'object' in the filecoin network with state and a set of methods that can be used to interact with it. Every actor has a Filecoin balance attributed to it, a `state` pointer, a `code` CID which tells the system what type of actor it is, and a `nonce` which tracks the number of messages sent by this actor. (TODO: the nonce is really only needed for external user interface actors, AKA `account actors`. Maybe we should find a way to clean that up?) - -There are two routes to calling a method on an `actor`. First, to call a method as an external participant of the system (aka, a normal user with Filecoin) you must send a signed `message` to the network, and pay a fee to the miner that includes your `message`. The signature on the message must match the key associated with an account with sufficient Filecoin to pay for the messages execution. The fee here is equivalent to transaction fees in Bitcoin and Ethereum, where it is proportional to the work that is done to process the message (Bitcoin prices messages per byte, Ethereum uses the concept of 'gas'. We also use 'gas'). - -Second, an `actor` may call a method on another actor during the invocation of one of its methods. However, the only time this may happen is as a result of some actor being invoked by an external users message (note: an actor called by a user may call another actor that then calls another actor, as many layers deep as the execution can afford to run for). - -For full implementation details, see the {{}}. diff --git a/src/intro/process/_index.md b/src/intro/process/_index.md deleted file mode 100644 index 557e8cade..000000000 --- a/src/intro/process/_index.md +++ /dev/null @@ -1,47 +0,0 @@ ---- -menuTitle: Process -title: Filecoin Spec Process (v1) -entries: -- about -- fip -- contributing -- related_resources ---- - -# 🚀 Pre-launch mode - -Until we launch, we are making lots of changes to the spec to finish documenting the current version of the protocol. Changes will be made to the spec by a simple PR process, with approvals by key stakeholders. Some refinements are still to happen and testnet is expected to bring a few significant fixes/improvements. Most changes now are changing _the document_, **NOT** changing _the protocol_, at least not in a major way. - -Until we launch, if something is missing, PR it in. If something is wrong, PR a fix. If something needs to be elaborated, PR in updates. What is in the top level of this repo, in master, is the spec, is the Filecoin Protocol. Nothing else matters (ie. no other documents, issues contain "the protocol"). - -# New Proposals -> Drafts -> Spec - -{{% notice warning %}} -⚠️ **WARNING:** Filecoin is in pre-launch mode, and we are finishing protocol spec and implementations of the _current_ construction/version of the protocol only. We are highly unlikely to merge anything new into the Filecoin Protocol until after mainnet. Feel free to explore ideas anyway and prepare improvements for the future. -{{% /notice %}} - -For anything that is not part of the currently speced systems (like 'repair', for example) the process we will use is: - -- **(1) First, discuss the problem(s) and solution(s) in an issue** - - Or several issues, if the space is large and multithreaded enough. - - Work out all the details required to make this proposal work. -- **(2) Write a draft with all the details.** - - When you feel like a solution is near, write up a draft document that contains all the details, and includes what changes would need to happen to the spec - - E.g. "Add a System called X with ...", or "Add a library called Y, ...", or "Modify vm/state_tree to include ..." - - Place this document inside the `src/drafts/` directory. - - Anybody is welcome to contribute well-reasoned and detailed drafts. - - (Note: these drafts will give way to FIPs in the future) -- **(3) Seek approval to merge this into the specification.** - - To seek approval, open an issue and discuss it. - - If the draft is approved by the owners of the filecoin-spec, then the changes to the spec will need to be made in a PR. - - Once changes make it into the spec, remove the draft. - -It is acceptable for a PR for a draft to stay open for quite a while, as thought and discussion on the topic happens. At some point, if the reviewers and the author feel that the current state of the draft is stable enough (though not 'done') then it should be merged into the repo. Further changes to the draft are additional PRs, which may generate more discussion. Comments on these drafts are welcome from anyone, but if you wish to be involved in the actual research process, you will need to devote very considerable time and energy to the process. - -# On merging - -For anything in the drafts or notes folder, merge yourself after a review from a relevant person. For anything in the top level (canonical spec), @zixuanzh, @anorth, @whyrusleeping or @jbenet will merge after proper review. - -# Issues - -Issues in the specs repo will be high signal. They will either be proposals or issues directly relating to problems in the spec. More speculative research questions and discussion will happen in the research repo. diff --git a/src/intro/process/about.md b/src/intro/process/about.md deleted file mode 100644 index c3a4cfa89..000000000 --- a/src/intro/process/about.md +++ /dev/null @@ -1,6 +0,0 @@ ---- -menuTitle: About -title: "About this specification" ---- - -TODO diff --git a/src/intro/process/contributing.md b/src/intro/process/contributing.md deleted file mode 100644 index 6455309b6..000000000 --- a/src/intro/process/contributing.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -menuTitle: Contributing -title: "Contributing to the Filecoin spec" ---- - -## Adding new sections - -The specification is broken down into 5 levels (`#.#.#.#.#`). The L1 and L2 numbers in this sequence are determined by the first two directories extending from `/src/`; for example, `/src/systems/filecoin_mining/` resolves to `2.6.`. - -The L3 number is generated by creating an additional directory within a L2 directory, containing its own appropriately formatted `index.md`. This new directory name must then be added to the `entries` field of the L2 `index.md` file, sequentially ordered as they are to be within the specification. - -Further L4 and L5 subsections are added using the `##` and `###` headers respectively within a the content of a L3 section's `index.md` file. diff --git a/src/intro/process/fip.md b/src/intro/process/fip.md deleted file mode 100644 index 4f3e55093..000000000 --- a/src/intro/process/fip.md +++ /dev/null @@ -1,6 +0,0 @@ ---- -menuTitle: FIPs -title: "FIPs - Filecoin Improvement Proposals" ---- - -TODO diff --git a/src/intro/process/related_resources/_index.md b/src/intro/process/related_resources/_index.md deleted file mode 100644 index 0c82a06be..000000000 --- a/src/intro/process/related_resources/_index.md +++ /dev/null @@ -1,9 +0,0 @@ ---- -title: "Related Resources" -entries: - - research_portal - - network_tooling - - testing ---- - -TODO diff --git a/src/intro/process/related_resources/network_tooling.md b/src/intro/process/related_resources/network_tooling.md deleted file mode 100644 index 344a5ef28..000000000 --- a/src/intro/process/related_resources/network_tooling.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "Network tooling" ---- - -TODO diff --git a/src/intro/process/related_resources/research_portal.md b/src/intro/process/related_resources/research_portal.md deleted file mode 100644 index 8d8243f2d..000000000 --- a/src/intro/process/related_resources/research_portal.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "Research portal" ---- - -TODO diff --git a/src/intro/process/related_resources/testing.md b/src/intro/process/related_resources/testing.md deleted file mode 100644 index 381c33438..000000000 --- a/src/intro/process/related_resources/testing.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "Testing and implementation compliance" ---- - -TODO diff --git a/src/intro/system/_index.md b/src/intro/system/_index.md deleted file mode 100644 index dd2aceb03..000000000 --- a/src/intro/system/_index.md +++ /dev/null @@ -1,7 +0,0 @@ ---- -menuTitle: System Decomposition -title: System Decomposition -entries: -- why_systems -- impl_systems ---- diff --git a/src/intro/system/impl_systems.md b/src/intro/system/impl_systems.md deleted file mode 100644 index 05730b527..000000000 --- a/src/intro/system/impl_systems.md +++ /dev/null @@ -1,56 +0,0 @@ ---- -menuTitle: Implementing Systems -title: Implementing Systems ---- - -# System Requirements - -In order to make it easier to decouple functionality into systems, the Filecoin Protocol assumes -a set of functionality available to all systems. This functionality can be achieved by implementations -in a variety of ways, and should take the guidance here as a recommendation (SHOULD). - -All Systems, as defined in this document, require the following: - -- **Repository:** - - **Local `IpldStore`.** Some amount of persistent local storage for data structures (small structured objects). - Systems expect to be initialized with an IpldStore in which to store data structures they expect to persist across crashes. - - **User Configuration Values.** A small amount of user-editable configuration values. - These should be easy for end-users to access, view, and edit. - - **Local, Secure `KeyStore`.** A facility to use to generate and use cryptographic keys, which MUST remain secret to the - Filecoin Node. Systems SHOULD NOT access the keys directly, and should do so over an abstraction (ie the `KeyStore`) which - provides the ability to Encrypt, Decrypt, Sign, SigVerify, and more. -- **Local `FileStore`.** Some amount of persistent local storage for files (large byte arrays). - Systems expect to be initialized with a FileStore in which to store large files. - Some systems (like Markets) may need to store and delete large volumes of smaller files (1MB - 10GB). - Other systems (like Storage Mining) may need to store and delete large volumes of large files (1GB - 1TB). -- **Network.** Most systems need access to the network, to be able to connect to their counterparts in other Filecoin Nodes. - Systems expect to be initialized with a `libp2p.Node` on which they can mount their own protocols. -- **Clock.** Some systems need access to current network time, some with low tolerance for drift. - Systems expect to be initialized with a Clock from which to tell network time. Some systems (like Blockchain) - require very little clock drift, and require _secure_ time. - -For this purpose, we use the `FilecoinNode` data structure, which is passed into all systems at initialization: - -{{< readfile file="../../systems/filecoin_nodes/node_base/filecoin_node.id" code="true" lang="go" >}} - -{{< readfile file="../../systems/filecoin_nodes/repository/repository_subsystem.id" code="true" lang="go" >}} - -# System Limitations - -Further, Systems MUST abide by the following limitations: - -- **Random crashes.** A Filecoin Node may crash at any moment. Systems must be secure and consistent through crashes. - This is primarily achived by limiting the use of persistent state, persisting such state through Ipld data structures, - and through the use of initialization routines that check state, and perhaps correct errors. -- **Isolation.** Systems must communicate over well-defined, isolated interfaces. They must not build their critical - functionality over a shared memory space. (Note: for performance, shared memory abstractions can be used to power - IpldStore, FileStore, and libp2p, but the systems themselves should not require it.) This is not just an operational - concern; it also significantly simplifies the protocol and makes it easier to understand, analyze, debug, and change. -- **No direct access to host OS Filesystem or Disk.** Systems cannot access disks directly -- they do so over the FileStore - and IpldStore abstractions. This is to provide a high degree of portability and flexibility for end-users, especially - storage miners and clients of large amounts of data, which need to be able to easily replace how their Filecoin Nodes - access local storage. -- **No direct access to host OS Network stack or TCP/IP.** Systems cannot access the network directly -- they do so over the - libp2p library. There must not be any other kind of network access. This provides a high degree of portability across - platforms and network protocols, enabling Filecoin Nodes (and all their critical systems) to run in a wide variety of - settings, using all kinds of protocols (eg Bluetooth, LANs, etc). diff --git a/src/intro/system/system.id b/src/intro/system/system.id deleted file mode 100644 index e69de29bb..000000000 diff --git a/src/intro/system/why_systems.md b/src/intro/system/why_systems.md deleted file mode 100644 index 60b7f85a9..000000000 --- a/src/intro/system/why_systems.md +++ /dev/null @@ -1,75 +0,0 @@ ---- -menuTitle: What are Systems? -title: What are Systems? How do they work? ---- - - -Filecoin decouples and modularizes functionality into loosely-joined `systems`. -Each system adds significant functionality, usually to achieve a set of important and tightly related goals. - -For example, the Blockchain System provides structures like Block, Tipset, and Chain, and provides functionality -like Block Sync, Block Propagation, Block Validation, Chain Selection, and Chain Access. This is -separated from the Files, Pieces, Piece Preparation, and Data Transfer. Both of these systems are separated from -the Markets, which provide Orders, Deals, Market Visibility, and Deal Settlement. - -# Why is System decoupling useful? - -This decoupling is useful for: - -- **Implementation Boundaries:** it is possible to build implementations of Filecoin that only implement a - subset of systems. This is especially useful for _Implementation Diversity_: we want many implementations - of security critical systems (eg Blockchain), but do not need many implementations of Systems that can be - decoupled. -- **Runtime Decoupling:** system decoupling makes it easier to build and run Filecoin Nodes that isolate - Systems into separate programs, and even separate physical computers. -- **Security Isolation:** some systems require higher operational security than others. System decoupling allows - implementations to meet their security and functionality needs. A good example of this is separating Blockchain - processing from Data Transfer. -- **Scalability:** systems, and various use cases, may drive different performance requirements for different opertators. - System decoupling makes it easier for operators to scale their deployments along system boundaries. - - -# Filecoin Nodes don't need all the systems - -Filecoin Nodes vary significantly, and do not need all the systems. -Most systems are only needed for a subset of use cases. - -For example, the Blockchain System is required for synchronizing the chain, participating in secure consensus, -storage mining, and chain validation. -Many Filecoin Nodes do not need the chain and can perform their work by just fetching content from the latest -StateTree, from a node they trust. - -Note: Filecoin does not use the "full node" or "light client" terminology, in wide use in Bitcoin and other blockchain -networks. In filecoin, these terms are not well defined. It is best to define nodes in terms of their capabilities, -and therefore, in terms of the Systems they run. For example: - -- **Chain Verifier Node:** Runs the Blockchain system. Can sync and validate the chain. Cannot mine or produce blocks. -- **Client Node:** Runs the Blockchain, Market, and Data Transfer systems. Can sync and validate the chain. Cannot mine or produce blocks. -- **Retrieval Miner Node:** Runs the Market and Data Transfer systems. Does not need the chain. Can make Retrieval Deals - (Retrieval Provider side). Can send Clients data, and get paid for it. -- **Storage Miner Node:** Runs the Blockchain, Storage Market, Storage Mining systems. Can sync and validate the chain. - Can make Storage Deals (Storage Provider side). Can seal stored data into sectors. Can acquire - storage consensus power. Can mine and produce blocks. - -# Separating Systems - -> How do we determine what functionality belongs in one system vs another? - -Drawing boundaries between systems is the art of separating tightly related functionality from unrelated parts. -In a sense, we seek to keep tightly integrated components in the same system, and away from other unrelated -components. This is sometimes straightforward, the boundaries naturally spring from the data structures or -functionality. For example, it is straightforward to observe that Clients and Miners negotiating a deal -with each other is very unrelated to VM Execution. - -Sometimes this is harder, and it requires detangling, adding, or removing abstractions. For -example, the `StoragePowerActor` and the `StorageMarketActor` were a single `Actor` previously. This caused -a large coupling of functionality across `StorageDeal` making, the `StorageMarket`, markets in general, with -Storage Mining, Sector Sealing, PoSt Generation, and more. Detangling these two sets of related functionality -requried breaking apart the one actor into two. - -# Decomposing within a System - -Systems themselves decompose into smaller subunits. These are sometimes called "subsystems" to avoid confusion -with the much larger, first-class Systems. Subsystems themselves may break down further. The naming here is not -strictly enforced, as these subdivisions are more related to protocol and implementation engineering concerns -than to user capabilities. diff --git a/src/intro/underconstruction.gif b/src/intro/underconstruction.gif deleted file mode 100644 index 7d0345098..000000000 Binary files a/src/intro/underconstruction.gif and /dev/null differ diff --git a/src/libraries/_index.md b/src/libraries/_index.md deleted file mode 100644 index 0b9353436..000000000 --- a/src/libraries/_index.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -menuTitle: Libraries -title: Libraries used in Filecoin -entries: -- filcrypto -- fcs -- ipld -- libp2p -- ipfs -- multiformats ---- - -{{< incTocMap "/docs/libraries" >}} diff --git a/src/libraries/fcs/_index.md b/src/libraries/fcs/_index.md deleted file mode 100644 index 2169f6d0e..000000000 --- a/src/libraries/fcs/_index.md +++ /dev/null @@ -1,3 +0,0 @@ ---- -title: FCS ---- diff --git a/src/libraries/filcrypto/_index.md b/src/libraries/filcrypto/_index.md deleted file mode 100644 index ed5b6f45f..000000000 --- a/src/libraries/filcrypto/_index.md +++ /dev/null @@ -1,8 +0,0 @@ ---- -menuTitle: Filcrypto -title: Cryptographic libraries used in Filecoin -entries: -- filproofs ---- - -{{< incTocMap "/docs/libraries/filcrypto" >}} diff --git a/src/libraries/filcrypto/filproofs/_index.md b/src/libraries/filcrypto/filproofs/_index.md deleted file mode 100644 index 15c4556e2..000000000 --- a/src/libraries/filcrypto/filproofs/_index.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -menuTitle: filproofs -title: filproofs - Filecoin Storage Proofs ---- - -{{< readfile file="filecoin_proofs_subsystem.id" code="true" lang="go" >}} - -{{< readfile file="algorithms.id" code="true" lang="go" >}} - -{{< readfile file="algorithms.go" code="true" lang="go" >}} diff --git a/src/libraries/filcrypto/filproofs/algorithms.go b/src/libraries/filcrypto/filproofs/algorithms.go deleted file mode 100644 index ea717dc98..000000000 --- a/src/libraries/filcrypto/filproofs/algorithms.go +++ /dev/null @@ -1,835 +0,0 @@ -package filproofs - -import ( - "bytes" - "errors" - "fmt" - "math" - "math/rand" - - "encoding/binary" - big "math/big" - - abi "github.com/filecoin-project/specs-actors/actors/abi" - file "github.com/filecoin-project/specs/systems/filecoin_files/file" - sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector" - sector_index "github.com/filecoin-project/specs/systems/filecoin_mining/sector_index" - util "github.com/filecoin-project/specs/util" - cid "github.com/ipfs/go-cid" -) - -type Bytes32 []byte -type UInt = util.UInt -type PieceInfo = abi.PieceInfo -type Label Bytes32 -type Commitment = sector.Commitment -type PrivatePostCandidateProof = abi.PrivatePoStCandidateProof -type SectorSize = abi.SectorSize -type RegisteredProof = abi.RegisteredProof - -const WRAPPER_LAYER_WINDOW_INDEX = -1 - -const NODE_SIZE = 32 -const ELECTION_POST_PARTITIONS = 1 -const SURPRISE_POST_PARTITIONS = 1 -const POST_LEAF_CHALLENGE_COUNT = 66 -const POST_CHALLENGE_RANGE_SIZE = 1 - -const GIB_32 = 32 * 1024 * 1024 * 1024 - -var PROOFS ProofRegistry = ProofRegistry(map[util.UInt]ProofInstance{util.UInt(abi.RegisteredProof_WinStackedDRG32GiBSeal): &ProofInstance_I{ - ID_: abi.RegisteredProof_WinStackedDRG32GiBSeal, - Type_: ProofType_SealProof, - CircuitType_: &ConcreteCircuit_I{ - Name_: "HASHOFCIRCUITPARAMETERS1", - }, -}, - util.UInt(abi.RegisteredProof_WinStackedDRG32GiBPoSt): &ProofInstance_I{ - ID_: abi.RegisteredProof_WinStackedDRG32GiBPoSt, - Type_: ProofType_PoStProof, - CircuitType_: &ConcreteCircuit_I{ - Name_: "HASHOFCIRCUITPARAMETERS2", - }, - Cfg_: ProofCfg_Make_PoStCfg(&PoStInstanceCfg_I{}), - // FIXME: integrate - // return sector.PoStInstanceCfg_Make_PoStCfgV1(§or.PoStCfgV1_I{ - // Type_: pType, - // Nodes_: nodes, - // Partitions_: partitions, - // LeafChallengeCount_: POST_LEAF_CHALLENGE_COUNT, - // ChallengeRangeSize_: POST_CHALLENGE_RANGE_SIZE, - // }).Impl() - - }, - util.UInt(abi.RegisteredProof_StackedDRG32GiBSeal): &ProofInstance_I{ - ID_: abi.RegisteredProof_StackedDRG32GiBSeal, - Type_: ProofType_SealProof, - CircuitType_: &ConcreteCircuit_I{ - Name_: "HASHOFCIRCUITPARAMETERS3", - }, - }, - util.UInt(abi.RegisteredProof_StackedDRG32GiBPoSt): &ProofInstance_I{ - ID_: abi.RegisteredProof_StackedDRG32GiBPoSt, - Type_: ProofType_PoStProof, - CircuitType_: &ConcreteCircuit_I{ - Name_: "HASHOFCIRCUITPARAMETERS4", - }, - }, -}) - -func RegisteredProofInstance(r RegisteredProof) ProofInstance { - return PROOFS[util.UInt(r)] -} - -func (c *ConcreteCircuit_I) GrothParameterFileName() string { - return c.Name() + ".params" -} - -func (c *ConcreteCircuit_I) VerifyingKeyFileName() string { - return c.Name() + ".vk" -} - -func (cfg *SealInstanceCfg_I) SectorSize() SectorSize { - switch cfg.Which() { - case SealInstanceCfg_Case_WinStackedDRGCfgV1: - { - return cfg.As_WinStackedDRGCfgV1().SectorSize() - } - } - panic("TODO") -} - -func PoStCfg(pType PoStType, sectorSize SectorSize, partitions UInt) RegisteredProof { - return abi.RegisteredProof_WinStackedDRG32GiBPoSt -} - -func MakeSealVerifier(registeredProof abi.RegisteredProof) *SealVerifier_I { - return &SealVerifier_I{ - SealCfg_: RegisteredProofInstance(registeredProof).Cfg().As_SealCfg(), - } -} - -func SurprisePoStCfg(sectorSize SectorSize) RegisteredProof { - return PoStCfg(PoStType_SurprisePoSt, sectorSize, SURPRISE_POST_PARTITIONS) -} - -func ElectionPoStCfg(sectorSize SectorSize) RegisteredProof { - return PoStCfg(PoStType_ElectionPoSt, sectorSize, ELECTION_POST_PARTITIONS) -} - -func MakeElectionPoStVerifier(registeredProof RegisteredProof) *PoStVerifier_I { - return &PoStVerifier_I{ - PoStCfg_: RegisteredProofInstance(registeredProof).Cfg().As_PoStCfg(), - } -} - -func MakeSurprisePoStVerifier(registeredProof RegisteredProof) *PoStVerifier_I { - return &PoStVerifier_I{ - PoStCfg_: RegisteredProofInstance(registeredProof).Cfg().As_PoStCfg(), - } -} - -func (drg *DRG_I) Parents(node UInt) []UInt { - config := drg.Config() - degree := UInt(config.Degree()) - return DRGAlgorithmComputeParents(config.Algorithm().ParentsAlgorithm(), degree, node) -} - -// TODO: Verify this. Both the port from impl and the algorithm. -func DRGAlgorithmComputeParents(alg DRGCfg_Algorithm_ParentsAlgorithm, degree UInt, node UInt) (parents []UInt) { - switch alg { - case DRGCfg_Algorithm_ParentsAlgorithm_DRSample: - util.Assert(node > 0) - parents = append(parents, node-1) - - m := degree - 1 - - var k UInt - for k = 0; k < m; k++ { - logi := int(math.Floor(math.Log2(float64(node * m)))) - // FIXME: Make RNG parameterizable and specify it. - j := rand.Intn(logi) - jj := math.Min(float64(node*m+k), float64(UInt(1)<>1), 2)), int(jj+1)) - out := (node*m + k - backDist) / m - - parents = append(parents, out) - } - - return parents - - default: - panic(fmt.Sprintf("DRG algorithm not supported: %v", alg)) - } -} - -func randInRange(lowInclusive int, highExclusive int) UInt { - // NOTE: current implementation uses a more sophisticated method for repeated sampling within a range. - // We need to converge on and fully specify the actual method, since this must be deterministic. - return UInt(rand.Intn(highExclusive-lowInclusive) + lowInclusive) -} - -func (exp *ExpanderGraph_I) Parents(node UInt) []UInt { - d := exp.Config().Degree() - - // TODO: How do we handle choice of algorithm generically? - return exp.Config().Algorithm().As_ChungExpanderAlgorithm().Parents(node, d, exp.Config().Nodes()) -} - -func (chung *ChungExpanderAlgorithm_I) Parents(node UInt, d ExpanderGraphDegree, nodes ExpanderGraphNodeCount) []UInt { - var parents []UInt - var i UInt - for i = 0; i < UInt(d); i++ { - parent := chung._ithParent(node, i, d, nodes) - parents = append(parents, parent) - } - return parents -} - -func (chung *ChungExpanderAlgorithm_I) _ithParent(node UInt, i UInt, degree ExpanderGraphDegree, nodes ExpanderGraphNodeCount) UInt { - // ithParent generates one of d parents of node. - d := UInt(degree) - - // This is done by operating on permutations of a set with d elements per node. - setSize := UInt(nodes) * d - - // There are d ways of mapping each node into the set, and we choose the ith. - // Note that we can project the element back to the original node: element / d == node. - element := node*d + i - - // Permutations of the d elements corresponding to each node yield d new elements, - permuted := chung.PermutationAlgorithm().As_Feistel().Permute(setSize, element) - - // each of which can be projected back to a node. - projected := permuted / d - - // We have selected the ith such parent of node. - return projected -} - -func (f *Feistel_I) Permute(size UInt, i UInt) UInt { - // Call into feistel.go. - panic("TODO") -} - -func getProverID(minerID abi.ActorID) []byte { - // return leb128(minerID) - panic("TODO") -} - -func computeSealSeed(sid abi.SectorID, randomness abi.SealRandomness, commD abi.UnsealedSectorCID) sector.SealSeed { - proverId := getProverID(sid.Miner) - sectorNumber := sid.Number - - var preimage []byte - preimage = append(preimage, proverId...) - preimage = append(preimage, bigEndianBytesFromUInt(UInt(sectorNumber), 8)...) - preimage = append(preimage, randomness...) - preimage = append(preimage, Commitment_UnsealedSectorCID(commD)...) - - sealSeed := HashBytes_SHA256Hash(preimage) - return sector.SealSeed(sealSeed) -} - -func generateSDRKeyLayers(drg *DRG_I, expander *ExpanderGraph_I, sealSeed sector.SealSeed, window int, nodes int, layers int, nodeSize int, modulus big.Int) [][]byte { - var keyLayers [][]byte - var prevLayer []byte - - for i := 0; i < layers; i++ { - currentLayer := labelLayer(drg, expander, sealSeed, window, nodeSize, nodes, prevLayer) - keyLayers = append(keyLayers, currentLayer) - prevLayer = currentLayer - } - - return keyLayers -} - -func labelLayer(drg *DRG_I, expander *ExpanderGraph_I, sealSeed sector.SealSeed, window int, nodeSize int, nodes int, prevLayer []byte) []byte { - size := nodes * nodeSize - labels := make([]byte, size) - - for i := 0; i < nodes; i++ { - var parents []Label - - // The first node of every layer has no DRG Parents. - if i > 0 { - for parent := range drg.Parents(UInt(i)) { - start := parent * nodeSize - parents = append(parents, labels[start:start+nodeSize]) - } - } - - // The first layer has no expander parents. - if prevLayer != nil { - for parent := range expander.Parents(UInt(i)) { - start := parent * nodeSize - parents = append(parents, prevLayer[start:start+nodeSize]) - } - } - - label := generateLabel(sealSeed, i, window, parents) - labels = append(labels, label...) - } - - return labels -} - -// Encodes data in-place, mutating it. -func encodeDataInPlace(data []byte, key []byte, nodeSize int, modulus *big.Int) []byte { - if len(data) != len(key) { - panic("Key and data must be same length.") - } - - for i := 0; i < len(data); i += nodeSize { - copy(data[i:i+nodeSize], encodeNode(data[i:i+nodeSize], key[i:i+nodeSize], modulus, nodeSize)) - } - - return data -} - -func generateLabel(sealSeed sector.SealSeed, node int, window int, dependencies []Label) []byte { - preimage := sealSeed - - if window != WRAPPER_LAYER_WINDOW_INDEX { - windowBytes := make([]byte, 8) - binary.LittleEndian.PutUint64(windowBytes, uint64(window)) - - preimage = append(preimage, windowBytes...) - } - - nodeBytes := make([]byte, 8) - binary.LittleEndian.PutUint64(nodeBytes, uint64(node)) - - preimage = append(preimage, nodeBytes...) - for _, dependency := range dependencies { - preimage = append(preimage, dependency...) - } - - return deriveLabel(preimage) -} - -func deriveLabel(elements []byte) []byte { - return trimToFr32(HashBytes_SHA256Hash(elements)) -} - -func computeCommC(keyLayers [][]byte, nodeSize int) (PedersenHash, file.Path) { - leaves := make([]byte, len(keyLayers[0])) - - // For each node in the graph, - for start := 0; start < len(leaves); start += nodeSize { - end := start + nodeSize - - var column []Label - // Concatenate that node's label at each layer, in order, into a column. - for i := 0; i < len(keyLayers); i++ { - label := keyLayers[i][start:end] - column = append(column, label) - } - - // And hash that column to create the leaf of a new tree. - hashed := hashColumn(column) - copy(leaves[start:end], hashed[:]) - } - - // Return the root of and path to the column tree. - return BuildTree_PedersenHash(leaves) -} - -func computeCommQ(layerBytes []byte, nodeSize int) (PedersenHash, file.Path) { - leaves := make([]byte, len(layerBytes)/nodeSize) - for i := 0; i < len(leaves); i++ { - leaves = append(leaves, layerBytes[i*nodeSize:(i+1)*nodeSize]...) - } - - return BuildTree_PedersenHash(leaves) -} - -func hashColumn(column []Label) PedersenHash { - var preimage []byte - for _, label := range column { - preimage = append(preimage, label...) - } - return HashBytes_PedersenHash(preimage) -} - -func createColumnProofs(drg *DRG_I, expander *ExpanderGraph_I, challenge UInt, nodeSize UInt, columnTree MerkleTree, aux sector.ProofAuxTmp, windows int, windowSize int) []SDRColumnProof { - columnElements := getColumnElements(drg, expander, challenge) - - var columnProofs []SDRColumnProof - for c := range columnElements { - chall := UInt(c) - - columnProof := createColumnProof(chall, nodeSize, windows, windowSize, columnTree, aux) - columnProofs = append(columnProofs, columnProof) - } - - return columnProofs -} - -func createWindowProof(drg *DRG_I, expander *ExpanderGraph_I, challenge UInt, nodeSize UInt, dataTree MerkleTree, columnTree MerkleTree, qLayerTree MerkleTree, aux sector.ProofAuxTmp, windows int, windowSize int) (proof OfflineWindowProof) { - columnElements := getColumnElements(drg, expander, challenge) - - var columnProofs []SDRColumnProof - for c := range columnElements { - chall := UInt(c) - - columnProof := createColumnProof(chall, nodeSize, windows, windowSize, columnTree, aux) - columnProofs = append(columnProofs, columnProof) - } - - dataProof := dataTree.ProveInclusion(challenge) - qLayerProof := qLayerTree.ProveInclusion(challenge) - - proof = OfflineWindowProof{ - DataProof: dataProof, - QLayerProof: qLayerProof, - } - - return proof -} - -func createWrapperProof(drg *DRG_I, expander *ExpanderGraph_I, sealSeed sector.SealSeed, challenge UInt, nodeSize UInt, qTree MerkleTree, replicaTree MerkleTree, aux sector.ProofAuxTmp, windows int, windowSize int) (proof OfflineWrapperProof) { - proof.ReplicaProof = replicaTree.ProveInclusion(challenge) - - parents := expander.Parents(challenge) - - for _, parent := range parents { - proof.QLayerProofs = append(proof.QLayerProofs, qTree.ProveInclusion(parent)) - } - return proof -} - -func getColumnElements(drg *DRG_I, expander *ExpanderGraph_I, challenge UInt) (columnElements []UInt) { - columnElements = append(columnElements, challenge) - columnElements = append(columnElements, drg.Parents(challenge)...) - columnElements = append(columnElements, expander.Parents(challenge)...) - - return columnElements -} - -func createColumnProof(c UInt, nodeSize UInt, windowSize int, windows int, columnTree MerkleTree, aux sector.ProofAuxTmp) (columnProof SDRColumnProof) { - layers := aux.KeyLayers() - var column []Label - - for w := 0; w < windows; w++ { - for i := 0; i < len(layers); i++ { - start := (w * windowSize) + int(c) - end := start + int(nodeSize) - column = append(column, layers[i][start:end]) - } - } - columnProof = SDRColumnProof{ - Column: column, - InclusionProof: columnTree.ProveInclusion(c), - } - - return columnProof -} - -type PrivateOfflineProof struct { - ColumnProofs []SDRColumnProof - WindowProofs []OfflineWindowProof - WrapperProofs []OfflineWrapperProof -} - -type OfflineWindowProof struct { - // TODO: these proofs need to depend on hash function. - DataProof InclusionProof // SHA256 - QLayerProof InclusionProof -} - -type OfflineWrapperProof struct { - ReplicaProof InclusionProof // Pedersen - QLayerProofs []InclusionProof -} - -func (ip *InclusionProof_I) Leaf() []byte { - panic("TODO") -} - -func (ip *InclusionProof_I) LeafIndex() UInt { - panic("TODO") -} - -func (ip *InclusionProof_I) Root() Commitment { - panic("TODO") -} - -func (mt *MerkleTree_I) ProveInclusion(challenge UInt) InclusionProof { - panic("TODO") -} - -func (mt *MerkleTree_I) Leaf(index UInt) []byte { - panic("TODO") -} - -func LoadMerkleTree(path file.Path) MerkleTree { - panic("TODO") -} - -func (ip *InclusionProof_I) Verify(root []byte, challenge UInt) bool { - // FIXME: need to verify proof length of private inclusion proofs. - panic("TODO") -} - -type SDRColumnProof struct { - Column []Label - InclusionProof InclusionProof -} - -func (proof *SDRColumnProof) Verify(root []byte, challenge UInt) bool { - if !bytes.Equal(hashColumn(proof.Column), proof.InclusionProof.Leaf()) { - return false - } - - if proof.InclusionProof.LeafIndex() != challenge { - return false - } - - return proof.InclusionProof.Verify(root, challenge) -} - -func generateOfflineChallenges(challengeRange int, sealSeed sector.SealSeed, randomness abi.InteractiveSealRandomness, challengeCount int) []UInt { - var challenges []UInt - challengeRangeSize := challengeRange - 1 // Never challenge the first node. - challengeModulus := new(big.Int) - challengeModulus.SetUint64(uint64(challengeRangeSize)) - - // Maybe factor this into a separate function, since the logic is the same... - - for i := 0; i < challengeCount; i++ { - var preimage []byte - preimage = append(preimage, sealSeed...) - preimage = append(preimage, randomness...) - preimage = append(preimage, littleEndianBytesFromInt(i, 4)...) - - hash := HashBytes_SHA256Hash(preimage) - bigChallenge := bigIntFromLittleEndianBytes(hash) - bigChallenge = bigChallenge.Mod(bigChallenge, challengeModulus) - - // Sectors nodes must be 64-bit addressable, always a safe assumption. - challenge := bigChallenge.Uint64() - challenge += 1 // Never challenge the first node. - challenges = append(challenges, challenge) - } - return challenges -} - -func encodeNode(data []byte, key []byte, modulus *big.Int, nodeSize int) []byte { - // TODO: Make this a method of WinStackedDRG. - return addEncode(data, key, modulus, nodeSize) -} - -func addEncode(data []byte, key []byte, modulus *big.Int, nodeSize int) []byte { - - d := bigIntFromLittleEndianBytes(data) - k := bigIntFromLittleEndianBytes(key) - - sum := new(big.Int).Add(d, k) - result := new(big.Int).Mod(sum, modulus) - - return littleEndianBytesFromBigInt(result, nodeSize) -} - -//////////////////////////////////////////////////////////////////////////////// -// Seal Verification - -func (sv *SealVerifier_I) VerifySeal(svi abi.SealVerifyInfo) bool { - switch svi.OnChain.RegisteredProof { - case abi.RegisteredProof_WinStackedDRG32GiBSeal: - { - sdr := WinSDRParams(svi.OnChain.RegisteredProof) - - return sdr.VerifySeal(svi) - } - case abi.RegisteredProof_StackedDRG32GiBSeal: - { - panic("TODO") - } - } - - return false -} - -func ComputeUnsealedSectorCIDFromPieceInfos(sectorSize abi.SectorSize, pieceInfos []PieceInfo) (unsealedCID abi.UnsealedSectorCID, err error) { - rootPieceInfo := computeRootPieceInfo(pieceInfos) - rootSize := uint64(rootPieceInfo.Size) - - if rootSize != uint64(sectorSize) { - return unsealedCID, errors.New("Wrong sector size.") - } - - return UnsealedSectorCID(rootPieceInfo.PieceCID.Bytes()), nil -} - -func computeRootPieceInfo(pieceInfos []PieceInfo) PieceInfo { - // Construct root PieceInfo by (shift-reduce) parsing the constituent PieceInfo array. - // Later pieces must always be joined with equal-sized predecessors to create a new root twice their size. - // So if a piece is larger than the current root (top of stack), add padding until it is not. - // If a piece is smaller than the root, let it be the new root (top of stack) until reduced to a replacement that can be joined - // with the previous. - var stack []PieceInfo - - shift := func(p PieceInfo) { - stack = append(stack, p) - } - peek := func() PieceInfo { - return stack[len(stack)-1] - } - peek2 := func() PieceInfo { - return stack[len(stack)-2] - } - pop := func() PieceInfo { - stack = stack[:len(stack)-1] - return stack[len(stack)-1] - } - reduce1 := func() bool { - if len(stack) > 1 && peek().Size == peek2().Size { - right := pop() - left := pop() - joined := joinPieceInfos(left, right) - shift(joined) - return true - } - return false - } - reduce := func() { - for reduce1() { - } - } - shiftReduce := func(p PieceInfo) { - shift(p) - reduce() - } - - // Prime the pump with first pieceInfo. - shift(pieceInfos[0]) - - // Consume the remainder. - for _, pieceInfo := range pieceInfos[1:] { - // TODO: Assert that pieceInfo.Size is a power of 2. - - // Add padding until top of stack is large enough to receive current pieceInfo. - for peek().Size < pieceInfo.Size { - shiftReduce(zeroPadding(peek().Size)) - } - - // Add the current piece. - shiftReduce(pieceInfo) - } - - // Add any necessary final padding. - for len(stack) > 1 { - shiftReduce(zeroPadding(peek().Size)) - } - util.Assert(len(stack) == 1) - - return pop() -} - -func zeroPadding(size int64) PieceInfo { - return abi.PieceInfo{ - Size: size, - // CommP_: FIXME: Implement. - } -} - -func joinPieceInfos(left PieceInfo, right PieceInfo) PieceInfo { - util.Assert(left.Size == right.Size) - - // FIXME: make this whole function generic? - // Note: cid.Bytes() isn't actually the payload data that we want input to the binary hash function, for more - // information see discussion: https://filecoinproject.slack.com/archives/CHMNDCK9P/p1578629688082700 - sectorPieceCID, err := cid.Cast(BinaryHash_SHA256Hash(cid.Cid(left.PieceCID).Bytes(), cid.Cid(right.PieceCID).Bytes())) - util.Assert(err == nil) - - return abi.PieceInfo{ - Size: left.Size + right.Size, - PieceCID: abi.PieceCID(sectorPieceCID), - } -} - -//////////////////////////////////////////////////////////////////////////////// -// PoSt - -func getChallengedSectors(sectorIDs []abi.SectorID, randomness abi.PoStRandomness, eligibleSectors []abi.SectorID, candidateCount int) (sectors []abi.SectorID) { - for i := 0; i < candidateCount; i++ { - sector := generateSectorChallenge(randomness, i, sectorIDs) - sectors = append(sectors, sector) - } - - return sectors -} - -func generateSectorChallenge(randomness abi.PoStRandomness, n int, sectorIDs []abi.SectorID) (sector abi.SectorID) { - preimage := append(randomness, littleEndianBytesFromInt(n, 8)...) - hash := SHA256Hash(preimage) - sectorChallenge := bigIntFromLittleEndianBytes(hash) - - challengeModulus := new(big.Int) - challengeModulus.SetUint64(uint64(len(sectorIDs))) - - sectorIndex := sectorChallenge.Mod(sectorChallenge, challengeModulus) - return sectorIDs[int(sectorIndex.Uint64())] -} - -func generateLeafChallenge(randomness abi.PoStRandomness, sectorChallengeIndex UInt, leafChallengeIndex int, nodes int, challengeRangeSize int) UInt { - preimage := append(randomness, littleEndianBytesFromUInt(sectorChallengeIndex, 8)...) - preimage = append(preimage, littleEndianBytesFromInt(leafChallengeIndex, 8)...) - hash := SHA256Hash(preimage) - bigHash := bigIntFromLittleEndianBytes(hash) - - challengeSpaceSize := nodes / challengeRangeSize - challengeModulus := new(big.Int) - challengeModulus.SetUint64(UInt(challengeSpaceSize)) - - leafChallenge := bigHash.Mod(bigHash, challengeModulus) - - return leafChallenge.Uint64() -} - -func generateCandidate(randomness abi.PoStRandomness, aux sector.PersistentProofAux, sectorID abi.SectorID, sectorChallengeIndex UInt) abi.PoStCandidate { - var candidate abi.PoStCandidate - - // switch algorithm { - // case ProofAlgorithm_StackedDRGSeal: - // panic("TODO") - // case ProofAlgorithm_WinStackedDRGSeal: - // sdr := WinStackedDRG_I{} - // candidate = sdr._generateCandidate(cfg, randomness, aux, sectorID, sectorChallengeIndex) - // } - return candidate -} - -func computePartialTicket(randomness abi.PoStRandomness, sectorID abi.SectorID, data []byte) abi.PartialTicket { - preimage := randomness - preimage = append(preimage, getProverID(sectorID.Miner)...) - preimage = append(preimage, littleEndianBytesFromUInt(UInt(sectorID.Number), 8)...) - preimage = append(preimage, data...) - partialTicket := abi.PartialTicket(HashBytes_PedersenHash(preimage)) - - return partialTicket -} - -type PoStCandidatesMap map[ProofAlgorithm][]abi.PoStCandidate - -func CreatePoStProof(privateCandidateProofs []PrivatePostCandidateProof, challengeSeed abi.PoStRandomness) []abi.PoStProof { - var proofsMap map[RegisteredProof][]PrivatePostCandidateProof - - for _, proof := range privateCandidateProofs { - registeredProof := proof.RegisteredProof - proofsMap[registeredProof] = append(proofsMap[registeredProof], proof) - } - - var circuitProofs []abi.PoStProof - for registeredProof, proofs := range proofsMap { - privateProof := createPrivatePoStProof(registeredProof, proofs, challengeSeed) - circuitProof := createPoStCircuitProof(registeredProof, privateProof) - circuitProofs = append(circuitProofs, circuitProof) - } - - return circuitProofs -} - -type PrivatePoStProof struct { - RegisteredProof RegisteredProof - ChallengeSeed abi.PoStRandomness - CandidateProofs []PrivatePostCandidateProof -} - -func createPrivatePoStProof(registeredProof abi.RegisteredProof, candidateProofs []PrivatePostCandidateProof, challengeSeed abi.PoStRandomness) PrivatePoStProof { - // TODO: Verify that all candidateProofs share algorithm. - return PrivatePoStProof{ - RegisteredProof: registeredProof, - ChallengeSeed: challengeSeed, - CandidateProofs: candidateProofs, - } -} - -type InternalPrivateCandidateProof struct { - InclusionProofs []InclusionProof -} - -// This exists because we need to pass private proofs out of filproofs for winner selection. -// Actually implementing it would (will?) be tedious, since it means doing the same for InclusionProofs. - -func (p *InternalPrivateCandidateProof) externalize(registeredProof RegisteredProof) abi.PrivatePoStCandidateProof { - return abi.PrivatePoStCandidateProof{ - RegisteredProof: registeredProof, - Externalized: []byte{}, // Unimplemented. - } -} - -// This is the inverse of InternalPrivateCandidateProof.externalize and equally tedious. -func newInternalPrivateProof(externalPrivateProof abi.PrivatePoStCandidateProof) InternalPrivateCandidateProof { - return InternalPrivateCandidateProof{} -} - -func createPoStCircuitProof(registeredProof abi.RegisteredProof, privateProof PrivatePoStProof) (proof abi.PoStProof) { - switch registeredProof { - case abi.RegisteredProof_WinStackedDRG32GiBPoSt: - sdr := WinStackedDRG_I{} - proof = sdr._createPoStCircuitProof(privateProof) - case abi.RegisteredProof_StackedDRG32GiBPoSt: - panic("TODO") - } - - return proof -} - -func (pv *PoStVerifier_I) _verifyPoStProof(sv abi.PoStVerifyInfo) bool { - // commT := sv.CommT() - // candidates := sv.Candidates() - // randomness := sv.Randomness() - // postProofs := sv.OnChain.Proofs() - - // Verify circuit proof. - panic("TODO") -} - -//////////////////////////////////////////////////////////////////////////////// -// General PoSt - -func generatePoStCandidates(challengeSeed abi.PoStRandomness, eligibleSectors []abi.SectorID, candidateCount int, sectorStore sector_index.SectorStore) (candidates []abi.PoStCandidate) { - challengedSectors := getChallengedSectors(eligibleSectors, challengeSeed, eligibleSectors, candidateCount) - - for i, sectorID := range challengedSectors { - proofAux := sectorStore.GetSectorPersistentProofAux(sectorID) - - candidate := generateCandidate(challengeSeed, proofAux, sectorID, UInt(i)) - - candidates = append(candidates, candidate) - } - - return candidates -} - -//////////////////////////////////////////////////////////////////////////////// -// Election PoSt - -func GenerateElectionPoStCandidates(challengeSeed abi.PoStRandomness, eligibleSectors []abi.SectorID, candidateCount int, sectorStore sector_index.SectorStore) (candidates []abi.PoStCandidate) { - return generatePoStCandidates(challengeSeed, eligibleSectors, candidateCount, sectorStore) -} - -func CreateElectionPoStProof(privateCandidateProofs []PrivatePostCandidateProof, challengeSeed abi.PoStRandomness) []abi.PoStProof { - return CreatePoStProof(privateCandidateProofs, challengeSeed) -} - -func (pv *PoStVerifier_I) VerifyElectionPoSt(sv abi.PoStVerifyInfo) bool { - return pv._verifyPoStProof(sv) -} - -//////////////////////////////////////////////////////////////////////////////// -// Surprise PoSt - -func GenerateSurprisePoStCandidates(challengeSeed abi.PoStRandomness, eligibleSectors []abi.SectorID, candidateCount int, sectorStore sector_index.SectorStore) []abi.PoStCandidate { - panic("TODO") -} - -func CreateSurprisePoStProof(privateCandidateProofs []PrivatePostCandidateProof, challengeSeed abi.PoStRandomness) []abi.PoStProof { - return CreatePoStProof(privateCandidateProofs, challengeSeed) -} - -func (pv *PoStVerifier_I) VerifySurprisePoSt(sv abi.PoStVerifyInfo) bool { - return pv._verifyPoStProof(sv) -} diff --git a/src/libraries/filcrypto/filproofs/algorithms.id b/src/libraries/filcrypto/filproofs/algorithms.id deleted file mode 100644 index 1dd872e71..000000000 --- a/src/libraries/filcrypto/filproofs/algorithms.id +++ /dev/null @@ -1,299 +0,0 @@ -import abi "github.com/filecoin-project/specs-actors/actors/abi" -import file "github.com/filecoin-project/specs/systems/filecoin_files/file" -import sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector" -import sectorIndex "github.com/filecoin-project/specs/systems/filecoin_mining/sector_index" - -type WinStackedDRGLayers UInt -type WinStackedDRGNodeSize UInt -type WinStackedDRGNodes UInt -type WinStackedDRGWindowCount UInt -type WinStackedDRGPartitions UInt -type WinStackedDRGChallenges UInt -type WinStackedDRGWindowChallenges UInt - -type PoStLeafChallengeCount UInt -type PoStChallengeRangeSize UInt - -type DRGDepth struct {} -type DRGFraction struct {} -type DRGDegree UInt -type DRGSeed struct {} -type DRGNodeCount UInt -type ExpanderGraphNodeCount UInt -type ChungExpanderPermutationFeistelKeys [UInt] -type ChungExpanderPermutationFeistelRounds UInt -type ChungExpanderPermutationFeistelHashFunction enum { - Blake2S - SHA256 -} -type ChungExpanderAlpha struct {} -type ChungExpanderBeta struct {} -type ExpanderGraphDegree UInt -type ExpanderGraphSeed struct {} -type DRGNodeSize UInt - -type SealAlgorithmArtifacts struct { - AlgorithmWideSetupArtifacts struct { - // trusted setup output parameters go here - // updates to public parameters go here - } - - SealSetupArtifacts - - // ProveArtifacts or - ChallengeArtifacts struct { - // inputs into prove() go here - } - - VerifyArtifacts struct { - // inputs into verify() go here - } -} - -// per-sector setup artifacts go here -type SealSetupArtifacts struct { - CommD sector.Commitment - CommR abi.SealedSectorCID - CommC sector.Commitment - CommQ sector.Commitment - CommRLast sector.Commitment - CommDTreePath file.Path - CommCTreePath file.Path - CommQTreePath file.Path - CommRLastTreePath file.Path - Seed sector.SealSeed - KeyLayers [Bytes] - Replica Bytes // This is what we challenge in PoSt. It will be regenerated just in time. Should probably be removed from here. -} - -type EllipticCurve struct { - FieldModulus &util.BigInt -} - -type WinStackedDRG struct { - Layers WinStackedDRGLayers - NodeSize WinStackedDRGNodeSize - Nodes WinStackedDRGNodes - WindowCount WinStackedDRGWindowCount - Partitions WinStackedDRGPartitions - Challenges WinStackedDRGChallenges - WindowChallenges WinStackedDRGWindowChallenges - Algorithm struct {} - DRGCfg - ExpanderGraphCfg - WindowDRGCfg DRGCfg - WindowExpanderGraphCfg ExpanderGraphCfg - // invariant: DRGCfg.Nodes == ExpanderGraphCfg.Nodes - Curve EllipticCurve - RegisteredProof abi.RegisteredProof - Cfg SealInstanceCfg - - Drg() DRG - Expander() ExpanderGraph - - WindowDrg() DRG - WindowExpander() ExpanderGraph - - Seal( - registeredProof abi.RegisteredProof - sid abi.SectorID - data Bytes - randomness abi.SealRandomness - ) SealSetupArtifacts - CreateSealProof( - challengeSeed abi.InteractiveSealRandomness - aux sector.ProofAuxTmp - ) abi.SealProof - CreatePrivateSealProof( - randomness abi.InteractiveSealRandomness - aux sector.ProofAuxTmp - ) PrivateOfflineProof - - CreateOfflineCircuitProof( - challengeProofs [OfflineWindowProof] - aux sector.ProofAuxTmp - ) abi.SealProof - VerifyPrivateSealProof( - privateProof [OfflineWindowProof] - sealSeeds [sector.SealSeed] - randomness abi.InteractiveSealRandomness - commD Commitment - commR abi.SealedSectorCID - ) bool - VerifySeal(sv abi.SealVerifyInfo) bool - - GenerateElectionPoStCandidates( - challengeSeed abi.PoStRandomness - eligibleSectors [abi.SectorNumber] - candidateCount int - sectorStore sectorIndex.SectorStore - ) [abi.PoStCandidate] - CreateElectionPoStProof(privateProofs [PrivatePoStProof]) abi.PoStProof - VerifyElectionPoSt(sv abi.PoStVerifyInfo) bool - - GenerateSurprisePoStCandidates( - challengeSeed abi.PoStRandomness - eligibleSectors [abi.SectorNumber] - candidateCount int - sectorStore sectorIndex.SectorStore - ) [abi.PoStCandidate] - CreateSurprisePoStProof(privateProofs [PrivatePoStProof]) abi.PoStProof - VerifySurprisePoSt(sv abi.PoStVerifyInfo) bool - CreatePrivatePoStProof( - candidateProofs [abi.PrivatePoStCandidateProof] - challengeSeed abi.PoStRandomness - aux sector.PersistentProofAux - ) PrivatePoStProof - VerifyPrivatePoStProof( - privateProof PrivatePoStProof - candidates [abi.PoStCandidate] - commRLast sector.Commitment - ) bool -} - -type SealVerifier struct { - SealCfg SealInstanceCfg -} - -type PoStVerifier struct { - PoStCfg PoStInstanceCfg -} - -type DRGCfg struct { - Algorithm struct { - Depth DRGDepth // D - Fraction DRGFraction // E - - ParentsAlgorithm enum { - DRSample - } - - RNGAlgorithm enum { - ChaCha20 - } - } - Degree DRGDegree - Seed DRGSeed - Nodes DRGNodeCount -} - -type DRG struct { - Config DRGCfg - Parents(UInt) [UInt] -} - -type ExpanderGraphCfg struct { - Algorithm union { - ChungExpanderAlgorithm - } - - Degree ExpanderGraphDegree - Seed ExpanderGraphSeed - Nodes ExpanderGraphNodeCount -} - -type ExpanderGraph struct { - Config ExpanderGraphCfg - Parents(UInt) [UInt] -} - -type ChungExpanderAlgorithm struct { - Alpha ChungExpanderAlpha - Beta ChungExpanderBeta - PermutationAlgorithm union { - Feistel - } - Parents(node UInt, ExpanderGraphDegree, nodes ExpanderGraphNodeCount) [UInt] -} - -type Feistel struct { - Keys ChungExpanderPermutationFeistelKeys - Rounds ChungExpanderPermutationFeistelRounds - HashFunction ChungExpanderPermutationFeistelHashFunction - Permute(size UInt, n UInt) UInt -} - -type MerkleTree struct { - ProveInclusion(challenge UInt) InclusionProof - Leaf(index UInt) Bytes -} - -// TODO: Needs to be generic over hash. -type InclusionProof struct { - Leaf() Bytes - LeafIndex() UInt - Root() Commitment - Verify(root Bytes, challenge UInt) bool -} - -type ProofRegistry {UInt: ProofInstance} - -type ProofInstance struct { - // FIXME: move some or all of these types into filproofs. - ID abi.RegisteredProof - Type ProofType - Algorithm ProofAlgorithm - CircuitType ConcreteCircuit - Partitions UInt - Cfg ProofCfg -} - -type ConcreteCircuit struct { - // Name must be globally unique. It will be a hash derived from semantic content of circuit. - Name string - GrothParameterFileName() string - VerifyingKeyFileName() string -} - -type ProofCfg union { - SealCfg SealInstanceCfg - PoStCfg PoStInstanceCfg -} - -type ProofType enum { - SealProof - PoStProof -} - -type ProofAlgorithm enum { - StackedDRGSeal - WinStackedDRGSeal - StackedDRGPoSt - WinStackedDRGPoSt -} - -// New proof ProofInstances can add new cfg types if needed. -type SealInstanceCfg union { - WinStackedDRGCfgV1 -} - -type WinStackedDRGCfgV1 struct { - SectorSize abi.SectorSize - WindowCount UInt -} - -// New proof ProofInstances can add new cfg types if needed. -type PoStInstanceCfg union { - PoStCfgV1 - PoStCfgVBogus -} - -type PoStCfgV1 struct { - Type PoStType - Nodes UInt - Partitions UInt - LeafChallengeCount UInt - ChallengeRangeSize UInt -} - -type PoStCfgVBogus struct { - Type PoStType - Nodes UInt - Partitions UInt - QuantumMonkeyBrains UInt -} - -type PoStType enum { - ElectionPoSt - SurprisePoSt -} diff --git a/src/libraries/filcrypto/filproofs/feistel.go b/src/libraries/filcrypto/filproofs/feistel.go deleted file mode 100644 index 40f584e6e..000000000 --- a/src/libraries/filcrypto/filproofs/feistel.go +++ /dev/null @@ -1,92 +0,0 @@ -package filproofs - -import ( - "golang.org/x/crypto/blake2b" -) - -// TODO/FIXME: Update to use uint64, not uint32. - -func Permute(numElements uint32, index uint32, keys []uint32) uint32 { - u := encode(numElements, index, keys) - for u >= numElements { - u = encode(numElements, u, keys) - } - - return u -} - -func InvertPermute(numElements uint32, index uint32, keys []uint32) uint32 { - u := decode(numElements, index, keys) - for u >= numElements { - u = decode(numElements, u, keys) - } - - return u -} - -func encode(numElements uint32, index uint32, keys []uint32) uint32 { - // find nextPow4 - nextPow4 := uint32(4) - log4 := uint32(1) - for nextPow4 < numElements { - nextPow4 *= 4 - log4++ - } - - // left and right masks - leftMask := ((uint32(1) << log4) - 1) << log4 - rightMask := (uint32(1) << log4) - 1 - halfBits := log4 - - left := ((index & leftMask) >> halfBits) - right := (index & rightMask) - - for i := 0; i < 4; i++ { - left, right = right, left^feistel(right, keys[i], rightMask) - } - - return (left << halfBits) | right -} - -func decode(numElements uint32, index uint32, keys []uint32) uint32 { - - // find nextPow4 - nextPow4 := uint32(4) - log4 := uint32(1) - for nextPow4 < numElements { - nextPow4 *= 4 - log4++ - } - - // left and right masks - leftMask := ((uint32(1) << log4) - 1) << log4 - rightMask := (uint32(1) << log4) - 1 - halfBits := log4 - - left := ((index & leftMask) >> halfBits) - right := (index & rightMask) - - for i := 3; i > -1; i-- { - left, right = right^feistel(left, keys[i], rightMask), left - } - - return (left << halfBits) | right -} - -func feistel(right uint32, key uint32, rightMask uint32) uint32 { - var data [8]byte - data[0] = byte(right >> 24) - data[1] = byte(right >> 16) - data[2] = byte(right >> 8) - data[3] = byte(right) - - data[4] = byte(key >> 24) - data[5] = byte(key >> 16) - data[6] = byte(key >> 8) - data[7] = byte(key) - - hash := blake2b.Sum256(data[:]) - - r := uint32(hash[0])<<24 | uint32(hash[1])<<16 | uint32(hash[2])<<8 | uint32(hash[3]) - return r & rightMask -} diff --git a/src/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go b/src/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go deleted file mode 100644 index c48c735dc..000000000 --- a/src/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.go +++ /dev/null @@ -1,9 +0,0 @@ -package filproofs - -import abi "github.com/filecoin-project/specs-actors/actors/abi" - -func (fps *FilecoinProofsSubsystem_I) VerifySeal(sealVerifyInfo abi.SealVerifyInfo) bool { - registeredProof := sealVerifyInfo.OnChain.RegisteredProof - sdr := WinSDRParams(registeredProof) - return sdr.VerifySeal(sealVerifyInfo) -} diff --git a/src/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id b/src/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id deleted file mode 100644 index be96bb8ed..000000000 --- a/src/libraries/filcrypto/filproofs/filecoin_proofs_subsystem.id +++ /dev/null @@ -1,10 +0,0 @@ -import abi "github.com/filecoin-project/specs-actors/actors/abi" - -type SectorInfo struct {} -type Block struct {} -type SectorID struct {} - -type FilecoinProofsSubsystem struct { - VerifySeal(sealVerifyInfo abi.SealVerifyInfo) bool - ValidateBlock(block Block) bool -} diff --git a/src/libraries/filcrypto/filproofs/hashing.go b/src/libraries/filcrypto/filproofs/hashing.go deleted file mode 100644 index 5b6b407d5..000000000 --- a/src/libraries/filcrypto/filproofs/hashing.go +++ /dev/null @@ -1,75 +0,0 @@ -package filproofs - -import util "github.com/filecoin-project/specs/util" - -type SHA256Hash Bytes32 -type PedersenHash Bytes32 - -//////////////////////////////////////////////////////////////////////////////// -/// Generic Hashing - -/// Binary hash compression. -// BinaryHash -func BinaryHash_T(left []byte, right []byte) util.T { - var preimage = append(left, right...) - return HashBytes_T(preimage) -} - -func TernaryHash_T(a []byte, b []byte, c []byte) util.T { - var preimage = append(a, append(b, c...)...) - return HashBytes_T(preimage) -} - -// BinaryHash -func BinaryHash_PedersenHash(left []byte, right []byte) PedersenHash { - return PedersenHash{} -} - -func TernaryHash_PedersenHash(a []byte, b []byte, c []byte) PedersenHash { - return PedersenHash{} -} - -// BinaryHash -func BinaryHash_SHA256Hash(left []byte, right []byte) SHA256Hash { - result := SHA256Hash{} - return trimToFr32(result) -} - -func TernaryHash_SHA256Hash(a []byte, b []byte, c []byte) SHA256Hash { - return SHA256Hash{} -} - -//////////////////////////////////////////////////////////////////////////////// - -/// Digest -// HashBytes -func HashBytes_T(data []byte) util.T { - return util.T{} -} - -// HashBytes -func HashBytes_PedersenHash(data []byte) PedersenHash { - return PedersenHash{} -} - -// HashBytes -func BuildTree_T(data []byte) (util.T, file.Path) { - // Plan: define this in terms of BinaryHash_T, then copy-paste changes into T-specific specializations, for now. - - // Nodes are always the digest size so data cannot be compressed to digest for storage. - nodeSize := DigestSize_T() - - // TODO: Fail if len(dat) is not a power of 2 and a multiple of the node size. - - rows := [][]byte{data} - - for row := []byte{}; len(row) > nodeSize; { - for i := 0; i < len(data); i += 2 * nodeSize { - left := data[i : i+nodeSize] - right := data[i+nodeSize : i+2*nodeSize] - - hashed := BinaryHash_T(left, right) - - row = append(row, AsBytes_T(hashed)...) - } - rows = append(rows, row) - } - - // Last row is the root - root := rows[len(rows)-1] - - if len(root) != nodeSize { - panic("math failed us") - } - - var filePath file.Path // TODO: dump tree to file. - // NOTE: merkle tree file layout is illustrative, not prescriptive. - - // TODO: Check above more carefully. It's just an untested sketch for the moment. - return fromBytes_T(root), filePath -} - -// BuildTree -func BuildTree_PedersenHash(data []byte) (PedersenHash, file.Path) { - return PedersenHash{}, file.Path("") // FIXME -} - -// BuildTree -func BuildTree_SHA256Hash(data []byte) (SHA256Hash, file.Path) { - return []byte{}, file.Path("") // FIXME -} diff --git a/src/libraries/filcrypto/filproofs/util.go b/src/libraries/filcrypto/filproofs/util.go deleted file mode 100644 index 7f563dcf5..000000000 --- a/src/libraries/filcrypto/filproofs/util.go +++ /dev/null @@ -1,154 +0,0 @@ -package filproofs - -import ( - "encoding/binary" - big "math/big" - - abi "github.com/filecoin-project/specs-actors/actors/abi" - file "github.com/filecoin-project/specs/systems/filecoin_files/file" - util "github.com/filecoin-project/specs/util" -) - -// Utilities - -func reverse(bytes []byte) { - for i, j := 0, len(bytes)-1; i < j; i, j = i+1, j-1 { - bytes[i], bytes[j] = bytes[j], bytes[i] - } -} - -func bigIntFromLittleEndianBytes(bytes []byte) *big.Int { - reverse(bytes) - return new(big.Int).SetBytes(bytes) -} - -func bigIntFromBigEndianBytes(bytes []byte) *big.Int { - return new(big.Int).SetBytes(bytes) -} - -// size is number of bytes to return -func littleEndianBytesFromBigInt(z *big.Int, size int) []byte { - bytes := z.Bytes()[0:size] - reverse(bytes) - - return bytes -} - -// size is number of bytes to return -func bigEndianBytesFromBigInt(z *big.Int, size int) []byte { - return z.Bytes()[0:size] -} - -func littleEndianBytesFromInt(n int, size int) []byte { - z := new(big.Int) - z.SetInt64(int64(n)) - return littleEndianBytesFromBigInt(z, size) -} - -func bigEndianBytesFromInt(n int, size int) []byte { - z := new(big.Int) - z.SetInt64(int64(n)) - return bigEndianBytesFromBigInt(z, size) -} - -func littleEndianBytesFromUInt(n UInt, size int) []byte { - z := new(big.Int) - z.SetUint64(uint64(n)) - return littleEndianBytesFromBigInt(z, size) -} - -func bigEndianBytesFromUInt(n UInt, size int) []byte { - z := new(big.Int) - z.SetUint64(uint64(n)) - return bigEndianBytesFromBigInt(z, size) -} - -func AsBytes_T(t util.T) []byte { - panic("Unimplemented for T") - - return []byte{} -} - -func AsBytes_UnsealedSectorCID(cid abi.UnsealedSectorCID) []byte { - panic("Unimplemented for UnsealedSectorCID") - - return []byte{} -} - -func AsBytes_SealedSectorCID(CID abi.SealedSectorCID) []byte { - panic("Unimplemented for SealedSectorCID") - - return []byte{} -} - -func AsBytes_PieceCID(CID abi.PieceCID) []byte { - panic("Unimplemented for PieceCID") - - return []byte{} -} - -func fromBytes_T(_ interface{}) util.T { - panic("Unimplemented for T") - return util.T{} -} - -func fromBytes_PieceCID(_ interface{}) abi.PieceCID { - panic("Unimplemented for PieceCID") -} - -func isPow2(n int) bool { - return n != 0 && n&(n-1) == 0 -} - -// FIXME: This does not belong in filproofs, and no effort is being made to ensure it has any particular properties. -func RandomInt(randomness util.Randomness, nonce int, limit *big.Int) *big.Int { - nonceBytes := make([]byte, 8) - binary.LittleEndian.PutUint64(nonceBytes, uint64(nonce)) - input := randomness - input = append(input, nonceBytes...) - ranHash := HashBytes_SHA256Hash(input[:]) - hashInt := bigIntFromLittleEndianBytes(ranHash) - num := hashInt.Mod(hashInt, limit) - return num -} - -//////////////////////////////////////////////////////////////////////////////// - -// Destructively trim data so most significant two bits of last byte are 0. -// This ensure data interpreted as little-endian will not exceed a field with 254-bit capacity. -// NOTE: 254 bits is the capacity of BLS12-381, but other curves with ~32-byte field elements -// may have a different capacity. (Example: BLS12-377 has a capacity of 252 bits.) -func trimToFr32(data []byte) []byte { - util.Assert(len(data) == 32) - data[31] &= 0x3f // 0x3f = 0b0011_1111 - return data -} - -func UnsealedSectorCID(h SHA256Hash) abi.UnsealedSectorCID { - panic("not implemented -- re-arrange bits") -} - -func SealedSectorCID(h PedersenHash) abi.SealedSectorCID { - panic("not implemented -- re-arrange bits") -} - -func Commitment_UnsealedSectorCID(cid abi.UnsealedSectorCID) Commitment { - panic("not implemented -- re-arrange bits") -} - -func Commitment_SealedSectorCID(cid abi.SealedSectorCID) Commitment { - panic("not implemented -- re-arrange bits") -} - -func ComputeDataCommitment(data []byte) (abi.UnsealedSectorCID, file.Path) { - // TODO: make hash parameterizable - hash, path := BuildTree_SHA256Hash(data) - return UnsealedSectorCID(hash), path -} - -// Compute CommP or CommD. -func ComputeUnsealedSectorCID(data []byte) (abi.UnsealedSectorCID, file.Path) { - // TODO: check that len(data) > minimum piece size and is a power of 2. - hash, treePath := BuildTree_SHA256Hash(data) - return UnsealedSectorCID(hash), treePath -} diff --git a/src/libraries/filcrypto/filproofs/win_stacked_sdr.go b/src/libraries/filcrypto/filproofs/win_stacked_sdr.go deleted file mode 100644 index eff7c4adf..000000000 --- a/src/libraries/filcrypto/filproofs/win_stacked_sdr.go +++ /dev/null @@ -1,524 +0,0 @@ -package filproofs - -import ( - "bytes" - big "math/big" - - abi "github.com/filecoin-project/specs-actors/actors/abi" - file "github.com/filecoin-project/specs/systems/filecoin_files/file" - sector "github.com/filecoin-project/specs/systems/filecoin_mining/sector" - util "github.com/filecoin-project/specs/util" - "github.com/ipfs/go-cid" -) - -func WinSDRParams(registeredProof abi.RegisteredProof) *WinStackedDRG_I { - c := RegisteredProofInstance(registeredProof).Cfg().As_SealCfg() - cfg := c.As_WinStackedDRGCfgV1() - // TODO: Bridge constants with orient model. - const LAYERS = 10 - const OFFLINE_CHALLENGES = 6666 - const OFFLINE_WINDOW_CHALLENGES = 1111 - const FEISTEL_ROUNDS = 3 - var FEISTEL_KEYS = [FEISTEL_ROUNDS]UInt{1, 2, 3} - var FIELD_MODULUS = new(big.Int) - // https://github.com/zkcrypto/pairing/blob/master/src/bls12_381/fr.rs#L4 - FIELD_MODULUS.SetString("52435875175126190479447740508185965837690552500527637822603658699938581184513", 10) - - nodes := UInt(cfg.SectorSize() / NODE_SIZE) - - return &WinStackedDRG_I{ - Layers_: WinStackedDRGLayers(LAYERS), - Challenges_: WinStackedDRGChallenges(OFFLINE_CHALLENGES), - WindowChallenges_: WinStackedDRGWindowChallenges(OFFLINE_WINDOW_CHALLENGES), - NodeSize_: WinStackedDRGNodeSize(NODE_SIZE), - Nodes_: WinStackedDRGNodes(nodes), - Algorithm_: &WinStackedDRG_Algorithm_I{}, - DRGCfg_: &DRGCfg_I{ - Algorithm_: &DRGCfg_Algorithm_I{ - ParentsAlgorithm_: DRGCfg_Algorithm_ParentsAlgorithm_DRSample, - RNGAlgorithm_: DRGCfg_Algorithm_RNGAlgorithm_ChaCha20, - }, - Degree_: 6, - Nodes_: DRGNodeCount(nodes), - }, - ExpanderGraphCfg_: &ExpanderGraphCfg_I{ - Algorithm_: ExpanderGraphCfg_Algorithm_Make_ChungExpanderAlgorithm( - &ChungExpanderAlgorithm_I{ - PermutationAlgorithm_: ChungExpanderAlgorithm_PermutationAlgorithm_Make_Feistel(&Feistel_I{ - Keys_: FEISTEL_KEYS[:], - Rounds_: FEISTEL_ROUNDS, - HashFunction_: ChungExpanderPermutationFeistelHashFunction_SHA256, - }), - }), - Degree_: 8, - Nodes_: ExpanderGraphNodeCount(nodes), - }, - WindowDRGCfg_: &DRGCfg_I{ - Algorithm_: &DRGCfg_Algorithm_I{ - ParentsAlgorithm_: DRGCfg_Algorithm_ParentsAlgorithm_DRSample, - RNGAlgorithm_: DRGCfg_Algorithm_RNGAlgorithm_ChaCha20, - }, - Degree_: 0, - Nodes_: DRGNodeCount(nodes), - }, - WindowExpanderGraphCfg_: &ExpanderGraphCfg_I{ - Algorithm_: ExpanderGraphCfg_Algorithm_Make_ChungExpanderAlgorithm( - &ChungExpanderAlgorithm_I{ - PermutationAlgorithm_: ChungExpanderAlgorithm_PermutationAlgorithm_Make_Feistel(&Feistel_I{ - Keys_: FEISTEL_KEYS[:], - Rounds_: FEISTEL_ROUNDS, - HashFunction_: ChungExpanderPermutationFeistelHashFunction_SHA256, - }), - }), - Degree_: 8, - Nodes_: ExpanderGraphNodeCount(nodes), - }, - - Curve_: &EllipticCurve_I{ - FieldModulus_: *FIELD_MODULUS, - }, - Cfg_: c, - } -} - -func (sdr *WinStackedDRG_I) Drg() *DRG_I { - return &DRG_I{ - Config_: sdr.DRGCfg(), - } -} - -func (sdr *WinStackedDRG_I) Expander() *ExpanderGraph_I { - return &ExpanderGraph_I{ - Config_: sdr.ExpanderGraphCfg(), - } -} - -func (sdr *WinStackedDRG_I) WindowDrg() *DRG_I { - return &DRG_I{ - Config_: sdr.WindowDRGCfg(), - } -} - -func (sdr *WinStackedDRG_I) WindowExpander() *ExpanderGraph_I { - return &ExpanderGraph_I{ - Config_: sdr.WindowExpanderGraphCfg(), - } -} - -func (sdr *WinStackedDRG_I) Seal(registeredProof abi.RegisteredProof, sid abi.SectorID, data []byte, randomness abi.SealRandomness) SealSetupArtifacts { - - windowCount := int(sdr.WindowCount()) - nodeSize := int(sdr.NodeSize()) - nodes := int(sdr.Nodes()) - curveModulus := sdr.Curve().FieldModulus() - - var windowData [][]byte - - for i := 0; i < len(data); i += nodeSize { - windowData = append(windowData, data[i*nodeSize:(i+1)*nodeSize]) - } - - util.Assert(len(windowData) == windowCount) - - var windowKeyLayers [][]byte - var finalWindowKeyLayer []byte - - commD, commDTreePath := ComputeDataCommitment(data) - sealSeed := computeSealSeed(sid, randomness, commD) - - for i := 0; i < windowCount; i++ { - keyLayers := sdr._generateWindowKey(sealSeed, i, sid, commD, nodes, randomness) - - lastIndex := len(keyLayers) - 1 - windowKeyLayers = append(windowKeyLayers, keyLayers[:lastIndex]...) - finalWindowKeyLayer = append(finalWindowKeyLayer, keyLayers[lastIndex]...) - } - - qLayer := encodeDataInPlace(data, finalWindowKeyLayer, nodeSize, &curveModulus) - // NOTE: qLayer and data are now the same, and qLayer is introduced here for descriptive clarity only. - - replica := labelLayer(sdr.Drg(), sdr.Expander(), sealSeed, WRAPPER_LAYER_WINDOW_INDEX, nodes, nodeSize, qLayer) - - commC, commQ, commRLast, commR, commCTreePath, commQTreePath, commRLastTreePath := sdr.GenerateCommitments(replica, windowKeyLayers, qLayer) - - result := SealSetupArtifacts_I{ - CommD_: cid.Cid(commD).Bytes(), - CommR_: SealedSectorCID(commR), - CommC_: Commitment(commC), - CommQ_: Commitment(commQ), - CommRLast_: Commitment(commRLast), - CommDTreePath_: commDTreePath, - CommCTreePath_: commCTreePath, - CommQTreePath_: commQTreePath, - CommRLastTreePath_: commRLastTreePath, - Seed_: sealSeed, - KeyLayers_: windowKeyLayers, - Replica_: replica, - } - return &result -} - -func (sdr *WinStackedDRG_I) _generateWindowKey(sealSeed sector.SealSeed, windowIndex int, sid abi.SectorID, commD abi.UnsealedSectorCID, nodes int, randomness abi.SealRandomness) [][]byte { - nodeSize := int(sdr.NodeSize()) - curveModulus := sdr.Curve().FieldModulus() - layers := int(sdr.Layers()) - - keyLayers := generateSDRKeyLayers(sdr.WindowDrg(), sdr.WindowExpander(), sealSeed, windowIndex, nodes, layers, nodeSize, curveModulus) - - return keyLayers -} - -func (sdr *WinStackedDRG_I) GenerateCommitments(replica []byte, windowKeyLayers [][]byte, qLayer []byte) (commC PedersenHash, commQ PedersenHash, commRLast PedersenHash, commR PedersenHash, commCTreePath file.Path, commQTreePath file.Path, commRLastTreePath file.Path) { - commC, commCTreePath = computeCommC(windowKeyLayers, int(sdr.NodeSize())) - commQ, commQTreePath = computeCommQ(qLayer, int(sdr.NodeSize())) - commRLast, commRLastTreePath = BuildTree_PedersenHash(replica) - commR = TernaryHash_PedersenHash(commC, commQ, commRLast) - - return commC, commQ, commRLast, commR, commCTreePath, commQTreePath, commRLastTreePath -} - -func (sdr *WinStackedDRG_I) CreateSealProof(challengeSeed abi.InteractiveSealRandomness, aux sector.ProofAuxTmp) abi.SealProof { - privateProof := sdr.CreatePrivateSealProof(challengeSeed, aux) - - // Sanity check: newly-created proofs must pass verification. - util.Assert(sdr.VerifyPrivateSealProof(privateProof, aux.Seed(), challengeSeed, aux.CommD(), aux.CommR())) - - return sdr.CreateOfflineCircuitProof(privateProof, aux) -} - -func (sdr *WinStackedDRG_I) CreatePrivateSealProof(randomness abi.InteractiveSealRandomness, aux sector.ProofAuxTmp) (privateProof PrivateOfflineProof) { - sealSeed := aux.Seed() - nodeSize := UInt(sdr.NodeSize()) - wrapperChallenges, windowChallenges := sdr._generateOfflineChallenges(sealSeed, randomness, sdr.Challenges(), sdr.WindowChallenges()) - - dataTree := LoadMerkleTree(aux.CommDTreePath()) - columnTree := LoadMerkleTree(aux.CommCTreePath()) - replicaTree := LoadMerkleTree(aux.PersistentAux().CommRLastTreePath()) - qTree := LoadMerkleTree(aux.CommQTreePath()) - - windows := int(sdr.WindowCount()) - windowSize := int(uint64(sdr.Cfg().As_WinStackedDRGCfgV1().SectorSize()) / UInt(sdr.WindowCount())) - - for c := range windowChallenges { - columnProofs := createColumnProofs(sdr.WindowDrg(), sdr.WindowExpander(), UInt(c), nodeSize, columnTree, aux, windows, windowSize) - privateProof.ColumnProofs = append(privateProof.ColumnProofs, columnProofs...) - - windowProof := createWindowProof(sdr.WindowDrg(), sdr.WindowExpander(), UInt(c), nodeSize, dataTree, columnTree, qTree, aux, windows, windowSize) - privateProof.WindowProofs = append(privateProof.WindowProofs, windowProof) - } - - for c := range wrapperChallenges { - wrapperProof := createWrapperProof(sdr.Drg(), sdr.Expander(), sealSeed, UInt(c), nodeSize, qTree, replicaTree, aux, windows, windowSize) - privateProof.WrapperProofs = append(privateProof.WrapperProofs, wrapperProof) - } - - return privateProof -} - -// Verify a private proof. -// NOTE: Verification of a private proof is exactly the computation we will prove we have performed in a zk-SNARK. -// If we can verifiably prove that we have performed the verification of a private proof, then we need not reveal the proof itself. -// Since the zk-SNARK circuit proof is much smaller than the private proof, this allows us to save space on the chain (at the cost of increased computation to generate the zk-SNARK proof). -func (sdr *WinStackedDRG_I) VerifyPrivateSealProof(privateProof PrivateOfflineProof, sealSeed sector.SealSeed, randomness abi.InteractiveSealRandomness, commD Commitment, commR abi.SealedSectorCID) bool { - nodeSize := int(sdr.NodeSize()) - windowCount := int(sdr.WindowCount()) - windowSize := int(UInt(sdr.Cfg().As_WinStackedDRGCfgV1().SectorSize()) / UInt(sdr.WindowCount())) // TOOD: Make this a function. - layers := int(sdr.Layers()) - curveModulus := sdr.Curve().FieldModulus() - windowChallenges, wrapperChallenges := sdr._generateOfflineChallenges(sealSeed, randomness, sdr.Challenges(), sdr.WindowChallenges()) - - windowProofs := privateProof.WindowProofs - columnProofs := privateProof.ColumnProofs - wrapperProofs := privateProof.WrapperProofs - - // commC, commQ, and commRLast must be the same for all challenge proofs, so we can arbitrarily verify against the first. - firstColumnProof := columnProofs[0] - firstWrapperProof := wrapperProofs[0] - commC := firstColumnProof.InclusionProof.Root() - commQ := firstWrapperProof.QLayerProofs[0].Root() - commRLast := firstWrapperProof.ReplicaProof.Root() - - windowDrgParentCount := int(sdr.WindowDRGCfg().Degree()) - windowExpanderParentCount := int(sdr.WindowDRGCfg().Degree()) - wrapperExpanderParentCount := int(sdr.ExpanderGraphCfg().Degree()) - - for i, challenge := range windowChallenges { - // Verify one OfflineSDRChallengeProof. - windowProof := windowProofs[i] - dataProof := windowProof.DataProof - qLayerProof := windowProof.QLayerProof - - // Verify column proofs and that they represent the right columns. - columnElements := getColumnElements(sdr.Drg(), sdr.Expander(), challenge) - - // Check column openings. - for i, columnElement := range columnElements { - columnProof := columnProofs[i] - - // The provided column proofs must correspond to the expected columns. - if !columnProof.Verify(commC, UInt(columnElement)) { - return false - } - } - - // Check labeling. - for w := 0; w < windowCount; w++ { - for layer := 0; layer < layers; layer++ { - var parents []Label - - // First column proof is the challenge. - // Then the DRG parents. - for _, drgParentProof := range columnProofs[1 : 1+windowDrgParentCount] { - parent := drgParentProof.Column[layer] - parents = append(parents, parent) - } - // And the expander parents, if not the first layer. - if layer > 0 { - for _, expanderParentProof := range columnProofs[1+windowDrgParentCount : 1+windowExpanderParentCount] { - parent := expanderParentProof.Column[layer-1] - parents = append(parents, parent) - } - } - - calculatedLabel := generateLabel(sealSeed, i, w, parents) - - if layer == layers-1 { - // Last layer includes encoding. - dataNode := dataProof.Leaf() - qLayerNode := qLayerProof.Leaf() - - if !dataProof.Verify(commD, UInt(windowSize*w)+challenge) { - return false - } - - encodedNode := encodeNode(dataNode, calculatedLabel, &curveModulus, nodeSize) - - if !bytes.Equal(encodedNode, qLayerNode) { - return false - } - - } else { - providedLabel := columnProofs[columnElements[0]].Column[layer] - - if !bytes.Equal(calculatedLabel, providedLabel) { - return false - } - } - } - } - } - - for i, challenge := range wrapperChallenges { - wrapperProof := wrapperProofs[i] - replicaProof := wrapperProof.ReplicaProof - qLayerProofs := wrapperProof.QLayerProofs - - if !replicaProof.Verify(commRLast, challenge) { - return false - } - - var parents []Label - for i := 0; i < wrapperExpanderParentCount; i++ { - parent := qLayerProofs[i].Leaf() - parents = append(parents, parent) - } - - label := generateLabel(sealSeed, i, windowCount+1, parents) - replicaNode := replicaProof.Leaf() - - if !bytes.Equal(label, replicaNode) { - return false - } - } - - commRCalculated := TernaryHash_PedersenHash(commC, commQ, commRLast) - - if !bytes.Equal(commRCalculated, AsBytes_SealedSectorCID(commR)) { - return false - } - - return true -} - -func (sdr *WinStackedDRG_I) CreateOfflineCircuitProof(proof PrivateOfflineProof, aux sector.ProofAuxTmp) abi.SealProof { - // partitions := sdr.Partitions() - // publicInputs := GeneratePublicInputs() - - panic("TODO") - var proofBytes []byte - panic("TODO") - - sealProof := abi.SealProof{ - ProofBytes: proofBytes, - } - - return sealProof -} - -func (sdr *WinStackedDRG_I) _generateOfflineChallenges(sealSeed sector.SealSeed, randomness abi.InteractiveSealRandomness, wrapperChallengeCount WinStackedDRGChallenges, windowChallengeCount WinStackedDRGWindowChallenges) (windowChallenges []UInt, wrapperChallenges []UInt) { - wrapperChallenges = generateOfflineChallenges(int(sdr.Nodes()), sealSeed, randomness, int(wrapperChallengeCount)) - windowChallenges = generateOfflineChallenges(int(sdr.WindowDRGCfg().Nodes()), sealSeed, randomness, int(windowChallengeCount)) - - return windowChallenges, wrapperChallenges -} - -//////////////////////////////////////////////////////////////////////////////// -// Seal Verification - -func (sdr *WinStackedDRG_I) VerifySeal(sv abi.SealVerifyInfo) bool { - onChain := sv.OnChain - sealProof := onChain.Proof - commR := abi.SealedSectorCID(onChain.SealedCID) - commD := abi.UnsealedSectorCID(sv.UnsealedCID) - sealSeed := computeSealSeed(sv.SectorID, sv.Randomness, commD) - - wrapperChallenges, windowChallenges := sdr._generateOfflineChallenges(sealSeed, sv.InteractiveRandomness, sdr.Challenges(), sdr.WindowChallenges()) - return sdr._verifyOfflineCircuitProof(commD, commR, sealSeed, windowChallenges, wrapperChallenges, sealProof) -} - -func (sdr *WinStackedDRG_I) _verifyOfflineCircuitProof(commD abi.UnsealedSectorCID, commR abi.SealedSectorCID, sealSeed sector.SealSeed, windowChallenges []UInt, wrapperChallenges []UInt, sv abi.SealProof) bool { - //publicInputs := GeneratePublicInputs() - panic("TODO") -} - -//////////////////////////////////////////////////////////////////////////////// -// PoSt - -func (sdr *WinStackedDRG_I) _generateCandidate(postCfg PoStInstanceCfg, randomness abi.PoStRandomness, aux sector.PersistentProofAux, sectorID abi.SectorID, sectorChallengeIndex uint64) abi.PoStCandidate { - cfg := postCfg.As_PoStCfgV1() - - nodes := int(cfg.Nodes()) - leafChallengeCount := int(cfg.LeafChallengeCount()) - challengeRangeSize := int(cfg.ChallengeRangeSize()) - treePath := aux.CommRLastTreePath() - tree := LoadMerkleTree(treePath) - - var data []byte - var inclusionProofs []InclusionProof - for i := 0; i < leafChallengeCount; i++ { - leafChallenge := generateLeafChallenge(randomness, sectorChallengeIndex, i, nodes, challengeRangeSize) - - for j := 0; j < challengeRangeSize; j++ { - leafIndex := leafChallenge + UInt(j) - data = append(data, tree.Leaf(leafIndex)...) - inclusionProof := tree.ProveInclusion(leafIndex) - inclusionProofs = append(inclusionProofs, inclusionProof) - } - } - - partialTicket := computePartialTicket(randomness, sectorID, data) - - privateProof := InternalPrivateCandidateProof{ - InclusionProofs: inclusionProofs, - } - - var registeredProof abi.RegisteredProof - - // FIXME: Need to get registeredProof! - - candidate := abi.PoStCandidate{ - PartialTicket: partialTicket, - PrivateProof: privateProof.externalize(registeredProof), - SectorID: sectorID, - ChallengeIndex: int64(sectorChallengeIndex), - } - return candidate -} - -func (sdr *WinStackedDRG_I) VerifyInternalPrivateCandidateProof(postCfg PoStInstanceCfg, p *InternalPrivateCandidateProof, challengeSeed abi.PoStRandomness, candidate abi.PoStCandidate, commRLast Commitment) bool { - cfg := postCfg.As_PoStCfgV1() - //util.Assert(candidate.PrivateProof == nil) - nodes := int(cfg.Nodes()) - challengeRangeSize := int(cfg.ChallengeRangeSize()) - - sectorID := candidate.SectorID - claimedPartialTicket := candidate.PartialTicket - - allInclusionProofs := p.InclusionProofs - - var ticketData []byte - - for _, p := range allInclusionProofs { - ticketData = append(ticketData, p.Leaf()...) - } - - // Check partial ticket - calculatedTicket := computePartialTicket(challengeSeed, sectorID, ticketData) - - if len(calculatedTicket) != len(claimedPartialTicket) { - return false - } - for i, byte := range claimedPartialTicket { - if byte != calculatedTicket[i] { - return false - } - } - - // Helper to get InclusionProofs sequentially. - next := func() InclusionProof { - if len(allInclusionProofs) < 1 { - return nil - } - - proof := allInclusionProofs[0] - allInclusionProofs = allInclusionProofs[1:] - return proof - } - - // Check all inclusion proofs. - for i := 0; i < int(cfg.LeafChallengeCount()); i++ { - leafChallenge := generateLeafChallenge(challengeSeed, UInt(candidate.ChallengeIndex), i, nodes, challengeRangeSize) - for j := 0; j < challengeRangeSize; j++ { - leafIndex := leafChallenge + UInt(j) - proof := next() - if proof == nil { - // All required inclusion proofs must be provided. - return false - } - if !proof.Verify(commRLast, leafIndex) { - return false - } - } - } - - return true -} - -func (sdr *WinStackedDRG_I) VerifyPrivatePoStProof(cfg PoStInstanceCfg, privateProof PrivatePoStProof, candidates []abi.PoStCandidate, sectorIDs []abi.SectorID, sectorCommitments sector.SectorCommitments) bool { - // This is safe by construction. - challengeSeed := privateProof.ChallengeSeed - - for i, p := range privateProof.CandidateProofs { - proof := newInternalPrivateProof(p) - - candidate := candidates[i] - ci := candidate.ChallengeIndex - expectedSectorID := sectorIDs[ci] - - challengedSectorID := generateSectorChallenge(challengeSeed, i, sectorIDs) - - if expectedSectorID != challengedSectorID { - return false - } - - commRLast := sectorCommitments[expectedSectorID] - - if !sdr.VerifyInternalPrivateCandidateProof(cfg, &proof, challengeSeed, candidate, commRLast) { - return false - } - } - return true -} - -func (sdr *WinStackedDRG_I) _createPoStCircuitProof(privateProof PrivatePoStProof) abi.PoStProof { - panic("TODO") - - var proofBytes []byte - panic("TODO") - - postProof := abi.PoStProof{ - ProofBytes: proofBytes, - } - - return postProof -} diff --git a/src/libraries/ipfs/_index.md b/src/libraries/ipfs/_index.md deleted file mode 100644 index 3a4efe0f3..000000000 --- a/src/libraries/ipfs/_index.md +++ /dev/null @@ -1,8 +0,0 @@ ---- -menuTitle: IPFS -title: IPFS - InterPlanetary File System -entries: -- bitswap -- graphsync -- unixfs ---- diff --git a/src/libraries/ipfs/bitswap.md b/src/libraries/ipfs/bitswap.md deleted file mode 100644 index 218888d51..000000000 --- a/src/libraries/ipfs/bitswap.md +++ /dev/null @@ -1,3 +0,0 @@ ---- -title: BitSwap ---- \ No newline at end of file diff --git a/src/libraries/ipfs/graphsync.md b/src/libraries/ipfs/graphsync.md deleted file mode 100644 index 5bb8fe8e8..000000000 --- a/src/libraries/ipfs/graphsync.md +++ /dev/null @@ -1,3 +0,0 @@ ---- -title: GraphSync ---- \ No newline at end of file diff --git a/src/libraries/ipfs/unixfs.md b/src/libraries/ipfs/unixfs.md deleted file mode 100644 index 7d947a809..000000000 --- a/src/libraries/ipfs/unixfs.md +++ /dev/null @@ -1,3 +0,0 @@ ---- -title: UnixFS ---- \ No newline at end of file diff --git a/src/libraries/ipld/_index.md b/src/libraries/ipld/_index.md deleted file mode 100644 index 1615cfaee..000000000 --- a/src/libraries/ipld/_index.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -menuTitle: IPLD -title: IPLD - InterPlanetary Linked Data -entries: -- cid -- datamodel -- selectors ---- - -{{< readfile file="ipld.id" code="true" lang="go" >}} diff --git a/src/libraries/ipld/cid.md b/src/libraries/ipld/cid.md deleted file mode 100644 index 5db4db613..000000000 --- a/src/libraries/ipld/cid.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -menuTitle: CID -title: CIDs - Content IDentifiers ---- - -For most objects referenced by Filecoin, a Content Identifier (CID for short) is used. Any pointer inclusions in the Filecoin spec `id` files (e.g. `&Object`) denotes the CID of said object. Some objects explicitly name a CID field. The spec treats these notations interchangeably. -This is effectively a hash value, prefixed with its hash function (multihash) as well as extra labels to inform applications about how to deserialize the given data. - -For a more detailed specification, we refer the reader to the -[IPLD repository](https://github.com/ipld/cid). diff --git a/src/libraries/ipld/datamodel.md b/src/libraries/ipld/datamodel.md deleted file mode 100644 index 062b7b0a8..000000000 --- a/src/libraries/ipld/datamodel.md +++ /dev/null @@ -1,3 +0,0 @@ ---- -title: Data Model ---- \ No newline at end of file diff --git a/src/libraries/ipld/ipld.id b/src/libraries/ipld/ipld.id deleted file mode 100644 index 5cbffcae1..000000000 --- a/src/libraries/ipld/ipld.id +++ /dev/null @@ -1,17 +0,0 @@ -// imported as ipld.Object - -import cid "github.com/ipfs/go-cid" - -type Object interface { - CID() cid.Cid - - // Populate(v interface{}) error -} - -type GraphStore struct { - // Retrieves a serialized value from the store by CID. Returns the value and whether it was found. - Get(c cid.Cid) (util.Bytes, bool) - - // Puts a serialized value in the store, returning the CID. - Put(value util.Bytes) (c cid.Cid) -} diff --git a/src/libraries/ipld/selectors.id b/src/libraries/ipld/selectors.id deleted file mode 100644 index 34beda5a9..000000000 --- a/src/libraries/ipld/selectors.id +++ /dev/null @@ -1,153 +0,0 @@ -// This is a compression of the IPLD Selector Spec -// Full spec: https://github.com/ipld/specs/blob/master/selectors/selectors.md - -type Selector union { - Matcher - ExploreAll - ExploreFields - ExploreIndex - ExploreRange - ExploreRecursive - ExploreUnion - ExploreConditional - ExploreRecursiveEdge -} - -// ExploreAll is similar to a `*` -- it traverses all elements of an array, -// or all entries in a map, and applies a next selector to the reached nodes. -type ExploreAll struct { - next Selector -} - -// ExploreFields traverses named fields in a map (or equivalently, struct, if -// traversing on typed/schema nodes) and applies a next selector to the -// reached nodes. -// -// Note that a concept of exploring a whole path (e.g. "foo/bar/baz") can be -// represented as a set of three nexted ExploreFields selectors, each -// specifying one field. -type ExploreFields struct { - fields {string: Selector} -} - -// ExploreIndex traverses a specific index in a list, and applies a next -// selector to the reached node. -type ExploreIndex struct { - index UInt - next Selector -} - -// ExploreIndex traverses a list, and for each element in the range specified, -// will apply a next selector to those reached nodes. -type ExploreRange struct { - start UInt - end UInt - next Selector -} - -// ExploreRecursive traverses some structure recursively. -// To guide this exploration, it uses a "sequence", which is another Selector -// tree; some leaf node in this sequence should contain an ExploreRecursiveEdge -// selector, which denotes the place recursion should occur. -// -// In implementation, whenever evaluation reaches an ExploreRecursiveEdge marker -// in the recursion sequence's Selector tree, the implementation logically -// produces another new Selector which is a copy of the original -// ExploreRecursive selector, but with a decremented maxDepth parameter, and -// continues evaluation thusly. -// -// It is not valid for an ExploreRecursive selector's sequence to contain -// no instances of ExploreRecursiveEdge; it *is* valid for it to contain -// more than one ExploreRecursiveEdge. -// -// ExploreRecursive can contain a nested ExploreRecursive! -// This is comparable to a nested for-loop. -// In these cases, any ExploreRecursiveEdge instance always refers to the -// nearest parent ExploreRecursive (in other words, ExploreRecursiveEdge can -// be thought of like the 'continue' statement, or end of a for-loop body; -// it is *not* a 'goto' statement). -// -// Be careful when using ExploreRecursive with a large maxDepth parameter; -// it can easily cause very large traversals (especially if used in combination -// with selectors like ExploreAll inside the sequence). -type ExploreRecursive struct { - sequence Selector - maxDepth UInt - stopAt Condition -} - -// ExploreRecursiveEdge is a special sentinel value which is used to mark -// the end of a sequence started by an ExploreRecursive selector: the recursion -// goes back to the initial state of the earlier ExploreRecursive selector, -// and proceeds again (with a decremented maxDepth value). -// -// An ExploreRecursive selector that doesn't contain an ExploreRecursiveEdge -// is nonsensical. Containing more than one ExploreRecursiveEdge is valid. -// An ExploreRecursiveEdge without an enclosing ExploreRecursive is an error. -type ExploreRecursiveEdge struct {} - -// ExploreUnion allows selection to continue with two or more distinct selectors -// while exploring the same tree of data. -// -// ExploreUnion can be used to apply a Matcher on one node (causing it to -// be considered part of a (possibly labelled) result set), while simultaneously -// continuing to explore deeper parts of the tree with another selector, -// for example. -type ExploreUnion [Selector] - -// Note that ExploreConditional versus a Matcher with a Condition are distinct: -// ExploreConditional progresses deeper into a tree; -// whereas a Matcher with a Condition may look deeper to make its decision, -// but returns a match for the node it's on rather any of the deeper values. -type ExploreConditional struct { - condition Condition - next Selector -} - -// Matcher marks a node to be included in the "result" set. -// (All nodes traversed by a selector are in the "covered" set (which is a.k.a. -// "the merkle proof"); the "result" set is a subset of the "covered" set.) -// -// In libraries using selectors, the "result" set is typically provided to -// some user-specified callback. -// -// A selector tree with only "explore*"-type selectors and no Matcher selectors -// is valid; it will just generate a "covered" set of nodes and no "result" set. -type Matcher struct { - onlyIf Condition? // match is true based on position alone if this is not set. - label string? // labels can be used to match multiple different structures in one selection. -} - -// Condition is expresses a predicate with a boolean result. -// -// Condition clauses are used several places: -// - in Matcher, to determine if a node is selected. -// - in ExploreRecursive, to halt exploration. -// - in ExploreConditional, -// -// -// TODO -- Condition is very skeletal and incomplete. -// The place where Condition appears in other structs is correct; -// the rest of the details inside it are not final nor even completely drafted. -type Condition union { - // We can come back to this and expand it later... - // TODO: figure out how to make this recurse correctly, so I can say "hasField{hasField{or{hasValue{1}, hasValue{2}}}}". - Condition_HasField - Condition_HasValue - Condition_HasKind - Condition_IsLink - Condition_GreaterThan - Condition_LessThan - Condition_And - Condition_Or - // REVIEW: since we introduced "and" and "or" here, we're getting into dangertown again. we'll need a "max conditionals limit" (a la 'gas' of some kind) near here. -} - -type Condition_HasField struct {} -type Condition_HasKind struct {} -type Condition_HasValue struct {} -type Condition_And struct {} -type Condition_GreaterThan struct {} -type Condition_IsLink struct {} -type Condition_LessThan struct {} -type Condition_Or struct {} diff --git a/src/libraries/ipld/selectors.md b/src/libraries/ipld/selectors.md deleted file mode 100644 index a0e43c65c..000000000 --- a/src/libraries/ipld/selectors.md +++ /dev/null @@ -1,6 +0,0 @@ ---- -menuTitle: Selectors -title: Selectors - IPLD Query Language ---- - -{{< readfile file="selectors.id" code="true" lang="go" >}} diff --git a/src/libraries/libp2p/_index.md b/src/libraries/libp2p/_index.md deleted file mode 100644 index 75fe4804c..000000000 --- a/src/libraries/libp2p/_index.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -menuTitle: libp2p -title: libp2p -entries: -- gossipsub -- kad_dht -- fil_libp2p_nodes ---- - -{{< readfile file="libp2p.id" code="true" lang="go" >}} diff --git a/src/libraries/libp2p/fil_libp2p_nodes.md b/src/libraries/libp2p/fil_libp2p_nodes.md deleted file mode 100644 index 6a29e3362..000000000 --- a/src/libraries/libp2p/fil_libp2p_nodes.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -menuTitle: fil-libp2p Nodes -title: Filecoin libp2p Nodes ---- \ No newline at end of file diff --git a/src/libraries/libp2p/gossipsub.md b/src/libraries/libp2p/gossipsub.md deleted file mode 100644 index 09234a2db..000000000 --- a/src/libraries/libp2p/gossipsub.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -menuTitle: gossipsub -title: Gossipsub for broadcasts ---- \ No newline at end of file diff --git a/src/libraries/libp2p/kad_dht.md b/src/libraries/libp2p/kad_dht.md deleted file mode 100644 index 171a0f14d..000000000 --- a/src/libraries/libp2p/kad_dht.md +++ /dev/null @@ -1,4 +0,0 @@ ---- -menuTitle: kad-dht -title: Kademlia DHT for Peer Routing ---- \ No newline at end of file diff --git a/src/libraries/libp2p/libp2p.id b/src/libraries/libp2p/libp2p.id deleted file mode 100644 index 40fd0055e..000000000 --- a/src/libraries/libp2p/libp2p.id +++ /dev/null @@ -1,94 +0,0 @@ -import peer "github.com/libp2p/go-libp2p-core/peer" - -type Node struct { - // PeerID returns the PeerID associated with this libp2p Node - PeerID() peer.ID - - // MountProtocol adds given Protocol under specified protocol id. - MountProtocol(path ProtocolPath, protocol Protocol) - - // ConnectPeerID establishes a connection to peer matching given PeerInfo. - // - // peer.AddrInfo may be empty. If so: - // - Libp2pNode will try to use any Multiaddrs it knows (internal PeerStore) - // - Libp2pNode may use any `PeerRouting` protocol mounted onto the libp2p node. - // TODO: how to define this. - // NOTE: probably implies using kad-dht or gossipsub for this. - // - // Idempotent. If a connection already exists, this method returns silently. - Connect(peerInfo peer.AddrInfo) -} - -type ProtocolPath string - -type Protocol union { - StreamProtocol - DatagramProtocol -} - -// Stream is an interface to deal with networked processes, which communicate -// via streams of bytes. -// -// See golang.org/pkg/io -- as this is modelled after io.Reader and io.Writer -type Stream struct { - // Read reads bytes from the underlying stream and copies them to buf. - // Read returns the number of bytes read (n), and potentially an error - // encountered while reading. Read reads at most len(buf) byte. - // Read may read 0 bytes. - Read(buf Bytes) union {n int, err error} - - // Write writes bytes to the underlying stream, copying them from buf. - // Write returns the number of bytes written (n), and potentially an error - // encountered while writing. Write writes at most len(buf) byte. - // Write may read 0 bytes. - Write(buf Bytes) union {n int, err error} - - // Close terminates client's use of the stream. - // Calling Read or Write after Close is an error. - Close() error -} - -type StreamProtocol struct { - // AcceptStream accepts an incoming stream connection. - AcceptStream() struct { - stream Stream - peerInfo peer.AddrInfo - err error - } - - // OpenStream opens a stream to a particular PeerID. - OpenStream(peerInfo peer.AddrInfo) struct { - stream Stream - err error - } -} - -// Datagram -type Datagram Bytes - -// Datagrams are "messages" in the network packet sense of the word. -// -// "message-oriented network protocols" should use this interface, -// not the StreamProtocol interface. -// -// We call it "Datagram" here because unfortunately the word "Message" -// is very overloaded in Filecoin. -// Suggestion for libp2p: use datagram too. -type DatagramProtocol struct { - // AcceptDatagram accepts an incoming message. - AcceptDatagram() struct { - datagram Datagram - peerInfo peer.AddrInfo - err error - } - - // OpenStream opens a stream to a particular PeerID - SendDatagram(datagram Datagram, peerInfo peer.AddrInfo) struct {err error} -} - -// type StorageDealLibp2pProtocol struct { -// StreamProtocol StreamProtocol -// // --- -// AcceptStream() struct {} -// OpenStream() struct {} -// } diff --git a/src/libraries/multiformats/_index.md b/src/libraries/multiformats/_index.md deleted file mode 100644 index 28c2d2531..000000000 --- a/src/libraries/multiformats/_index.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -menuTitle: Multiformats -title: Multiformats - self describing protocol values ---- - -# Multihash - self describing hash values - -{{< readfile file="multihash.id" code="true" lang="go" >}} - -# Multiaddr - self describing network addresses - -{{< readfile file="multiaddr.id" code="true" lang="go" >}} - diff --git a/src/libraries/multiformats/multiaddr.id b/src/libraries/multiformats/multiaddr.id deleted file mode 100644 index 5ca10d4d1..000000000 --- a/src/libraries/multiformats/multiaddr.id +++ /dev/null @@ -1 +0,0 @@ -type Multiaddr Bytes diff --git a/src/libraries/multiformats/multihash.id b/src/libraries/multiformats/multihash.id deleted file mode 100644 index 1c199309c..000000000 --- a/src/libraries/multiformats/multihash.id +++ /dev/null @@ -1 +0,0 @@ -type Multihash Bytes diff --git a/src/listings/_index.md b/src/listings/_index.md deleted file mode 100644 index 1cd0b04f1..000000000 --- a/src/listings/_index.md +++ /dev/null @@ -1,9 +0,0 @@ ---- -title: Listings -entries: - - actors - - reserved_ranges - - data_structures - - system_map - - libp2p_protocols ---- diff --git a/src/listings/actors.md b/src/listings/actors.md deleted file mode 100644 index ab4b20504..000000000 --- a/src/listings/actors.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "Filecoin VM Actors" ---- - -TODO diff --git a/src/listings/data_structures.md b/src/listings/data_structures.md deleted file mode 100644 index 1b6a5a3d2..000000000 --- a/src/listings/data_structures.md +++ /dev/null @@ -1,66 +0,0 @@ ---- -title: "Data Structures" ---- - -# RLE+ Bitset Encoding - -RLE+ is a lossless compression format based on [RLE](https://en.wikipedia.org/wiki/Run-length_encoding). -Its primary goal is to reduce the size in the case of many individual bits, where RLE breaks down quickly, -while keeping the same level of compression for large sets of contiugous bits. - -In tests it has shown to be more compact than RLE itself, as well as [Concise](https://arxiv.org/pdf/1004.0403.pdf) and [Roaring](https://roaringbitmap.org/). - -## Format - -The format consists of a header, followed by a series of blocks, of which there are three different types. - -The format can be expressed as the following [BNF](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form) grammar. - -``` - ::=
-
::= - ::= "00" - ::= | "" - ::= | | - ::= "1" - ::= "01" - ::= "00" - ::= "0" | "1" -``` - -An `` is defined as specified [here](https://github.com/multiformats/unsigned-varint). - -### Blocks - -The blocks represent how many bits, of the current bit type there are. As `0` and `1` alternate in a bit vector -the inital bit, which is stored in the header, is enough to determine if a length is currently referencing -a set of `0`s, or `1`s. - -#### Block Single - -If the running length of the current bit is only `1`, it is encoded as a single set bit. - -#### Block Short - -If the running length is less than `16`, it can be encoded into up to four bits, which a short block -represents. The length is encoded into a 4 bits, and prefixed with `01`, to indicate a short block. - -#### Block Long - -If the running length is `16` or larger, it is encoded into a varint, and then prefixed with `00` to indicate -a long block. - -> **Note:** The encoding is unique, so no matter which algorithm for encoding is used, it should produce -> the same encoding, given the same input. - -#### Bit Numbering - -For Filecoin, byte arrays representing RLE+ bitstreams are encoded using [LSB 0](https://en.wikipedia.org/wiki/Bit_numbering#LSB_0_bit_numbering) bit numbering. - -# HAMT - -See the draft [IPLD hash map spec](https://github.com/ipld/specs/blob/master/data-structures/hashmap.md) for details on implementing the HAMT used for the global state tree map and throughout the actor code. - -# Other Considerations - -- The maximum size of an Object should be 1MB (2^20 bytes). Objects larger than this are invalid. \ No newline at end of file diff --git a/src/listings/libp2p_protocols/_index.md b/src/listings/libp2p_protocols/_index.md deleted file mode 100644 index 1f3949b48..000000000 --- a/src/listings/libp2p_protocols/_index.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "libp2p Protocols" -entries: - - data_transfer_protocol ---- diff --git a/src/listings/libp2p_protocols/data_transfer_protocol.md b/src/listings/libp2p_protocols/data_transfer_protocol.md deleted file mode 100644 index 2debd4c8b..000000000 --- a/src/listings/libp2p_protocols/data_transfer_protocol.md +++ /dev/null @@ -1,33 +0,0 @@ ---- -title: Data Transfer Protocol ---- - -- **Name**: Data Transfer Protocol -- **Protocol ID**: `/fil/data-transfer/0.0.1` - -Message Protobuf - -``` - -message DataTransferMessage { - message Request { - int32 transferID = 1 - bool isPull = 2 - bytes voucher = 3 - bytes pieceID = 4 - bytes selector = 5 - bool isPartial = 6 - bool isCancel = 7 - } - - message Response { - int32 transferID = 1 - boolean accepted = 2 - } - - bool isResponse = 1 - Request request = 2 - Response response = 3 -} - -``` diff --git a/src/listings/reserved_ranges.md b/src/listings/reserved_ranges.md deleted file mode 100644 index 406efcc38..000000000 --- a/src/listings/reserved_ranges.md +++ /dev/null @@ -1,30 +0,0 @@ ---- -title: "Reserved Ranges" ---- - -# Actor ID Reserved Ranges - -| Actor | ID | -|---|---| -| SystemActor | 0 | -| InitActor | 1 | -| RewardActor | 2 | -| CronActor | 3 | -| StoragePowerActor | 4 | -| StorageMarketActor | 5 | -| BurntFundsActor | 99 | - -All values below 100 are reserved for singleton actors. The first non-singleton actor starts at 100. - -# Method Reserved Ranges - -| Method | ID | -|---|---| -| value send | 0 | -| constructor | 1 | - -All other positive values are free for actors to use. For the canonical list, see TODO LINK TO ACTOR CODE WHEN DONE. - -# Error Codes - -TODO diff --git a/src/listings/system_map.md b/src/listings/system_map.md deleted file mode 100644 index 78ebf0fd6..000000000 --- a/src/listings/system_map.md +++ /dev/null @@ -1,5 +0,0 @@ ---- -title: "Components" ---- - -TODO diff --git a/src/orient/bin/chung_spec.py b/src/orient/bin/chung_spec.py deleted file mode 100755 index 078f94261..000000000 --- a/src/orient/bin/chung_spec.py +++ /dev/null @@ -1,153 +0,0 @@ -#!/usr/bin/env python3 - -import os.path -import sys -import os -import json -import argparse -import warnings -import math - -warnings.filterwarnings("error") - -def frange(start, stop=None, step=None): - #Use float number in range() function - # if stop and step argument is null set start=0.0 and step = 1.0 - if stop == None: - stop = start + 0.0 - start = 0.0 - if step == None: - step = 1.0 - while True: - if step > 0 and start >= stop: - break - elif step < 0 and start <= stop: - break - yield float(start) - start = start + step - -def bin_entropy(x): - return -x * math.log2(x) - (1 - x) * math.log2(1 - x) - -def chung_formula(d,alpha,beta): - h = bin_entropy - try: - return h(alpha) + h(beta) + d * (beta * h(alpha/beta) - h(alpha)) - except: - return 0 - -def find_max_beta(d,alpha): - betas = frange(0.01,1,0.01) - max_beta = 0 - for b in betas: - r = chung_formula(d,alpha,b) - if r < 0 and b > max_beta: - max_beta = b - return max_beta - - -def find_optimal_degree(alpha, target_beta,max_degree=1000): - degree = 1 - while degree < max_degree: - r = chung_formula(degree,alpha,target_beta) - if r < 0: - return degree - degree += 1 - -def parse(): - parser = argparse.ArgumentParser() - parser.add_argument('json', nargs='?', type=argparse.FileType('r'), - default=sys.stdin) - parser.add_argument("-d","--degree",help="field name in JSON representing degree") - parser.add_argument("-a","--alpha",help="field name in JSON representing alpha") - parser.add_argument("-b","--beta",help="field name to output for beta") - args = parser.parse_args() - alpha = args.alpha if args.alpha is not None else "chung_alpha" - beta = args.beta if args.beta is not None else "chung_beta" - degree = args.degree if args.degree is not None else "expander_parents" - # sys.stderr.write("parsing json %s" %args.json) - try: - json_input = json.load(args.json) - except Exception as e: - sys.exit("json reading error",e) - finally: - args.json.close() - - return [json_input, alpha,beta,degree] - -# From https://hackersandslackers.com/extract-data-from-complex-json-python/ -def extract_value(obj, key): - arr = [] - - def extract(obj, arr, key): - if isinstance(obj, dict): - for k, v in obj.items(): - if isinstance(v, (dict, list)): - extract(v, arr, key) - elif k == key: - arr.append(v) - elif isinstance(obj, list): - for item in obj: - extract(item, arr, key) - return arr - - results = extract(obj, arr, key) - if len(results) > 1: - sys.exit("Multiple %s values inside JSON file. Exit." % key) - elif len(results) == 0: - return None - return results[0] - -def inject_value(input_json,search_key,inject_key,inject_value): - def extract(obj): - if isinstance(obj, dict): - for k, v in obj.items(): - if isinstance(v, (dict, list)): - extract(v) - elif k == search_key: - # add the key/value here - obj[inject_key] = inject_value - return - elif isinstance(obj, list): - for item in obj: - extract(item) - extract(input_json) - -path = "./chung.log" -def rmlog(): - if os.path.isfile(path): - os.remove(path) - -def log(msg): - try: - with open(path,"a+") as f: - f.write(msg + "\n") - except Exception as e: - sys.stderr.write("[LOG] %s \n" % msg) - -def main(): - rmlog() - jinput, alphaT,betaT, degreeT = parse() - alpha = extract_value(jinput,alphaT) - beta = extract_value(jinput,betaT) - degree = extract_value(jinput,degreeT) - - # find the optimal degree (lowest) - if alpha is not None and beta is not None: - degree = find_optimal_degree(alpha,beta) - print("{\"expander_parents\": %s}" % degree) - # inject_value(jinput,alphaT,degreeT,degree) - log("injecting degree %s" % degree) - elif alpha is not None and degree is not None: - beta = find_max_beta(degree,alpha) - rounded = round(beta,5) - # inject_value(jinput,alphaT,betaT,rounded) - print("{\"chung_beta\": %s}" % rounded) - log("injecting beta %s" % rounded) - log("injecting alpha %s" % alpha) - log("injecting degree %s" % degree) - # default behavior: return same thing if nothing to be done - # log("json is now: %s" % str(jinput)) - # json.dump(jinput, sys.stdout) - -main() diff --git a/src/orient/fast-porep.json b/src/orient/fast-porep.json deleted file mode 100644 index c60e89be3..000000000 --- a/src/orient/fast-porep.json +++ /dev/null @@ -1,34 +0,0 @@ -[ - { - "hashes_per_node": 10, - "block_time": 15, - "drg_layers": 1, - "drg_d": 0.003, - "spacegap": 0.6, - "node_size": 32, - "challenges": 1250, - "rig_size": 1, - "rig_ram_gb": 32, - "sector_size_gb": 32, - "onboard_storage": 32 - }, - [ - { - "rig_storage_latency": 0.0033333, - "rig_storage": "HDD" - } - ], - [ - { - "hash_function": "SHA256", - "hashing_amax": 3, - "hashing_time": 0.0000000128 - }, - { - "hash_function": "BLAKE2S", - "hashing_amax": 12, - "hashing_time": 0.0000000314 - } - ] -] - diff --git a/src/orient/fast-porep.orient b/src/orient/fast-porep.orient deleted file mode 100644 index ce39caddb..000000000 --- a/src/orient/fast-porep.orient +++ /dev/null @@ -1,59 +0,0 @@ -FastPoRep: - declare(rig_ram_gb, gb) - declare(block_time, seconds) - declare(drg_layers, drg_layers) - declare(drg_d, ratio) - declare(num_parallel_encoding, integer) - declare(encoding_time, seconds) - declare(sector_size_gb, gb) - declare(rig_cores, integer) - declare(seal_throughput, gb/s) - declare(onboard_storage, gb) - declare(onboard_time, seconds) - declare(onboard_time_hours, hours) - declare(onboard_time_days, days) - declare(rig_size, integer) - declare(onboard_storage_tb, tb) - declare(sealing_per_gb, s/gb) - declare(node_gen_time, seconds) - declare(rig_storage_latency, seconds) - declare(challenges, integer) - declare(hashes_per_node, integer) - declare(hashing_time, seconds) - declare(response_honest, seconds) - declare(response_malicious, seconds) - declare(node_size, bytes) - declare(nodes, nodes) - declare(node_gen_path, nodes) - declare(hashing_amax, integer) - declare(spacegap, ratio) - declare(miner_size_min, gb) - declare(miner_sectors_min, integer) - - miner_size_min = 100 * 1024 - miner_sectors_min = miner_size_min / sector_size_gb - - Encoding: - nodes = (sector_size_gb * 1024 * 1024 * 1024) / node_size - encoding_time = nodes * hashes_per_node * hashing_time * drg_layers - - Throughput: - num_parallel_encoding = rig_ram_gb * rig_size / sector_size_gb - rig_cores = num_parallel_encoding - seal_throughput = (sector_size_gb * num_parallel_encoding) / encoding_time - - Response: - Malicious: - node_gen_path = drg_d * nodes - node_gen_time = node_gen_path * hashes_per_node * hashing_time / hashing_amax - response_malicious = node_gen_time * challenges - - Honest: - response_honest = challenges * rig_storage_latency - - Onboarding: - onboard_storage = seal_throughput * onboard_time - onboard_storage_tb = onboard_storage / 1000 - onboard_time_hours = onboard_time / (60 * 60) - onboard_time_days = onboard_time / (60 * 60 * 24) - diff --git a/src/orient/filecoin.json b/src/orient/filecoin.json deleted file mode 100644 index a95205a94..000000000 --- a/src/orient/filecoin.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "degree_expander": 8, - "degree_base": 6, - "node_size": 32, - "reseal": 0, - "proving_period_hours": 24, - "block_time": 15, - "kdf_hash_time": 0.000000045608, - "leaf_hash_time": 0.000000045608, - "encoding_amax": 2, - "cores": 16, - "leaf_hash_constraints": 1300, - "merkle_hash_time_circuit": 0.076994, - "merkle_hash_time": 0.000013078, - "leaf_hash_circuit_time": 0.076994, - "merkle_hash_constraints": 1300, - "kdf_hash_size": 32, - "proof_messages_fraction": 0.4, - "tx_messages_fraction": 0.3, - "miners": 1000, - "spacegap": 0.1, - "expected_winning_miners": 5, - "lambda": 10, - "sector_size_gib": 32, - "post_challenge_hours": 2 -} diff --git a/src/orient/filecoin.orient b/src/orient/filecoin.orient deleted file mode 100644 index 466367267..000000000 --- a/src/orient/filecoin.orient +++ /dev/null @@ -1,421 +0,0 @@ -Assumptions: - CID [CRH]: - declare(cid_size, bytes) - describe(cid_size, "The size of a CID.", bytes) - cid_size = 32 + 1 + 1 + 1 - - SLE [VRF]: - declare(vrf_proof_size) // TODO - describe(vrf_proof_size, "The size of a VRF proof.", bytes) - -Primitives: - declare(varint, bytes) - describe(varint, "The size of a VarInt.", bytes) - varint = 4 - - u64 = 8 - describe(u64, "The size of a U64, in bytes.") - - Dimensions: - Size: - kib = 1024 - describe (kib, "The number of bytes in one KiB.", bytes) - - mib = 1024 * kib - describe (mib, "The number of bytes in one MiB.", bytes) - - gib = 1024 * mib - describe (mib, "The number of bytes in one GiB.", bytes) - - tib = 1024 * gib - describe (mib, "The number of bytes in one TiB.", bytes) - - pib = 1024 * tib - describe (mib, "The number of bytes in one PiB.", bytes) - - eix = 1024 * pib - describe (mib, "The number of bytes in one EiX.", bytes) - Time: - year_in_seconds = 365.25 * 24 * 60 * 60 - describe(year_in_seconds, "The number of seconds in one year.", seconds) - -VDFRSA: - declare(rsa_element, bytes) - describe(rsa_element, "The size of an RSA element.", bytes) - rsa_element = (2048/8) - -Blockchain: - declare(block_time, seconds) - Address: - address_size = cid_size - describe(address_size, "The size of an address.", bytes) - - Block: - block_framing_size = block_header_size + messages_size + receipts_size - describe(block_framing_size, "The total amount of block framing.", bytes) - - Messages: - // declare(messages, integer) // TODO - messages_size = messages * message_size - describe(messages_size, "The total size of the messages in a block.", bytes) - - messages_root_cid = cid_size - describe(messages_root_cid, "Size of the CID of the root merkle tree of the messages.", bytes) - - Message: - message_size = to_address + from_address + message_nonce + value + gas_price + gas_limit + actor_method - describe(message_size, "The size of a single message.", bytes) - - to_address = address_size - describe(to_address, "The size of a message's 'to address'.", bytes) - - from_address = address_size - describe(to_address, "The size of a message's 'from address'.", bytes) - - Nonce: - declare(message_nonce, bytes) // TODO - describe(message_nonce, "The size of a message's nonce.", bytes) - message_nonce = varint - - Value: - declare(value, bytes) - describe(value, "The size of a 'value' element.", bytes) - value = u64 - - Gas: - declare(gas_price, bytes) - describe(gas_price, "The size required to represent the gas price.", bytes) - gas_price = u64 - - declare(gas_limit, bytes) - describe(gas_price, "The size required to represent the gas limit.", bytes) - gas_limit = u64 - - ActorMethod: - declare(actor_method, bytes) // TODO: actor_method what is it? how big is it? - actor_method = u64 - describe(actor_method, "The size required to represent an actor method.", bytes) - - Receipts: - receipts = messages // TODO check - // declare(receipts, integer) // TODO - receipts_size = receipts * message_receipt - describe(receipts_size, "The total size of all message receipts, in bytes.") - message_receipts_cid = cid_size - describe(message_receipts_cid, "The size of one message receipt's CID.", bytes) - - Receipt: - message_receipt = exit_code + return + gas_used - describe(message_receipt, "The size of one message receipt.", bytes) - - // declare(exit_code, bytes) // TODO - exit_code = varint - describe(exit_code, "The size of an exit code.", bytes) - // declare(return, bytes) // TODO - return = varint - describe(return, "The size of a message's return value.", bytes) - - // declare(gas_used, bytes) // TODO - gas_used = u64 - describe(gas_used, "The size required to represent the amount of gas used by a message.", bytes) - - BlockHeader (EC): - declare(block_header_size, bytes) - assume(block_header_size > 0) - assume(block_header_size < 1024*1024*10) // assume max is 10MB - - block_header_size = block_header_fixed_size + block_header_variable_size - block_header_fixed_size = miner_address_size + election_proof_size + parent_weight_size + block_height_size + state_root_cid + messages_root_cid + bls_agg_size + message_receipts_cid + timestamp_size + block_sig_size - block_header_variable_size = tickets_size + parents_cids - - StateTree: - state_root_cid = cid_size - - Weight: - declare(parent_weight_size, bytes) // TODO - parent_weight_size = u64 - - Height: - declare(block_height_size, bytes) // TODO - block_height_size = u64 - - MinerAddress [CID]: - miner_address_size = address_size - - ElectionProof (VRFBls) [SLE, BLSSig]: - declare(election_proof_size, bytes) // TODO - election_proof_size = 64 - - // ElectionProof (VRFSecpk) [SLE, Secpk]: - // declare(election_proof_size, bytes) // TODO - // election_proof_size = 80 - - Parents [CID]: - // declare(parents, integer) // TODO - parents = expected_winning_miners - parents_cids = parents * cid_size - - BLSSignatures (BLSSigAgg) [BLSSigAgg]: - declare(bls_agg_size, bytes) // TODO - bls_agg_size = 96 - - Timestamp: - // declare(timestamp_size, integer) // TODO - timestamp_size = u64 - - // BlockSig (BlockSigSecpk): - // declare(block_sig_size, integer) // TODO - // block_sig_size = 80 - - BlockSig (BlockSigBls): - declare(block_sig_size, integer) // TODO - block_sig_size = 96 - - Tickets: - // declare(tickets, integer) - declare(tickets_size, bytes) - tickets_size = ticket_size * tickets - ticket_size = election_proof_size + vdf_proof_size + vdf_output_size - -SNARK [SNARKAssumptions]: - declare(snark_single_proof_size, bytes) - snark_single_proof_size = 192 - snark_max_constraints = 100000000 - -// VDF (VDFStorageBased): -// vdf_proof_size = (vdf_snark_circuit / snark_max_constraints) * snark_single_proof_size -// vdf_output_size = hash_size - -VDF (VDFRSA): - vdf_proof_size = 3 * rsa_element - vdf_output_size = 0 - -Proofs: - ProofOfReplication: - Graph: - // declare(node_size, integer) - // declare(sector_size, integer) - // declare(nodes, integer) - nodes = sector_size / node_size - degree = degree_base + degree_expander - sector_size_gib = sector_size / gib - - DRG (DRSample) [DRGAssumption]: - // declare(degree_base, integer) - drg_e = 0.80 - drg_d = 1/4 - - ExpanderParents (Chung) [ChungAssumption]: - // declare(degree_expander, integer) - - Layers: - // declare(layers, integer) - assume(layers > 0) - - Soundness: - // declare(lambda, integer) - assume(soundness > 0) - assume(soundness < 0.5) - soundness = 1/(2^lambda) - - SpaceGap: - assume(spacegap > 0) - assume(spacegap < 0.5) - - Challenges: - OfflineChallenges: - // declare(offline_challenges, integer) - // declare(offline_challenges_all, integer) - assume(offline_challenges > 0) - - OnlineChallenges: - // declare(online_challenges, integer) - assume(online_challenges > 0) - - Seal: - Encoding [KDFTiming]: - assume(kdf_content > 0) - assume(encoding_time > 0) - assume(polling_time > 0) - kdf_content = degree + 1 - encoding_time = layers * nodes * (kdf_content - 1) * kdf_hash_time * (node_size / kdf_hash_size) - encoding_time_mins = encoding_time / 60 - malicious_encoding = encoding_time / encoding_amax - polling_time = malicious_encoding * drg_d - - Commitment (ColumnCommitments) [CRH]: - commit_size = cid_size - assume(replica_commit_time > 0) - replica_commit_time = commit_time * 3 + leaf_time * nodes - seal_commitments_size = commit_size * 2 // 1 commD, 1 CommR - - ProofGeneration (ColumnCommitments): - assume(opening_time > 0) - openings = offline_challenges * opening_per_challenge - - Leaf: - leaf_constraints = layers * leaf_hash_constraints - leaf_circuit_time = layers * leaf_hash_circuit_time - leaf_time = layers * leaf_hash_time - - Inclusion (MerkleVC) [CRH]: - // declare(tree_depth, integer) - tree_depth = (log2(nodes)) - inclusion_circuit_time = tree_depth * merkle_hash_time_circuit - inclusion_constraints = tree_depth * merkle_hash_constraints - commit_time = nodes * merkle_hash_time - - SNARK [SNARKAssumptions]: - comm_d_openings = 1 - comm_d_time = offline_challenges * (comm_d_openings * inclusion_circuit_time) - comm_d_constraints = offline_challenges * (comm_d_openings * inclusion_constraints) - - comm_r_openings = degree_base - comm_r_time = offline_challenges * (comm_r_openings * inclusion_circuit_time) - comm_r_constraints = offline_challenges * (comm_r_openings * inclusion_constraints) - - comm_c_openings = opening_per_challenge - comm_c_time = offline_challenges * (comm_c_openings * (inclusion_circuit_time + leaf_circuit_time)) - comm_c_constraints = offline_challenges * (comm_c_openings * (inclusion_constraints + leaf_constraints)) - - porep_snark_time = comm_d_time + comm_r_time + comm_c_time - porep_snark_constraints = comm_d_constraints + comm_r_constraints + comm_c_constraints - - porep_snark_partitions = porep_snark_constraints / snark_max_constraints - porep_snark_proof_size = porep_snark_partitions * snark_single_proof_size - - proofgen_time = porep_snark_time - - Size: - seal_proof_size = porep_snark_proof_size + seal_commitments_size - - Time: - seal_time = replica_commit_time + proofgen_time + encoding_time - parallel_seal_time = (porep_snark_time + commit_time)/cores + encoding_time - declare(unseal_time) // TODO - - Cost: - seal_cost = seal_time * (cpu_cost_per_second + memory_cost_per_second) - declare(unseal_cost) // TODO - - ProofOfReplication (SDR): - Graph: - Layers: - layers = layers_b // TODO max(layers_a, layers_b) + 1 - layers_a = (0.68 - epsilon + delta) / (0.12 - delta) - layers_b = (log2(1 / (3 * (epsilon - 2 * delta)))) + 0.12 / (0.12 - delta) + 1 - - SpaceGap: - assume(epsilon <= 0.24) - // delta < epsilon/2 - // delta = epsilon/2 + 0.001 - // spacegap = epsilon + 2 * delta - spacegap = 2 * epsilon - 0.001 - delta = epsilon/2 - 0.001 - - Challenges: - OfflineChallenges: - offline_challenges = (- lambda) / (log2(1 - delta)) - - OnlineChallenges: - online_challenges = (- lambda) / (log2(2 - epsilon - 2 * delta) - 1) - - ProofGeneration (ColumnCommitments): - opening_per_challenge = degree_base + degree_expander + 1 - - ProofOfSpacetime: - Randomness [RandomBeacon]: - declare(post_randomness_lookback) - - Parameters: - declare(proving_period_hours) - declare(max_proving_sectors) - - declare(post_challenge_blocks) - describe(post_challenge_blocks, "The time offset before which the actual work of generating the PoSt cannot be started. This is some delta before the end of the Proving Period, and as such less than a single Proving Period.", blocks) - - describe(post_challenge_time, "PoSt challenge time (see POST_CHALLENGE_BLOCKS).", seconds) - post_challenge_time = post_challenge_blocks * block_time - post_challenge_time = post_challenge_hours * 60 * 60 - describe(post_challenge_hours "PoSt challenge time (see POST_CHALLENGE_BLOCKS).", hours) - - ProofOfSpacetime (RationalPoSt): - Parameters: - post_challenges = online_challenges - post_proving_period = proving_period_seconds / block_time - describe(post_proving_period, "The time interval in which a PoSt has to be submitted", blocks) - - Cost: - declare(post_proving_cost) - - SNARK: - post_snark_circuit = online_challenges * inclusion_constraints - - Size: - post_proof_size = post_snark_proof_size - post_snark_proof_partitions = 1 // TODO post_snark_circuit / snark_max_constraints - post_snark_proof_size = post_snark_proof_partitions * snark_single_proof_size - - -Consensus [ProofOfReplication, ProofOfSpacetime]: - // declare(expected_winning_miners, integer) - // declare(finality_height, integer) - Tickets: - tickets = avg_tickets - avg_tickets = 1 - min_tickets = 0 - max_tickets = log(one_block_in_ten_years)/log(0.36) + 1 // 0.36^(max_tickets-1) = one_block_in_ten_years - blocks_in_a_year = (year_in_seconds / block_time) * expected_winning_miners - blocks_in_ten_years = blocks_in_a_year * 10 - one_block_in_ten_years = 1/blocks_in_ten_years - -StorageMarket: - declare(min_storing_time) - Deals (OnChainDeals): - comm_p_size = cid_size - declare(p_size, 1) - p_size = (log2(sector_size)) - sector_manifest_size = pieces * comm_p_size + p_size - max_sector_manifest_hashes = sector_size / min_piece_size - - -Mining: - proving_period_seconds = proving_period_hours * 60 * 60 - - seals_per_sector_per_year = reseal+1 - posts_per_sector_per_year = year_in_seconds / proving_period_seconds - -ScalingRequirements: - storage_network_capacity = 10 * eix - -ChainBandwidth: - sectors_count = storage_network_capacity / sector_size - all_seal_size_per_year = all_seal_messages_per_year - all_seal_messages_per_year = sectors_count * seals_per_sector_per_year - all_post_messages_per_year = sectors_count * posts_per_sector_per_year / miners - - Chain Size: - - Block Size: - chain_size_year = block_size * blocks_in_a_year - chain_size_year_gib = chain_size_year / gib - block_size_kib = block_size / kib - - Block Content: - block_size = block_framing_size + proofs_size_per_block - messages = avg_proofs_messages_per_block + tx_messages_per_block + actors_messages_per_block // TODO messages dont include deals - - Proofs: - avg_proofs_messages_per_block = avg_seals_messages_per_block + avg_posts_messages_per_block - avg_seals_messages_per_block = all_seal_messages_per_year / blocks_in_a_year - avg_posts_messages_per_block = all_post_messages_per_year / blocks_in_a_year - - seal_size_per_block = avg_seals_messages_per_block * seal_proof_size - post_size_per_block = avg_posts_messages_per_block * post_proof_size - proofs_size_per_block = seal_size_per_block + post_size_per_block - proofs_size_per_block_kib = proofs_size_per_block / kib - - Composition: - avg_proofs_messages_per_block = proof_messages_fraction * messages - tx_messages_per_block = tx_messages_fraction * messages - actors_messages_per_block = actors_messages_fraction * messages diff --git a/src/orient/multi-params.json b/src/orient/multi-params.json deleted file mode 100644 index d4eae2778..000000000 --- a/src/orient/multi-params.json +++ /dev/null @@ -1,45 +0,0 @@ -[ - { - "degree_expander": 8, - "degree_base": 6, - "node_size": 32, - "reseal": 0, - "proving_period_hours": 24, - "block_time": 15, - "kdf_hash_time": 0.000000045608, - "leaf_hash_time": 0.000000045608, - "encoding_amax": 2, - "cores": 16, - "leaf_hash_constraints": 1300, - "merkle_hash_time_circuit": 0.076994, - "merkle_hash_time": 0.000013078, - "leaf_hash_circuit_time": 0.076994, - "merkle_hash_constraints": 1300, - "kdf_hash_size": 32, - "proof_messages_fraction": 0.4, - "tx_messages_fraction": 0.3, - "miners": 1000 - }, - [ - { "spacegap": 0.03 }, - { "spacegap": 0.06 }, - { "spacegap": 0.1 }, - { "spacegap": 0.2 } - ] - , - [ - { "expected_winning_miners": 1 }, - { "expected_winning_miners": 5 }, - { "expected_winning_miners": 15 } - ], - [ - { "lambda": 10 }, - { "lambda": 80 } - ], - [ - { "sector_size_gib": 32 }, - { "sector_size_gib": 128 }, - { "sector_size_gib": 256 }, - { "sector_size_gib": 1024 } - ] -] diff --git a/src/orient/rational-calc.json b/src/orient/rational-calc.json deleted file mode 100644 index c04a249d5..000000000 --- a/src/orient/rational-calc.json +++ /dev/null @@ -1,84 +0,0 @@ -[ - [ - { - "!ElectionWithFallbackPoSt": true, - "!SectorEncoding": true, - "!VectorR": true, - "!Wrapping": true, - "!WrappingVariant": false, - "!StackedReplicas": false - }, - { - "!ElectionWithFallbackPoSt": true, - "!SectorEncoding": true, - "!VectorR": true, - "!WrappingVariant": true, - "!Wrapping": false, - "!StackedReplicas": false - }, - { - "!ElectionWithFallbackPoSt": true, - "!SectorEncoding": true, - "!VectorR": true, - "!Wrapping": false, - "!WrappingVariant": false, - "!StackedReplicas": true - } - ], - [ - { - "!StackedChungParameters": true, - "!StackedSDRParameters": false, - "chung_delta": 0.01 - }, - { - "!StackedChungParameters": false, - "!StackedSDRParameters": true, - "sdr_delta": 0.01 - } - ], - { - "spacegap": 0.2, - "column_leaf_hash_constraints": 1376, - "column_leaf_hash_time": 2.56e-7, - "cost_amax": 1, - "cost_gb_per_month": 0.005, - "ec_e": 5, - "epost_challenged_sectors_fraction": 0.04, - "extra_storage_time": 0, - "fallback_period_days": 1, - "fallback_ratio": 0.05, - "filecoin_reseals_per_year": 1, - "filecoin_storage_capacity_eib": 10, - "hash_gb_per_second": 5, - "hashing_amax": 2, - "kdf_constraints": 25000, - "kdf_time": 1.28e-8, - "merkle_tree_datahash_constraints": 56000, - "merkle_tree_datahash_time": 1.28e-8, - "merkle_tree_hash_constraints": 1376, - "merkle_tree_hash_time": 2.56e-7, - "node_size": 32, - "block_time": 15, - "porep_lambda": 10, - "porep_snark_partition_constraints": 100000000, - "post_lambda": 10, - "post_mtree_layers_cached": 25, - "post_snark_partition_constraints": 3000000, - "proofs_block_fraction": 0.3, - "rig_cores": 16, - "rig_malicious_cost_per_year": 2.5, - "rig_ram_gib": 32, - "rig_storage_latency": 0.003, - "rig_storage_min_tib": 100, - "rig_storage_parallelization": 30, - "rig_storage_read_mbs": 80, - "sector_size_gib": 32, - "snark_constraint_time": 0.000004642, - "snark_size": 192, - "ticket_constraints": 1376, - "ticket_hash": 2.56e-7, - "window_size_mib": 32768, - "wrapper_parents": 10 - } -] diff --git a/src/orient/rational-calc.orient b/src/orient/rational-calc.orient deleted file mode 100644 index ddee87d1d..000000000 --- a/src/orient/rational-calc.orient +++ /dev/null @@ -1,836 +0,0 @@ -// If you wish to make an apple pie from scratch, you must first uber-calc the universe. - -Rig: - describe(rig_sectors_min, "Minimum sectors require to mine") - - describe(rig_storage_latency, "Random Access latency on the storage medium (honest)", secs) - describe(rig_storage_parallelization, "Storage Units that can be accessed in parallel (honest)") - describe(rig_storage_min, "Minimum storage required to mine", bytes) - describe(rig_storage_min_tib, "Minimum storage required to mine", tib) - describe(rig_storage_parallelization_min, "Minimum storage units that must be accessed in parallel in order to mine (honest)") - describe(rig_storage_unit_max, "Maximum storage capacity for a storage unit", bytes) - describe(rig_storage_unit_max_tib, "Maximum storage capacity for a storage unit", tib) - - describe(rig_malicious_cost_per_year, "Cost of the malicious computing rig per year") - describe(rig_cores, "Number of CPU cores") - describe(rig_snark_parallelization, "Number of SNARK proofs that can be generated in parallel") - describe(rig_storage_read_mbs, "Sequential read speed (MB/s)") - describe(rig_storage_write_mbs, "Sequential write speed (MB/s)") - describe(rig_storage_read_mibs, "Sequential read speed (MiB/s)") - describe(rig_storage_write_mibs, "Sequential write speed (MiB/s)") - - describe(rig_storage_unit_cost, "Cost of a single storage unit", dollar) - describe(rig_storage_unit_gb, "Amount of storage in a storage unit", gb) - describe(rig_storage_unit_gib, "Amount of storage in a storage unit", gib) - describe(rig_storage_unit_pib, "Amount of storage in a storage unit", pib) - describe(rig_storage_cost_gib, "Cost of 1GB", dollar) - describe(rig_storage_cost_pib, "Cost of 1PB", dollar) - - rig_storage_unit_gib = rig_storage_unit_gb * gb_to_gib - rig_storage_cost_gib = rig_storage_unit_cost / rig_storage_unit_gib - rig_storage_cost_pib = rig_storage_cost_gib * gib_in_pib - - describe(rig_gpu_cost, "Cost of a GPU", dollar) - describe(rig_cpu_cost, "Cost of a CPU", dollar) - describe(rig_gpu_cost_secs, "Cost of a GPU per second", dollar) - describe(rig_cpu_core_cost, "Cost of a single CPU core", dollar) - describe(rig_cpu_core_cost_secs, "Cost of a CPU core per second", dollar) - describe(rig_cpu_lifetime_years, "Lifetime of a CPU", years) - describe(rig_gpu_lifetime_years, "Lifetime of a GPU", years) - - rig_storage_read_mibs = rig_storage_read_mbs * mb_to_mib - rig_storage_write_mibs = rig_storage_write_mbs * mb_to_mib - rig_storage_min = rig_storage_min_tib * b_in_tib - rig_sectors_min = rig_storage_min / sector_size - rig_storage_parallelization_min = epost_data_access / block_time - - rig_storage_unit_max = rig_storage_min / rig_storage_parallelization_min - rig_storage_unit_max_tib = rig_storage_unit_max / b_in_tib - - rig_gpu_cost_secs = rig_gpu_cost / (rig_gpu_lifetime_years * secs_in_year) - rig_cpu_core_cost = rig_cpu_cost / rig_cores - rig_cpu_cost_secs = rig_cpu_cost / (rig_cpu_lifetime_years * secs_in_year) - rig_cpu_core_cost_secs = rig_cpu_core_cost / (rig_cpu_lifetime_years * secs_in_year) - -Crypto: - describe(snark_size, "Size of a SNARK proof", bytes) - describe(snark_constraint_time, "Time of proving a SNARK constraint", secs) - describe(hashing_amax, "Factor of difference between stock CPU hashing and the fastest hashing") - - describe(commc_hash_time, "Time to hash 64 bytes in the CommC merkle tree", secs) - describe(commc_column_hash_time, "Average time to hash 32 bytes in the CommC column", secs) - describe(commd_hash_time, "Time to hash 64 bytes in the CommD merkle tree", secs) - describe(commr_hash_time, "Time to hash 64 bytes in the CommR merkle tree", secs) - - describe(commc_hash_constraints, "Constraints for hashing 64 bytes in the CommC merkle tree", constraints) - describe(commc_column_hash_constraints, "Average constraints for hashing 32 bytes in CommC column", constraints) - describe(commd_hash_constraints, "Constraints for hashing 64 bytes in the CommD merkle tree", constraints) - describe(commr_hash_constraints, "Constraints for hashing 64 bytes in the CommR merkle tree", constraints) - -Utils: - describe(cid_size, "Size of a CID", bytes) - describe(secs_in_month, "Number of seconds in a month") - describe(secs_in_year, "Number of seconds in a year") - describe(secs_in_day, "Number of seconds in a day") - describe(secs_in_min, "Number of seconds in a minute") - describe(b_in_eib, "Number of bytes in a EiB") - describe(b_in_pib, "Number of bytes in a PiB") - describe(b_in_tib, "Number of bytes in a TiB") - describe(b_in_gib, "Number of bytes in a GiB") - describe(b_in_mib, "Number of bytes in a MiB") - describe(b_in_kib, "Number of bytes in a KiB") - describe(gib_in_tib, "Number of GiB in a TiB") - describe(gib_in_pib, "Number of GiB in a PiB") - describe(gb_to_gib, "Ratio between GB and GiB") - describe(mb_to_mib, "Ratio between MB and MiB") - - b_in_eib = (1024 * 1024 * 1024 * 1024 * 1024 * 1024) - b_in_pib = (1024 * 1024 * 1024 * 1024 * 1024) - b_in_tib = (1024 * 1024 * 1024 * 1024) - b_in_gib = (1024 * 1024 * 1024) - b_in_mib = (1024 * 1024) - gib_in_tib = 1024 - gib_in_pib = 1024 * 1024 - b_in_kib = 1024 - secs_in_month = (24 * 60 * 60 * 30) - secs_in_year = (24 * 60 * 60 * 365) - secs_in_day = (24 * 60 * 60) - secs_in_min = (60) - cid_size = 32 + 1 + 1 + 1 - gb_to_gib = (1024 * 1024 * 1024) / (1000 * 1000 * 1000) - mb_to_mib = (1024 * 1024) / (1000 * 1000) - -ProofOfSpacetime: - // post_vanilla_size = node_size * (log2(nodes) + 1) * post_challenges - Security: - describe(post_challenges, "Number of challenges in a PoSt proof") - describe(post_lambda, "Bits of security of a PoSt proof") - describe(post_soundness, "Probability of an adversary to succeed in generating a convincing PoSt proof") - post_soundness = expt(2, -post_lambda) - - Size: - describe(post_proof_size, "Size of a PoSt proof") - post_proof_size = post_snark_size - - ProofGeneration: - describe(post_time, "Time to generate a PoSt Proof on a single core CPU", secs) - describe(post_time_parallel, "Parallel time to generate a PoSt proof on RIG_CORES CPU cores", secs) - describe(post_snark_time, "Time to generate a PoSt SNARK", secs) - describe(post_snark_time_parallel, "Time to generate a PoSt SNARK in parallel", secs) - describe(post_proof_gen, "Time to generate a PoSt Proof (including SNARKs, generating witnesses and reading from storage the challenged leaves)", secs) - describe(post_proof_gen_parallel, "Time to generate a PoSt Proof (including SNARKs, generating witnesses and reading from storage the challenged leaves) in parallel", secs) - describe(post_inclusions_time, "Time to generate merkle tree inclusion proofs for PoSt (assuming all data in memory)", secs) - describe(post_inclusions_time_parallel, "Time to regenerate and to read the merkle tree inclusion proofs for the challenged nodes from memory in parallel", secs) - describe(post_ticket_gen, "Time to generate a ticket", secs) - - post_time = post_proof_gen - post_time_parallel = post_proof_gen_parallel - post_proof_gen = post_snark_time + post_inclusions_time + post_ticket_gen + post_data_access - // TODO: this should be max(), not sum - post_proof_gen_parallel = post_snark_time_parallel + post_inclusions_time_parallel + post_data_access_parallel + post_ticket_gen - - // This only accounts for generating the merkle trees - Ticket: - describe(ticket_hash_time, "Time to compute the hash of a node for ticket generation in PoSt", secs) - post_ticket_gen = ticket_hash_time * post_challenges - - InclusionProofs: - Caching: - describe(post_mtree_cached, "Size of the cached parts of the replica merkle tree", bytes) - describe(post_mtree_cached_hashnodes, "Number of intermediary hash nodes cached of the replica merkle tree") - describe(post_mtree_cached_gib, "POST_MTREE_CACHED in GiB") - describe(post_mtree_overhead, "Fraction of extra storage a miner will have to use to cache the replica merkle tree") - describe(post_mtree_layers_cached, "Number of layers of the replica merkle tree being cached") - describe(post_mtree_layers_deleted, "Number of layers of the replica merkle tree not being cached") - - post_mtree_cached = post_mtree_cached_hashnodes * node_size - post_mtree_cached_gib = post_mtree_cached / b_in_gib - post_mtree_overhead = post_mtree_cached / sector_size - post_mtree_cached_hashnodes = expt(2, post_mtree_layers_cached) - 1 - post_mtree_layers_deleted = commr_tree_depth - post_mtree_layers_cached - - Generation: - describe(post_mtree_regen_hashnodes, "Number of intermediary nodes to be regenerated for a single replica merkle tree inclusion proof in PoSt") - describe(post_mtree_regen_nodes, "Number of leaf nodes to be access for a single replica merkle tree inclusion proof in PoSt") - describe(post_inclusion_time, "Time to generate a Merkle tree inclusion proof for PoSt (assuming all data in memory)", secs) - - post_mtree_regen_hashnodes = expt(2, post_mtree_layers_deleted + 1) - 1 // TODO check if -1 should be removed - - post_mtree_regen_nodes = expt(2, post_mtree_layers_deleted) - 1 // TODO check if -1 should be removed - post_inclusions_time = post_inclusion_time * post_challenges - post_inclusions_time_parallel = post_inclusions_time / rig_cores - - Generation (Wrapping): - post_inclusion_time = (post_mtree_regen_hashnodes - 1) * commr_hash_time - - Generation (StackedReplicas): - post_inclusion_time = (post_mtree_regen_hashnodes - 1) * commr_hash_time - - Generation (WrappingVariant): - describe(wrapper_kdf_time, "Time to generate a node on the wrapper layer", secs) - - wrapper_kdf_time = kdf_time * wrapper_parents_all * post_mtree_regen_nodes - post_inclusion_time = (post_mtree_regen_hashnodes - 1) * commr_hash_time + wrapper_kdf_time - - StorageAccess: - describe(post_mtree_read, "Time to read Merkle tree data during PoSt", secs) - describe(post_mtree_read_parallel, "Time to read Merkle tree data during PoSt", secs) - describe(post_challenge_read, "Time to read from storage medium data required for a single challenge in PoSt", secs) - describe(post_data_access, "Time to retrieve from the storage unit the data for PoSt", secs) - describe(post_data_access_parallel, "Time to retrieve from the storage unit the data in parallel for PoSt", secs) - describe(post_leaf_read, "Time to retrieve the challenged leaf in PoSt", secs) - describe(post_leaves_read, "Time to retrieve the all the challenged leaves in PoSt", secs) - describe(post_leaves_read_parallel, "Time to retrieve the all the challenged leaves in PoSt in parallel", secs) - - post_data_access = post_challenge_read * post_challenges - post_leaves_read = post_leaf_read * post_challenges - // TODO(enhancement): calculate first mtree and then challenge_read - post_mtree_read = (post_challenge_read - post_leaf_read) * post_challenges - post_data_access_parallel = post_data_access / rig_storage_parallelization - post_leaves_read_parallel = post_leaves_read / rig_storage_parallelization - post_mtree_read_parallel = post_mtree_read / rig_storage_parallelization - - Access (Wrapping): - // TODO(enhancement): this is using random access, we should use seq access instead - post_leaf_read = rig_storage_latency - post_challenge_read = (1 + post_mtree_regen_nodes) * rig_storage_latency - // TODO: log2(nodes) > post_mtree_layers_cached - - Access (WrappingVariant): - describe(wrapper_lookup_read, "Time to retrieve from storage medium all the parents of a wrapper layer node", secs) - describe(wrapper_lookup_with_mtree, "Time to retrieved from storage medium all the parents of the challenged node and those required for the merkle tree regeneration", secs) - - wrapper_lookup_read = wrapper_parents_all * rig_storage_latency - post_leaf_read = wrapper_lookup_read - - wrapper_lookup_with_mtree = wrapper_lookup_read * (1 + post_mtree_regen_nodes) - post_challenge_read = wrapper_lookup_with_mtree - - // TODO: this might be incorrect depending on the vector - // TODO: fix vector calculation - // TODO: add merkle tree reads - Access (StackedReplicas): - describe(stack_lookup_read, "Time to read from storage medium the column of a single window", secs) - describe(rig_storage_random_access_size, "Size of storage read via a random access in the storage medium", bytes) - describe(rig_storage_random_access_nodes, "Number of nodes read via a random access in the storage medium") - - - // TODO: this should be a parameter, not hardcoded - DataAligned (StackedReplicaAligned): - rig_storage_random_access_size = 4 * b_in_kib - rig_storage_random_access_nodes = rig_storage_random_access_size / node_size - - // The first random_access_nodes are read by the random read, the remaining ones are read sequentially - stack_lookup_read = rig_storage_latency + ((windows - rig_storage_random_access_nodes) * node_size_mib) / rig_storage_read_mibs - - DataAligned (StackedReplicaUnaligned): - stack_lookup_read = rig_storage_latency * windows - - post_leaf_read = stack_lookup_read - post_challenge_read = stack_lookup_read - - SNARK: - describe(inclusion_proof, "Constraints for checking an inclusion proof in a binary merkle tree as large as the sector") - describe(post_inclusion_proofs, "Constraints for checking all inclusion proofs (in PoSt)") - describe(ticket_proofs, "Constraints for checking the partial ticket (in PoSt)") - describe(ticket_hash_constraints, "Constraints of a partial ticket per challenged node (in PoSt)") - describe(post_snark_constraints, "Constraints for a PoSt") - describe(post_snark_partitions, "Number of partitions of a PoSt proof") - describe(post_snark_size, "Size of a PoSt proof", bytes) - describe(post_snark_size_kib, "Size of a Post proof", kib) - describe(post_snark_partition_constraints, "Number of constraints for a PoSt partition") - describe(post_snark_partition_time, "Time to generate a single PoSt SNARK partition", secs) - describe(commr_column_size, "Number of nodes in the CommR leaf") - - // TODO: make sure VectorR/etc are handled correctly - inclusion_proof = commr_hash_constraints * commr_tree_depth - post_inclusion_proofs = inclusion_proof * post_challenges - ticket_proofs = ticket_hash_constraints * commr_column_size * post_challenges - // TODO: handle different constructions - post_snark_constraints = ticket_proofs + post_inclusion_proofs - post_snark_partitions = post_snark_constraints / post_snark_partition_constraints - post_snark_size = post_snark_partitions * snark_size - post_snark_size_kib = post_snark_size / b_in_kib - post_snark_time = snark_constraint_time * post_snark_constraints - post_snark_partition_time = snark_constraint_time * post_snark_constraints - // Parallelization calculation: it must take at least the time for a single snark - // the remaining can be done in parallel - // Similar in spirit to: - // min(porep_snark_partition_time, porep_snark_time / snarrk_parallelization) - post_snark_time_parallel = post_snark_partition_time + (post_snark_time - post_snark_partition_time) / (rig_snark_parallelization) - -// TODO: add proof of window possession -ProofOfReplication: - Security: - describe(porep_challenges, "Number of challenges in a PoRep proof") - describe(porep_lambda, "Bits of security of a PoRep proof") - describe(spacegap, "Maximum difference in storage between an honest prover and a malicious prover") - describe(porep_soundness, "Probability of an adversary to succeed in generating a convincing PoRep proof") - - porep_soundness = expt(2, -porep_lambda) - - Graph: - describe(nodes, "Number of nodes in a sector") - describe(stacked_layers, "Number of stacked layers of the graph") - - Sector: - describe(sector_size, "Size of a sector", bytes) - describe(sector_size_mib, "Size of a sector", mib) - describe(sector_size_gib, "Size of a sector", gib) - - sector_size = sector_size_gib * b_in_gib - sector_size_mib = sector_size / b_in_mib - - Window: - describe(window_nodes, "Number of nodes in a window") - describe(window_size, "Size of a window", bytes) - describe(window_size_mib, "Size of a window", mib) - describe(window_size_gib, "Size of a window", mib) - describe(windows, "Number of windows in a sector") - - window_size = window_size_mib * b_in_mib - window_size = window_size_gib * b_in_gib - windows = sector_size / window_size - window_nodes = nodes / windows - - Parents: - describe(graph_parents, "Number of parents of a node in the PoRep window graph") - describe(drg_parents, "Number of DRG parents of a node in the PoRep window graph") - describe(expander_parents, "Number of Chung Expander parents of a node in the PoRep window graph") - describe(wrapper_parents, "Number of parents in the wrapper layer per window") - describe(wrapper_parents_all, "Number of parents in the wrapper layer") - wrapper_parents_all = wrapper_parents * windows - - graph_parents = drg_parents + expander_parents - - Nodes: - describe(node_size, "Size of a node", bytes) - describe(node_size_mib, "Size of a node", mib) - describe(node_size_gib, "Size of a node", gib) - describe(kdf_hash_size, "Size of the input to the KDF hash", bytes) - describe(kdf_hash_size_gib, "Size of the input to the KDF hash", gib) - - nodes = sector_size / node_size - node_size_mib = node_size / b_in_mib - node_size_gib = node_size / b_in_gib - kdf_hash_size_gib = graph_parents * node_size_gib - kdf_hash_size = kdf_hash_size_gib * b_in_gib - - Time: - describe(porep_time, "Time to seal a sector (PoRep proof)", secs) - describe(porep_precommit_time, "Time to pre-commit a sector (PoRep proof)", secs) - describe(porep_precommit_time_parallel, "Time to pre-commit a sector in parallel (PoRep proof)", secs) - describe(porep_time_mins, "Time to seal a sector (PoRep proof)", mins) - describe(porep_time_parallel, "Time to seal a sector (PoRep proof) with parallelization", secs) - describe(porep_proof_gen, "Time to generate a PoRep proof (SNARK, witness generation, loading data from storage medium)", secs) - describe(porep_proof_gen_parallel, "Time to generate a PoRep proof (SNARK, witness generation, loading data from storage medium) in parallel", secs) - - porep_proof_gen = porep_snark_time // TODO(enhancement): add porep_inclusions_time + porep_data_access - porep_proof_gen_parallel = porep_snark_time_parallel - - porep_time = porep_proof_gen + porep_commit_time + encoding_time - porep_time_mins = porep_time / secs_in_min - porep_time_parallel = porep_proof_gen_parallel + porep_commit_time_parallel + encoding_time_parallel - - porep_precommit_time = porep_commit_time + encoding_time - porep_precommit_time_parallel = porep_commit_time_parallel + encoding_time_parallel - - describe(dig_encoding_time, "Time to encode and generate CommC leaves (Dig's benchmarks)") - describe(dig_encoding_time_parallel, "Time to encode and generate CommC leaves in parallel (Dig's benchmarks)") - dig_encoding_time = encoding_time + commc_columns_time - dig_encoding_time_parallel = encoding_time_parallel + commc_columns_time_parallel - - Size: - describe(porep_proof_size, "Size of a PoRep proof") - describe(porep_proof_size_kib, "Size of a PoRep proof", kib) - porep_proof_size = porep_snark_size + seal_onchain_commitments_size - porep_proof_size_kib = porep_proof_size / b_in_kib - - // TODO: rename commR to commRLast - Commitment: - describe(commc_window_tree_time, "Time to generate a merkle tree of stacked windows", secs) - describe(commc_window_columns_time, "Time to commit columns of a window", secs) - - describe(commit_size, "Size of a commitment", bytes) - describe(commr_size, "Size of CommR", bytes) - describe(commd_size, "Size of CommD", bytes) - describe(commrlast_size, "Size of CommRLast", bytes) - - describe(commr_tree_depth, "Number of layers of the merkle tree with root hash CommR") - - describe(seal_onchain_commitments_size, "Size of the seal commitments", bytes) - describe(porep_commit_time, "Time to generate CommC, CommR and CommQ", secs) - describe(porep_commit_time_mins, "Time to generate CommC, CommR and CommQ", mins) - describe(porep_commit_time_parallel, "Time to generate CommC, CommR and CommQ in parallel", secs) - - describe(commr_time, "Time to generate CommR", secs) - describe(commr_time_parallel, "Time to generate CommR in parallel", secs) - describe(commq_time, "Time to generate CommQ", secs) - describe(commd_time, "Time to generate CommD", secs) - describe(commd_time_parallel, "Time to generate CommD in parallel", secs) - describe(commc_time, "Time to generate the merkle tree of CommC (assuming leaves in memory)", secs) - - commit_size = cid_size - commc_window_tree_time = commc_hash_time * (window_nodes - 1) - commc_window_columns_time = commc_column_hash_time * (window_nodes - 1) - commr_size = commit_size - commd_size = commit_size - commrlast_size = commit_size - - seal_onchain_commitments_size = commd_size + commr_size - // seal_commitment_time = commr_time - - commd_time = commd_hash_time * (nodes - 1) - commd_time_parallel = commd_time / rig_cores - - commq_time = commr_time - porep_commit_time = commr_time + commd_time + commc_time - porep_commit_time_parallel = porep_commit_time / rig_cores - porep_commit_time_mins = porep_commit_time / 60 - - commr_time_parallel = commr_time / rig_cores - - CommR: // was VectorR - commr_time = commr_hash_time * (nodes - 1) - commr_tree_depth = log2(nodes) - commr_column_size = 1 - - CommC: - describe(commc_tree_time, "Time to generate CommC (Merkle tree only)", secs) - describe(commc_tree_time_parallel, "Time to generate CommC parallel (Merkle tree only)", secs) - describe(commc_columns_time, "Time to generate CommC (Leaves only)", secs) - describe(commc_columns_time_parallel, "Time to generate CommC in parallel (Leaves only)", secs) - describe(commc_tree_write_time, "Time to write commc tree on disk", secs) - commc_tree_time = commc_window_tree_time - commc_tree_time_parallel = commc_tree_time / rig_cores - commc_columns_time = commc_window_columns_time * stacked_layers * windows - commc_columns_time_parallel = commc_columns_time / rig_cores - commc_time = commc_tree_time + commc_columns_time - - describe(dig_commc_tree_time, "Time to compute commc and store it on on storage medium (Dig's Benchmark)", secs) - describe(dig_commc_tree_time_parallel, "Time to compute commc and store it on on storage medium (Dig's Benchmark) in parallel", secs) - dig_commc_tree_time = commc_tree_time + commc_tree_write_time - dig_commc_tree_time_parallel = commc_tree_time / rig_cores + commc_tree_write_time / rig_storage_parallelization - commc_tree_write_time = (window_size * 2) / (b_in_mib * rig_storage_write_mibs) - - Encoding: - describe(encoding_time, "Time to encode a sector", secs) - describe(encoding_time_mins, "Time to encode a sector", mins) - describe(encoding_time_parallel, "Time to encode a sector in parallel", secs) - describe(encoding_time_asic, "Time to encode a sector with an ASIC", secs) - describe(encoding_window_time, "Time to encode a window", secs) - describe(encoding_window_time_parallel, "Time to encode a window in parallel", secs) - describe(encoding_window_time_asic, "Time to encode a window with an ASIC", secs) - describe(encoding_window_time_parallel_asic, "Time to encode a window in parallel with ASICs", secs) - describe(kdf_time, "Average time to hash 32 bytes during KDF computation", secs) - describe(kdf_time_asic, "Average time to hash 32 bytes during KDF computation", secs) - describe(kdf_latency_bandwidth, "Amount of data hashed per second (B/s)") - describe(kdf_latency_bandwidth_asic, "Amount of data hashed per second (B/s)") - describe(kdf_latency_bandwidth_gb, "Amount of data hashed per second (GB/s)") - describe(kdf_latency_bandwidth_gb_asic, "Amount of data hashed per second (GB/s)") - - kdf_latency_bandwidth = ((kdf_latency_bandwidth_gb * gb_to_gib) * b_in_gib) - kdf_time = (32/kdf_latency_bandwidth) - - - - // TODO: adding wrapper layer - encoding_time = encoding_window_time * windows - encoding_time_mins = encoding_time / secs_in_min - - encoding_window_time = window_nodes * ((1 + graph_parents) * kdf_time) * stacked_layers - - ParallelEncoding (StackedSDRParameters): - encoding_time_parallel = encoding_window_time + ((windows - 1) * encoding_window_time) / rig_cores - encoding_window_time_parallel = encoding_window_time - - ParallelEncoding (StackedChungParameters): - encoding_time_parallel = encoding_time / rig_cores - encoding_window_time_parallel = encoding_window_time / rig_cores - - Asic: - kdf_latency_bandwidth_asic = ((kdf_latency_bandwidth_gb_asic * gb_to_gib) * b_in_gib) - kdf_time_asic = (32/kdf_latency_bandwidth_asic) - - kdf_time_asic = kdf_time / hashing_amax - encoding_time_asic = encoding_time / hashing_amax - encoding_window_time_asic = encoding_window_time / hashing_amax - encoding_window_time_parallel_asic = encoding_window_time_parallel / hashing_amax - - Retrieval: - describe(window_read_time, "Time to read a window from storage unit", secs) - describe(window_read_time_parallel, "Time to read a window from storage unit in parallel", secs) - describe(decoding_time, "Time to decode a sector", secs) - describe(decoding_time_parallel, "Time to decode a sector in parallel", secs) - describe(decoding_first_node_time, "Time to decode the first node in a sector", secs) - describe(decoding_first_node_time_parallel, "Time to decode the first node in a sector in parallel", secs) - - // This scales down encoding time by one layer - Decoding (StackedReplicas): - // Decoding in StackedReplicas: read the window output and decode it - window_read_time = window_size_mib / rig_storage_read_mibs - window_read_time_parallel = window_read_time / rig_storage_parallelization - decoding_time = encoding_window_time + window_read_time - - // Note: this is an upperbound, it can be lower in theory min(time, disk access) - decoding_time_parallel = encoding_window_time_parallel + window_read_time_parallel - - decoding_first_node_time = encoding_window_time * ((stacked_layers - 1) / stacked_layers) - decoding_first_node_time_parallel = encoding_window_time_parallel * ((stacked_layers - 1) / stacked_layers) - - Decoding (WrappingVariant): - // Decoding in WrappingVariant: read the window output and decode them - window_read_time = window_size_mib / rig_storage_read_mibs - window_read_time_parallel = window_read_time / rig_storage_parallelization - decoding_time = encoding_window_time + window_read_time - // Note: this is an upperbound, it can be lower in theory min(time, disk access) - decoding_time_parallel = encoding_window_time_parallel + window_read_time_parallel - - Decoding (Wrapping): - // Decoding in Wrapping: read all the window outputs and decode them - window_read_time = sector_size_mib / rig_storage_read_mibs - window_read_time_parallel = window_read_time / rig_storage_parallelization - decoding_time = encoding_time + window_read_time - // Note: this is an upperbound, it can be lower in theory min(time, disk access) - decoding_time_parallel = encoding_time_parallel + window_read_time_parallel - - Cost: - describe(porep_cost, "Cost of a seal proof", dollar) - - describe(porep_cost_snark, "Cost of a snark proof", dollar) - describe(porep_cost_commit, "Cost of generating merkle trees", dollar) - describe(porep_cost_decoding, "Cost of decoding a sector", dollar) - describe(porep_cost_encoding, "Cost of decoding a sector", dollar) - describe(porep_cost_gib, "Cost of sealing 1 GiB", dollar) - describe(porep_cost_pib, "Cost of sealing 1 PiB", dollar) - - porep_cost_commit = porep_commit_time * rig_cpu_core_cost_secs - porep_cost_snark = porep_snark_time * rig_gpu_cost_secs - porep_cost = porep_cost_commit + porep_cost_encoding + porep_cost_snark - porep_cost_gib = porep_cost / sector_size_gib - porep_cost_pib = porep_cost_gib * gib_in_pib - - EncodingCost (StackedSDRParameters): - porep_cost_encoding = encoding_time * rig_cpu_core_cost_secs - porep_cost_decoding = decoding_time * rig_cpu_core_cost_secs - - SNARK: - describe(porep_snark_constraints, "Constraints for a PoRep", constraints) - describe(porep_snark_partitions, "Number of partitions of a PoRep proof") - describe(porep_snark_time, "Time to generate a PoRep SNARK proof", secs) - describe(porep_snark_time_mins, "Time to generate a PoRep SNARK proof", mins) - describe(porep_snark_time_parallel, "Time to compute a PoRep snark in parallel") - describe(porep_snark_size, "Size of a PoRep proof", bytes) - describe(porep_snark_size_kib, "Size of a PoRep proof", kib) - describe(porep_snark_partition_constraints, "Number of constraints for a PoRep partition") - - describe(kdf_constraints, "Constraints of KDF per node parent") - describe(labeling_constraints, "Constraints to check labeling of a single node") - describe(porep_labelings_window_constraints, "Constraints to check labeling of a window") - describe(porep_labelings_windows_constraints, "Constraints to check correct labeling for all windows") - describe(commd_inclusion_constraints, "Constraints to check a single inclusion in CommD") - describe(porep_commd_vector_inclusions_constraints, "Constraints to check all the inclusions required in a window in CommD") - describe(window_data_inclusions, "Constraints to check all the inclusions required for all windows in CommD") - describe(commr_inclusion_constraints, "Constraints to check a single inclusion in CommR") - describe(porep_commr_window_inclusions_constraints, "Constraints to check all the inclusions required in a window in CommR") - describe(porep_commr_windows_inclusions_constraints, "Constraints to check all the inclusions required for all windows in CommR") - describe(commc_inclusion_constraints, "Constraints to check a single inclusion proof in a window") - describe(porep_commc_window_inclusions_constraints, "Constraints to check all the required inclusion proofs in a window") - describe(commc_column_constraints, "Constraints to check a single leaf generation from a column in a window") - describe(porep_commc_window_columns_constraints, "Constraints to check all the leaves generation required in a window") - describe(porep_commc_windows_columns_constraints, "Constraints to check all the leaves generation required for all windows") - describe(porep_snark_partition_time, "Time to compute a single snark partion", secs) - describe(porep_commd_inclusions_constraints, "Constraints for CommD inclusions (PoRep)") - describe(porep_commr_inclusions_constraints, "Constraints for CommR inclusions (PoRep)") - describe(porep_commc_inclusions_constraints, "Constraints for CommC inclusions (PoRep)") - describe(porep_commc_leaves_constraints, "Constraints for CommC leaves (PoRep)") - describe(porep_labelings_constraints, "Constraints for labeling proofs (PoRep)") - describe(commr_hash_constraints, "Constraints of the Merkle Tree hash in CommR") - - // D - // Data layer committed with merkle tree - commd_inclusion_constraints = commd_hash_constraints * log2(nodes) - porep_commd_vector_inclusions_constraints = commd_inclusion_constraints * porep_challenges - - // C - commc_inclusion_constraints = commc_hash_constraints * log2(window_nodes) - porep_commc_window_inclusions_constraints = commc_inclusion_constraints * porep_challenges * (graph_parents + 1) - commc_column_constraints = commc_column_hash_constraints * stacked_layers - porep_commc_window_columns_constraints = commc_column_constraints * porep_challenges * (graph_parents + 1) - porep_commc_windows_columns_constraints = porep_commc_window_columns_constraints * windows - - // Labeling - labeling_constraints = kdf_constraints * graph_parents - porep_labelings_window_constraints = labeling_constraints * stacked_layers * porep_challenges - porep_labelings_windows_constraints = porep_labelings_window_constraints * windows - - // Q and R - commr_inclusion_constraints = commr_hash_constraints * commr_tree_depth - porep_commr_window_inclusions_constraints = commr_inclusion_constraints * porep_challenges - porep_commr_windows_inclusions_constraints = porep_commr_window_inclusions_constraints * windows - - // Final SNARK - porep_snark_partitions = porep_snark_constraints / porep_snark_partition_constraints - porep_snark_size = porep_snark_partitions * snark_size - porep_snark_size_kib = porep_snark_size / b_in_kib - porep_snark_time = snark_constraint_time * porep_snark_constraints - porep_snark_time_mins = porep_snark_time / secs_in_min - porep_snark_partition_time = snark_constraint_time * porep_snark_constraints - // Parallelization calculation: it must take at least the time for a single snark - // the remaining can be done in parallel - // Similar in spirit to: - // min(porep_snark_partition_time, porep_snark_time / snarrk_parallelization) - porep_snark_time_parallel = porep_snark_partition_time + (porep_snark_time - porep_snark_partition_time) / (rig_snark_parallelization) - - // Constraints (WindowEncoding): - // porep_snark_constraints = porep_commc_window_inclusions_constraints + porep_commc_windows_columns_constraints + porep_labelings_windows_constraints + window_data_inclusions + window_replica_inclusions*2 - - - Constraints (StackedReplicas): - porep_commd_inclusions_constraints = porep_commd_vector_inclusions_constraints - porep_commr_inclusions_constraints = porep_commr_window_inclusions_constraints - porep_commc_inclusions_constraints = porep_commc_window_inclusions_constraints - porep_commc_leaves_constraints = porep_commc_windows_columns_constraints - porep_labelings_constraints = porep_labelings_windows_constraints - - porep_snark_constraints = porep_commc_leaves_constraints + porep_commc_inclusions_constraints + porep_commr_inclusions_constraints + porep_commd_inclusions_constraints + porep_labelings_constraints - - // porep_snark_constraints = porep_commc_window_inclusions_constraints + porep_commc_windows_columns_constraints + porep_labelings_windows_constraints + porep_commd_vector_inclusions_constraints + replica_inclusions*2 - - // TODO: add wrapper constraints - Constraints (Wrapping): - porep_snark_constraints = porep_commc_window_inclusions_constraints + porep_commc_windows_columns_constraints + porep_labelings_windows_constraints + porep_commd_vector_inclusions_constraints + replica_inclusions*2 - - Constraints (WrappingVariant): - porep_snark_constraints = porep_commc_window_inclusions_constraints + porep_commc_windows_columns_constraints + porep_labelings_windows_constraints + porep_commd_vector_inclusions_constraints + replica_inclusions*2 - - // Column comitting data or replica. - -SDR: - describe(sdr_layers_a, "SDR layers computation a") - describe(sdr_layers_b, "SDR layers computation b") - describe(sdr_layers_c, "SDR layers computation c") - describe(sdr_delta, "Fraction of pebbled nodes encoded incorrectly") - -ProofOfReplication (StackedSDRParameters): - sdr_eps = spacegap - - stacked_layers = sdr_layers_a + 1 // TODO max(layers_a, layers_b) + 1 - sdr_layers_a = (0.68 - sdr_eps + 4 * sdr_delta) / (0.12 - sdr_delta) + 2 - sdr_layers_b = (log2(1 / (3 * (sdr_eps - 4 * sdr_delta)))) + 0.24 / (0.12 - sdr_delta) + 1 - sdr_layers_c = (log2(2 / (1 + 3 * (sdr_eps - 5 * sdr_delta)))) + (0.57 - sdr_eps + 3 * sdr_delta) / (0.12 - sdr_delta) + 1 - - porep_challenges = -porep_lambda / (log2(1 - sdr_delta)) - post_challenges = -post_lambda / (log2(1 - sdr_eps/2)) - - drg_e = 0.8 - drg_d = 0.2 // 1/4 - - sdr_eps > 0 - sdr_eps <= 0.48 - sdr_delta > 0 - sdr_delta >= (sdr_eps/2 - 0.12) - sdr_delta < sdr_eps / 4 - -ProofOfReplication (StackedChungParameters): - describe(chung_a, "Chung A") - describe(chung_c, "Chung C") - describe(chung_delta, "Chung chung_delta") - describe(chung_sigma, "Chung sigma") - - stacked_layers = (log2(chung_psi / chung_a) / log2(chung_c)) + 1 - porep_challenges = -porep_lambda / (log2(1 - chung_delta)) - post_challenges = -post_lambda / (log2(chung_sigma)) - - drg_parents = 0 - - chung_alpha = regeneration_fraction * cost_amax - chung_eps = spacegap - - chung_a = chung_eps - (chung_c * chung_delta / (chung_c -1)) + (((chung_c - 1) * (chung_sigma - 1))/ chung_c) - chung_c = chung_beta / chung_alpha - - chung_psi = chung_alpha - chung_sigma = 1 - chung_eps + chung_delta + 0.0001 - - Chung: ./bin/chung_spec.py - chung_beta = extern(chung_alpha, expander_parents) - // chung_alpha = extern(chung_beta, expander_parents) - // expander_parents = extern(chung_alpha, chung_beta) - -EC: - describe(ec_e, "Number of winning miners per epoch on expectation") - -Filecoin: - describe(filecoin_block_time, "Time between two blocks", secs) - describe(blocks_in_a_year, "Number of blocks in a year") - - filecoin_block_time = block_time - blocks_in_a_year = (secs_in_year / filecoin_block_time) * ec_e - - Onboarding: - describe(onboard_gib_time, "Time to onboard 1 GiB in the network", secs) - describe(onboard_tib_time, "Time to onboard 1 TiB in the network", secs) - describe(onboard_tib_time_days, "Time to onboard 1 TiB in the network", days) - onboard_gib_time = (1 / sector_size_gib) * porep_time - onboard_tib_time = onboard_gib_time * gib_in_tib - onboard_tib_time_days = onboard_tib_time / secs_in_day - - Storage: - describe(filecoin_sectors, "Number of sectors in the Filecoin DSN") - describe(filecoin_miners, "Number of Storage Miners") - describe(filecoin_storage_capacity, "Amount of storage that the Filecoin DSN can support", bytes) - describe(filecoin_storage_capacity_gib, "Amount of storage that the Filecoin DSN can support", gib) - describe(filecoin_storage_capacity_eib, "Amount of storage that the Filecoin DSN can support", eib) - - filecoin_sectors = filecoin_storage_capacity_gib / sector_size_gib - filecoin_storage_capacity_eib = filecoin_storage_capacity / b_in_eib - filecoin_storage_capacity_gib = filecoin_storage_capacity / b_in_gib - - Chain: - describe(chain_size_year, "Size of one year worth of blocks", bytes) - describe(chain_size_year_gib, "Size of one year worth of blocks", kib) - describe(block_size, "Size of a block", bytes) - describe(block_size_kib, "Size of a block", bytes) - describe(proofs_block_fraction, "Fraction of the block dedicated to proofs") - - chain_size_year = block_size * blocks_in_a_year - chain_size_year_gib = chain_size_year / b_in_gib - block_size_kib = block_size / b_in_kib - - // Note this is simplistic and accounts for no framing - block_size = (proofs_per_block / proofs_block_fraction) - not_proofs_per_block = block_size - proofs_per_block - - proofs_per_block_kib = proofs_per_block / b_in_kib - not_proofs_per_block_kib = not_proofs_per_block / b_in_kib - - OnChainProofs: - describe(seals_per_year, "Number of PoRep proofs per year") - describe(posts_per_year, "Number of PoSt proofs per year") - describe(filecoin_reseals_per_year, "Number of times a sector is re-sealed in a year") - describe(seals_per_sector_per_year, "Number of seal proofs per sector per year") - describe(posts_per_sector_per_year, "Number of post proofs per sector per year") - describe(seals_size_per_year, "Size of seal proofs per year", bytes) - describe(posts_size_per_year, "Size of post proofs per year", bytes) - describe(seals_size_per_block, "Size of seal proofs per block", bytes) - describe(posts_size_per_block, "Size of post proofs per block", bytes) - describe(posts_size_per_block_kib, "Size of post proofs per block", kib) - describe(seals_size_per_block_kib, "Size of seal proofs per block", kib) - describe(proofs_per_block, "Size of proofs per block", bytes) - describe(proofs_per_block_kib, "Size of proofs per block", kib) - describe(not_proofs_per_block, "Size of non-proof data per block", bytes) - describe(not_proofs_per_block_kib, "Size of non-proof data per block", kib) - - seals_per_sector_per_year = filecoin_reseals_per_year + 1 - seals_per_year = filecoin_sectors * seals_per_sector_per_year - posts_per_year = filecoin_sectors * posts_per_sector_per_year - - seals_size_per_year = seals_per_year * porep_proof_size - posts_size_per_year = posts_per_year * post_proof_size - - seals_size_per_block = seals_size_per_year / blocks_in_a_year - posts_size_per_block = posts_size_per_year / blocks_in_a_year - - proofs_per_block = seals_size_per_block + posts_size_per_block - proofs_per_block_kib = proofs_per_block / b_in_kib - seals_size_per_block_kib = seals_size_per_block / b_in_kib - posts_size_per_block_kib = posts_size_per_block / b_in_kib - - PoSt (ElectionWithFallbackPoSt): - describe(fposts_per_sector_per_year, "Number of fallback post proofs per sector per year") - describe(eposts_per_sector_per_year, "Number of election post proofs per sector per year") - describe(fallback_ratio, "Fraction of fallback PoSts") - describe(fallback_period, "Time between last proof submitted and a required fallback PoSt", secs) - describe(fallback_period_days, "Time between last proof submitted and a required fallback PoSt", secs) - - fallback_period_days = fallback_period / secs_in_day - posts_per_sector_per_year = eposts_per_sector_per_year + fposts_per_sector_per_year - - // TODO: model single ticket vs multiple tickets - ElectionPoSt: - eposts_per_sector_per_year = blocks_in_a_year / filecoin_sectors - - FallbackPoSt: - fposts_per_sector_per_year = (secs_in_year / fallback_period) * fallback_ratio - - Mining: - ElectionPoSt: - describe(epost_challenged_sectors, "Number of challenged sectors during Election PoSt") - describe(epost_challenged_sectors_fraction, "Fraction of challenged sectors during Election PoSt") - describe(epost_data_access, "Time to access data for Election PoSt", secs) - describe(epost_data_access_parallel, "Time to access data for Election PoSt in parallel", secs) - describe(epost_time, "Time to generate an Election PoSt", secs) - describe(epost_time_parallel, "Time to generate an Election PoSt in parallel", secs) - describe(epost_inclusions_time, "Time to generate all inclusions in Election PoSt", secs) - describe(epost_inclusions_time_parallel, "Time to generate all the inclusions in Election PoSt in parallel", secs) - describe(epost_leaves_read, "Time to read the challenged leaves nodes during EPoSt", secs) - describe(epost_leaves_read_parallel, "Time to read the challenged leaves nodes during EPoSt in parallel", secs) - describe(epost_mtree_read, "Time to read Merkle tree nodes during EPoSt", secs) - describe(epost_mtree_read_parallel, "Time to read the Merkle tree during EPoSt in parallel", secs) - - epost_challenged_sectors = rig_sectors_min * epost_challenged_sectors_fraction - epost_leaves_read = post_leaves_read * epost_challenged_sectors - epost_mtree_read = post_mtree_read - epost_data_access = epost_leaves_read + epost_mtree_read - epost_data_access_parallel = epost_data_access / rig_storage_parallelization - epost_mtree_read_parallel = epost_mtree_read / rig_storage_parallelization - epost_leaves_read_parallel = epost_leaves_read / rig_storage_parallelization - epost_inclusions_time = post_inclusions_time * epost_challenged_sectors - epost_inclusions_time_parallel = epost_inclusions_time / rig_cores - - epost_time = epost_data_access + post_ticket_gen + epost_inclusions_time + post_snark_time - epost_time_parallel = epost_data_access_parallel + post_ticket_gen + epost_inclusions_time_parallel + post_snark_time_parallel - - describe(epost_cost, "Cost for generating a EPoSt", dollar) - describe(epost_snark_cost, "Cost for generating a EPoSt SNARK", dollar) - describe(epost_inclusions_cost, "Cost for generating a EPoSt mtrees", dollar) - - epost_inclusions_cost = epost_inclusions_time * rig_cpu_core_cost_secs - epost_snark_cost = post_snark_time * rig_gpu_cost_secs - // TODO: missing disk access - epost_cost = epost_inclusions_cost + epost_snark_cost - -Timing: - describe(malicious_regen_time, "Time for a malicious adversary to regenerate a sector", secs) - describe(time_amax, "Factor of how much slower than the blocktime the malicious encoding should take") - -Timing (TimingAssumption): - RegenAttack (StackedSDRParameters): - malicious_regen_time = (encoding_window_time_asic * drg_d) / (stacked_layers) - malicious_regen_time = block_time * time_amax - -Rationality: - describe(breakeven_nodes, "number of nodes / sector / challenge period after which it's cheaper to store the entire sector, than re-encode those") - describe(block_time, "Time between two PoSt proofs", secs) - describe(challenge_periods_per_month, "Number of challenge periods in a month") - describe(regeneration_fraction, "Fraction of nodes of a sector for which re-encoding them every `block_time` costs as much as storing them") - - breakeven_nodes = ((cost_gib_per_month * sector_size_gib) / ((1 - porep_soundness) * cost_node_encoding * challenge_periods_per_month)) - challenge_periods_per_month = secs_in_month / block_time - regeneration_fraction = breakeven_nodes / nodes - - Costs: - Compute: - describe(cost_node_encoding, "Cost of encoding a single node") - describe(nodes_per_second, "Nodes encoded per second using the fastest hardware") - describe(nodes_per_year, "Nodes encoded per year using the fastest hardware") - describe(hash_gb_per_second, "GB that can be hashed per second") - describe(hash_gib_per_second, "GiB that can be hashed per second") - - hash_gib_per_second = hash_gb_per_second * gb_to_gib - nodes_per_second = hash_gib_per_second / kdf_hash_size_gib - nodes_per_year = nodes_per_second * secs_in_year - cost_node_encoding = rig_malicious_cost_per_year / nodes_per_year - - Storage: - // TODO(important): add the hardware cost from first principle - describe(cost_gb_per_month, "Cost of storing 1GB per month") - describe(cost_gib_per_month, "Cost of storing 1GiB per month") - describe(cost_storage_gibs, "Cost of storing 1GiB per second") - describe(cost_storage_sector_block_time, "Cost of storage for `block_time`") - describe(extra_storage_time, "Time for which an honest user must be storing a file beyond the challenge period") - - cost_gib_per_month = cost_gb_per_month * gb_to_gib - cost_storage_gibs = cost_gib_per_month / secs_in_month - cost_storage_sector_block_time = cost_storage_gibs * (sector_size_gib * (block_time + extra_storage_time)) diff --git a/src/orient/snark-table.json b/src/orient/snark-table.json deleted file mode 100644 index 805195b25..000000000 --- a/src/orient/snark-table.json +++ /dev/null @@ -1,54 +0,0 @@ -[ - { - "degree_expander": 8, - "degree_base": 6, - "node_size": 32, - "reseal": 0, - "proving_period_hours": 24, - "block_time": 15, - "kdf_hash_time": 0.000000045608, - "leaf_hash_time": 0.000000045608, - "encoding_amax": 2, - "cores": 16, - "merkle_hash_time_circuit": 0.076994, - "merkle_hash_time": 0.000013078, - "leaf_hash_circuit_time": 0.076994, - "kdf_hash_size": 32, - "proof_messages_fraction": 0.4, - "tx_messages_fraction": 0.3, - "miners": 1000, - "expected_winning_miners": 5, - "sector_size_gib": 32, - "post_challenge_hours": 2 - }, - [ - { "lambda": 10 }, - { "lambda": 20 }, - { "lambda": 40 }, - { "lambda": 80 } - ], - [ - { "spacegap": 0.3 }, - { "spacegap": 0.2 }, - { "spacegap": 0.1 }, - { "spacegap": 0.05 }, - { "spacegap": 0.01 } - ], - [ - { - "merkle_hash_constraints": 1300, - "leaf_hash_constraints": 1300, - "merkle_hash_constraints_name": "PEDERSEN" - }, - { - "merkle_hash_constraints": 800, - "leaf_hash_constraints": 800, - "merkle_hash_constraints_name": "MIMC" - }, - { - "merkle_hash_constraints": 350, - "leaf_hash_constraints": 350, - "merkle_hash_constraints_name": "POSEIDON" - } - ] -] diff --git a/src/orient/visualization.orientable.js b/src/orient/visualization.orientable.js deleted file mode 100644 index 72ccd1f7a..000000000 --- a/src/orient/visualization.orientable.js +++ /dev/null @@ -1,121 +0,0 @@ -graph(solutions, 'spacegap', 'block_size_kib', ['sector_size_gib']) - -md`## Block size` - -table(solutions, ['expected_winning_miners', 'block_size_kib', 'chain_size_year_gib', 'spacegap'], ['sector_size_gib'], 'block_size_kib') - -md`## PoSt sizes` - -table(solutions, ['post_snark_circuit', 'post_snark_proof_size', 'post_snark_proof_partitions'], ['spacegap']) - -md`## PoSt in blockchain` - -table(solutions, ['sector_size_gib', 'post_size_per_block', 'avg_posts_messages_per_block'], ['spacegap']) - -graph(solutions, 'spacegap', 'post_size_per_block', ['sector_size_gib']) - -md`## PoRep in blockchain` - -graph(solutions, 'spacegap', 'seal_size_per_block', ['sector_size_gib', 'lambda']) - -graph(solutions, 'spacegap', 'block_size_kib', ['sector_size_gib', 'lambda']) - -md`## Interactivity` - -table(solutions, ['block_size_kib', 'sector_size_gib', 'spacegap'], ['lambda']) - -solutions = JSON.parse(await fetch_model('http://localhost:8000/solved-parameters.json')) - -md`---` - -clean = (solutions, group_by, filter) => { - return solutions.map(s => { - const solution = {} - - filter.forEach(d => { - solution[d] = s[d] - }) - solution.name = group_by.map(g => `${g}=${s[g]}`).join(', ') - - return solution - }) -} - -table = (solutions, filter, group_by, sort_by) => { - let results = clean(solutions, group_by, filter) - if (sort_by) { - results = results.sort((a, b) => +a[sort_by] > +b[sort_by]) - } - const header = ` - Sorted by: ${sort_by} - - | name | ${filter.join(' | ')} |` - const divider = `| --- | ${filter.map(f => '--:').join(' | ')} |` - const rows = results.map(r => { - return `| ${r.name} | ${filter.map(f => r[f]).join(' | ')}` - }) - const table = [header, divider, rows.join('\n')].join('\n') - - return md`${table}` -} - -graph = (solutions, x, y, group_by) => { - const results = clean(solutions, group_by, [x, y]) - return vl({ - "title": `Plotting: ${x} vs ${y}`, - "width": 600, - "data": {"values": results}, - "mark": {"type": "line"}, - "encoding": { - "x": { - "field": x, - "type": "quantitative", - }, - "y": { - "field": y, - "type": "quantitative", - }, - "color": { - "field": "name", - "type": "nominal", - "scale": {"scheme": "category10"} - }, - }, - }) -} - - -fetch_model = (model_url) => { - return fetch(model_url).then(response => { - return (response.ok) ? response.text() : false; - }); - // form.dispatchEvent(new CustomEvent("input")); -} - -vl = require('@observablehq/vega-lite') - -html`` - - -chart = { - const svg = d3.create("svg") - - const g = svg.append("image") - .attr("xlink:href","http://localhost:8000/filecoin.svg") - .attr("viewBox", [0, 0, width, 400]); - - svg.call(d3.zoom() - .extent([[0, 0], [width, 400]]) - .scaleExtent([1, 8]) - .on("zoom", zoomed)); - - function zoomed() { - g.attr("transform", d3.event.transform); - } - - return svg.node(); -} - -style = html`` - -d3 = require("d3@5") diff --git a/src/orient/viz/README.md b/src/orient/viz/README.md deleted file mode 100644 index 0a92bbd31..000000000 --- a/src/orient/viz/README.md +++ /dev/null @@ -1,15 +0,0 @@ -# Ubercalc visualizations - -## Install - -- Install [orient](https://github.com/filecoin-project/orient) -- Install [obs](https://github.com/nicola/obs) - -## Usage - -``` -# Run these commands from the root folder of the spec repo on two different terminals -$ ORIENT_CACHE_DIR=/absolute/path/to/cache ./orient/bin/orient web --system=src/orient/rational-calc.orient --port=8000 -$ obs serve 8081 src/orient/viz -``` - diff --git a/src/orient/viz/bench.json b/src/orient/viz/bench.json deleted file mode 100644 index c27f67f89..000000000 --- a/src/orient/viz/bench.json +++ /dev/null @@ -1,37 +0,0 @@ -{ - "window_size":1073741824, - "sector_size":1073741824, - "drg_parents":6, - "expander_parents":8, - "porep_challenges":700, - "porep_snark_partitions":10, - "post_snark_partitions":1, - "post_challenges":30, - "post_challenged_nodes":1, - "stacked_layers":7, - "commd_time":26.067, - "commd_time_parallel":3.244, - "dig_encoding_time":6856.392, - "dig_encoding_time_parallel":854.161, - "porep_precommit_time":9248.525, - "porep_precommit_time_parallel":1008.672, - "epost_cpu_time_ms":1, - "epost_wall_time_ms":1, - "dig_commc_tree_time":2365.468, - "dig_commc_tree_time_parallel":150.268, - "porep_proof_gen":7876.16, - "porep_proof_gen_parallel":4945.03, - "post_proof_gen":8.249, - "post_proof_gen_parallel":6.085, - "post_verify_cpu_time_ms":15, - "post_verify_wall_time_ms":15, - "commr_time":2365.555, - "commr_time_parallel":150.343, - "porep_snark_constraints":2379940030, - "post_snark_constraints":1075683, - "labeling_proof":212428, - "rig_cores": 8, - "column_leaf_hash_time": 17.1e-6, - "merkle_tree_hash_time": 13.652e-6, - "kdf_time": 1.051e-7 -} diff --git a/src/orient/viz/rational-calc.notebook.js b/src/orient/viz/rational-calc.notebook.js deleted file mode 100644 index ad71da4e0..000000000 --- a/src/orient/viz/rational-calc.notebook.js +++ /dev/null @@ -1,1458 +0,0 @@ -md`# Proofs Tradeoff Report - -1. Calculator may contain errors and definitely TODOs -2. Adding new graphs is easy -3. Fixing errors or change construction is easy -` - -md`## Sliders` - -md`### Parameters` - -viewof base = jsonToSliders( - { - "porep_lambda": {value: 10, min: 0, max: 128, step: 1}, - "post_mtree_layers_cached": {value: 25, min: 0, max: 40, step: 1}, - "post_lambda": {value: 10, min: 0, max: 128, step: 1}, - }, - { "!StackedReplicaUnaligned": true} -) - -md`### Constants` - -md`#### Graph` - -md`##### Chung params` -viewof stackedChungParams = jsonToSliders( - { - "chung_delta": {value: 0.06, min: 0.01, max: 0.08, step: 0.01}, - "expander_parents": {value: 16, min: 0, max: 128, step: 1}, - "rig_malicious_cost_per_year": {value: 2000, min: 0, max: 10000, step: 0.1}, - "hash_gb_per_second": {value: 640000, min: 0, max: 100000000, step: 1}, - "sector_size_gib": {value: 32, min: 1, max: 1024, step: 1}, - "window_size_mib": {value: 1024, min: 4, max: 32 * 1024, step: 1}, - "wrapper_parents": {value: 100, min: 0, max: 1000, step: 1}, - }, - { - "graph_name": "Chung", - "!StackedChungParameters": true, - }) - -md`##### SDR params` -viewof stackedSDRParams = jsonToSliders( - { - "sdr_delta": {value: 0.01, min: 0.01, max: 0.08, step: 0.01}, - "time_amax": { value: 2, min: 1, max: 10, step: 1 }, - "rig_malicious_cost_per_year": {value: 3, min: 0, max: 10000, step: 0.1}, - "hash_gb_per_second": {value: 5, min: 0, max: 10000, step: 1}, - }, - { - "graph_name": "SDR", - "!StackedSDRParameters": true, - "!TimingAssumption": true, - "windows": 1, - }) - - -md`#### Proofs` - -wrapper = ({ - "proof_name": "wrapping", - "!ElectionWithFallbackPoSt": true, - "!VectorR": true, - "!Wrapping": true, -}) - -wrapperVariant = ({ - "proof_name": "wrappingVariant", - "!ElectionWithFallbackPoSt": true, - "!VectorR": true, - "!WrappingVariant": true, -}) - -stackedReplicas = ({ - "proof_name": "stackedReplicas", - "!ElectionWithFallbackPoSt": true, - "!SectorEncoding": true, - "!VectorR": true, - "!StackedReplicas": true -}) - -md`#### Protocol` - -viewof filecoin = jsonToSliders({ - "ec_e": {value: 5, min: 1, max: 20, step: 1}, - "fallback_period_days": {value: 1, min: 1, max: 10, step: 1}, - "fallback_ratio": {value: 0.05, min: 0.01, max: 1, step: 0.01}, - "filecoin_reseals_per_year": {value: 1, min: 0, max: 365, step: 1}, - "filecoin_storage_capacity_eib": {value: 1, min: 0.5, max: 20, step: 0.5}, - "block_time": {value: 15, min: 15, max: 60, step: 1}, - "cost_amax": {value: 1, min: 1, max: 10, step: 1}, - // "hashing_amax": {value: 3, min: 1, max: 10, step: 1}, - "spacegap": {value: 0.2, min: 0.01, max: 0.2, step: 0.01}, - "proofs_block_fraction": {value: 0.3, min: 0.01, max: 1, step: 0.01}, - "epost_challenged_sectors_fraction": {value: 0.04, min: 0.01, max: 1, step: 0.01}, -}, { - node_size: 32 -}) - -md`### Miner` - -md`#### Hardware Config` - -viewof rig = jsonToSliders({ - "rig_cpu_cost": {value: 1200, min: 0, max: 10000, step: 100}, - "rig_gpu_cost": {value: 1200, min: 0, max: 10000, step: 100}, - "rig_cpu_lifetime_years": {value: 2, min: 1, max: 10, step: 1}, - "rig_gpu_lifetime_years": {value: 2, min: 1, max: 10, step: 1}, - "rig_cores": {value: 16, min: 1, max: 512, step: 1}, - "rig_snark_parallelization": {value: 2, min: 1, max: 64, step: 1}, - "rig_ram_gib": {value: 32, min: 1, max: 128, step: 1}, - "rig_storage_latency": {value: 0.003, min: 0.0003, max: 0.01, step: 0.0001}, - "rig_storage_min_tib": {value: 100, min: 0.5, max: 1024, step: 0.5}, - "rig_storage_parallelization": {value: 4, min: 1, max: 128, step: 1}, - "rig_storage_read_mbs": {value: 80, min: 80, max: 1000, step: 1}, - "rig_storage_write_mbs": {value: 2000, min: 10, max: 5000, step: 1}, - "cost_gb_per_month": {value: 0.0025, min: 0.0001, max: 0.1, step: 0.0001}, - "extra_storage_time": {value: 0, min: 0, max: 10, step: 1 }, -}) - -md`#### Benchmarks` - -hashes = ({ - pedersen64: { - constraints: 1376, - time: 13.652e-6 - }, - poseidon64: { - constraints: 1376/8, - time: 13.652e-6 - }, - sha64: { - constraints: 25840, - time: 130e-9, - }, - sha32: { - constraints: 25840/2, - time: 269.41e-9/10, - } -}) - -bench = ({ - "kdf_time": hashes.sha32.time, - // "kdf_latency_bandwidth_gb": 1.2, - "kdf_latency_bandwidth_gb_asic": 7.5, - "merkle_tree_datahash_time": 0.3876e-6, - "merkle_tree_hash_time": 13.652e-6, - "column_leaf_hash_time": 171e-6/10, - "snark_constraint_time": 0.00000317488, -}) - -md`### SNARKs` - - -makeHash = (hash_name, obj) => { - let json = {} - Object.keys(obj).forEach(d => { - json['hash_name'] = hash_name - json[`${d}_hash_name`] = obj[d] - json[`${d}_hash_time`] = hashes[obj[d]].time - json[`${d}_hash_constraints`] = hashes[obj[d]].constraints - }) - return json -} - -pedersen = makeHash("pedersen", { - commc: 'pedersen64', - commc_column: 'pedersen64', - commd: 'sha64', - commr: 'pedersen64', - ticket: 'pedersen64' -}) - -poseidon = makeHash("poseidon", { - commc: 'poseidon64', - commc_column: 'poseidon64', - commd: 'sha64', - commr: 'poseidon64', - ticket: 'poseidon64' -}) - -sha = makeHash("sha_poseidon", { - commc: 'poseidon64', - commc_column: 'sha64', - commd: 'sha64', - commr: 'poseidon64', - ticket: 'poseidon64' -}) - -sha_pedersen = makeHash("sha_pedersen", { - commc: 'pedersen64', - commc_column: 'sha64', - commd: 'sha64', - commr: 'pedersen64', - ticket: 'pedersen64' -}) - - -// sha_pure = makeHash("sha_pure", { -// commc: 'sha64', -// commc_column: 'sha64', -// commd: 'sha64', -// commr: 'poseidon64', -// ticket: 'poseidon64' -// }) - -constraints = ({ - "kdf_name": "sha", - // "kdf_latency_bandwidth_gb": 2.5, - "kdf_constraints": hashes.sha32.constraints, - "snark_size": 192, - "porep_snark_partition_constraints": 100000000, - "post_snark_partition_constraints": 3000000, -}) - -md`## Filters` - -// Window size MiB -// window_size_mib_choices = [4, 64, 128, 1024, 16384, 32768] -// viewof window_size_mib_config = checkbox({ -// title: "Window Sizes", -// options: solved_many_pre.map(d => d['window_size_mib']).map(d => ({value: d, label: d})), -// value: solved_many_pre.map(d => d['window_size_mib']), -// }) - -md`## Utility` - -html`Link to current setting` - -viewof utility_raw = codeView({ - localStorageKey: 'utility', - value: qs('utility_raw') || `function (d) { - return 0.5 * d['porep_time_parallel'] -}`, - mode: 'javascript', - height: 300 -}) - -// viewof reset_button = button({value: "Reset" }) - -viewof utility_cols = checkbox({ - title: "Vars to show in utility table", - options: Object.keys(vars).sort().map(d => ({value: d, label: d})), - value: qs('utility_cols') || ['decoding_time_parallel', 'proofs_per_block_kib', 'epost_time_parallel', 'porep_cost', 'porep_decoding_cost', 'epost_cost'] -}) - -table_constraints( - solved_many, - ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name', 'utility'].concat(utility_cols), - [], - 'utility' -) - -md`## Graphs` -md`### On-chain footprint - -This graphshows the average proofs per block (assuming a network size of ${filecoin.filecoin_storage_capacity_eib}EiB) -` - -viewof proofs_per_block_kib_ruler = chooser(solved_many, 'proofs_per_block_kib', 1000) -bar_chart(solved_many, 'proofs_per_block_kib', [ - 'seals_size_per_block_kib', - 'posts_size_per_block_kib', -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, proofs_per_block_kib_ruler), - yrule: Math.pow(10, proofs_per_block_kib_ruler) -}) - -md`### Encoding time (estimated from benchmarks)` - -viewof encoding_time_ruler = chooser(solved_many, 'encoding_time_mins', 60) - -bar_chart(solved_many, 'encoding_time_mins', [ - 'encoding_time_mins', -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, encoding_time_ruler), - yrule: Math.pow(10, encoding_time_ruler) -}) - -table_constraints(solved_many, [ - 'proof_name', - 'graph_name', - 'window_size_mib', - 'hash_name', - 'porep_snark_constraints', - 'porep_challenges', - 'stacked_layers', - 'porep_commc_leaves_constraints', - 'porep_commc_inclusions_constraints', - 'porep_commr_inclusions_constraints', - 'porep_commd_inclusions_constraints', - 'encoding_time_mins' -], [], 'encoding_time_mins') - - - -md`### Retrieval` - -viewof decoding_time_parallel_ruler = chooser(solved_many, 'decoding_time_parallel', 2) - -bar_chart(solved_many, 'decoding_time_parallel', [ - 'encoding_window_time_parallel', - 'window_read_time_parallel', -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, decoding_time_parallel_ruler), - yrule: Math.pow(10, decoding_time_parallel_ruler) -}) - -viewof decoding_time_ruler = chooser(solved_many, 'decoding_time', 16) - -bar_chart(solved_many, 'decoding_time', [ - 'encoding_window_time', - 'window_read_time', -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, decoding_time_ruler), - yrule: Math.pow(10, decoding_time_ruler) -}) - - -// table_constraints(solved_many, [ -// 'proof_name', -// 'graph_name', -// 'window_size_mib', -// 'decoding_time_parallel', -// 'encoding_window_time_parallel', -// 'window_read_time_parallel' -// ], []) - -md`### PoRep time` - -viewof porep_time_parallel_ruler = chooser(solved_many, 'porep_time_parallel', 12 * 60 * 60) - -bar_chart(solved_many, 'porep_time_parallel', [ - 'porep_snark_time_parallel', - 'porep_commit_time_parallel', - 'encoding_time_parallel' -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, porep_time_parallel_ruler), - yrule: Math.pow(10, porep_time_parallel_ruler) -}) - -md`### PoRep cost` - -viewof porep_cost_ruler = chooser(solved_many, 'porep_cost', 2) - -bar_chart(solved_many, 'porep_cost', [ - 'porep_cost_commit', - 'porep_cost_encoding', - 'porep_cost_snark' -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, porep_cost_ruler), - yrule: Math.pow(10, porep_cost_ruler) -}) - -md`### PoRep constraints` - -viewof porep_snark_constraints_ruler = chooser(solved_many, 'porep_snark_constraints', 1000 * 1000 * 1000) - -bar_chart(solved_many, 'porep_snark_constraints', [ - 'porep_commc_leaves_constraints', - 'porep_commc_inclusions_constraints', - 'porep_commr_inclusions_constraints', - 'porep_commd_inclusions_constraints', - 'porep_labelings_constraints' -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, porep_snark_constraints_ruler), - yrule: Math.pow(10, porep_snark_constraints_ruler) -}) - -table_constraints(solved_many, [ - 'proof_name', - 'graph_name', - 'window_size_mib', - 'hash_name', - 'porep_snark_constraints', - 'porep_challenges', - 'stacked_layers', - 'porep_commc_leaves_constraints', - 'porep_commc_inclusions_constraints', - 'porep_commr_inclusions_constraints', - 'porep_commd_inclusions_constraints', - 'porep_labelings_constraints' -], [], 'porep_snark_constraints') - - - -// bar_chart(solved_many, 'porep_commit_time', [ -// 'commr_time', -// 'commq_time', -// 'commc_time' -// ], ['proof_name', 'graph_parents', 'window_size_mib']) - -// bar_chart(solved_many, 'commc_time', [ -// 'commc_tree_time', -// 'commc_leaves_time', -// ], ['proof_name', 'graph_parents', 'window_size_mib']) - -md`### EPoSt` - -viewof epost_time_parallel_ruler = chooser(solved_many, 'epost_time_parallel', 30) - -bar_chart(solved_many, 'epost_time_parallel', [ - 'epost_leaves_read_parallel', - 'epost_mtree_read_parallel', - // 'epost_data_access_parallel', - 'post_ticket_gen', - 'epost_inclusions_time_parallel', - 'post_snark_time_parallel' -], ['proof_name', 'graph_parents', 'window_size_mib', 'hash_name'], { - filter: d => d < Math.pow(10, epost_time_parallel_ruler), - yrule: Math.pow(10, epost_time_parallel_ruler) -}) - -table_constraints(solved_many, [ - 'proof_name', - 'graph_name', - 'window_size_mib', - 'hash_name', - 'epost_time_parallel', - 'epost_data_access_parallel', - 'epost_mtree_read_parallel', - 'epost_leaves_read_parallel', - 'epost_leaves_read', - 'epost_challenged_sectors', - 'post_leaf_read', - 'post_ticket_gen', - 'epost_inclusions_time_parallel', - 'post_snark_time_parallel', - 'post_challenges', - 'post_challenge_read', - 'windows' -], []) - -md`### Merkle tree caching` - - -// graph_constraints(mtree_solved, 'post_mtree_layers_cached', 'epost_time_parallel', ['proof_name'], { height: 100, yrule: 15 }) -// graph_constraints(mtree_solved, 'post_mtree_layers_cached', 'post_inclusion_time', ['proof_name'], { height: 100 }) - -md`### Impact of \`chung_delta\` in StackedChung` -queries = [...Array(8)].map((_, i) => { - const query = Object.assign( - {}, - constants, - stackedChungParams, - { chung_delta: 0.01 * (i+1) }, - { window_size_mib: 128 } - ) - - return [ - Object.assign({}, query, stackedReplicas), - Object.assign({}, query, wrapper), - Object.assign({}, query, wrapperVariant), - ] -}).flat() - -// delta_solved = (await solve_many(queries)).map(d => d[0]) - -// // graph_constraints(delta_solved, 'chung_delta', 'stacked_layers', [], { height: 100 }) -// // graph_constraints(delta_solved, 'chung_delta', 'porep_challenges', [], { height: 100 }) -// // graph_constraints(delta_solved, 'chung_delta', 'post_challenges', [], { height: 100 }) -// graph_constraints(delta_solved, 'chung_delta', 'decoding_time_parallel', ['proof_name'], {yrule: 0.5, height: 100}) -// graph_constraints(delta_solved, 'chung_delta', 'epost_time_parallel', ['proof_name'], {yrule: 10, height: 100}) -// graph_constraints(delta_solved, 'chung_delta', 'porep_proof_size_kib', ['proof_name'], { height: 100 }) -// graph_constraints(delta_solved, 'chung_delta', 'block_size_kib', ['proof_name'], { height: 100 }) -// graph_constraints(delta_solved, 'chung_delta', 'onboard_tib_time_days', ['proof_name'], { height: 100 }) -// graph_constraints(delta_solved, 'chung_delta', 'porep_time_parallel', ['proof_name'], { height: 100 }) -// plot3d(delta_solved, 'chung_delta', 'epost_time_parallel', 'onboard_tib_time_days') - -md`---` - -md`#### Other important vars` - -table_constraints(solved_many, [ - 'proof_name', - 'graph_name', - 'window_size_mib', - 'hash_name', - 'decoding_time_parallel', - 'porep_time_parallel', - 'porep_proof_size_kib', - 'block_size_kib', - 'epost_time_parallel', -], []) - -// md`#### Graphs` -// table_constraints(solved_many, [ -// 'proof_name', -// 'graph_name', -// 'window_size_mib', -// 'porep_lambda', -// 'porep_challenges', -// 'post_lambda', -// 'post_challenges', -// 'stacked_layers', -// 'expander_parents', -// 'drg_parents', -// 'windows', -// 'window_size_mib', -// 'sector_size_gib', -// ], []) - -// md`#### PoRep` -// table_constraints(solved_many, [ -// 'proof_name', -// 'graph_name', -// 'window_size_mib', -// 'encoding_time', -// 'encoding_time_parallel', -// 'porep_commit_time', -// 'porep_commit_time_parallel', -// 'porep_snark_time', -// 'porep_snark_time_parallel', -// 'porep_proof_size', -// 'porep_snark_constraints', -// 'porep_time' -// ], []) - -// md`#### PoSt` -// table_constraints(solved_many, [ -// 'proof_name', -// 'graph_name', -// 'window_size_mib', -// 'post_proof_size', -// 'post_snark_constraints', -// 'post_snark_time', -// 'post_snark_time_parallel', -// 'post_time', -// 'post_time_parallel', -// 'post_inclusions_time', -// 'post_inclusions_time_parallel', -// 'post_data_access', -// 'post_data_access_parallel' -// ], []) - -// md`#### EPoSt` -// table_constraints(solved_many, [ -// 'proof_name', -// 'graph_name', -// 'window_size_mib', -// 'epost_time', -// 'epost_time_parallel', -// 'epost_inclusions_time', -// 'epost_inclusions_time_parallel', -// 'epost_data_access', -// 'epost_data_access_parallel' -// ], []) - -// md`## Debug` -// report_from_result(solved_many[0], combos[0]) -// report_from_result(solved_many[1], combos[1]) -// report_from_result(solved_many[2], combos[2]) -// report_from_result(solved_many[3], combos[3]) -// report_from_result(solved_many[4], combos[4]) -// report_from_result(solved_many[5], combos[5]) - -md`---` -md`## Dev` - -md`### Vars` -constants = Object.assign({}, base, constraints, filecoin, bench, rig) - -class Query { - constructor(query = []) { - this.query = query - } - add (query) { - this.query = extend_query(this.query, [query]) - return this - } - extend(query) { - this.query = extend_query(this.query, query) - return this - } - compile() { - return this.query - } -} - -makeQuery = (query = []) => { - return new Query(query) -} - -range = d3.range - -combos = { - return makeQuery([constants]) - .add(stackedReplicas) - .add(stackedSDRParams) - .add({ rig_storage_unit_cost: 46, rig_storage_unit_gb: 3000}) - .extend([ - Object.assign({ sdr_delta: 0.038 }, sha_pedersen), - Object.assign({ sdr_delta: 0.038 }, poseidon), - Object.assign({ sdr_delta: 0.049 }, poseidon) - ]) - .add({ spacegap: 0.2}) - .add({ drg_parents: 6 }) - .add({ sector_size_mib: 32 * 1024 }) - .compile() -} - -// combos = { -// return makeQuery([constants]) -// .add(stackedReplicas) -// .add(stackedSDRParams) -// .extend([poseidon, sha_pedersen]) -// .extend(range(0.005, 0.06, 0.001).map(d => ({ -// sdr_delta: d, -// }))) -// .add({ spacegap: 0.2}) -// .add({ drg_parents: 6 }) -// .add({ sector_size_mib: 32 * 1024 }) -// .compile() -// } - -// combos = { -// return makeQuery([constants]) -// .add(stackedReplicas) -// .add(stackedSDRParams) -// .extend([poseidon, pedersen, sha, sha_pedersen]) -// // .extend(range(0.001, 0.02, 0.001).map(d => ({ -// .extend(range(0.005, 0.04, 0.001).map(d => ({ -// sdr_delta: d, -// }))) -// // .add({spacegap: 0.2}) -// // .extend(range(20, 30, 5).map(d => ({ drg_parents: 6, expander_parents: 8+d}))) -// .extend(range(0.05, 0.20, 0.05).map(d => ({ spacegap: d}))) -// .extend(range(20, 30, 5).map(d => ({ drg_parents: 6, expander_parents: 8+d}))) -// .compile() -// } - -createJsonDownloadButton(combos) - -solved_many_pre = (await solve_many_chunk(combos)) - .map(d => { - d.construction = `${d.graph_name}_${d.proof_name}` - d.proof_name = `${d.spacegap}_${d.sdr_delta}` - return d - }) - -utility_fun = (data) => ev(utility_raw, data) - -solved_many = solved_many_pre - .filter(d => d !== null) - .map(d => { - const utility = utility_fun(d) - return Object.assign({}, d, {utility: utility}) - }) -// solved_manys = (await solve_manys(combos)).flat() - -createJsonDownloadButton(solved_many) - -// mtree_query = { -// let query = [constants] -// const proofs = [wrapper, wrapperVariant, stackedReplicas] -// const post_mtree_layers_cached = [...Array(10)].map((_, i) => ({post_mtree_layers_cached: i+20})) - -// query = extend_query(query, proofs, post_mtree_layers_cached, [stackedChungParams]) - -// return query -// } - -// mtree_solved = (await solve_many(mtree_query)).map(d => d[0]) - - -md`### Orient` - -function dump_vars() { - return fetch(orientServer + '/dump-vars') - .then(response => response.json()) - .then(json => { - - const map = {} - json.forEach(d => { - map[d.name] = d - }) - - return map - }) -} - -vars = dump_vars() - -function solve_multiple(json) { - return fetch(orientServer + '/solve', { - body: JSON.stringify(json), - headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, - method: 'POST' - }) - .then(res => { - return res.json() - }) - .then(res => { - return res.map(d => { - const results = {} - Object.keys(res[0]) - .filter(d => !d.includes('%')) - .map(d => { - results[d] = res[0][d] - }) - return results - }) - }) - -} - -chunk = (json, parts) => { - return json.reduce((acc, curr) => { - const index = acc.length - 1 - - if (index < 0) { - acc.push([curr]) - return acc - } - - if (acc[index].length === parts) { - acc.push([curr]) - } else { - acc[index].push(curr) - } - - return acc - }, []) -} - -async function solve_many_chunk(json) { - const promised = await Promise.all(chunk(json, 10).map(chunk_json => { - return fetch(orientServer + '/solve-many', { - body: JSON.stringify(chunk_json), - headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, - method: 'POST' - }).then(res => { - return res.json() - }).then(res => { - return res - .filter(d => d !== null) - .map(d => d.flat()) - .flat() - .filter(d => d !== null) - .map(d => { - const results = {} - Object.keys(d) - .filter(key => !key.includes('%')) - .map(key => { - results[key] = d[key] - }) - - return results - }) - }) - })) - return promised.flat() -} - -function solve_manys(json) { - return fetch(orientServer + '/solve-many', { - body: JSON.stringify(json), - headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, - method: 'POST' - }).then(res => { - return res.json() - }).then(res => { - return res - .filter(d => d !== null) - .map(d => d.flat()) - .flat() - .filter(d => d !== null) - .map(d => { - const results = {} - Object.keys(d) - .filter(key => !key.includes('%')) - .map(key => { - results[key] = d[key] - }) - - return results - }) - }) -} - -function ev (func, data) { - let res - - try { - res = (1, eval)(`(${func})`)(data) - } catch(err) { - throw err - } - - return res -} - -function solve_many(json) { - return Promise.all(json.map(j => solve(j))).then(json => json.map(d => d[0])) -} - -function solve(json) { - return fetch(orientServer + '/solve', { - body: JSON.stringify(json), - headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, - method: 'POST' - }).then(res => { - return res.json() - }).then(res => { - const results = {} - Object.keys(res[0]) - .filter(d => !d.includes('%')) - .map(d => { - results[d] = res[0][d] - }) - return results - }) -} - -orientServer = `http://${window.location.hostname}:8000` - -md`### Orientable` - -function report_from_result(result, starting_assignments, simplify_terms) { - const html = md` - -| name | val | type | desc | -| ---- | --- | ---- | ---- | -${Object.keys(result).sort() - .map(d => `| ${!starting_assignments[d] ? `**${d}**` : d} | ${result[d]} | ${vars[d] && vars[d].type ? vars[d].type : ''} | ${vars[d] && vars[d].description ? vars[d].description : ''} |\n`)} -` - html.value = result - return html -} - -bar_chart = (raw, title, variables, group_by, opts) => { - let data = raw - .map(d => { - return variables.map(key => ({ - construction: group_by.map(g => `${d[g]}`).join(', '), - type: key, - value: d[key], - title: d[title] - })) - }) - .flat() - .reduce((acc, curr) => { - let exists = acc.count[`${curr.construction}_${curr.type}`] - if (exists) { - return acc - } - acc.count[`${curr.construction}_${curr.type}`] = 1 - acc.res.push(curr) - return acc - }, {res: [], count: {}}) - .res - - let discarded_data = [] - let organized_data = [] - - if (opts && opts.filter) { - organized_data = data.filter(d => opts.filter(d['title'])) - discarded_data = data.filter(d => !opts.filter(d['title'])) - } - let graph = { - "$schema": "https://vega.github.io/schema/vega-lite/v4.json", - "title": `Composition of ${title} (${vars[title].type || ''})`, - vconcat: [ - { - layer: [{ - "width": 800, - "mark": "bar", - "data": { values: organized_data }, - "encoding": { - "x": {"aggregate": "sum", "field": "value", "type": "quantitative"}, - "y": {"field": "construction", "type": "nominal", "sort": {"op": "sum", "field": "title"}}, - "color": {"field": "type", "type": "nominal"} - } - }] - }, - ] - } - - if (discarded_data.length > 0) { - graph.vconcat.push({ - "mark": "bar", - "width": 800, - "title": "Data filtered out", - "data": { values: discarded_data }, - "encoding": { - "x": {"aggregate": "sum", "field": "value", "type": "quantitative"}, - "y": {"field": "construction", "type": "nominal", "sort": {"op": "sum", "field": "title"}}, - "color": {"field": "type", "type": "nominal"} - } - }) - } - - if (opts && opts.yrule) { - const rule = [{}] - rule[0][title] = opts.yrule - graph.vconcat[0].layer.push({ - "data": { "values": rule }, - "layer": [{ - "mark": "rule", - "encoding": { - "x": {"field": title, "type": "quantitative"}, - "color": {"value": "red"}, - "size": {"value": 3} - } - }] - }) - } - return vl(graph) -} - -add_query = (query, ext) => { - return query.map(d => Object.assign({}, d, ext)) -} - -extend_query = (array, ...exts) => { - let query = array - - const extend_one = (arr, ext) => arr.map(d => ext.map((_, i) => Object.assign({}, d, ext[i]))) - - exts.forEach(ext => { - query = extend_one(query, ext).flat() - }) - - return query -} - -multiple_solutions = (solutions, group_by, filter) => { - return solutions.map(s => { - const solution = {} - - filter.forEach(d => { - solution[d] = s[d] - }) - solution.name = group_by.map(g => `${g}=${s[g]}`).join(', ') - - return solution - }) -} - -table_constraints = (solutions, filter, group_by, sort_by) => { - let results = multiple_solutions(solutions, group_by, filter) - if (sort_by) { - results = results.sort((a, b) => +a[sort_by] - +b[sort_by]) - } - const header = ` - ${sort_by ? `Sorted by: ${sort_by}` : ''} - - ${group_by.length ? `| name ` : ``}| ${filter.join(' | ')} |` - const divider = `${group_by.length ? `| --- ` : ``}| ${filter.map(f => '--:').join(' | ')} |` - const rows = results.map(r => { - return `${group_by.length ? `| ${r.name} ` : ``}| ${filter.map(f => `\`${_f(r[f])}\``).join(' | ')}` - }) - const table = [header, divider, rows.join('\n')].join('\n') - - return md`${table}` -} - -chooser = (data, field, base) => { - const log_base = base ? Math.log10(base) : false - const maximum = Math.log10(Math.max(...solved_many.map(d => d[field])))+0.5 - const minimum = Math.log10(Math.min(...solved_many.map(d => d[field]))) - const format = v => `${_f(Math.pow(10, v))} ${vars[field].type || ''}` - - return slider({ - title: field, - description: vars[field].description, - min: minimum, - max: maximum, - value: log_base || maximum, - step: 0.01, - format: format, - }) -} - -md`### Utils` - -_f = (d) => typeof d == 'number' || !Number.isNaN(+d) ? d3.format('0.10~f')(d) : d - -jsonToSliders = (obj, assigned) => { - const inputs = Object.keys(obj).map(d => ` -
-
${d}
-
- -
-
${vars && vars[d] && vars[d].description ? vars[d].description : ''}
-
`) - const form = formToObject(html` -
- ${inputs.join('\n')} -
`) - - if (assigned) { - form.value = Object.assign({}, form.value, assigned) - } - - return form -} - -function formToObject (form) { - // Array.from(form.children).forEach(el => { - // el.append(html`hey`) - // }) - Array.from(form.querySelectorAll('input')).forEach(el => { - el.parentNode.append(html``) - }) - - - Array.from(form.querySelectorAll('input')).forEach(el => { - el.oninput = (e) => { - form[`output_${el.name}`].value = `${el.value} ${vars[el.name].type || ''}` - e.stopPropagation() - } - }) - - form.oninput = (e) => { - const value = Array.from(form.elements) - .reduce(function(map, _, i) { - if (form.elements[i].name.substr(0,6) !== 'output') { - map[form.elements[i].name] = form.elements[i].valueAsNumber - } - return map; - }, {}); - - Object.keys(value).forEach(k => { - form[`output_${k}`].value = `${form[k].value} ${vars && vars[k] ? vars[k].type || '' : ''}` - }) - - e.stopPropagation() - } - - form.onmouseup = form.onkeyup = form.ontouchend = e => { - form.value = Array.from(form.elements) - .reduce(function(map, _, i) { - if (form.elements[i].name.substr(0,6) !== 'output') { - map[form.elements[i].name] = form.elements[i].valueAsNumber - } - return map; - }, {}); - - Object.keys(form.value).forEach(k => { - form[`output_${k}`].value = `${form[k].value} ${vars && vars[k] ? vars[k].type || '' : ''}` - }) - - form.dispatchEvent(new CustomEvent('input')); - }; - - form.onmouseup() - return form -} - -function flatten(items) { - const flat = []; - - items.forEach(item => { - if (Array.isArray(item)) { - flat.push(...flatten(item)); - } else { - flat.push(item); - } - }); - - return flat; -} - -md`### Imports` - -import {slider, checkbox, number, button} from "@jashkenas/inputs" -d3 = require('d3') -vl = require('@observablehq/vega-lite') -import { createJsonDownloadButton } from "@trebor/download-json" -import {localStorage} from "@mbostock/safe-local-storage" - -md`### Styles` - -html`` - -graph_constraints = (solutions, x, y, group_by, opts) => { - const results = multiple_solutions(solutions, group_by, [x, y]) - const graph = { - "title": `Plotting: ${x} vs ${y}`, - "width": 600, - layer: [{ - "data": {"values": results}, - "mark": {"type": "line"}, - "encoding": { - "x": { - "field": x, - "type": "quantitative", - "axis": { - "labelLimit": 400, - "labelPadding": 30 - } - }, - "y": { - "field": y, - "type": "quantitative", - }, - "color": { - "field": "name", - "type": "nominal", - "scale": {"scheme": "category10"} - }, - }, - }] - } - if (opts && opts.height) { - graph.height = opts.height - } - if (opts && opts.yrule) { - const rule = [{}] - rule[0][y] = opts.yrule - - graph.layer.push({ - "data": { "values": rule }, - "layer": [{ - "mark": "rule", - "encoding": { - "y": {"field": y, "type": "quantitative"}, - "color": {"value": "red"}, - "size": {"value": 3} - } - }] - }) - } - return vl(graph) - -} - -Plotly = require("https://cdn.plot.ly/plotly-latest.min.js") - - -plot3d = (rows, x, y, z) => { - var zData = rows.map(d => { - return [d[x], d[y], d[z]] - }); - - var data = [{ - z: zData, - type: 'surface' - }]; - - var data2 = [{ - x: rows.map(d => d[x]), - y: rows.map(d => d[y]), - z: rows.map(d => d[z]), - type: 'scatter3d' - }] - - var layout = { - title: `${x} vs ${y} vs ${z}`, - autosize: false, - width: width * 0.7, - height: width * 0.7, - scene: { - xaxis: { - title:{ - text: x, - font: { - family: 'Courier New, monospace', - size: 18, - color: '#7f7f7f' - } - } - }, - yaxis: { - title:{ - text: y, - font: { - family: 'Courier New, monospace', - size: 18, - color: '#7f7f7f' - } - } - }, - zaxis: { - title:{ - text: z, - font: { - family: 'Courier New, monospace', - size: 18, - color: '#7f7f7f' - } - } - } - }, - margin: { - l: 65, - r: 50, - b: 65, - t: 90, - } - }; - - const div = DOM.element('div'); - Plotly.newPlot(div, data2, layout); - return div -} - -// plotMultiLine(delta_solved, 'chung_delta', ['decoding_time_parallel', 'epost_time_parallel', 'onboard_tib_time_days']) - -plotMultiLine = (solutions, x, names) => { - - const traces = names.map(y => { - return { - x: solutions.map(d => d[x]), - y: solutions.map(d => d[y]), - name: `${y} data`, - yaxis: y, - type: 'scatter' - } - }) - - var layout = { - title: 'multiple y-axes example', - // width: 800, - autosize: false, - xaxis: {domain: [0.01, 0.20]}, - yaxis: { - title: 'yaxis title', - titlefont: {color: '#1f77b4'}, - tickfont: {color: '#1f77b4'} - }, - yaxis2: { - title: 'yaxis2 title', - titlefont: {color: '#ff7f0e'}, - tickfont: {color: '#ff7f0e'}, - anchor: 'free', - overlaying: 'y', - side: 'left', - position: 0.15 - }, - yaxis3: { - title: 'yaxis4 title', - titlefont: {color: '#d62728'}, - tickfont: {color: '#d62728'}, - anchor: 'right', - overlaying: 'y', - side: 'left' - }, - }; - - const div = DOM.element('div'); - Plotly.newPlot(div, traces, layout); - return div -} - -codeView =({value, mode, height, localStorageKey}) => { - - value = localStorage.getItem(localStorageKey) || value - - const fn = ({CodeMirror} = {}) => { - return ({id, value, mode}) => { - const cm = CodeMirror(document.body, { - value, - mode, - lineNumbers: true - }) - CodeMirror.modeURL = 'https://codemirror.net/mode/%N/%N.js' - CodeMirror.autoLoadMode(cm, mode) - - cm.on('keypress', (cm, event) => { - if (event.key === 'Enter' && event.shiftKey) { - event.preventDefault() - window.parent.postMessage({ - id, - value: cm.getValue(), - height: document.body.offsetHeight - }, document.origin) - } - }) - setInterval(() => { - window.parent.postMessage({ - id, - height: document.body.offsetHeight - }, document.origin) - }, 100) - } - } - const randomId = `el${Math.floor(Math.random() * 1000000)}` - const frameSrc = ` - - - - - - - ` - const frameStyle = `width: 100%; height: 300px; border: 0; overflow-y: hidden;` - const frame = html`` - const messageListener = event => { - if (document.contains(frame)) { - if (event.data.id === randomId) { - if (event.data.value !== undefined) { - frame.value = event.data.value - localStorage.setItem(localStorageKey, frame.value) - frame.dispatchEvent(new CustomEvent("input")) - } - frame.style.height = `${event.data.height}px` - } - } else { - window.removeEventListener('message', messageListener) - } - } - window.addEventListener('message', messageListener, false) - frame.srcdoc = frameSrc - frame.value = value - return frame -} - -// { -// reset_button; -// if (this) { -// localStorage.removeItem('utility') -// } - -// return !this -// } - -function qs(variable) { - var query = window.location.search.substring(1); - var vars = query.split('&'); - for (var i = 0; i < vars.length; i++) { - var pair = vars[i].split('='); - if (decodeURIComponent(pair[0]) == variable) { - return decodeURIComponent(pair[1]); - } - } - return false -} - -benchmark_theory = solve_manys([benchmark_theory_query]) - -createJsonDownloadButton(benchmark_theory[0]) - -benchmark_theory_query = { - const settings = { - sector_size_gib: 1, - porep_challenges: 700, - post_challenges: 30, - stacked_layers: 7, - rig_cores: 8, - rig_storage_write_mbs: 2000, - } - - let query = extend_query([{}], [stackedReplicas]) - - query = extend_query(query, [{ - "!StackedSDRParameters": true, - "!TimingAssumption": true, - "!ElectionWithFallbackPoSt": true, - "!SectorEncoding": true, - "!VectorR": true, - "!StackedReplicas": true, - "!StackedReplicaUnaligned": true, - post_mtree_layers_deleted: 0, - // time_amax: 1, - // hash_gb_per_second: 7.5, - graph_name: 'SDR', - proof_name: "stackedReplicas", - windows: 1, - }]) - - query = extend_query(query, [pedersen]) - query = extend_query(query, [filecoin]) - query = extend_query(query, [constraints]) - query = extend_query(query, [settings]) - query = extend_query(query, [{ - "kdf_time": 1.051e-7, // 0.0000000256 / 2, // 2 1.28e-8/2, //5.4e-7, - "merkle_tree_datahash_time": 0.3876e-6, // 1.051e-7, // 0.0000000256/2, - "merkle_tree_hash_time": 13.652e-6, // 1.7028e-5/2, - "column_leaf_hash_time": 171e-6/10, // 1.7028e-5/2, - "snark_constraint_time": 0.00000317488, // 3.012e-5/2, - "ticket_hash": 1.7028e-5/2, - "rig_snark_parallelization": 1, - "rig_storage_latency": 0.0003, - "rig_storage_parallelization": 1, - "drg_parents": 6, - "expander_parents": 8 - }]) - - return query -} - -createJsonDownloadButton(benchmark_theory_query[0]) - -benchmark_practice = fetch(`./bench.json?date=${(new Date()).getTime()}`) - .then(r => r.json()) - -md` -| name | -| ---- | -${Object.keys(benchmark_practice).filter(k => !benchmark_theory[0][k]).map(k => `| ${k}| `).join('\n')} -` -report_comparison(benchmark_theory[0], benchmark_practice) - -function report_comparison(result1, result2) { - const html = md` - -| name | val1 | val2 | type | desc | -| ---- | ---- | ---- | ---- | ---- | -${Object.keys(result1).sort() - .filter(d => result2[d] && result1[d]) - .map(d => { - let name = d - if (result2[d] === result1[d]) name = `**${d}**` - if (result2[d] !== result1[d]) name = `**${d}**` - if (!result2[d]) name = `**${d}**` - - return `| ${name} | ${result1[d]} | ${result2[d]} | ${vars[d] && vars[d].type ? vars[d].type : ''} | ${vars[d] && vars[d].description ? vars[d].description : ''} |\n` -})} -` - return html -} - -// encoding time is everything but the SNARK -// precommmit - -// porep_time -> porep_precommit_time: -// encoding_time -> dig_encoding_time: column leaves + encoding time -// generate_tree_c_time -> commc_tree_time -// kdf_constraints -> labeling_proof -// tree_r_last_cpu_time_ms -> commr_time -// porep_constraints -> porep_snark_constraints -// post_constraints -> post_snark_constraints - -// TODO: make sure that lotus proofs take the same time as ubercalc diff --git a/src/static/ox-hugo/data-layer.png b/src/static/ox-hugo/data-layer.png deleted file mode 100644 index 2930bf738..000000000 Binary files a/src/static/ox-hugo/data-layer.png and /dev/null differ diff --git a/src/static/ox-hugo/layer-1.png b/src/static/ox-hugo/layer-1.png deleted file mode 100644 index 514124f18..000000000 Binary files a/src/static/ox-hugo/layer-1.png and /dev/null differ diff --git a/src/static/ox-hugo/layer-2.png b/src/static/ox-hugo/layer-2.png deleted file mode 100644 index 0390da15d..000000000 Binary files a/src/static/ox-hugo/layer-2.png and /dev/null differ diff --git a/src/static/ox-hugo/layer-3.png b/src/static/ox-hugo/layer-3.png deleted file mode 100644 index cdf02ba97..000000000 Binary files a/src/static/ox-hugo/layer-3.png and /dev/null differ diff --git a/src/static/ox-hugo/layer-4.png b/src/static/ox-hugo/layer-4.png deleted file mode 100644 index c70ce3ee0..000000000 Binary files a/src/static/ox-hugo/layer-4.png and /dev/null differ diff --git a/src/static/ox-hugo/legend.png b/src/static/ox-hugo/legend.png deleted file mode 100644 index 87d9b043a..000000000 Binary files a/src/static/ox-hugo/legend.png and /dev/null differ diff --git a/src/static/ox-hugo/replica-layer.png b/src/static/ox-hugo/replica-layer.png deleted file mode 100644 index 7fc2ff666..000000000 Binary files a/src/static/ox-hugo/replica-layer.png and /dev/null differ diff --git a/src/systems/_index.md b/src/systems/_index.md deleted file mode 100644 index efe349508..000000000 --- a/src/systems/_index.md +++ /dev/null @@ -1,11 +0,0 @@ ---- -title: Systems -entries: -- filecoin_nodes -- filecoin_files -- filecoin_vm -- filecoin_blockchain -- filecoin_token -- filecoin_mining -- filecoin_markets ---- diff --git a/src/systems/filecoin_blockchain/_index.md b/src/systems/filecoin_blockchain/_index.md deleted file mode 100644 index 8d92c5ab8..000000000 --- a/src/systems/filecoin_blockchain/_index.md +++ /dev/null @@ -1,33 +0,0 @@ ---- -menuIcon: 📦 -title: "**Blockchain**" -entries: -- struct -- message_pool -- genesis -- chainsync -- storage_power_consensus ---- - -{{< incTocMap "/docs/systems/filecoin_blockchain" 3 >}} - - -The Filecoin Blockchain is a distributed virtual machine that achieves consensus, processes messages, accounts for storage, and maintains security in the Filecoin Protocol. It is the main interface linking various actors in the Filecoin system. - -It includes: - -- A {{}} subsystem that nodes use to track and propagate messages related to the storage market throughout a gossip network. -- A {{}} subsystem used to interpret and execute messages in order to update system state. -- A {{}} subsystem which manages the creation and maintenance of state trees (the system state) deterministically generated by the vm from a given subchain. -- A {{}} susbystem that tracks and propagates validated message blocks, maintaining sets of candidate chains on which the miner may mine and running syntactic validation on incoming blocks. -- A {{}} subsystem which tracks {{}} state for a given chain and helps the blockchain system choose subchains to extend and blocks to include in them. - -And also: - -- A {{ }} -- which maintains a given chain's state, providing facilities to other blockchain subsystems which will query state about the latest chain in order to run, and ensuring incoming blocks are semantically validated before inclusion into the chain. -- A {{ }} -- which is called in the event of a successful leader election in order to produce a new block that will extend the current heaviest chain before forwarding it to the syncer for propagation. - -At a high-level, the Filecoin blockchain grows through successive rounds of leader election in which a number of miners are elected to generate a block, whose inclusion in the chain will earn them block rewards. -Filecoin's blockchain runs on storage power. That is, its consensus algorithm by which miners agree on which subchain to mine is predicated on the amount of storage backing that subchain. At a high-level, the {{}} subsystem maintains a _Power Table_ that tracks the amount of storage {{}} have contributed to the network through _Sector commitments_ and _Proofs of Spacetime_. - -Most of the functions of the Filecoin blockchain system are detailed in the code below. \ No newline at end of file diff --git a/src/systems/filecoin_blockchain/blockchain.id b/src/systems/filecoin_blockchain/blockchain.id deleted file mode 100644 index 30206351f..000000000 --- a/src/systems/filecoin_blockchain/blockchain.id +++ /dev/null @@ -1,52 +0,0 @@ -import abi "github.com/filecoin-project/specs-actors/actors/abi" -import clock "github.com/filecoin-project/specs/systems/filecoin_nodes/clock" -import st "github.com/filecoin-project/specs/systems/filecoin_vm/state_tree" -import block "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/block" -import chain "github.com/filecoin-project/specs/systems/filecoin_blockchain/struct/chain" - -type SectorID struct {} - -type Booting struct {} -type CatchingUp struct {} -type Synchronized struct {} -type SyncState union { - Booting - CatchingUp - Synchronized -} - -type BlockchainSubsystem struct @(mutable) { - Clock &clock.UTCClock - - LatestEpoch() abi.ChainEpoch - BestChain() chain.Chain - CandidateChains() [chain.Chain] - - // // Receiving blocks and tipset - // should be channels or notifications - NewTipsets() - NewBestTipset() - - // validateBlockSemantics(Block) - SyncState() SyncState - - // call by StorageClient in StorageDealMake - VerifySectorExists(sectorId SectorID) bool - - // call by BlockSyncer in BlockReception - HandleBlock(block block.Block) bool - - // call by BlockchainSubsystem itself in BlockProduction - ValidateBlock(block block.Block) bool - - // call by BlockchainSubsystem itself in BlockProduction - // apply messages in the parent tipset to the StateTree - // and verify state root - TryGenerateStateTree(block block.Block) st.StateTree - - // call by clock in BlockReception upon new epoch - AssembleTipsets() [chain.Tipset] - - // call by BlockchainSubsystem itself in BlockReception upon new epoch - ChooseTipset(tipsets [chain.Tipset]) chain.Tipset -} diff --git a/src/systems/filecoin_blockchain/bootstrap/index.md b/src/systems/filecoin_blockchain/bootstrap/index.md deleted file mode 100644 index a0ca452e8..000000000 --- a/src/systems/filecoin_blockchain/bootstrap/index.md +++ /dev/null @@ -1,15 +0,0 @@ ---- -menuTitle: Genesis -statusIcon: 🔁 -title: Genesis - starting the Blockchain ---- - -{{% notice warning %}} -⚠️ **WARNING:** This section is not yet complete. -{{% /notice %}} - -Network Bootstrapping starts with production of the genesis block. - -The genesis block will contain: - - An initial participant set, including committed storage from these miners (pre-sealed using special-cased randomness) - - An initial randomness ticket \ No newline at end of file diff --git a/src/systems/filecoin_blockchain/chainsync/_index.md b/src/systems/filecoin_blockchain/chainsync/_index.md deleted file mode 100644 index 0356e34b2..000000000 --- a/src/systems/filecoin_blockchain/chainsync/_index.md +++ /dev/null @@ -1,499 +0,0 @@ ---- -menuTitle: ChainSync -statusIcon: ✅ -title: ChainSync - synchronizing the Blockchain ---- - -{{