From 12a7171a5d64bfd6adbd20e0c88f5c3abaa973d1 Mon Sep 17 00:00:00 2001 From: Icebob Date: Thu, 20 May 2021 18:05:22 +0200 Subject: [PATCH 01/13] update changelog --- CHANGELOG.md | 202 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 194 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 13e3f19a..bb994f5e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,9 +1,130 @@ + +## 0.3.3 (2021-05-20) + +* 0.3.3 ([40cc5c5](https://github.com/icebob/fakerator/commit/40cc5c5)) +* Create main.yml ([baa7d3e](https://github.com/icebob/fakerator/commit/baa7d3e)) +* Delete main.yml ([fc5a1dd](https://github.com/icebob/fakerator/commit/fc5a1dd)) +* npm audit ([afa00f0](https://github.com/icebob/fakerator/commit/afa00f0)) +* Update .travis.yml ([f8cb00b](https://github.com/icebob/fakerator/commit/f8cb00b)) +* Update lodash to version 4.17.20 (#1) ([3df651a](https://github.com/icebob/fakerator/commit/3df651a)), closes [#1](https://github.com/icebob/fakerator/issues/1) +* update readme ([8fd83b2](https://github.com/icebob/fakerator/commit/8fd83b2)) +* refactor: jan's typo ([7e01d70](https://github.com/icebob/fakerator/commit/7e01d70)) +* style: linted quotes and semicolons ([1e81ed1](https://github.com/icebob/fakerator/commit/1e81ed1)) +* style: using doublequotes ([6e1bc46](https://github.com/icebob/fakerator/commit/6e1bc46)) +* feat: added base enums and vocabulary ([515fdc6](https://github.com/icebob/fakerator/commit/515fdc6)) + + + + +## 0.3.2 (2020-11-16) + +* 0.3.2 ([3573b48](https://github.com/icebob/fakerator/commit/3573b48)) +* Add Gender to User return ([51c81ab](https://github.com/icebob/fakerator/commit/51c81ab)) +* npm audit ([3325451](https://github.com/icebob/fakerator/commit/3325451)) + + + + +## 0.3.1 (2020-01-12) + +* :pencil: docs: fix typo ([56fb3c2](https://github.com/icebob/fakerator/commit/56fb3c2)) +* 0.3.1 ([a0babc5](https://github.com/icebob/fakerator/commit/a0babc5)) +* Added typescript declarations ([6f1d7b6](https://github.com/icebob/fakerator/commit/6f1d7b6)) +* fix autocorrect ([2d86bb7](https://github.com/icebob/fakerator/commit/2d86bb7)) +* npm audit ([1d6f9ca](https://github.com/icebob/fakerator/commit/1d6f9ca)) +* remove v0.12 node from travis ([24f81b5](https://github.com/icebob/fakerator/commit/24f81b5)) +* spelling fix ([9326b7a](https://github.com/icebob/fakerator/commit/9326b7a)) +* Update README.md ([896b9b1](https://github.com/icebob/fakerator/commit/896b9b1)) +* chore(package): update babel-core to version 6.13.2 ([f4233b4](https://github.com/icebob/fakerator/commit/f4233b4)) +* chore(package): update babel-core to version 6.17.0 ([5d1bef8](https://github.com/icebob/fakerator/commit/5d1bef8)) +* chore(package): update babel-core to version 6.20.0 ([906557e](https://github.com/icebob/fakerator/commit/906557e)) +* chore(package): update babel-core to version 6.21.0 ([77e197f](https://github.com/icebob/fakerator/commit/77e197f)) +* chore(package): update babel-loader to version 6.2.5 ([1dbbd24](https://github.com/icebob/fakerator/commit/1dbbd24)) +* chore(package): update babel-loader to version 6.2.8 ([9adc8ef](https://github.com/icebob/fakerator/commit/9adc8ef)) +* chore(package): update babel-loader to version 6.2.9 ([e7d7f1d](https://github.com/icebob/fakerator/commit/e7d7f1d)) +* chore(package): update babel-plugin-transform-runtime to version 6.15.0 ([31a61aa](https://github.com/icebob/fakerator/commit/31a61aa)) +* chore(package): update babel-preset-es2015 to version 6.13.2 ([5e35b1d](https://github.com/icebob/fakerator/commit/5e35b1d)) +* chore(package): update coveralls to version 2.11.11 ([01a58ed](https://github.com/icebob/fakerator/commit/01a58ed)) +* chore(package): update coveralls to version 2.11.12 ([660e410](https://github.com/icebob/fakerator/commit/660e410)) +* chore(package): update coveralls to version 2.11.14 ([5899116](https://github.com/icebob/fakerator/commit/5899116)) +* chore(package): update coveralls to version 2.11.15 ([bbc3086](https://github.com/icebob/fakerator/commit/bbc3086)) +* chore(package): update del to version 2.2.2 ([a693b4f](https://github.com/icebob/fakerator/commit/a693b4f)) +* chore(package): update eslint to version 3.0.1 ([4af58fb](https://github.com/icebob/fakerator/commit/4af58fb)) +* chore(package): update eslint to version 3.1.1 ([90f18c5](https://github.com/icebob/fakerator/commit/90f18c5)) +* chore(package): update eslint to version 3.10.1 ([082cfb8](https://github.com/icebob/fakerator/commit/082cfb8)) +* chore(package): update eslint to version 3.10.2 ([47986af](https://github.com/icebob/fakerator/commit/47986af)) +* chore(package): update eslint to version 3.11.0 ([60a0446](https://github.com/icebob/fakerator/commit/60a0446)) +* chore(package): update eslint to version 3.11.1 ([eeaf44d](https://github.com/icebob/fakerator/commit/eeaf44d)) +* chore(package): update eslint to version 3.12.0 ([5bddcf6](https://github.com/icebob/fakerator/commit/5bddcf6)) +* chore(package): update eslint to version 3.13.0 ([8f7dfd2](https://github.com/icebob/fakerator/commit/8f7dfd2)) +* chore(package): update eslint to version 3.3.0 ([b03506b](https://github.com/icebob/fakerator/commit/b03506b)) +* chore(package): update eslint to version 3.3.1 ([c48a42f](https://github.com/icebob/fakerator/commit/c48a42f)) +* chore(package): update eslint to version 3.4.0 ([6a898ee](https://github.com/icebob/fakerator/commit/6a898ee)) +* chore(package): update eslint to version 3.5.0 ([e7a0017](https://github.com/icebob/fakerator/commit/e7a0017)) +* chore(package): update eslint to version 3.6.1 ([ec45ab0](https://github.com/icebob/fakerator/commit/ec45ab0)) +* chore(package): update eslint to version 3.8.0 ([d21cdf8](https://github.com/icebob/fakerator/commit/d21cdf8)) +* chore(package): update eslint to version 3.9.1 ([be1380d](https://github.com/icebob/fakerator/commit/be1380d)) +* chore(package): update eslint-friendly-formatter to version 2.0.6 ([1bb441d](https://github.com/icebob/fakerator/commit/1bb441d)) +* chore(package): update eslint-friendly-formatter to version 2.0.7 ([91664a9](https://github.com/icebob/fakerator/commit/91664a9)) +* chore(package): update glob to version 7.0.6 ([db8e25b](https://github.com/icebob/fakerator/commit/db8e25b)) +* chore(package): update glob to version 7.1.0 ([d707131](https://github.com/icebob/fakerator/commit/d707131)) +* chore(package): update glob to version 7.1.1 ([cba2e97](https://github.com/icebob/fakerator/commit/cba2e97)) +* chore(package): update karma to version 1.2.0 ([17d535d](https://github.com/icebob/fakerator/commit/17d535d)) +* chore(package): update karma to version 1.3.0 ([701a3a0](https://github.com/icebob/fakerator/commit/701a3a0)) +* chore(package): update karma-coverage to version 1.1.1 ([fd3aab8](https://github.com/icebob/fakerator/commit/fd3aab8)) +* chore(package): update karma-mocha to version 1.2.0 ([4f88150](https://github.com/icebob/fakerator/commit/4f88150)) +* chore(package): update karma-phantomjs-launcher to version 1.0.1 ([9666a36](https://github.com/icebob/fakerator/commit/9666a36)) +* chore(package): update karma-sinon-chai to version 1.2.3 ([b77352c](https://github.com/icebob/fakerator/commit/b77352c)) +* chore(package): update karma-sinon-chai to version 1.2.4 ([77b2851](https://github.com/icebob/fakerator/commit/77b2851)) +* chore(package): update karma-webpack to version 1.8.0 ([443b85f](https://github.com/icebob/fakerator/commit/443b85f)) +* chore(package): update lodash to version 4.14.0 ([e759b0f](https://github.com/icebob/fakerator/commit/e759b0f)) +* chore(package): update lodash to version 4.14.1 ([b796c4d](https://github.com/icebob/fakerator/commit/b796c4d)) +* chore(package): update lodash to version 4.15.0 ([5598bc9](https://github.com/icebob/fakerator/commit/5598bc9)) +* chore(package): update lodash to version 4.16.0 ([44bb502](https://github.com/icebob/fakerator/commit/44bb502)) +* chore(package): update lodash to version 4.16.2 ([4af600a](https://github.com/icebob/fakerator/commit/4af600a)) +* chore(package): update lodash to version 4.16.3 ([a420529](https://github.com/icebob/fakerator/commit/a420529)) +* chore(package): update lodash to version 4.16.4 ([12a2a34](https://github.com/icebob/fakerator/commit/12a2a34)) +* chore(package): update lodash to version 4.16.5 ([2b56c41](https://github.com/icebob/fakerator/commit/2b56c41)) +* chore(package): update lodash to version 4.17.0 ([8b6e193](https://github.com/icebob/fakerator/commit/8b6e193)) +* chore(package): update lodash to version 4.17.1 ([d839fdb](https://github.com/icebob/fakerator/commit/d839fdb)) +* chore(package): update lodash to version 4.17.2 ([ecd2c39](https://github.com/icebob/fakerator/commit/ecd2c39)) +* chore(package): update lodash to version 4.17.3 ([4c4a5c7](https://github.com/icebob/fakerator/commit/4c4a5c7)) +* chore(package): update lodash to version 4.17.4 ([7d460e8](https://github.com/icebob/fakerator/commit/7d460e8)) +* chore(package): update lolex to version 1.5.1 ([2271f31](https://github.com/icebob/fakerator/commit/2271f31)) +* chore(package): update lolex to version 1.5.2 ([e9c2bce](https://github.com/icebob/fakerator/commit/e9c2bce)) +* chore(package): update mocha-loader to version 1.1.0 ([622924b](https://github.com/icebob/fakerator/commit/622924b)) +* chore(package): update phantomjs-prebuilt to version 2.1.12 ([36852f0](https://github.com/icebob/fakerator/commit/36852f0)) +* chore(package): update phantomjs-prebuilt to version 2.1.14 ([4c054b0](https://github.com/icebob/fakerator/commit/4c054b0)) +* chore(package): update sinon to version 1.17.5 ([a25d6ee](https://github.com/icebob/fakerator/commit/a25d6ee)) +* chore(package): update sinon to version 1.17.6 ([7eacdd0](https://github.com/icebob/fakerator/commit/7eacdd0)) +* chore(package): update sinon to version 1.17.7 ([dd56d0d](https://github.com/icebob/fakerator/commit/dd56d0d)) +* chore(package): update uuid to version 2.0.3 ([154721d](https://github.com/icebob/fakerator/commit/154721d)) +* chore(package): update uuid to version 3.0.0 ([fea1471](https://github.com/icebob/fakerator/commit/fea1471)) +* chore(package): update uuid to version 3.0.1 ([c0d4b80](https://github.com/icebob/fakerator/commit/c0d4b80)) +* chore(package): update webpack to version 1.13.2 ([9e9b30d](https://github.com/icebob/fakerator/commit/9e9b30d)) +* chore(package): update webpack to version 1.14.0 ([df2511e](https://github.com/icebob/fakerator/commit/df2511e)) +* chore(package): update webpack-merge to version 0.14.1 ([fb8b6ae](https://github.com/icebob/fakerator/commit/fb8b6ae)) +* chore(package): update webpack-merge to version 0.15.0 ([900abba](https://github.com/icebob/fakerator/commit/900abba)) +* chore(package): update webpack-merge to version 0.18.0 ([0224d73](https://github.com/icebob/fakerator/commit/0224d73)) +* chore(package): update webpack-merge to version 1.0.2 ([76f757f](https://github.com/icebob/fakerator/commit/76f757f)) +* chore(package): update webpack-merge to version 1.1.0 ([d59a791](https://github.com/icebob/fakerator/commit/d59a791)) +* chore(package): update webpack-merge to version 1.1.1 ([3b99297](https://github.com/icebob/fakerator/commit/3b99297)) +* chore(package): update webpack-merge to version 1.1.2 ([8bbe76d](https://github.com/icebob/fakerator/commit/8bbe76d)) +* chore(package): update webpack-merge to version 2.1.0 ([3ca676a](https://github.com/icebob/fakerator/commit/3ca676a)) +* chore(package): update webpack-merge to version 2.1.1 ([2853780](https://github.com/icebob/fakerator/commit/2853780)) +* chore(package): update webpack-merge to version 2.2.0 ([0eb1618](https://github.com/icebob/fakerator/commit/0eb1618)) +* chore(package): update webpack-merge to version 2.3.0 ([dd5b095](https://github.com/icebob/fakerator/commit/dd5b095)) +* chore(package): update webpack-merge to version 2.3.1 ([b5d99ab](https://github.com/icebob/fakerator/commit/b5d99ab)) + + + -# 0.3.0 (2016-07-01) +## 0.3.0 (2016-07-01) * :package: build: Bump version and build ([aa9c2d0](https://github.com/icebob/fakerator/commit/aa9c2d0)) +* :pencil: docs: update CHANGELOG ([07fba4e](https://github.com/icebob/fakerator/commit/07fba4e)) * :pencil: docs: update README ([908bc20](https://github.com/icebob/fakerator/commit/908bc20)) -* Add cs-CZ locale ([06a0c70](https://github.com/icebob/fakerator/commit/06a0c70)) +* Add cs-CZ locale ([06a0c70](https://github.com/icebob/fakerator/commit/06a0c70)), closes [#23](https://github.com/icebob/fakerator/issues/23) * Update README.md ([d087a9d](https://github.com/icebob/fakerator/commit/d087a9d)) * Update README.md ([d057ed5](https://github.com/icebob/fakerator/commit/d057ed5)) * chore(package): update del to version 2.2.1 ([4eb8d83](https://github.com/icebob/fakerator/commit/4eb8d83)) @@ -18,10 +139,11 @@ -# 0.2.0 (2016-06-03) +## 0.2.0 (2016-06-03) * :package: Build iwth new locales ([666e0fb](https://github.com/icebob/fakerator/commit/666e0fb)) * :package: build: build v0.2.0 ([752fa55](https://github.com/icebob/fakerator/commit/752fa55)) +* :pencil: docs: update changelog ([d878d12](https://github.com/icebob/fakerator/commit/d878d12)) * :pencil: docs: update readme with new locales ([7f8c226](https://github.com/icebob/fakerator/commit/7f8c226)) * Add en-AU locales ([a62f5c3](https://github.com/icebob/fakerator/commit/a62f5c3)) * add local en-CA ([b076585](https://github.com/icebob/fakerator/commit/b076585)) @@ -31,13 +153,15 @@ * Modify npm script ([dc62c58](https://github.com/icebob/fakerator/commit/dc62c58)) * Remove unused file ([a68756a](https://github.com/icebob/fakerator/commit/a68756a)) * Update README.md ([92d8f37](https://github.com/icebob/fakerator/commit/92d8f37)) -* docs: remove new keywords from readme #3 ([6969491](https://github.com/icebob/fakerator/commit/6969491)) +* docs: remove new keywords from readme #3 ([6969491](https://github.com/icebob/fakerator/commit/6969491)), closes [#3](https://github.com/icebob/fakerator/issues/3) -## 0.1.1 (2016-05-31) +## 0.1.1 (2016-05-31) +* docs(changelog): Create changelog ([7cc265b](https://github.com/icebob/fakerator/commit/7cc265b)) +* docs(changelog): update changelog ([e26006d](https://github.com/icebob/fakerator/commit/e26006d)) * :package: build: Build v0.1.1 ([785301e](https://github.com/icebob/fakerator/commit/785301e)) * :star: new(locales): add localized country list ([6c152b6](https://github.com/icebob/fakerator/commit/6c152b6)) * Create LOCALES.md ([ab673ae](https://github.com/icebob/fakerator/commit/ab673ae)) @@ -48,13 +172,12 @@ * Update karma-mocha and karma-coverage ([1661a77](https://github.com/icebob/fakerator/commit/1661a77)) * Update README.md ([703c080](https://github.com/icebob/fakerator/commit/703c080)) * Update README.md ([27317b8](https://github.com/icebob/fakerator/commit/27317b8)) -* docs(changelog): Create changelog ([7cc265b](https://github.com/icebob/fakerator/commit/7cc265b)) * chore(package): update dependencies ([9fa601e](https://github.com/icebob/fakerator/commit/9fa601e)) -# 0.1.0 (2016-05-31) +## 0.1.0 (2016-05-31) * :package: build v0.1.0 ([d3c552a](https://github.com/icebob/fakerator/commit/d3c552a)) * :star: new: Add bump npm scripts ([3d3de1b](https://github.com/icebob/fakerator/commit/3d3de1b)) @@ -68,9 +191,72 @@ * Remove publish-please dep ([392443c](https://github.com/icebob/fakerator/commit/392443c)) * Rename locale build files ([853ab8d](https://github.com/icebob/fakerator/commit/853ab8d)) * Update badges ([647e7b6](https://github.com/icebob/fakerator/commit/647e7b6)) +* Update README.md ([73288ff](https://github.com/icebob/fakerator/commit/73288ff)) * Update README.md ([4b79d86](https://github.com/icebob/fakerator/commit/4b79d86)) * Update README.md ([5af56fc](https://github.com/icebob/fakerator/commit/5af56fc)) * Update README.md ([6d825ab](https://github.com/icebob/fakerator/commit/6d825ab)) * Update README.md ([030d025](https://github.com/icebob/fakerator/commit/030d025)) -* Update README.md ([73288ff](https://github.com/icebob/fakerator/commit/73288ff)) + + + + +## 0.0.1 (2016-05-30) + +* :arrow_up: test: add coverage ([f8ab51c](https://github.com/icebob/fakerator/commit/f8ab51c)) +* :bug: add chai dependency ([7e24e9b](https://github.com/icebob/fakerator/commit/7e24e9b)) +* :bug: fix: don't merge functions ([5e2bbdf](https://github.com/icebob/fakerator/commit/5e2bbdf)) +* :package: Build ([ba87629](https://github.com/icebob/fakerator/commit/ba87629)) +* :star: change country list to code + name ([de56912](https://github.com/icebob/fakerator/commit/de56912)) +* :star: new: add date.weekdays and months ([1574ff6](https://github.com/icebob/fakerator/commit/1574ff6)) +* :star: new: Add entity generators: user, address, company, post ([95e1774](https://github.com/icebob/fakerator/commit/95e1774)) +* :star: new: add french locale ([fa0add7](https://github.com/icebob/fakerator/commit/fa0add7)) +* :star: new: Add gravatar generator ([f5ac1c9](https://github.com/icebob/fakerator/commit/f5ac1c9)) +* :star: new: add Italic locale ([dce3063](https://github.com/icebob/fakerator/commit/dce3063)) +* :star: new: add polish locale ([2f0ff7b](https://github.com/icebob/fakerator/commit/2f0ff7b)) +* :star: new: add random.string with length ([97135b2](https://github.com/icebob/fakerator/commit/97135b2)) +* :star: new: add russian locale ([530c015](https://github.com/icebob/fakerator/commit/530c015)) +* :star: new: add spanish locale ([d45edac](https://github.com/icebob/fakerator/commit/d45edac)) +* :star: new: createGenerator method ([b1cdd88](https://github.com/icebob/fakerator/commit/b1cdd88)) +* :star: new: email generator with domain parameter ([6214433](https://github.com/icebob/fakerator/commit/6214433)) +* :star: new: Geman locale ([33b6688](https://github.com/icebob/fakerator/commit/33b6688)) +* :star: new: ipv6 generator ([9255809](https://github.com/icebob/fakerator/commit/9255809)) +* :star: new: time with min,max param ([bb475c0](https://github.com/icebob/fakerator/commit/bb475c0)) +* :star: new: utimes as unique times generator ([3cc6893](https://github.com/icebob/fakerator/commit/3cc6893)) +* :white_check_mark: test: create tests ([0148185](https://github.com/icebob/fakerator/commit/0148185)) +* :white_check_mark: test: new tests ([fe4f94b](https://github.com/icebob/fakerator/commit/fe4f94b)) +* Add altitude and swap random.number params ([364ffa8](https://github.com/icebob/fakerator/commit/364ffa8)) +* Add bower support ([002bff7](https://github.com/icebob/fakerator/commit/002bff7)) +* add codacy badge ([2d683d8](https://github.com/icebob/fakerator/commit/2d683d8)) +* Add coveralls support ([7a7ee99](https://github.com/icebob/fakerator/commit/7a7ee99)) +* Add date.age generator ([b9406a3](https://github.com/icebob/fakerator/commit/b9406a3)) +* Add demo fiddle ([946b862](https://github.com/icebob/fakerator/commit/946b862)) +* add likelihood to random.boolean ([d57d0e9](https://github.com/icebob/fakerator/commit/d57d0e9)) +* Add mask helper function ([9d620b6](https://github.com/icebob/fakerator/commit/9d620b6)) +* Add more helper functions ([69dbc7b](https://github.com/icebob/fakerator/commit/69dbc7b)) +* Add seed to hu-HU test ([af7f8da](https://github.com/icebob/fakerator/commit/af7f8da)) +* Add uuid generator ([4c6d216](https://github.com/icebob/fakerator/commit/4c6d216)) +* Build ([76501aa](https://github.com/icebob/fakerator/commit/76501aa)) +* Build ([f60ac6f](https://github.com/icebob/fakerator/commit/f60ac6f)) +* Build ([19daced](https://github.com/icebob/fakerator/commit/19daced)) +* Create dev and build env ([c905539](https://github.com/icebob/fakerator/commit/c905539)) +* Create dev env ([c6123af](https://github.com/icebob/fakerator/commit/c6123af)) +* Create fake functions ([c4ba559](https://github.com/icebob/fakerator/commit/c4ba559)) +* Create fake functions ([5b63720](https://github.com/icebob/fakerator/commit/5b63720)) +* Create general generator ([4f47db3](https://github.com/icebob/fakerator/commit/4f47db3)) +* Dev base code ([2fade52](https://github.com/icebob/fakerator/commit/2fade52)) +* Dev base code ([d192d6c](https://github.com/icebob/fakerator/commit/d192d6c)) +* Fix lint and build ([84dcd30](https://github.com/icebob/fakerator/commit/84dcd30)) +* Initial commit ([aaafd02](https://github.com/icebob/fakerator/commit/aaafd02)) +* Merge gendered first names ([f1b4695](https://github.com/icebob/fakerator/commit/f1b4695)) +* Merge nearby GPS locations ([b8de09c](https://github.com/icebob/fakerator/commit/b8de09c)) +* Remove demo build files ([3e4a35c](https://github.com/icebob/fakerator/commit/3e4a35c)) +* remove demo script ([c412f54](https://github.com/icebob/fakerator/commit/c412f54)) +* Remove publish-please dep ([401f69c](https://github.com/icebob/fakerator/commit/401f69c)) +* Rename domainSuffix to tld ([e7ff562](https://github.com/icebob/fakerator/commit/e7ff562)) +* Test environment ([9dffac8](https://github.com/icebob/fakerator/commit/9dffac8)) +* Update readme ([cf5269c](https://github.com/icebob/fakerator/commit/cf5269c)) +* Update readme ([deb6dc0](https://github.com/icebob/fakerator/commit/deb6dc0)) +* new: Add hu-HU localization ([0642ed6](https://github.com/icebob/fakerator/commit/0642ed6)) + + From 80578abc8c67d8d6e7e9076205cdb94bc2972a4e Mon Sep 17 00:00:00 2001 From: Icebob Date: Thu, 20 May 2021 18:06:29 +0200 Subject: [PATCH 02/13] skip folders from npm publish --- .npmignore | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .npmignore diff --git a/.npmignore b/.npmignore new file mode 100644 index 00000000..675110d5 --- /dev/null +++ b/.npmignore @@ -0,0 +1,2 @@ +demo/ +test/ \ No newline at end of file From b7960a06c0781670944d7c551c07ca3d80997a32 Mon Sep 17 00:00:00 2001 From: Pedro Teixeira Date: Thu, 5 Aug 2021 18:21:15 +0100 Subject: [PATCH 03/13] export types in package.json --- package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/package.json b/package.json index fb030fe5..4ef6da02 100644 --- a/package.json +++ b/package.json @@ -39,6 +39,7 @@ "mocks", "test" ], + "types": "fakerator.d.ts", "author": "Icebob", "license": "MIT", "bugs": { From fe6336fe913a23b2394de6bbb234169caa63206b Mon Sep 17 00:00:00 2001 From: Pedro Teixeira Date: Thu, 5 Aug 2021 18:49:13 +0100 Subject: [PATCH 04/13] local file name --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 4ef6da02..30f3fd17 100644 --- a/package.json +++ b/package.json @@ -39,7 +39,7 @@ "mocks", "test" ], - "types": "fakerator.d.ts", + "types": "./fakerator.d.ts", "author": "Icebob", "license": "MIT", "bugs": { From 7ad324acb5dd396cc0f7129bf9a98ba903a235c8 Mon Sep 17 00:00:00 2001 From: Martin DONADIEU Date: Wed, 18 Aug 2021 16:16:16 +0200 Subject: [PATCH 05/13] Update fakerator.d.ts --- fakerator.d.ts | 1024 ++++++++++++++++++++++++------------------------ 1 file changed, 511 insertions(+), 513 deletions(-) diff --git a/fakerator.d.ts b/fakerator.d.ts index f078a6f2..5e35995a 100644 --- a/fakerator.d.ts +++ b/fakerator.d.ts @@ -1,516 +1,514 @@ declare module 'fakerator' { - export interface IRandomStringOptions { - min?: number, - max?: number - } - - export type ITimesOptions = IRandomStringOptions; - - export interface ICountryAndCode { - code: string, - name: string - } - - export interface ILatitudeAndLongitude { - latitude: number, - longitude: number - } - - export enum LoremPixelCategories { - Abstract = 'abstract', - Animals = 'animals', - Business = 'business', - Cats = 'cats', - City = 'city', - Food = 'food', - Nightlife = 'nightlife', - Fashion = 'fashion', - People = 'people', - Nature = 'nature', - Sports = 'sports', - Technics = 'technics', - Transport = 'transport', - Technics = 'flickr', - ColorImage = 'color', - GrayImage = 'gray' - } - - export interface IUser { - "firstName": string, - "lastName": string, - "userName": string, - "password": string, - "email": string, - "phone": string, - "dob": string, - "website": string, - "ip": string, - "avatar": string, - "gravatar": string, - "address": IAddress, - "status": boolean - } - - export interface ICompany { - "name": string, - "email": string, - "phone": string, - "website": string, - "ip": string, - "address": IAddress - } - - export interface IAddress { - "country": string, - "countryCode": string, - "state": string, - "city": string, - "street": string, - "zip": string, - "geo": ILatitudeAndLongitude - } - - export interface IPost { - "title": string, - "keywords": Array, - "created": string, - "content": string - } - - class fakeratorRandom { - /** - * It starts from 0 - * Sample: 0 - * @param max Max number function will select - * @returns number - */ - number(max: number): number; - - /** - * Random number selection between min and max. Min and max values are included. - * Sample: 0 - * @param min Min number function will select - * @param max Max number function will select - * @returns number - */ - number(min: number, max: number): number; - - /** - * Random number selection between min and max. Min and max values are included. - * Sample: 45.2 - * @param min Min number function will select - * @param max Max number function will select - * @param precision Can generate floating number if you define this parameter. Note: Do not use 0 - * @returns number - */ - number(min: number, max: number, precision: number = 1): number; - - - /** - * Random boolean value. - * Sample: true - * @returns boolean - */ - boolean(): boolean; - - /** - * Random boolean value if it below likelyhood - * Sample: true - * @param likelyhood Returns true if selected random value between 0 and 100 below this parameter. - * @returns boolean - */ - boolean(likelyhood: number = 50): boolean; - - - /** - * Random 9 character string - * Sample: - * @returns string - */ - digit(): string; - - - /** - * Random hexedemical string - * @returns string - */ - hex(): string; - - /** - * Random hexedemical string - * @param length Length of the generated string - * @returns string - */ - hex(length: number = 1): string; - - /** - * Just one letter. - */ - letter(): string; - - string(): string; - string(length: number): string; - string(options: IRandomStringOptions): string; - - arrayElement(array: Array): T; - - objectElement(object: object): returnType; - - masked(format: string): string; - } - - class fakeratorNames { - /** - * Dr. Sheryl Gleichner - */ - name(): string; - - /** - * Bruce Weber - */ - nameM(): string; - - /** - * Juanita Daniel - */ - nameF(): string; - - /** - * Marco - */ - firstName(): string; - - /** - * Bruce - */ - firstNameM(): string; - - /** - * Kelly - */ - firstNameF(): string; - - /** - * Reilly - */ - lastName(): string; - - /** - * Collier - */ - lastNameM(): string; - - /** - * Moore - */ - lastNameF(): string; - - /** - * Mr. - */ - prefix(): string; - - /** - * MD - */ - suffix(): string; - } - - class fakeratorAddress { - /** - * Romania - */ - country(): string; - - /** - * RO - */ - countryCode(): string; - - /** - * { code: "RO", name: "Romania" } - */ - countryAndCode(): ICountryAndCode; - - /** - * Merlestad - */ - city(): string; - - /** - * 96214 Annette Radial Apt. 543 - */ - street(): string; - - /** - * Gabriel Islands - */ - streetName(): string; - - /** - * 196 - */ - buildingNumber(): string; - - /** - * 54360-6405 - */ - postCode(): string; - - /** - * { latitude: 40.4233, longitude: -131.9741 } - */ - geoLocation(): ILatitudeAndLongitude; - - /** - * 1180 - */ - altitude(): number; - } - - class fakeratorPhone { - /** - * (640) 552-0763 - */ - number(): string; - } - - class fakeratorCompany { - /** - * Weber, Gleichner and Kertzmann Inc. - */ - name(): string; - - /** - * LLC - */ - suffix(): string; - } - - class fakeratorInternet { - /** - * kelly.moore14 - */ - userName(): string; - - /** - * Generate a username based an existing name - * Sample: johndoe19 - * @param firstName First name - * @param lastName Last Name - */ - userName(firstName: string, lastName: string): string; - - /** - * Generates a password - */ - password(): string; - - /** - * Generates a password - */ - password(length: number): string; - - password(length: number, memorable: boolean): string; - - password(length: number, memorable: boolean, pattern: string): string; - - password(length: number, memorable: boolean, pattern: string, prefix: string): string; - - /** - * merle-gleichner.net - */ - domain(): string; - - /** - * http://ella-parisian.com - */ - url(): string; - - url(/service/ishttps: boolean): string; - - url(/service/ishttps: boolean, hasWWW: boolean): string; - - /** - * kelly.moore@gmail.com - */ - email(): string; - - /** - * Generate an email address from an existing name - * Sample: john.doe@hotmail.com - * @param firstName First name - * @param lastName Last name - */ - email(firstName: string, lastName: string): string; - - email(firstName: string, lastName: string, domain: string): string; - - - /** - * http://lorempixel.com/640/480 - */ - image(): string; - - /** - * http://lorempixel.com/640/480 - */ - image(width: number, height: number): string; - - /** - * http://lorempixel.com/640/480/sports - */ - image(width: number, height: number, category: LoremPixelCategories): string; - - - /** - * 65:a1:a6:18:94:0b - */ - mac(): string; - - - /** - * 69.45.112.94 - */ - ip(): string; - - - /** - * b2e9:4275:95a9:65a1:a618:940b:a6ce:adb6 - */ - ipv6(): string; - - - /** - * Generates a hexedemical color string - * b76f49 - */ - color(): string; - - /** - * Give an avatar link (uifaces.com) - * https://s3.amazonaws.com/uifaces/faces/twitter/snowwrite/128.jpg - */ - avatar(): string; - - - /** - * Generate a gravatar link - * https://www.gravatar.com/avatar/a91004b566f80271f0a3577f71d43cd4 - */ - gravatar(): string; - - /** - * Generate a gravatar link from an email address - * https://www.gravatar.com/avatar/a91004b566f80271f0a3577f71d43cd4 - */ - gravatar(email: string): string; - } - - class fakeratorLorem { - /** - * lorem - */ - word(): string; - - /** - * Libero similique quam voluptas soluta. - */ - sentence(): string; - - /** - * Ut velit enim vel. Unde aut sint possimus velit commodi numquam. Autem expedita dignissimos est qui consequatur et delectus. Et qui necessitatibus voluptas quam. Dicta temporibus animi optio tempora aperiam repudiandae beatae. Placeat quo voluptatibus neque repellendus dolorem. - */ - paragraph(): string; - } - - class fakeratorDate { - /** - * Asia/Bangkok - */ - timezone(): string; - - past(years: number, refDate: Date): Date; - - future(years: number, refDate: Date): Date; - - between(from: Date, to: Date): Date; - - recent(days): Date; - - age(min: number, max: number): number; - - month(): string; - - weekday(): string; - - weekdayShort(): string; - - weekdayMin(): string; - } - - class fakeratorMisc { - uuid(): string; - } - - class fakeratorEntity { - user(): IUser; - - user(sex: 'M' | 'F'): IUser; - - address(): IAddress; - - company(): ICompany; - - post(): IPost; - } - - class fakerator { - constructor(localeID: string = 'default'); - - seed(newSeed: string = 'default'); - - capitalize(textWillBeCapitalized: string): string; - - slugify(textWillBeSlugified: string): string; - - replaceSymbols(format: string): string; - replaceSymbols(format: string, numberSymbol: string = "#", alphaSymbol: string = "\\?"): string; - - shuffle(textWillBeShuffled: string): string; - shuffle(arrayWillBeShuffled: Array): Array; - - populate(format: string, ...args: Array): string; - - times(functionWillRepeat: Function, nTimes: number, ...args: Array): Array; - times(functionWillRepeat: Function, options: ITimesOptions, ...args: Array): Array; - - utimes(functionWillRepeat: Function, nTimes: number, ...args: Array): Array; - utimes(functionWillRepeat: Function, options: ITimesOptions, ...args: Array): Array; - - generate(functionWillBeUsedForGeneration: Function, ...args: Array): string; - - public random = new fakeratorRandom(); - - public names = new fakeratorNames(); - - public address = new fakeratorAddress(); - - public phone = new fakeratorPhone(); - - public company = new fakeratorCompany(); - - public internet = new fakeratorInternet(); - - public lorem = new fakeratorLorem(); - - public date = new fakeratorDate(); - - public misc = new fakeratorMisc(); - - public entity = new fakeratorEntity(); - } - - export default new fakerator(); + export interface RandomStringOptions { + min?: number; + max?: number; + } + + export type TimesOptions = RandomStringOptions; + + export interface CountryAndCode { + code: string; + name: string; + } + + export interface LatitudeAndLongitude { + latitude: number; + longitude: number; + } + + export enum LoremPixelCategories { + Abstract = 'abstract', + Animals = 'animals', + Business = 'business', + Cats = 'cats', + City = 'city', + Food = 'food', + Nightlife = 'nightlife', + Fashion = 'fashion', + People = 'people', + Nature = 'nature', + Sports = 'sports', + Technics = 'technics', + Transport = 'transport', + Technics = 'flickr', + ColorImage = 'color', + GrayImage = 'gray' + } + + export interface User { + "firstName": string; + "lastName": string; + "userName": string; + "password": string; + "email": string; + "phone": string; + "dob": string; + "website": string; + "ip": string; + "avatar": string; + "gravatar": string; + "address": Address; + "status": boolean; + } + + export interface Company { + "name": string; + "email": string; + "phone": string; + "website": string; + "ip": string; + "address": Address; + } + + export interface Address { + "country": string; + "countryCode": string; + "state": string; + "city": string; + "street": string; + "zip": string; + "geo": LatitudeAndLongitude; + } + + export interface Post { + "title": string; + "keywords": Array; + "created": string; + "content": string; + } + + class FakeratorRandom { + /** + * It starts from 0 + * Sample: 0 + * @param max Max number function will select + * @returns number + */ + number(max: number): number; + + /** + * Random number selection between min and max. Min and max values are included. + * Sample: 0 + * @param min Min number function will select + * @param max Max number function will select + * @returns number + */ + number(min: number, max: number): number; + + /** + * Random number selection between min and max. Min and max values are included. + * Sample: 45.2 + * @param min Min number function will select + * @param max Max number function will select + * @param precision Can generate floating number if you define this parameter. Note: Do not use 0 + * @returns number + */ + number(min: number, max: number, precision: number = 1): number; + + + /** + * Random boolean value. + * Sample: true + * @returns boolean + */ + boolean(): boolean; + + /** + * Random boolean value if it below likelyhood + * Sample: true + * @param likelyhood Returns true if selected random value between 0 and 100 below this parameter. + * @returns boolean + */ + boolean(likelyhood: number = 50): boolean; + + + /** + * Random 9 character string + * Sample: + * @returns string + */ + digit(): string; + + + /** + * Random hexedemical string + * @returns string + */ + hex(): string; + + /** + * Random hexedemical string + * @param length Length of the generated string + * @returns string + */ + hex(length: number = 1): string; + + /** + * Just one letter. + */ + letter(): string; + + string(): string; + string(length: number): string; + string(options: RandomStringOptions): string; + + arrayElement(array: Array): T; + + objectElement(object: object): returnType; + + masked(format: string): string; + } + + class FakeratorNames { + /** + * Dr. Sheryl Gleichner + */ + name(): string; + + /** + * Bruce Weber + */ + nameM(): string; + + /** + * Juanita Daniel + */ + nameF(): string; + + /** + * Marco + */ + firstName(): string; + + /** + * Bruce + */ + firstNameM(): string; + + /** + * Kelly + */ + firstNameF(): string; + + /** + * Reilly + */ + lastName(): string; + + /** + * Collier + */ + lastNameM(): string; + + /** + * Moore + */ + lastNameF(): string; + + /** + * Mr. + */ + prefix(): string; + + /** + * MD + */ + suffix(): string; + } + + class FakeratorAddress { + /** + * Romania + */ + country(): string; + + /** + * RO + */ + countryCode(): string; + + /** + * { code: "RO", name: "Romania" } + */ + countryAndCode(): CountryAndCode; + + /** + * Merlestad + */ + city(): string; + + /** + * 96214 Annette Radial Apt. 543 + */ + street(): string; + + /** + * Gabriel Islands + */ + streetName(): string; + + /** + * 196 + */ + buildingNumber(): string; + + /** + * 54360-6405 + */ + postCode(): string; + + /** + * { latitude: 40.4233, longitude: -131.9741 } + */ + geoLocation(): LatitudeAndLongitude; + + /** + * 1180 + */ + altitude(): number; + } + + class FakeratorPhone { + /** + * (640) 552-0763 + */ + number(): string; + } + + class FakeratorCompany { + /** + * Weber, Gleichner and Kertzmann Inc. + */ + name(): string; + + /** + * LLC + */ + suffix(): string; + } + + class FakeratorInternet { + /** + * kelly.moore14 + */ + userName(): string; + + /** + * Generate a username based an existing name + * Sample: johndoe19 + * @param firstName First name + * @param lastName Last Name + */ + userName(firstName: string, lastName: string): string; + + /** + * Generates a password + */ + password(): string; + + /** + * Generates a password + */ + password(length: number): string; + + password(length: number, memorable: boolean): string; + + password(length: number, memorable: boolean, pattern: string): string; + + password(length: number, memorable: boolean, pattern: string, prefix: string): string; + + /** + * merle-gleichner.net + */ + domain(): string; + + /** + * http://ella-parisian.com + */ + url(): string; + + url(/service/ishttps: boolean): string; + + url(/service/ishttps: boolean, hasWWW: boolean): string; + + /** + * kelly.moore@gmail.com + */ + email(): string; + + /** + * Generate an email address from an existing name + * Sample: john.doe@hotmail.com + * @param firstName First name + * @param lastName Last name + */ + email(firstName: string, lastName: string): string; + + email(firstName: string, lastName: string, domain: string): string; + + + /** + * http://lorempixel.com/640/480 + */ + image(): string; + + /** + * http://lorempixel.com/640/480 + */ + image(width: number, height: number): string; + + /** + * http://lorempixel.com/640/480/sports + */ + image(width: number, height: number, category: LoremPixelCategories): string; + + + /** + * 65:a1:a6:18:94:0b + */ + mac(): string; + + + /** + * 69.45.112.94 + */ + ip(): string; + + + /** + * b2e9:4275:95a9:65a1:a618:940b:a6ce:adb6 + */ + ipv6(): string; + + + /** + * Generates a hexedemical color string + * b76f49 + */ + color(): string; + + /** + * Give an avatar link (uifaces.com) + * https://s3.amazonaws.com/uifaces/faces/twitter/snowwrite/128.jpg + */ + avatar(): string; + + + /** + * Generate a gravatar link + * https://www.gravatar.com/avatar/a91004b566f80271f0a3577f71d43cd4 + */ + gravatar(): string; + + /** + * Generate a gravatar link from an email address + * https://www.gravatar.com/avatar/a91004b566f80271f0a3577f71d43cd4 + */ + gravatar(email: string): string; + } + + class FakeratorLorem { + /** + * lorem + */ + word(): string; + + /** + * Libero similique quam voluptas soluta. + */ + sentence(): string; + + /** + * Ut velit enim vel. Unde aut sint possimus velit commodi numquam. Autem expedita dignissimos est qui consequatur et delectus. Et qui necessitatibus voluptas quam. Dicta temporibus animi optio tempora aperiam repudiandae beatae. Placeat quo voluptatibus neque repellendus dolorem. + */ + paragraph(): string; + } + + class FakeratorDate { + /** + * Asia/Bangkok + */ + timezone(): string; + + past(years: number, refDate: Date): Date; + + future(years: number, refDate: Date): Date; + + between(from: Date, to: Date): Date; + + recent(days): Date; + + age(min: number, max: number): number; + + month(): string; + + weekday(): string; + + weekdayShort(): string; + + weekdayMin(): string; + } + + class FakeratorMisc { + uuid(): string; + } + + class FakeratorEntity { + user(): User; + + user(sex: 'M' | 'F'): User; + + address(): Address; + + company(): Company; + + post(): Post; + } + class Fakerator { + constructor(localeID: string = 'default'); + + seed(newSeed: string = 'default'); + + capitalize(textWillBeCapitalized: string): string; + + slugify(textWillBeSlugified: string): string; + + replaceSymbols(format: string): string; + replaceSymbols(format: string, numberSymbol: string = "#", alphaSymbol: string = "\\?"): string; + + shuffle(textWillBeShuffled: string): string; + shuffle(arrayWillBeShuffled: Array): Array; + + populate(format: string, ...args: Array): string; + + times(functionWillRepeat: Function, nTimes: number, ...args: Array): Array; + times(functionWillRepeat: Function, options: ITimesOptions, ...args: Array): Array; + + utimes(functionWillRepeat: Function, nTimes: number, ...args: Array): Array; + utimes(functionWillRepeat: Function, options: ITimesOptions, ...args: Array): Array; + + generate(functionWillBeUsedForGeneration: Function, ...args: Array): string; + + public random = new FakeratorRandom(); + + public names = new FakeratorNames(); + + public address = new FakeratorAddress(); + + public phone = new FakeratorPhone(); + + public company = new FakeratorCompany(); + + public internet = new FakeratorInternet(); + + public lorem = new FakeratorLorem(); + + public date = new FakeratorDate(); + + public misc = new FakeratorMisc(); + + public entity = new FakeratorEntity(); + } + export default (localeID = 'default') => new Fakerator(localeID); } From 872683cc1e8b9badc6fd0763814c9aaaebde8f54 Mon Sep 17 00:00:00 2001 From: Martin DONADIEU Date: Wed, 18 Aug 2021 16:19:34 +0200 Subject: [PATCH 06/13] feat: add types in package --- package.json | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index 30f3fd17..8e65e0d8 100644 --- a/package.json +++ b/package.json @@ -3,12 +3,14 @@ "version": "0.3.3", "description": "Random data generator with localization", "main": "dist/fakerator.js", + "types": "dist/fakerator.d.ts", "directories": { "test": "test" }, "scripts": { "prebuild": "npm run test", - "build": "webpack --config config/webpack.build.config.js", + "copytype": "cp fakerator.d.ts dist/fakerator.d.ts", + "build": "webpack --config config/webpack.build.config.js && npm run copytype", "lint": "eslint --ext=.js lib test/specs", "coverall": "cat ./test/coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js", "coverage": "npm run test && npm run coverall", From e1a73470a60f93f94df9d351bf91cdff7954c68e Mon Sep 17 00:00:00 2001 From: Martin DONADIEU Date: Wed, 18 Aug 2021 16:22:45 +0200 Subject: [PATCH 07/13] Create fakerator.d.ts --- dist/fakerator.d.ts | 514 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 514 insertions(+) create mode 100644 dist/fakerator.d.ts diff --git a/dist/fakerator.d.ts b/dist/fakerator.d.ts new file mode 100644 index 00000000..5e35995a --- /dev/null +++ b/dist/fakerator.d.ts @@ -0,0 +1,514 @@ +declare module 'fakerator' { + + export interface RandomStringOptions { + min?: number; + max?: number; + } + + export type TimesOptions = RandomStringOptions; + + export interface CountryAndCode { + code: string; + name: string; + } + + export interface LatitudeAndLongitude { + latitude: number; + longitude: number; + } + + export enum LoremPixelCategories { + Abstract = 'abstract', + Animals = 'animals', + Business = 'business', + Cats = 'cats', + City = 'city', + Food = 'food', + Nightlife = 'nightlife', + Fashion = 'fashion', + People = 'people', + Nature = 'nature', + Sports = 'sports', + Technics = 'technics', + Transport = 'transport', + Technics = 'flickr', + ColorImage = 'color', + GrayImage = 'gray' + } + + export interface User { + "firstName": string; + "lastName": string; + "userName": string; + "password": string; + "email": string; + "phone": string; + "dob": string; + "website": string; + "ip": string; + "avatar": string; + "gravatar": string; + "address": Address; + "status": boolean; + } + + export interface Company { + "name": string; + "email": string; + "phone": string; + "website": string; + "ip": string; + "address": Address; + } + + export interface Address { + "country": string; + "countryCode": string; + "state": string; + "city": string; + "street": string; + "zip": string; + "geo": LatitudeAndLongitude; + } + + export interface Post { + "title": string; + "keywords": Array; + "created": string; + "content": string; + } + + class FakeratorRandom { + /** + * It starts from 0 + * Sample: 0 + * @param max Max number function will select + * @returns number + */ + number(max: number): number; + + /** + * Random number selection between min and max. Min and max values are included. + * Sample: 0 + * @param min Min number function will select + * @param max Max number function will select + * @returns number + */ + number(min: number, max: number): number; + + /** + * Random number selection between min and max. Min and max values are included. + * Sample: 45.2 + * @param min Min number function will select + * @param max Max number function will select + * @param precision Can generate floating number if you define this parameter. Note: Do not use 0 + * @returns number + */ + number(min: number, max: number, precision: number = 1): number; + + + /** + * Random boolean value. + * Sample: true + * @returns boolean + */ + boolean(): boolean; + + /** + * Random boolean value if it below likelyhood + * Sample: true + * @param likelyhood Returns true if selected random value between 0 and 100 below this parameter. + * @returns boolean + */ + boolean(likelyhood: number = 50): boolean; + + + /** + * Random 9 character string + * Sample: + * @returns string + */ + digit(): string; + + + /** + * Random hexedemical string + * @returns string + */ + hex(): string; + + /** + * Random hexedemical string + * @param length Length of the generated string + * @returns string + */ + hex(length: number = 1): string; + + /** + * Just one letter. + */ + letter(): string; + + string(): string; + string(length: number): string; + string(options: RandomStringOptions): string; + + arrayElement(array: Array): T; + + objectElement(object: object): returnType; + + masked(format: string): string; + } + + class FakeratorNames { + /** + * Dr. Sheryl Gleichner + */ + name(): string; + + /** + * Bruce Weber + */ + nameM(): string; + + /** + * Juanita Daniel + */ + nameF(): string; + + /** + * Marco + */ + firstName(): string; + + /** + * Bruce + */ + firstNameM(): string; + + /** + * Kelly + */ + firstNameF(): string; + + /** + * Reilly + */ + lastName(): string; + + /** + * Collier + */ + lastNameM(): string; + + /** + * Moore + */ + lastNameF(): string; + + /** + * Mr. + */ + prefix(): string; + + /** + * MD + */ + suffix(): string; + } + + class FakeratorAddress { + /** + * Romania + */ + country(): string; + + /** + * RO + */ + countryCode(): string; + + /** + * { code: "RO", name: "Romania" } + */ + countryAndCode(): CountryAndCode; + + /** + * Merlestad + */ + city(): string; + + /** + * 96214 Annette Radial Apt. 543 + */ + street(): string; + + /** + * Gabriel Islands + */ + streetName(): string; + + /** + * 196 + */ + buildingNumber(): string; + + /** + * 54360-6405 + */ + postCode(): string; + + /** + * { latitude: 40.4233, longitude: -131.9741 } + */ + geoLocation(): LatitudeAndLongitude; + + /** + * 1180 + */ + altitude(): number; + } + + class FakeratorPhone { + /** + * (640) 552-0763 + */ + number(): string; + } + + class FakeratorCompany { + /** + * Weber, Gleichner and Kertzmann Inc. + */ + name(): string; + + /** + * LLC + */ + suffix(): string; + } + + class FakeratorInternet { + /** + * kelly.moore14 + */ + userName(): string; + + /** + * Generate a username based an existing name + * Sample: johndoe19 + * @param firstName First name + * @param lastName Last Name + */ + userName(firstName: string, lastName: string): string; + + /** + * Generates a password + */ + password(): string; + + /** + * Generates a password + */ + password(length: number): string; + + password(length: number, memorable: boolean): string; + + password(length: number, memorable: boolean, pattern: string): string; + + password(length: number, memorable: boolean, pattern: string, prefix: string): string; + + /** + * merle-gleichner.net + */ + domain(): string; + + /** + * http://ella-parisian.com + */ + url(): string; + + url(/service/ishttps: boolean): string; + + url(/service/ishttps: boolean, hasWWW: boolean): string; + + /** + * kelly.moore@gmail.com + */ + email(): string; + + /** + * Generate an email address from an existing name + * Sample: john.doe@hotmail.com + * @param firstName First name + * @param lastName Last name + */ + email(firstName: string, lastName: string): string; + + email(firstName: string, lastName: string, domain: string): string; + + + /** + * http://lorempixel.com/640/480 + */ + image(): string; + + /** + * http://lorempixel.com/640/480 + */ + image(width: number, height: number): string; + + /** + * http://lorempixel.com/640/480/sports + */ + image(width: number, height: number, category: LoremPixelCategories): string; + + + /** + * 65:a1:a6:18:94:0b + */ + mac(): string; + + + /** + * 69.45.112.94 + */ + ip(): string; + + + /** + * b2e9:4275:95a9:65a1:a618:940b:a6ce:adb6 + */ + ipv6(): string; + + + /** + * Generates a hexedemical color string + * b76f49 + */ + color(): string; + + /** + * Give an avatar link (uifaces.com) + * https://s3.amazonaws.com/uifaces/faces/twitter/snowwrite/128.jpg + */ + avatar(): string; + + + /** + * Generate a gravatar link + * https://www.gravatar.com/avatar/a91004b566f80271f0a3577f71d43cd4 + */ + gravatar(): string; + + /** + * Generate a gravatar link from an email address + * https://www.gravatar.com/avatar/a91004b566f80271f0a3577f71d43cd4 + */ + gravatar(email: string): string; + } + + class FakeratorLorem { + /** + * lorem + */ + word(): string; + + /** + * Libero similique quam voluptas soluta. + */ + sentence(): string; + + /** + * Ut velit enim vel. Unde aut sint possimus velit commodi numquam. Autem expedita dignissimos est qui consequatur et delectus. Et qui necessitatibus voluptas quam. Dicta temporibus animi optio tempora aperiam repudiandae beatae. Placeat quo voluptatibus neque repellendus dolorem. + */ + paragraph(): string; + } + + class FakeratorDate { + /** + * Asia/Bangkok + */ + timezone(): string; + + past(years: number, refDate: Date): Date; + + future(years: number, refDate: Date): Date; + + between(from: Date, to: Date): Date; + + recent(days): Date; + + age(min: number, max: number): number; + + month(): string; + + weekday(): string; + + weekdayShort(): string; + + weekdayMin(): string; + } + + class FakeratorMisc { + uuid(): string; + } + + class FakeratorEntity { + user(): User; + + user(sex: 'M' | 'F'): User; + + address(): Address; + + company(): Company; + + post(): Post; + } + class Fakerator { + constructor(localeID: string = 'default'); + + seed(newSeed: string = 'default'); + + capitalize(textWillBeCapitalized: string): string; + + slugify(textWillBeSlugified: string): string; + + replaceSymbols(format: string): string; + replaceSymbols(format: string, numberSymbol: string = "#", alphaSymbol: string = "\\?"): string; + + shuffle(textWillBeShuffled: string): string; + shuffle(arrayWillBeShuffled: Array): Array; + + populate(format: string, ...args: Array): string; + + times(functionWillRepeat: Function, nTimes: number, ...args: Array): Array; + times(functionWillRepeat: Function, options: ITimesOptions, ...args: Array): Array; + + utimes(functionWillRepeat: Function, nTimes: number, ...args: Array): Array; + utimes(functionWillRepeat: Function, options: ITimesOptions, ...args: Array): Array; + + generate(functionWillBeUsedForGeneration: Function, ...args: Array): string; + + public random = new FakeratorRandom(); + + public names = new FakeratorNames(); + + public address = new FakeratorAddress(); + + public phone = new FakeratorPhone(); + + public company = new FakeratorCompany(); + + public internet = new FakeratorInternet(); + + public lorem = new FakeratorLorem(); + + public date = new FakeratorDate(); + + public misc = new FakeratorMisc(); + + public entity = new FakeratorEntity(); + } + export default (localeID = 'default') => new Fakerator(localeID); +} From 02e615d4cbd0fc56fa02a79d2d0d80ab8f760306 Mon Sep 17 00:00:00 2001 From: Martin DONADIEU Date: Sun, 29 Aug 2021 08:59:39 +0200 Subject: [PATCH 08/13] Update package.json --- package.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index 8e65e0d8..f553f089 100644 --- a/package.json +++ b/package.json @@ -9,7 +9,7 @@ }, "scripts": { "prebuild": "npm run test", - "copytype": "cp fakerator.d.ts dist/fakerator.d.ts", + "copytype": "copyfiles fakerator.d.ts dist", "build": "webpack --config config/webpack.build.config.js && npm run copytype", "lint": "eslint --ext=.js lib test/specs", "coverall": "cat ./test/coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js", @@ -57,6 +57,7 @@ "babel-preset-stage-0": "6.5.0", "chai": "3.5.0", "conventional-changelog-cli": "1.2.0", + "copyfiles": "^2.4.1", "coveralls": "2.11.15", "del": "2.2.2", "eslint": "3.13.0", From a3f1e3f9ec8f81a31596280de44413dc4e8c1a63 Mon Sep 17 00:00:00 2001 From: Icebob Date: Mon, 30 Aug 2021 09:12:22 +0200 Subject: [PATCH 09/13] audit fix --- package-lock.json | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/package-lock.json b/package-lock.json index 3d5ef81b..41c82920 100644 --- a/package-lock.json +++ b/package-lock.json @@ -756,6 +756,15 @@ "dev": true } } + }, + "minimatch": { + "version": "2.0.10", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz", + "integrity": "sha1-jQh8OcazjAAbl/ynzm0OHoCvusc=", + "dev": true, + "requires": { + "brace-expansion": "^1.0.0" + } } } }, @@ -1007,9 +1016,7 @@ }, "minimatch": { "version": "2.0.10", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz", - "integrity": "sha1-jQh8OcazjAAbl/ynzm0OHoCvusc=", - "dev": true, + "resolved": "", "requires": { "brace-expansion": "^1.0.0" } @@ -1956,8 +1963,7 @@ }, "kind-of": { "version": "6.0.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", - "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "resolved": "", "dev": true } } @@ -8424,9 +8430,9 @@ "dev": true }, "path-parse": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", - "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", "dev": true }, "path-type": { @@ -10201,8 +10207,7 @@ }, "kind-of": { "version": "6.0.2", - "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz", - "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==", + "resolved": "", "dev": true } } @@ -10745,8 +10750,7 @@ }, "minimist": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", - "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "resolved": "", "dev": true } } From 85c2f2b46c90f4405f64e8eb3f7fb2855e5922c7 Mon Sep 17 00:00:00 2001 From: Icebob Date: Mon, 30 Aug 2021 09:16:12 +0200 Subject: [PATCH 10/13] audit fix --- package-lock.json | 225 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 224 insertions(+), 1 deletion(-) diff --git a/package-lock.json b/package-lock.json index 41c82920..7294b257 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1016,7 +1016,8 @@ }, "minimatch": { "version": "2.0.10", - "resolved": "", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-2.0.10.tgz", + "integrity": "sha1-jQh8OcazjAAbl/ynzm0OHoCvusc=", "requires": { "brace-expansion": "^1.0.0" } @@ -3658,6 +3659,87 @@ "integrity": "sha1-Z29us8OZl8LuGsOpJP1hJHSPV40=", "dev": true }, + "copyfiles": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/copyfiles/-/copyfiles-2.4.1.tgz", + "integrity": "sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg==", + "dev": true, + "requires": { + "glob": "^7.0.5", + "minimatch": "^3.0.3", + "mkdirp": "^1.0.4", + "noms": "0.0.0", + "through2": "^2.0.1", + "untildify": "^4.0.0", + "yargs": "^16.1.0" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dev": true, + "requires": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true + }, + "string-width": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz", + "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" + } + }, + "strip-ansi": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", + "dev": true, + "requires": { + "ansi-regex": "^5.0.0" + } + }, + "yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dev": true, + "requires": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + } + } + } + }, "core-js": { "version": "2.6.11", "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.6.11.tgz", @@ -4080,6 +4162,12 @@ "integrity": "sha512-AP2HkLhfSOIxP7gDjlyZ4ywGWIcxRMZoU9+JriuVkQe2pSLDdWBsE6+eI6BQOqun1dohLrUTOPHsQLLhhFA7Eg==", "dev": true }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, "emojis-list": { "version": "2.1.0", "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-2.1.0.tgz", @@ -4358,6 +4446,12 @@ "es6-symbol": "^3.1.1" } }, + "escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true + }, "escape-html": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", @@ -5522,6 +5616,12 @@ "is-property": "^1.0.0" } }, + "get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true + }, "get-pkg-repo": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/get-pkg-repo/-/get-pkg-repo-1.4.0.tgz", @@ -8048,6 +8148,36 @@ } } }, + "noms": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/noms/-/noms-0.0.0.tgz", + "integrity": "sha1-2o69nzr51nYJGbJ9nNyAkqczKFk=", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "readable-stream": "~1.0.31" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=", + "dev": true + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "dev": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + } + } + }, "nopt": { "version": "3.0.6", "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", @@ -9862,6 +9992,12 @@ "throttleit": "^1.0.0" } }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", + "dev": true + }, "require-uncached": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz", @@ -11187,6 +11323,12 @@ } } }, + "untildify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/untildify/-/untildify-4.0.0.tgz", + "integrity": "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==", + "dev": true + }, "urix": { "version": "0.1.0", "resolved": "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz", @@ -11512,6 +11654,75 @@ "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=", "dev": true }, + "wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", + "integrity": "sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==", + "dev": true + }, + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "string-width": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.2.tgz", + "integrity": "sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.0" + } + }, + "strip-ansi": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.0.tgz", + "integrity": "sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==", + "dev": true, + "requires": { + "ansi-regex": "^5.0.0" + } + } + } + }, "wrappy": { "version": "1.0.2", "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", @@ -11549,6 +11760,12 @@ "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", "dev": true }, + "y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true + }, "yallist": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", @@ -11567,6 +11784,12 @@ "window-size": "0.1.0" } }, + "yargs-parser": { + "version": "20.2.9", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", + "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", + "dev": true + }, "yauzl": { "version": "2.4.1", "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.4.1.tgz", From 5efd4116686d4d29852c37d218baa1a73c4bb138 Mon Sep 17 00:00:00 2001 From: Icebob Date: Mon, 30 Aug 2021 09:16:33 +0200 Subject: [PATCH 11/13] remove duplicated types --- package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/package.json b/package.json index f553f089..9a790f2d 100644 --- a/package.json +++ b/package.json @@ -41,7 +41,6 @@ "mocks", "test" ], - "types": "./fakerator.d.ts", "author": "Icebob", "license": "MIT", "bugs": { From 32d99a117a267105ff52135276fd35905d733610 Mon Sep 17 00:00:00 2001 From: Icebob Date: Mon, 30 Aug 2021 09:18:46 +0200 Subject: [PATCH 12/13] build --- dist/fakerator.js | 24569 +++++++++++++++++++--------------- dist/fakerator.min.js | 32 +- dist/locales/cs-CZ.js | 18976 +++++++++++++++----------- dist/locales/cs-CZ.min.js | 19 +- dist/locales/de-DE.js | 18996 +++++++++++++++----------- dist/locales/de-DE.min.js | 18 +- dist/locales/default.js | 18356 ++++++++++++++----------- dist/locales/default.min.js | 16 +- dist/locales/en-AU.js | 18523 ++++++++++++++----------- dist/locales/en-AU.min.js | 16 +- dist/locales/en-CA.js | 18384 ++++++++++++++----------- dist/locales/en-CA.min.js | 16 +- dist/locales/es-ES.js | 18946 +++++++++++++++----------- dist/locales/es-ES.min.js | 17 +- dist/locales/fr-FR.js | 18970 +++++++++++++++----------- dist/locales/fr-FR.min.js | 17 +- dist/locales/hu-HU.js | 18988 +++++++++++++++----------- dist/locales/hu-HU.min.js | 17 +- dist/locales/it-IT.js | 19062 +++++++++++++++----------- dist/locales/it-IT.min.js | 17 +- dist/locales/nb-NO.js | 18932 +++++++++++++++----------- dist/locales/nb-NO.min.js | 17 +- dist/locales/pl-PL.js | 18932 +++++++++++++++----------- dist/locales/pl-PL.min.js | 17 +- dist/locales/pt-BR.js | 14817 ++++++++++++++++++++ dist/locales/pt-BR.min.js | 22 + dist/locales/ru-RU.js | 19066 +++++++++++++++----------- dist/locales/ru-RU.min.js | 17 +- dist/locales/sk-SK.js | 18978 +++++++++++++++----------- dist/locales/sk-SK.min.js | 17 +- dist/locales/sv-SE.js | 18978 +++++++++++++++----------- dist/locales/sv-SE.min.js | 16 +- 32 files changed, 184188 insertions(+), 119576 deletions(-) create mode 100644 dist/locales/pt-BR.js create mode 100644 dist/locales/pt-BR.min.js diff --git a/dist/fakerator.js b/dist/fakerator.js index b8e84a74..0597fd17 100644 --- a/dist/fakerator.js +++ b/dist/fakerator.js @@ -1,5 +1,5 @@ /** - * fakerator v0.3.0 + * fakerator v0.3.3 * https://github.com/icebob/fakerator * Released under the MIT License. */ @@ -97,32 +97,32 @@ return /******/ (function(modules) { // webpackBootstrap var _isFunction2 = _interopRequireDefault(_isFunction); - var _isObject = __webpack_require__(4); + var _isObject = __webpack_require__(10); var _isObject2 = _interopRequireDefault(_isObject); - var _mergeWith = __webpack_require__(5); + var _mergeWith = __webpack_require__(11); var _mergeWith2 = _interopRequireDefault(_mergeWith); - var _fakerator = __webpack_require__(118); + var _fakerator = __webpack_require__(99); var _fakerator2 = _interopRequireDefault(_fakerator); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } module.exports = function () { - var localeID = arguments.length <= 0 || arguments[0] === undefined ? "default" : arguments[0]; + var localeID = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default"; var locale = void 0; try { - locale = __webpack_require__(166)("./" + localeID + "/index"); + locale = __webpack_require__(134)("./" + localeID + "/index"); } catch (e) {} if (locale) { if (localeID != "default") { var fallbackID = locale._meta.fallback || "default"; - var fbLocale = __webpack_require__(166)("./" + fallbackID + "/index"); + var fbLocale = __webpack_require__(134)("./" + fallbackID + "/index"); if (fbLocale) { locale = (0, _mergeWith2.default)(locale, fbLocale, function (objValue) { if ((0, _isArray2.default)(objValue) || (0, _isFunction2.default)(objValue)) return objValue; @@ -132,7 +132,7 @@ return /******/ (function(modules) { // webpackBootstrap } } } else { - locale = __webpack_require__(201); + locale = __webpack_require__(169); } return new _fakerator2.default(locale); @@ -179,11 +179,9 @@ return /******/ (function(modules) { // webpackBootstrap * @static * @memberOf _ * @since 0.1.0 - * @type {Function} * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is correctly classified, - * else `false`. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. * @example * * _.isArray([1, 2, 3]); @@ -207,21 +205,14 @@ return /******/ (function(modules) { // webpackBootstrap /* 3 */ /***/ function(module, exports, __webpack_require__) { - var isObject = __webpack_require__(4); + var baseGetTag = __webpack_require__(4), + isObject = __webpack_require__(10); /** `Object#toString` result references. */ - var funcTag = '[object Function]', - genTag = '[object GeneratorFunction]'; - - /** Used for built-in method references. */ - var objectProto = Object.prototype; - - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; + var asyncTag = '[object AsyncFunction]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; /** * Checks if `value` is classified as a `Function` object. @@ -231,8 +222,7 @@ return /******/ (function(modules) { // webpackBootstrap * @since 0.1.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is correctly classified, - * else `false`. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. * @example * * _.isFunction(_); @@ -242,11 +232,13 @@ return /******/ (function(modules) { // webpackBootstrap * // => false */ function isFunction(value) { + if (!isObject(value)) { + return false; + } // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 8 which returns 'object' for typed array and weak map constructors, - // and PhantomJS 1.9 which returns 'function' for `NodeList` instances. - var tag = isObject(value) ? objectToString.call(value) : ''; - return tag == funcTag || tag == genTag; + // 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; } module.exports = isFunction; @@ -254,11 +246,163 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, /* 4 */ +/***/ function(module, exports, __webpack_require__) { + + var Symbol = __webpack_require__(5), + getRawTag = __webpack_require__(8), + objectToString = __webpack_require__(9); + + /** `Object#toString` result references. */ + var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + + /** Built-in value references. */ + var symToStringTag = Symbol ? Symbol.toStringTag : undefined; + + /** + * 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); + } + + module.exports = baseGetTag; + + +/***/ }, +/* 5 */ +/***/ function(module, exports, __webpack_require__) { + + var root = __webpack_require__(6); + + /** Built-in value references. */ + var Symbol = root.Symbol; + + module.exports = Symbol; + + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + var freeGlobal = __webpack_require__(7); + + /** 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')(); + + module.exports = root; + + +/***/ }, +/* 7 */ +/***/ function(module, exports) { + + /* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + + module.exports = freeGlobal; + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + var Symbol = __webpack_require__(5); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto.toString; + + /** Built-in value references. */ + var symToStringTag = Symbol ? Symbol.toStringTag : 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; + } + + module.exports = getRawTag; + + +/***/ }, +/* 9 */ +/***/ function(module, exports) { + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto.toString; + + /** + * 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); + } + + module.exports = objectToString; + + +/***/ }, +/* 10 */ /***/ function(module, exports) { /** * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/6.0/#sec-ecmascript-language-types) + * [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 @@ -283,24 +427,24 @@ return /******/ (function(modules) { // webpackBootstrap */ function isObject(value) { var type = typeof value; - return !!value && (type == 'object' || type == 'function'); + return value != null && (type == 'object' || type == 'function'); } module.exports = isObject; /***/ }, -/* 5 */ +/* 11 */ /***/ function(module, exports, __webpack_require__) { - var baseMerge = __webpack_require__(6), - createAssigner = __webpack_require__(110); + var baseMerge = __webpack_require__(12), + createAssigner = __webpack_require__(89); /** * 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 seven arguments: + * method instead. The `customizer` is invoked with six arguments: * (objValue, srcValue, key, object, source, stack). * * **Note:** This method mutates `object`. @@ -321,18 +465,11 @@ return /******/ (function(modules) { // webpackBootstrap * } * } * - * var object = { - * 'fruits': ['apple'], - * 'vegetables': ['beet'] - * }; - * - * var other = { - * 'fruits': ['banana'], - * 'vegetables': ['carrot'] - * }; + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; * * _.mergeWith(object, other, customizer); - * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] } + * // => { 'a': [1, 3], 'b': [2, 4] } */ var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { baseMerge(object, source, srcIndex, customizer); @@ -342,17 +479,16 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 6 */ +/* 12 */ /***/ function(module, exports, __webpack_require__) { - var Stack = __webpack_require__(7), - arrayEach = __webpack_require__(46), - assignMergeValue = __webpack_require__(47), - baseMergeDeep = __webpack_require__(48), - isArray = __webpack_require__(2), - isObject = __webpack_require__(4), - isTypedArray = __webpack_require__(104), - keysIn = __webpack_require__(106); + var Stack = __webpack_require__(13), + assignMergeValue = __webpack_require__(49), + baseFor = __webpack_require__(52), + baseMergeDeep = __webpack_require__(54), + isObject = __webpack_require__(10), + keysIn = __webpack_require__(83), + safeGet = __webpack_require__(79); /** * The base implementation of `_.merge` without support for multiple sources. @@ -369,21 +505,14 @@ return /******/ (function(modules) { // webpackBootstrap if (object === source) { return; } - if (!(isArray(source) || isTypedArray(source))) { - var props = keysIn(source); - } - arrayEach(props || source, function(srcValue, key) { - if (props) { - key = srcValue; - srcValue = source[key]; - } + baseFor(source, function(srcValue, key) { + stack || (stack = new Stack); if (isObject(srcValue)) { - stack || (stack = new Stack); baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); } else { var newValue = customizer - ? customizer(object[key], srcValue, (key + ''), object, source, stack) + ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) : undefined; if (newValue === undefined) { @@ -391,22 +520,22 @@ return /******/ (function(modules) { // webpackBootstrap } assignMergeValue(object, key, newValue); } - }); + }, keysIn); } module.exports = baseMerge; /***/ }, -/* 7 */ +/* 13 */ /***/ function(module, exports, __webpack_require__) { - var ListCache = __webpack_require__(8), - stackClear = __webpack_require__(16), - stackDelete = __webpack_require__(17), - stackGet = __webpack_require__(18), - stackHas = __webpack_require__(19), - stackSet = __webpack_require__(20); + var ListCache = __webpack_require__(14), + stackClear = __webpack_require__(22), + stackDelete = __webpack_require__(23), + stackGet = __webpack_require__(24), + stackHas = __webpack_require__(25), + stackSet = __webpack_require__(26); /** * Creates a stack cache object to store key-value pairs. @@ -416,7 +545,8 @@ return /******/ (function(modules) { // webpackBootstrap * @param {Array} [entries] The key-value pairs to cache. */ function Stack(entries) { - this.__data__ = new ListCache(entries); + var data = this.__data__ = new ListCache(entries); + this.size = data.size; } // Add methods to `Stack`. @@ -430,14 +560,14 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 8 */ +/* 14 */ /***/ function(module, exports, __webpack_require__) { - var listCacheClear = __webpack_require__(9), - listCacheDelete = __webpack_require__(10), - listCacheGet = __webpack_require__(13), - listCacheHas = __webpack_require__(14), - listCacheSet = __webpack_require__(15); + var listCacheClear = __webpack_require__(15), + listCacheDelete = __webpack_require__(16), + listCacheGet = __webpack_require__(19), + listCacheHas = __webpack_require__(20), + listCacheSet = __webpack_require__(21); /** * Creates an list cache object. @@ -448,7 +578,7 @@ return /******/ (function(modules) { // webpackBootstrap */ function ListCache(entries) { var index = -1, - length = entries ? entries.length : 0; + length = entries == null ? 0 : entries.length; this.clear(); while (++index < length) { @@ -468,7 +598,7 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 9 */ +/* 15 */ /***/ function(module, exports) { /** @@ -480,16 +610,17 @@ return /******/ (function(modules) { // webpackBootstrap */ function listCacheClear() { this.__data__ = []; + this.size = 0; } module.exports = listCacheClear; /***/ }, -/* 10 */ +/* 16 */ /***/ function(module, exports, __webpack_require__) { - var assocIndexOf = __webpack_require__(11); + var assocIndexOf = __webpack_require__(17); /** Used for built-in method references. */ var arrayProto = Array.prototype; @@ -519,6 +650,7 @@ return /******/ (function(modules) { // webpackBootstrap } else { splice.call(data, index, 1); } + --this.size; return true; } @@ -526,16 +658,16 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 11 */ +/* 17 */ /***/ function(module, exports, __webpack_require__) { - var eq = __webpack_require__(12); + var eq = __webpack_require__(18); /** * Gets the index at which the `key` is found in `array` of key-value pairs. * * @private - * @param {Array} array The array to search. + * @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`. */ @@ -553,12 +685,12 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 12 */ +/* 18 */ /***/ function(module, exports) { /** * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) * comparison between two values to determine if they are equivalent. * * @static @@ -570,8 +702,8 @@ return /******/ (function(modules) { // webpackBootstrap * @returns {boolean} Returns `true` if the values are equivalent, else `false`. * @example * - * var object = { 'user': 'fred' }; - * var other = { 'user': 'fred' }; + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; * * _.eq(object, object); * // => true @@ -596,10 +728,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 13 */ +/* 19 */ /***/ function(module, exports, __webpack_require__) { - var assocIndexOf = __webpack_require__(11); + var assocIndexOf = __webpack_require__(17); /** * Gets the list cache value for `key`. @@ -621,10 +753,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 14 */ +/* 20 */ /***/ function(module, exports, __webpack_require__) { - var assocIndexOf = __webpack_require__(11); + var assocIndexOf = __webpack_require__(17); /** * Checks if a list cache value for `key` exists. @@ -643,10 +775,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 15 */ +/* 21 */ /***/ function(module, exports, __webpack_require__) { - var assocIndexOf = __webpack_require__(11); + var assocIndexOf = __webpack_require__(17); /** * Sets the list cache `key` to `value`. @@ -663,6 +795,7 @@ return /******/ (function(modules) { // webpackBootstrap index = assocIndexOf(data, key); if (index < 0) { + ++this.size; data.push([key, value]); } else { data[index][1] = value; @@ -674,10 +807,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 16 */ +/* 22 */ /***/ function(module, exports, __webpack_require__) { - var ListCache = __webpack_require__(8); + var ListCache = __webpack_require__(14); /** * Removes all key-value entries from the stack. @@ -688,13 +821,14 @@ return /******/ (function(modules) { // webpackBootstrap */ function stackClear() { this.__data__ = new ListCache; + this.size = 0; } module.exports = stackClear; /***/ }, -/* 17 */ +/* 23 */ /***/ function(module, exports) { /** @@ -707,14 +841,18 @@ return /******/ (function(modules) { // webpackBootstrap * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function stackDelete(key) { - return this.__data__['delete'](key); + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; } module.exports = stackDelete; /***/ }, -/* 18 */ +/* 24 */ /***/ function(module, exports) { /** @@ -734,7 +872,7 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 19 */ +/* 25 */ /***/ function(module, exports) { /** @@ -754,11 +892,12 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 20 */ +/* 26 */ /***/ function(module, exports, __webpack_require__) { - var ListCache = __webpack_require__(8), - MapCache = __webpack_require__(21); + var ListCache = __webpack_require__(14), + Map = __webpack_require__(27), + MapCache = __webpack_require__(34); /** Used as the size to enable large array optimizations. */ var LARGE_ARRAY_SIZE = 200; @@ -774,11 +913,18 @@ return /******/ (function(modules) { // webpackBootstrap * @returns {Object} Returns the stack cache instance. */ function stackSet(key, value) { - var cache = this.__data__; - if (cache instanceof ListCache && cache.__data__.length == LARGE_ARRAY_SIZE) { - cache = this.__data__ = new MapCache(cache.__data__); + 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); } - cache.set(key, value); + data.set(key, value); + this.size = data.size; return this; } @@ -786,195 +932,74 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 21 */ +/* 27 */ /***/ function(module, exports, __webpack_require__) { - var mapCacheClear = __webpack_require__(22), - mapCacheDelete = __webpack_require__(40), - mapCacheGet = __webpack_require__(43), - mapCacheHas = __webpack_require__(44), - mapCacheSet = __webpack_require__(45); - - /** - * 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 ? entries.length : 0; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } + var getNative = __webpack_require__(28), + root = __webpack_require__(6); - // Add methods to `MapCache`. - MapCache.prototype.clear = mapCacheClear; - MapCache.prototype['delete'] = mapCacheDelete; - MapCache.prototype.get = mapCacheGet; - MapCache.prototype.has = mapCacheHas; - MapCache.prototype.set = mapCacheSet; + /* Built-in method references that are verified to be native. */ + var Map = getNative(root, 'Map'); - module.exports = MapCache; + module.exports = Map; /***/ }, -/* 22 */ +/* 28 */ /***/ function(module, exports, __webpack_require__) { - var Hash = __webpack_require__(23), - ListCache = __webpack_require__(8), - Map = __webpack_require__(39); + var baseIsNative = __webpack_require__(29), + getValue = __webpack_require__(33); /** - * Removes all key-value entries from the map. + * Gets the native function at `key` of `object`. * * @private - * @name clear - * @memberOf MapCache + * @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 mapCacheClear() { - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; } - module.exports = mapCacheClear; + module.exports = getNative; /***/ }, -/* 23 */ +/* 29 */ /***/ function(module, exports, __webpack_require__) { - var hashClear = __webpack_require__(24), - hashDelete = __webpack_require__(35), - hashGet = __webpack_require__(36), - hashHas = __webpack_require__(37), - hashSet = __webpack_require__(38); + var isFunction = __webpack_require__(3), + isMasked = __webpack_require__(30), + isObject = __webpack_require__(10), + toSource = __webpack_require__(32); /** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). */ - function Hash(entries) { - var index = -1, - length = entries ? entries.length : 0; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } - } + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; - // Add methods to `Hash`. - Hash.prototype.clear = hashClear; - Hash.prototype['delete'] = hashDelete; - Hash.prototype.get = hashGet; - Hash.prototype.has = hashHas; - Hash.prototype.set = hashSet; + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; - module.exports = Hash; + /** Used for built-in method references. */ + var funcProto = Function.prototype, + objectProto = Object.prototype; + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; -/***/ }, -/* 24 */ -/***/ function(module, exports, __webpack_require__) { + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; - var nativeCreate = __webpack_require__(25); - - /** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ - function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; - } - - module.exports = hashClear; - - -/***/ }, -/* 25 */ -/***/ function(module, exports, __webpack_require__) { - - var getNative = __webpack_require__(26); - - /* Built-in method references that are verified to be native. */ - var nativeCreate = getNative(Object, 'create'); - - module.exports = nativeCreate; - - -/***/ }, -/* 26 */ -/***/ function(module, exports, __webpack_require__) { - - var baseIsNative = __webpack_require__(27), - getValue = __webpack_require__(34); - - /** - * 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; - } - - module.exports = getNative; - - -/***/ }, -/* 27 */ -/***/ function(module, exports, __webpack_require__) { - - var isFunction = __webpack_require__(3), - isHostObject = __webpack_require__(28), - isMasked = __webpack_require__(29), - isObject = __webpack_require__(4), - toSource = __webpack_require__(33); - - /** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns). - */ - var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; - - /** Used to detect host constructors (Safari). */ - var reIsHostCtor = /^\[object .+?Constructor\]$/; - - /** Used for built-in method references. */ - var objectProto = Object.prototype; - - /** Used to resolve the decompiled source of functions. */ - var funcToString = Function.prototype.toString; - - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; - - /** Used to detect if a method is native. */ - var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' - ); + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); /** * The base implementation of `_.isNative` without bad shim checks. @@ -988,7 +1013,7 @@ return /******/ (function(modules) { // webpackBootstrap if (!isObject(value) || isMasked(value)) { return false; } - var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; return pattern.test(toSource(value)); } @@ -996,36 +1021,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 28 */ -/***/ function(module, exports) { - - /** - * Checks if `value` is a host object in IE < 9. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a host object, else `false`. - */ - function isHostObject(value) { - // Many host objects are `Object` objects that can coerce to strings - // despite having improperly defined `toString` methods. - var result = false; - if (value != null && typeof value.toString != 'function') { - try { - result = !!(value + ''); - } catch (e) {} - } - return result; - } - - module.exports = isHostObject; - - -/***/ }, -/* 29 */ +/* 30 */ /***/ function(module, exports, __webpack_require__) { - var coreJsData = __webpack_require__(30); + var coreJsData = __webpack_require__(31); /** Used to detect methods masquerading as native. */ var maskSrcKey = (function() { @@ -1048,10 +1047,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 30 */ +/* 31 */ /***/ function(module, exports, __webpack_require__) { - var root = __webpack_require__(31); + var root = __webpack_require__(6); /** Used to detect overreaching core-js shims. */ var coreJsData = root['__core-js_shared__']; @@ -1059,58 +1058,21 @@ return /******/ (function(modules) { // webpackBootstrap module.exports = coreJsData; -/***/ }, -/* 31 */ -/***/ function(module, exports, __webpack_require__) { - - /* WEBPACK VAR INJECTION */(function(global) {var checkGlobal = __webpack_require__(32); - - /** Detect free variable `global` from Node.js. */ - var freeGlobal = checkGlobal(typeof global == 'object' && global); - - /** Detect free variable `self`. */ - var freeSelf = checkGlobal(typeof self == 'object' && self); - - /** Detect `this` as the global object. */ - var thisGlobal = checkGlobal(typeof this == 'object' && this); - - /** Used as a reference to the global object. */ - var root = freeGlobal || freeSelf || thisGlobal || Function('return this')(); - - module.exports = root; - - /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) - /***/ }, /* 32 */ /***/ function(module, exports) { - /** - * Checks if `value` is a global object. - * - * @private - * @param {*} value The value to check. - * @returns {null|Object} Returns `value` if it's a global object, else `null`. - */ - function checkGlobal(value) { - return (value && value.Object === Object) ? value : null; - } - - module.exports = checkGlobal; - - -/***/ }, -/* 33 */ -/***/ function(module, exports) { + /** Used for built-in method references. */ + var funcProto = Function.prototype; /** Used to resolve the decompiled source of functions. */ - var funcToString = Function.prototype.toString; + var funcToString = funcProto.toString; /** * Converts `func` to its source code. * * @private - * @param {Function} func The function to process. + * @param {Function} func The function to convert. * @returns {string} Returns the source code. */ function toSource(func) { @@ -1129,7 +1091,7 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 34 */ +/* 33 */ /***/ function(module, exports) { /** @@ -1147,8 +1109,144 @@ return /******/ (function(modules) { // webpackBootstrap module.exports = getValue; +/***/ }, +/* 34 */ +/***/ function(module, exports, __webpack_require__) { + + var mapCacheClear = __webpack_require__(35), + mapCacheDelete = __webpack_require__(43), + mapCacheGet = __webpack_require__(46), + mapCacheHas = __webpack_require__(47), + mapCacheSet = __webpack_require__(48); + + /** + * 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]); + } + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + module.exports = MapCache; + + /***/ }, /* 35 */ +/***/ function(module, exports, __webpack_require__) { + + var Hash = __webpack_require__(36), + ListCache = __webpack_require__(14), + Map = __webpack_require__(27); + + /** + * 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 + }; + } + + module.exports = mapCacheClear; + + +/***/ }, +/* 36 */ +/***/ function(module, exports, __webpack_require__) { + + var hashClear = __webpack_require__(37), + hashDelete = __webpack_require__(39), + hashGet = __webpack_require__(40), + hashHas = __webpack_require__(41), + hashSet = __webpack_require__(42); + + /** + * 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]); + } + } + + // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + + module.exports = Hash; + + +/***/ }, +/* 37 */ +/***/ function(module, exports, __webpack_require__) { + + var nativeCreate = __webpack_require__(38); + + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; + } + + module.exports = hashClear; + + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(28); + + /* Built-in method references that are verified to be native. */ + var nativeCreate = getNative(Object, 'create'); + + module.exports = nativeCreate; + + +/***/ }, +/* 39 */ /***/ function(module, exports) { /** @@ -1162,17 +1260,19 @@ return /******/ (function(modules) { // webpackBootstrap * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function hashDelete(key) { - return this.has(key) && delete this.__data__[key]; + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; } module.exports = hashDelete; /***/ }, -/* 36 */ +/* 40 */ /***/ function(module, exports, __webpack_require__) { - var nativeCreate = __webpack_require__(25); + var nativeCreate = __webpack_require__(38); /** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = '__lodash_hash_undefined__'; @@ -1205,10 +1305,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 37 */ +/* 41 */ /***/ function(module, exports, __webpack_require__) { - var nativeCreate = __webpack_require__(25); + var nativeCreate = __webpack_require__(38); /** Used for built-in method references. */ var objectProto = Object.prototype; @@ -1227,17 +1327,17 @@ return /******/ (function(modules) { // webpackBootstrap */ function hashHas(key) { var data = this.__data__; - return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); } module.exports = hashHas; /***/ }, -/* 38 */ +/* 42 */ /***/ function(module, exports, __webpack_require__) { - var nativeCreate = __webpack_require__(25); + var nativeCreate = __webpack_require__(38); /** Used to stand-in for `undefined` hash values. */ var HASH_UNDEFINED = '__lodash_hash_undefined__'; @@ -1254,6 +1354,7 @@ return /******/ (function(modules) { // webpackBootstrap */ 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; } @@ -1262,23 +1363,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 39 */ +/* 43 */ /***/ function(module, exports, __webpack_require__) { - var getNative = __webpack_require__(26), - root = __webpack_require__(31); - - /* Built-in method references that are verified to be native. */ - var Map = getNative(root, 'Map'); - - module.exports = Map; - - -/***/ }, -/* 40 */ -/***/ function(module, exports, __webpack_require__) { - - var getMapData = __webpack_require__(41); + var getMapData = __webpack_require__(44); /** * Removes `key` and its value from the map. @@ -1290,17 +1378,19 @@ return /******/ (function(modules) { // webpackBootstrap * @returns {boolean} Returns `true` if the entry was removed, else `false`. */ function mapCacheDelete(key) { - return getMapData(this, key)['delete'](key); + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; } module.exports = mapCacheDelete; /***/ }, -/* 41 */ +/* 44 */ /***/ function(module, exports, __webpack_require__) { - var isKeyable = __webpack_require__(42); + var isKeyable = __webpack_require__(45); /** * Gets the data for `map`. @@ -1321,7 +1411,7 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 42 */ +/* 45 */ /***/ function(module, exports) { /** @@ -1342,10 +1432,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 43 */ +/* 46 */ /***/ function(module, exports, __webpack_require__) { - var getMapData = __webpack_require__(41); + var getMapData = __webpack_require__(44); /** * Gets the map value for `key`. @@ -1364,10 +1454,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 44 */ +/* 47 */ /***/ function(module, exports, __webpack_require__) { - var getMapData = __webpack_require__(41); + var getMapData = __webpack_require__(44); /** * Checks if a map value for `key` exists. @@ -1386,10 +1476,10 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 45 */ +/* 48 */ /***/ function(module, exports, __webpack_require__) { - var getMapData = __webpack_require__(41); + var getMapData = __webpack_require__(44); /** * Sets the map `key` to `value`. @@ -1402,7 +1492,11 @@ return /******/ (function(modules) { // webpackBootstrap * @returns {Object} Returns the map cache instance. */ function mapCacheSet(key, value) { - getMapData(this, key).set(key, value); + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; return this; } @@ -1410,73 +1504,151 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 46 */ -/***/ function(module, exports) { +/* 49 */ +/***/ function(module, exports, __webpack_require__) { + + var baseAssignValue = __webpack_require__(50), + eq = __webpack_require__(18); /** - * A specialized version of `_.forEach` for arrays without support for - * iteratee shorthands. + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. * * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns `array`. + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. */ - function arrayEach(array, iteratee) { - var index = -1, - length = array ? array.length : 0; - - while (++index < length) { - if (iteratee(array[index], index, array) === false) { - break; - } + function assignMergeValue(object, key, value) { + if ((value !== undefined && !eq(object[key], value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); } - return array; } - module.exports = arrayEach; + module.exports = assignMergeValue; /***/ }, -/* 47 */ +/* 50 */ /***/ function(module, exports, __webpack_require__) { - var eq = __webpack_require__(12); + var defineProperty = __webpack_require__(51); /** - * This function is like `assignValue` except that it doesn't assign - * `undefined` values. + * 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 assignMergeValue(object, key, value) { - if ((value !== undefined && !eq(object[key], value)) || - (typeof key == 'number' && value === undefined && !(key in object))) { + function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty) { + defineProperty(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { object[key] = value; } } - module.exports = assignMergeValue; + module.exports = baseAssignValue; /***/ }, -/* 48 */ +/* 51 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(28); + + var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} + }()); + + module.exports = defineProperty; + + +/***/ }, +/* 52 */ +/***/ function(module, exports, __webpack_require__) { + + var createBaseFor = __webpack_require__(53); + + /** + * 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(); + + module.exports = baseFor; + + +/***/ }, +/* 53 */ +/***/ function(module, exports) { + + /** + * 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; + }; + } + + module.exports = createBaseFor; + + +/***/ }, +/* 54 */ /***/ function(module, exports, __webpack_require__) { - var assignMergeValue = __webpack_require__(47), - baseClone = __webpack_require__(49), - copyArray = __webpack_require__(70), - isArguments = __webpack_require__(59), + var assignMergeValue = __webpack_require__(49), + cloneBuffer = __webpack_require__(55), + cloneTypedArray = __webpack_require__(57), + copyArray = __webpack_require__(60), + initCloneObject = __webpack_require__(61), + isArguments = __webpack_require__(66), isArray = __webpack_require__(2), - isArrayLikeObject = __webpack_require__(60), + isArrayLikeObject = __webpack_require__(69), + isBuffer = __webpack_require__(72), isFunction = __webpack_require__(3), - isObject = __webpack_require__(4), - isPlainObject = __webpack_require__(103), - isTypedArray = __webpack_require__(104), - toPlainObject = __webpack_require__(105); + isObject = __webpack_require__(10), + isPlainObject = __webpack_require__(74), + isTypedArray = __webpack_require__(75), + safeGet = __webpack_require__(79), + toPlainObject = __webpack_require__(80); /** * A specialized version of `baseMerge` for arrays and objects which performs @@ -1494,8 +1666,8 @@ return /******/ (function(modules) { // webpackBootstrap * counterparts. */ function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { - var objValue = object[key], - srcValue = source[key], + var objValue = safeGet(object, key), + srcValue = safeGet(source, key), stacked = stack.get(srcValue); if (stacked) { @@ -1509,42 +1681,49 @@ return /******/ (function(modules) { // webpackBootstrap var isCommon = newValue === undefined; if (isCommon) { + var isArr = isArray(srcValue), + isBuff = !isArr && isBuffer(srcValue), + isTyped = !isArr && !isBuff && isTypedArray(srcValue); + newValue = srcValue; - if (isArray(srcValue) || isTypedArray(srcValue)) { + if (isArr || isBuff || isTyped) { if (isArray(objValue)) { newValue = objValue; } else if (isArrayLikeObject(objValue)) { newValue = copyArray(objValue); } - else { + else if (isBuff) { isCommon = false; - newValue = baseClone(srcValue, true); + 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) || (srcIndex && isFunction(objValue))) { - isCommon = false; - newValue = baseClone(srcValue, true); - } - else { - newValue = objValue; + else if (!isObject(objValue) || isFunction(objValue)) { + newValue = initCloneObject(srcValue); } } else { isCommon = false; } } - stack.set(srcValue, newValue); - 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); } - stack['delete'](srcValue); assignMergeValue(object, key, newValue); } @@ -1552,444 +1731,268 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 49 */ +/* 55 */ /***/ function(module, exports, __webpack_require__) { - var Stack = __webpack_require__(7), - arrayEach = __webpack_require__(46), - assignValue = __webpack_require__(50), - baseAssign = __webpack_require__(51), - cloneBuffer = __webpack_require__(69), - copyArray = __webpack_require__(70), - copySymbols = __webpack_require__(71), - getAllKeys = __webpack_require__(74), - getTag = __webpack_require__(77), - initCloneArray = __webpack_require__(82), - initCloneByTag = __webpack_require__(83), - initCloneObject = __webpack_require__(98), - isArray = __webpack_require__(2), - isBuffer = __webpack_require__(100), - isHostObject = __webpack_require__(28), - isObject = __webpack_require__(4), - keys = __webpack_require__(53); + /* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(6); - /** `Object#toString` result references. */ - var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - boolTag = '[object Boolean]', - dateTag = '[object Date]', - errorTag = '[object Error]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - mapTag = '[object Map]', - numberTag = '[object Number]', - objectTag = '[object Object]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]', - weakMapTag = '[object WeakMap]'; + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; - 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]'; + /** Detect free variable `module`. */ + var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; - /** 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; - - /** - * The base implementation of `_.clone` and `_.cloneDeep` which tracks - * traversed objects. + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports = freeModule && freeModule.exports === freeExports; + + /** Built-in value references. */ + var Buffer = moduleExports ? root.Buffer : undefined, + allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined; + + /** + * Creates a clone of `buffer`. * * @private - * @param {*} value The value to clone. + * @param {Buffer} buffer The buffer to clone. * @param {boolean} [isDeep] Specify a deep clone. - * @param {boolean} [isFull] Specify a clone including 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, isDeep, isFull, customizer, key, object, stack) { - var result; - 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)) { - if (isHostObject(value)) { - return object ? value : {}; - } - result = initCloneObject(isFunc ? {} : value); - if (!isDeep) { - return copySymbols(value, baseAssign(result, value)); - } - } else { - if (!cloneableTags[tag]) { - return object ? value : {}; - } - result = initCloneByTag(value, tag, baseClone, isDeep); - } - } - // Check for circular references and return its corresponding clone. - stack || (stack = new Stack); - var stacked = stack.get(value); - if (stacked) { - return stacked; + * @returns {Buffer} Returns the cloned buffer. + */ + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); } - stack.set(value, result); + var length = buffer.length, + result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); - if (!isArr) { - var props = isFull ? getAllKeys(value) : keys(value); - } - // Recursively populate clone (susceptible to call stack limits). - arrayEach(props || value, function(subValue, key) { - if (props) { - key = subValue; - subValue = value[key]; - } - assignValue(result, key, baseClone(subValue, isDeep, isFull, customizer, key, value, stack)); - }); + buffer.copy(result); return result; } - module.exports = baseClone; + module.exports = cloneBuffer; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) /***/ }, -/* 50 */ -/***/ function(module, exports, __webpack_require__) { +/* 56 */ +/***/ function(module, exports) { - var eq = __webpack_require__(12); + module.exports = function(module) { + if(!module.webpackPolyfill) { + module.deprecate = function() {}; + module.paths = []; + // module.parent = undefined by default + module.children = []; + module.webpackPolyfill = 1; + } + return module; + } - /** Used for built-in method references. */ - var objectProto = Object.prototype; - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; +/***/ }, +/* 57 */ +/***/ function(module, exports, __webpack_require__) { + + var cloneArrayBuffer = __webpack_require__(58); /** - * Assigns `value` to `key` of `object` if the existing value is not equivalent - * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero) - * for equality comparisons. + * Creates a clone of `typedArray`. * * @private - * @param {Object} object The object to modify. - * @param {string} key The key of the property to assign. - * @param {*} value The value to assign. + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. */ - function assignValue(object, key, value) { - var objValue = object[key]; - if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || - (value === undefined && !(key in object))) { - object[key] = value; - } + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); } - module.exports = assignValue; + module.exports = cloneTypedArray; /***/ }, -/* 51 */ +/* 58 */ /***/ function(module, exports, __webpack_require__) { - var copyObject = __webpack_require__(52), - keys = __webpack_require__(53); + var Uint8Array = __webpack_require__(59); /** - * The base implementation of `_.assign` without support for multiple sources - * or `customizer` functions. + * Creates a clone of `arrayBuffer`. * * @private - * @param {Object} object The destination object. - * @param {Object} source The source object. - * @returns {Object} Returns `object`. + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. */ - function baseAssign(object, source) { - return object && copyObject(source, keys(source), object); + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array(result).set(new Uint8Array(arrayBuffer)); + return result; } - module.exports = baseAssign; + module.exports = cloneArrayBuffer; /***/ }, -/* 52 */ +/* 59 */ /***/ function(module, exports, __webpack_require__) { - var assignValue = __webpack_require__(50); + var root = __webpack_require__(6); + + /** Built-in value references. */ + var Uint8Array = root.Uint8Array; + + module.exports = Uint8Array; + + +/***/ }, +/* 60 */ +/***/ function(module, exports) { /** - * Copies properties of `source` to `object`. + * Copies the values of `source` to `array`. * * @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`. + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. */ - function copyObject(source, props, object, customizer) { - object || (object = {}); - + function copyArray(source, array) { var index = -1, - length = props.length; + length = source.length; + array || (array = Array(length)); while (++index < length) { - var key = props[index]; - - var newValue = customizer - ? customizer(object[key], source[key], key, object, source) - : source[key]; - - assignValue(object, key, newValue); + array[index] = source[index]; } - return object; + return array; } - module.exports = copyObject; + module.exports = copyArray; /***/ }, -/* 53 */ +/* 61 */ /***/ function(module, exports, __webpack_require__) { - var baseHas = __webpack_require__(54), - baseKeys = __webpack_require__(56), - indexKeys = __webpack_require__(57), - isArrayLike = __webpack_require__(61), - isIndex = __webpack_require__(67), - isPrototype = __webpack_require__(68); + var baseCreate = __webpack_require__(62), + getPrototype = __webpack_require__(63), + isPrototype = __webpack_require__(65); /** - * 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/6.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) + * Initializes an object clone. * - * _.keys('hi'); - * // => ['0', '1'] + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. */ - function keys(object) { - var isProto = isPrototype(object); - if (!(isProto || isArrayLike(object))) { - return baseKeys(object); - } - var indexes = indexKeys(object), - skipIndexes = !!indexes, - result = indexes || [], - length = result.length; - - for (var key in object) { - if (baseHas(object, key) && - !(skipIndexes && (key == 'length' || isIndex(key, length))) && - !(isProto && key == 'constructor')) { - result.push(key); - } - } - return result; + function initCloneObject(object) { + return (typeof object.constructor == 'function' && !isPrototype(object)) + ? baseCreate(getPrototype(object)) + : {}; } - module.exports = keys; + module.exports = initCloneObject; /***/ }, -/* 54 */ +/* 62 */ /***/ function(module, exports, __webpack_require__) { - var getPrototype = __webpack_require__(55); - - /** Used for built-in method references. */ - var objectProto = Object.prototype; + var isObject = __webpack_require__(10); - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; + /** Built-in value references. */ + var objectCreate = Object.create; /** - * The base implementation of `_.has` without support for deep paths. + * The base implementation of `_.create` without support for assigning + * properties to the created object. * * @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`. + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. */ - function baseHas(object, key) { - // Avoid a bug in IE 10-11 where objects with a [[Prototype]] of `null`, - // that are composed entirely of index properties, return `false` for - // `hasOwnProperty` checks of them. - return object != null && - (hasOwnProperty.call(object, key) || - (typeof object == 'object' && key in object && getPrototype(object) === null)); - } + 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; + }; + }()); - module.exports = baseHas; + module.exports = baseCreate; /***/ }, -/* 55 */ -/***/ function(module, exports) { +/* 63 */ +/***/ function(module, exports, __webpack_require__) { - /* Built-in method references for those with the same name as other `lodash` methods. */ - var nativeGetPrototype = Object.getPrototypeOf; + var overArg = __webpack_require__(64); - /** - * Gets the `[[Prototype]]` of `value`. - * - * @private - * @param {*} value The value to query. - * @returns {null|Object} Returns the `[[Prototype]]`. - */ - function getPrototype(value) { - return nativeGetPrototype(Object(value)); - } + /** Built-in value references. */ + var getPrototype = overArg(Object.getPrototypeOf, Object); module.exports = getPrototype; /***/ }, -/* 56 */ +/* 64 */ /***/ function(module, exports) { - /* Built-in method references for those with the same name as other `lodash` methods. */ - var nativeKeys = Object.keys; - - /** - * The base implementation of `_.keys` which doesn't skip the constructor - * property of prototypes or treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ - function baseKeys(object) { - return nativeKeys(Object(object)); - } - - module.exports = baseKeys; - - -/***/ }, -/* 57 */ -/***/ function(module, exports, __webpack_require__) { - - var baseTimes = __webpack_require__(58), - isArguments = __webpack_require__(59), - isArray = __webpack_require__(2), - isLength = __webpack_require__(64), - isString = __webpack_require__(66); - /** - * Creates an array of index keys for `object` values of arrays, - * `arguments` objects, and strings, otherwise `null` is returned. + * Creates a unary function that invokes `func` with its argument transformed. * * @private - * @param {Object} object The object to query. - * @returns {Array|null} Returns index keys, else `null`. + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. */ - function indexKeys(object) { - var length = object ? object.length : undefined; - if (isLength(length) && - (isArray(object) || isString(object) || isArguments(object))) { - return baseTimes(length, String); - } - return null; + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; } - module.exports = indexKeys; + module.exports = overArg; /***/ }, -/* 58 */ +/* 65 */ /***/ function(module, exports) { + /** Used for built-in method references. */ + var objectProto = Object.prototype; + /** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. + * Checks if `value` is likely a prototype object. * * @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. + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. */ - function baseTimes(n, iteratee) { - var index = -1, - result = Array(n); + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; - while (++index < n) { - result[index] = iteratee(index); - } - return result; + return value === proto; } - module.exports = baseTimes; + module.exports = isPrototype; /***/ }, -/* 59 */ +/* 66 */ /***/ function(module, exports, __webpack_require__) { - var isArrayLikeObject = __webpack_require__(60); - - /** `Object#toString` result references. */ - var argsTag = '[object Arguments]'; + var baseIsArguments = __webpack_require__(67), + isObjectLike = __webpack_require__(68); /** Used for built-in method references. */ var objectProto = Object.prototype; @@ -1997,13 +2000,6 @@ return /******/ (function(modules) { // webpackBootstrap /** Used to check objects for own properties. */ var hasOwnProperty = objectProto.hasOwnProperty; - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; - /** Built-in value references. */ var propertyIsEnumerable = objectProto.propertyIsEnumerable; @@ -2015,7 +2011,7 @@ return /******/ (function(modules) { // webpackBootstrap * @since 0.1.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is correctly classified, + * @returns {boolean} Returns `true` if `value` is an `arguments` object, * else `false`. * @example * @@ -2025,21 +2021,79 @@ return /******/ (function(modules) { // webpackBootstrap * _.isArguments([1, 2, 3]); * // => false */ - function isArguments(value) { - // Safari 8.1 incorrectly makes `arguments.callee` enumerable in strict mode. - return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') && - (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag); - } + var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && + !propertyIsEnumerable.call(value, 'callee'); + }; module.exports = isArguments; /***/ }, -/* 60 */ +/* 67 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGetTag = __webpack_require__(4), + isObjectLike = __webpack_require__(68); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]'; + + /** + * 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; + } + + module.exports = baseIsArguments; + + +/***/ }, +/* 68 */ +/***/ function(module, exports) { + + /** + * 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'; + } + + module.exports = isObjectLike; + + +/***/ }, +/* 69 */ /***/ function(module, exports, __webpack_require__) { - var isArrayLike = __webpack_require__(61), - isObjectLike = __webpack_require__(65); + var isArrayLike = __webpack_require__(70), + isObjectLike = __webpack_require__(68); /** * This method is like `_.isArrayLike` except that it also checks if `value` @@ -2074,12 +2128,11 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 61 */ +/* 70 */ /***/ function(module, exports, __webpack_require__) { - var getLength = __webpack_require__(62), - isFunction = __webpack_require__(3), - isLength = __webpack_require__(64); + var isFunction = __webpack_require__(3), + isLength = __webpack_require__(71); /** * Checks if `value` is array-like. A value is considered array-like if it's @@ -2107,56 +2160,14 @@ return /******/ (function(modules) { // webpackBootstrap * // => false */ function isArrayLike(value) { - return value != null && isLength(getLength(value)) && !isFunction(value); + return value != null && isLength(value.length) && !isFunction(value); } module.exports = isArrayLike; /***/ }, -/* 62 */ -/***/ function(module, exports, __webpack_require__) { - - var baseProperty = __webpack_require__(63); - - /** - * Gets the "length" property value of `object`. - * - * **Note:** This function is used to avoid a - * [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) that affects - * Safari on at least iOS 8.1-8.3 ARM64. - * - * @private - * @param {Object} object The object to query. - * @returns {*} Returns the "length" value. - */ - var getLength = baseProperty('length'); - - module.exports = getLength; - - -/***/ }, -/* 63 */ -/***/ function(module, exports) { - - /** - * 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]; - }; - } - - module.exports = baseProperty; - - -/***/ }, -/* 64 */ +/* 71 */ /***/ function(module, exports) { /** Used as references for various `Number` constants. */ @@ -2165,16 +2176,15 @@ return /******/ (function(modules) { // webpackBootstrap /** * Checks if `value` is a valid array-like length. * - * **Note:** This function is loosely based on - * [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * **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`. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. * @example * * _.isLength(3); @@ -2198,474 +2208,600 @@ return /******/ (function(modules) { // webpackBootstrap /***/ }, -/* 65 */ -/***/ function(module, exports) { - +/* 72 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(6), + stubFalse = __webpack_require__(73); + + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && 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; + + /** Built-in value references. */ + var Buffer = moduleExports ? root.Buffer : undefined; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; + /** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". + * Checks if `value` is a buffer. * * @static * @memberOf _ - * @since 4.0.0 + * @since 4.3.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. * @example * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); + * _.isBuffer(new Buffer(2)); * // => true * - * _.isObjectLike(_.noop); + * _.isBuffer(new Uint8Array(2)); * // => false + */ + var isBuffer = nativeIsBuffer || stubFalse; + + module.exports = isBuffer; + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) + +/***/ }, +/* 73 */ +/***/ function(module, exports) { + + /** + * This method returns `false`. * - * _.isObjectLike(null); - * // => false + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {boolean} Returns `false`. + * @example + * + * _.times(2, _.stubFalse); + * // => [false, false] */ - function isObjectLike(value) { - return !!value && typeof value == 'object'; + function stubFalse() { + return false; } - module.exports = isObjectLike; + module.exports = stubFalse; /***/ }, -/* 66 */ +/* 74 */ /***/ function(module, exports, __webpack_require__) { - var isArray = __webpack_require__(2), - isObjectLike = __webpack_require__(65); + var baseGetTag = __webpack_require__(4), + getPrototype = __webpack_require__(63), + isObjectLike = __webpack_require__(68); /** `Object#toString` result references. */ - var stringTag = '[object String]'; + var objectTag = '[object Object]'; /** Used for built-in method references. */ - var objectProto = Object.prototype; + var funcProto = Function.prototype, + objectProto = Object.prototype; - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; + /** 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 infer the `Object` constructor. */ + var objectCtorString = funcToString.call(Object); /** - * Checks if `value` is classified as a `String` primitive or object. + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. * * @static - * @since 0.1.0 * @memberOf _ + * @since 0.8.0 * @category Lang * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is correctly classified, - * else `false`. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. * @example * - * _.isString('abc'); - * // => true + * function Foo() { + * this.a = 1; + * } * - * _.isString(1); + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true */ - function isString(value) { - return typeof value == 'string' || - (!isArray(value) && isObjectLike(value) && objectToString.call(value) == stringTag); + 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; } - module.exports = isString; + module.exports = isPlainObject; /***/ }, -/* 67 */ -/***/ function(module, exports) { +/* 75 */ +/***/ function(module, exports, __webpack_require__) { - /** Used as references for various `Number` constants. */ - var MAX_SAFE_INTEGER = 9007199254740991; + var baseIsTypedArray = __webpack_require__(76), + baseUnary = __webpack_require__(77), + nodeUtil = __webpack_require__(78); - /** Used to detect unsigned integer values. */ - var reIsUint = /^(?:0|[1-9]\d*)$/; + /* Node.js helper references. */ + var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; /** - * Checks if `value` is a valid array-like index. + * Checks if `value` is classified as a typed array. * - * @private + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang * @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`. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false */ - function isIndex(value, length) { - length = length == null ? MAX_SAFE_INTEGER : length; - return !!length && - (typeof value == 'number' || reIsUint.test(value)) && - (value > -1 && value % 1 == 0 && value < length); - } + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; - module.exports = isIndex; + module.exports = isTypedArray; /***/ }, -/* 68 */ -/***/ function(module, exports) { +/* 76 */ +/***/ function(module, exports, __webpack_require__) { - /** Used for built-in method references. */ - var objectProto = Object.prototype; + var baseGetTag = __webpack_require__(4), + isLength = __webpack_require__(71), + isObjectLike = __webpack_require__(68); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + + 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 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; /** - * Checks if `value` is likely a prototype object. + * The base implementation of `_.isTypedArray` without Node.js optimizations. * * @private * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. */ - function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; - - return value === proto; + function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; } - module.exports = isPrototype; + module.exports = baseIsTypedArray; /***/ }, -/* 69 */ +/* 77 */ /***/ function(module, exports) { /** - * Creates a clone of `buffer`. + * The base implementation of `_.unary` without support for storing metadata. * * @private - * @param {Buffer} buffer The buffer to clone. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Buffer} Returns the cloned buffer. + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. */ - function cloneBuffer(buffer, isDeep) { - if (isDeep) { - return buffer.slice(); - } - var result = new buffer.constructor(buffer.length); - buffer.copy(result); - return result; + function baseUnary(func) { + return function(value) { + return func(value); + }; } - module.exports = cloneBuffer; + module.exports = baseUnary; /***/ }, -/* 70 */ +/* 78 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__(7); + + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && 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) {} + }()); + + module.exports = nodeUtil; + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) + +/***/ }, +/* 79 */ /***/ function(module, exports) { /** - * Copies the values of `source` to `array`. + * Gets the value at `key`, unless `key` is "__proto__" or "constructor". * * @private - * @param {Array} source The array to copy values from. - * @param {Array} [array=[]] The array to copy values to. - * @returns {Array} Returns `array`. + * @param {Object} object The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. */ - function copyArray(source, array) { - var index = -1, - length = source.length; + function safeGet(object, key) { + if (key === 'constructor' && typeof object[key] === 'function') { + return; + } - array || (array = Array(length)); - while (++index < length) { - array[index] = source[index]; + if (key == '__proto__') { + return; } - return array; + + return object[key]; } - module.exports = copyArray; + module.exports = safeGet; /***/ }, -/* 71 */ +/* 80 */ /***/ function(module, exports, __webpack_require__) { - var copyObject = __webpack_require__(52), - getSymbols = __webpack_require__(72); + var copyObject = __webpack_require__(81), + keysIn = __webpack_require__(83); /** - * Copies own symbol properties of `source` to `object`. + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. * - * @private - * @param {Object} source The object to copy symbols from. - * @param {Object} [object={}] The object to copy symbols to. - * @returns {Object} Returns `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 copySymbols(source, object) { - return copyObject(source, getSymbols(source), object); + function toPlainObject(value) { + return copyObject(value, keysIn(value)); } - module.exports = copySymbols; + module.exports = toPlainObject; /***/ }, -/* 72 */ +/* 81 */ /***/ function(module, exports, __webpack_require__) { - var stubArray = __webpack_require__(73); - - /** Built-in value references. */ - var getOwnPropertySymbols = Object.getOwnPropertySymbols; + var assignValue = __webpack_require__(82), + baseAssignValue = __webpack_require__(50); /** - * Creates an array of the own enumerable symbol properties of `object`. + * Copies properties of `source` to `object`. * * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. + * @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 getSymbols(object) { - // Coerce `object` to an object to avoid non-object errors in V8. - // See https://bugs.chromium.org/p/v8/issues/detail?id=3443 for more details. - return getOwnPropertySymbols(Object(object)); - } - - // Fallback for IE < 11. - if (!getOwnPropertySymbols) { - getSymbols = stubArray; - } + function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); - module.exports = getSymbols; + var index = -1, + length = props.length; + while (++index < length) { + var key = props[index]; -/***/ }, -/* 73 */ -/***/ function(module, exports) { + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; - /** - * A method that returns a new empty array. - * - * @static - * @memberOf _ - * @since 4.13.0 - * @category Util - * @returns {Array} Returns the new empty array. - * @example - * - * var arrays = _.times(2, _.stubArray); - * - * console.log(arrays); - * // => [[], []] - * - * console.log(arrays[0] === arrays[1]); - * // => false - */ - function stubArray() { - return []; + if (newValue === undefined) { + newValue = source[key]; + } + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + return object; } - module.exports = stubArray; + module.exports = copyObject; /***/ }, -/* 74 */ +/* 82 */ /***/ function(module, exports, __webpack_require__) { - var baseGetAllKeys = __webpack_require__(75), - getSymbols = __webpack_require__(72), - keys = __webpack_require__(53); + var baseAssignValue = __webpack_require__(50), + eq = __webpack_require__(18); + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; /** - * Creates an array of own enumerable property names and symbols of `object`. + * 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 query. - * @returns {Array} Returns the array of property names and symbols. + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. */ - function getAllKeys(object) { - return baseGetAllKeys(object, keys, getSymbols); + 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); + } } - module.exports = getAllKeys; + module.exports = assignValue; /***/ }, -/* 75 */ +/* 83 */ /***/ function(module, exports, __webpack_require__) { - var arrayPush = __webpack_require__(76), - isArray = __webpack_require__(2); + var arrayLikeKeys = __webpack_require__(84), + baseKeysIn = __webpack_require__(87), + isArrayLike = __webpack_require__(70); /** - * The base implementation of `getAllKeys` and `getAllKeysIn` which uses - * `keysFunc` and `symbolsFunc` to get the enumerable property names and - * symbols of `object`. + * Creates an array of the own and inherited enumerable property names of `object`. * - * @private + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object * @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)); - } - - module.exports = baseGetAllKeys; - - -/***/ }, -/* 76 */ -/***/ function(module, exports) { - - /** - * Appends the elements of `values` to `array`. + * @returns {Array} Returns the array of property names. + * @example * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) */ - function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length; - - while (++index < length) { - array[offset + index] = values[index]; - } - return array; + function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); } - module.exports = arrayPush; + module.exports = keysIn; /***/ }, -/* 77 */ +/* 84 */ /***/ function(module, exports, __webpack_require__) { - var DataView = __webpack_require__(78), - Map = __webpack_require__(39), - Promise = __webpack_require__(79), - Set = __webpack_require__(80), - WeakMap = __webpack_require__(81), - toSource = __webpack_require__(33); - - /** `Object#toString` result references. */ - var mapTag = '[object Map]', - objectTag = '[object Object]', - promiseTag = '[object Promise]', - setTag = '[object Set]', - weakMapTag = '[object WeakMap]'; - - var dataViewTag = '[object DataView]'; + var baseTimes = __webpack_require__(85), + isArguments = __webpack_require__(66), + isArray = __webpack_require__(2), + isBuffer = __webpack_require__(72), + isIndex = __webpack_require__(86), + isTypedArray = __webpack_require__(75); /** Used for built-in method references. */ var objectProto = Object.prototype; - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; - - /** 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 check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; /** - * Gets the `toStringTag` of `value`. + * Creates an array of the enumerable property names of the array-like `value`. * * @private * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. */ - function getTag(value) { - return objectToString.call(value); - } - - // Fallback for data views, maps, sets, and weak maps in IE 11, - // for data views in Edge, and promises in Node.js. - 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 = objectToString.call(value), - Ctor = result == objectTag ? value.constructor : undefined, - ctorString = Ctor ? toSource(Ctor) : undefined; - - if (ctorString) { - switch (ctorString) { - case dataViewCtorString: return dataViewTag; - case mapCtorString: return mapTag; - case promiseCtorString: return promiseTag; - case setCtorString: return setTag; - case weakMapCtorString: return weakMapTag; - } + 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; - }; + } + return result; } - module.exports = getTag; + module.exports = arrayLikeKeys; /***/ }, -/* 78 */ -/***/ function(module, exports, __webpack_require__) { +/* 85 */ +/***/ function(module, exports) { - var getNative = __webpack_require__(26), - root = __webpack_require__(31); + /** + * 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); - /* Built-in method references that are verified to be native. */ - var DataView = getNative(root, 'DataView'); + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } - module.exports = DataView; + module.exports = baseTimes; /***/ }, -/* 79 */ -/***/ function(module, exports, __webpack_require__) { - - var getNative = __webpack_require__(26), - root = __webpack_require__(31); - - /* Built-in method references that are verified to be native. */ - var Promise = getNative(root, 'Promise'); - - module.exports = Promise; +/* 86 */ +/***/ function(module, exports) { + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; -/***/ }, -/* 80 */ -/***/ function(module, exports, __webpack_require__) { + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; - var getNative = __webpack_require__(26), - root = __webpack_require__(31); + /** + * 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; - /* Built-in method references that are verified to be native. */ - var Set = getNative(root, 'Set'); + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); + } - module.exports = Set; + module.exports = isIndex; /***/ }, -/* 81 */ +/* 87 */ /***/ function(module, exports, __webpack_require__) { - var getNative = __webpack_require__(26), - root = __webpack_require__(31); - - /* Built-in method references that are verified to be native. */ - var WeakMap = getNative(root, 'WeakMap'); - - module.exports = WeakMap; - - -/***/ }, -/* 82 */ -/***/ function(module, exports) { + var isObject = __webpack_require__(10), + isPrototype = __webpack_require__(65), + nativeKeysIn = __webpack_require__(88); /** Used for built-in method references. */ var objectProto = Object.prototype; @@ -2674,3678 +2810,2993 @@ return /******/ (function(modules) { // webpackBootstrap var hasOwnProperty = objectProto.hasOwnProperty; /** - * Initializes an array clone. + * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. * * @private - * @param {Array} array The array to clone. - * @returns {Array} Returns the initialized clone. + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. */ - function initCloneArray(array) { - var length = array.length, - result = array.constructor(length); + function baseKeysIn(object) { + if (!isObject(object)) { + return nativeKeysIn(object); + } + var isProto = isPrototype(object), + result = []; - // Add properties assigned by `RegExp#exec`. - if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) { - result.index = array.index; - result.input = array.input; + for (var key in object) { + if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } } return result; } - module.exports = initCloneArray; + module.exports = baseKeysIn; /***/ }, -/* 83 */ -/***/ function(module, exports, __webpack_require__) { - - var cloneArrayBuffer = __webpack_require__(84), - cloneDataView = __webpack_require__(86), - cloneMap = __webpack_require__(87), - cloneRegExp = __webpack_require__(91), - cloneSet = __webpack_require__(92), - cloneSymbol = __webpack_require__(95), - cloneTypedArray = __webpack_require__(97); - - /** `Object#toString` result references. */ - var boolTag = '[object Boolean]', - dateTag = '[object Date]', - mapTag = '[object Map]', - numberTag = '[object Number]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]'; - - 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]'; +/* 88 */ +/***/ function(module, exports) { /** - * Initializes an object clone based on its `toStringTag`. - * - * **Note:** This function only supports cloning values with tags of - * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * 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 clone. - * @param {string} tag The `toStringTag` of the object to clone. - * @param {Function} cloneFunc The function to clone values. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the initialized clone. + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. */ - function initCloneByTag(object, tag, cloneFunc, 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 cloneMap(object, isDeep, cloneFunc); - - case numberTag: - case stringTag: - return new Ctor(object); - - case regexpTag: - return cloneRegExp(object); - - case setTag: - return cloneSet(object, isDeep, cloneFunc); - - case symbolTag: - return cloneSymbol(object); + function nativeKeysIn(object) { + var result = []; + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } } + return result; } - module.exports = initCloneByTag; + module.exports = nativeKeysIn; /***/ }, -/* 84 */ +/* 89 */ /***/ function(module, exports, __webpack_require__) { - var Uint8Array = __webpack_require__(85); + var baseRest = __webpack_require__(90), + isIterateeCall = __webpack_require__(98); /** - * Creates a clone of `arrayBuffer`. + * Creates a function like `_.assign`. * * @private - * @param {ArrayBuffer} arrayBuffer The array buffer to clone. - * @returns {ArrayBuffer} Returns the cloned array buffer. + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. */ - function cloneArrayBuffer(arrayBuffer) { - var result = new arrayBuffer.constructor(arrayBuffer.byteLength); - new Uint8Array(result).set(new Uint8Array(arrayBuffer)); - return result; - } - - module.exports = cloneArrayBuffer; - - -/***/ }, -/* 85 */ -/***/ function(module, exports, __webpack_require__) { - - var root = __webpack_require__(31); - - /** Built-in value references. */ - var Uint8Array = root.Uint8Array; - - module.exports = Uint8Array; - - -/***/ }, -/* 86 */ -/***/ function(module, exports, __webpack_require__) { + 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; - var cloneArrayBuffer = __webpack_require__(84); + customizer = (assigner.length > 3 && typeof customizer == 'function') + ? (length--, customizer) + : undefined; - /** - * 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); + 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; + }); } - module.exports = cloneDataView; + module.exports = createAssigner; /***/ }, -/* 87 */ +/* 90 */ /***/ function(module, exports, __webpack_require__) { - var addMapEntry = __webpack_require__(88), - arrayReduce = __webpack_require__(89), - mapToArray = __webpack_require__(90); + var identity = __webpack_require__(91), + overRest = __webpack_require__(92), + setToString = __webpack_require__(94); /** - * Creates a clone of `map`. + * The base implementation of `_.rest` which doesn't validate or coerce arguments. * * @private - * @param {Object} map The map to clone. - * @param {Function} cloneFunc The function to clone values. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned map. + * @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 cloneMap(map, isDeep, cloneFunc) { - var array = isDeep ? cloneFunc(mapToArray(map), true) : mapToArray(map); - return arrayReduce(array, addMapEntry, new map.constructor); + function baseRest(func, start) { + return setToString(overRest(func, start, identity), func + ''); } - module.exports = cloneMap; + module.exports = baseRest; /***/ }, -/* 88 */ +/* 91 */ /***/ function(module, exports) { /** - * Adds the key-value `pair` to `map`. + * This method returns the first argument it receives. * - * @private - * @param {Object} map The map to modify. - * @param {Array} pair The key-value pair to add. - * @returns {Object} Returns `map`. + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'a': 1 }; + * + * console.log(_.identity(object) === object); + * // => true */ - function addMapEntry(map, pair) { - // Don't return `Map#set` because it doesn't return the map instance in IE 11. - map.set(pair[0], pair[1]); - return map; + function identity(value) { + return value; } - module.exports = addMapEntry; + module.exports = identity; /***/ }, -/* 89 */ -/***/ function(module, exports) { +/* 92 */ +/***/ function(module, exports, __webpack_require__) { + + var apply = __webpack_require__(93); + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeMax = Math.max; /** - * A specialized version of `_.reduce` for arrays without support for - * iteratee shorthands. + * A specialized version of `baseRest` which transforms the rest array. * * @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. + * @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 arrayReduce(array, iteratee, accumulator, initAccum) { - var index = -1, - length = array ? array.length : 0; + 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); - if (initAccum && length) { - accumulator = array[++index]; - } - while (++index < length) { - accumulator = iteratee(accumulator, array[index], index, array); - } - return accumulator; + 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); + }; } - module.exports = arrayReduce; + module.exports = overRest; /***/ }, -/* 90 */ +/* 93 */ /***/ function(module, exports) { /** - * Converts `map` to its key-value pairs. + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. * * @private - * @param {Object} map The map to convert. - * @returns {Array} Returns the key-value pairs. + * @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 mapToArray(map) { - var index = -1, - result = Array(map.size); - - map.forEach(function(value, key) { - result[++index] = [key, value]; - }); - return result; + 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); } - module.exports = mapToArray; + module.exports = apply; /***/ }, -/* 91 */ -/***/ function(module, exports) { +/* 94 */ +/***/ function(module, exports, __webpack_require__) { - /** Used to match `RegExp` flags from their coerced string values. */ - var reFlags = /\w*$/; + var baseSetToString = __webpack_require__(95), + shortOut = __webpack_require__(97); /** - * Creates a clone of `regexp`. + * Sets the `toString` method of `func` to return `string`. * * @private - * @param {Object} regexp The regexp to clone. - * @returns {Object} Returns the cloned regexp. + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. */ - function cloneRegExp(regexp) { - var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); - result.lastIndex = regexp.lastIndex; - return result; - } + var setToString = shortOut(baseSetToString); - module.exports = cloneRegExp; + module.exports = setToString; /***/ }, -/* 92 */ +/* 95 */ /***/ function(module, exports, __webpack_require__) { - var addSetEntry = __webpack_require__(93), - arrayReduce = __webpack_require__(89), - setToArray = __webpack_require__(94); + var constant = __webpack_require__(96), + defineProperty = __webpack_require__(51), + identity = __webpack_require__(91); /** - * Creates a clone of `set`. + * The base implementation of `setToString` without support for hot loop shorting. * * @private - * @param {Object} set The set to clone. - * @param {Function} cloneFunc The function to clone values. - * @param {boolean} [isDeep] Specify a deep clone. - * @returns {Object} Returns the cloned set. + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. */ - function cloneSet(set, isDeep, cloneFunc) { - var array = isDeep ? cloneFunc(setToArray(set), true) : setToArray(set); - return arrayReduce(array, addSetEntry, new set.constructor); - } + var baseSetToString = !defineProperty ? identity : function(func, string) { + return defineProperty(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); + }; - module.exports = cloneSet; + module.exports = baseSetToString; /***/ }, -/* 93 */ +/* 96 */ /***/ function(module, exports) { /** - * Adds `value` to `set`. + * Creates a function that returns `value`. * - * @private - * @param {Object} set The set to modify. - * @param {*} value The value to add. - * @returns {Object} Returns `set`. + * @static + * @memberOf _ + * @since 2.4.0 + * @category Util + * @param {*} value The value to return from the new function. + * @returns {Function} Returns the new constant function. + * @example + * + * var objects = _.times(2, _.constant({ 'a': 1 })); + * + * console.log(objects); + * // => [{ 'a': 1 }, { 'a': 1 }] + * + * console.log(objects[0] === objects[1]); + * // => true */ - function addSetEntry(set, value) { - set.add(value); - return set; + function constant(value) { + return function() { + return value; + }; } - module.exports = addSetEntry; + module.exports = constant; /***/ }, -/* 94 */ +/* 97 */ /***/ function(module, exports) { + /** Used to detect hot functions by number of calls within a span of milliseconds. */ + var HOT_COUNT = 800, + HOT_SPAN = 16; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeNow = Date.now; + /** - * Converts `set` to an array of its values. + * 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 {Object} set The set to convert. - * @returns {Array} Returns the values. + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. */ - function setToArray(set) { - var index = -1, - result = Array(set.size); + function shortOut(func) { + var count = 0, + lastCalled = 0; - set.forEach(function(value) { - result[++index] = value; - }); - return result; + 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); + }; } - module.exports = setToArray; + module.exports = shortOut; /***/ }, -/* 95 */ +/* 98 */ /***/ function(module, exports, __webpack_require__) { - var Symbol = __webpack_require__(96); - - /** Used to convert symbols to primitives and strings. */ - var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; + var eq = __webpack_require__(18), + isArrayLike = __webpack_require__(70), + isIndex = __webpack_require__(86), + isObject = __webpack_require__(10); /** - * Creates a clone of the `symbol` object. + * Checks if the given arguments are from an iteratee call. * * @private - * @param {Object} symbol The symbol object to clone. - * @returns {Object} Returns the cloned symbol object. + * @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 cloneSymbol(symbol) { - return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; + 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; } - module.exports = cloneSymbol; + module.exports = isIterateeCall; /***/ }, -/* 96 */ +/* 99 */ /***/ function(module, exports, __webpack_require__) { - var root = __webpack_require__(31); + "use strict"; - /** Built-in value references. */ - var Symbol = root.Symbol; + var _get = __webpack_require__(100); - module.exports = Symbol; + var _get2 = _interopRequireDefault(_get); + var _each = __webpack_require__(112); -/***/ }, -/* 97 */ -/***/ function(module, exports, __webpack_require__) { + var _each2 = _interopRequireDefault(_each); - var cloneArrayBuffer = __webpack_require__(84); + var _capitalize = __webpack_require__(122); - /** - * 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); - } + var _capitalize2 = _interopRequireDefault(_capitalize); - module.exports = cloneTypedArray; + var _isNil = __webpack_require__(1); + var _isNil2 = _interopRequireDefault(_isNil); -/***/ }, -/* 98 */ -/***/ function(module, exports, __webpack_require__) { + var _isArray = __webpack_require__(2); - var baseCreate = __webpack_require__(99), - getPrototype = __webpack_require__(55), - isPrototype = __webpack_require__(68); + var _isArray2 = _interopRequireDefault(_isArray); - /** - * 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)) - : {}; - } + var _isString = __webpack_require__(131); - module.exports = initCloneObject; + var _isString2 = _interopRequireDefault(_isString); + var _isFunction = __webpack_require__(3); -/***/ }, -/* 99 */ -/***/ function(module, exports, __webpack_require__) { + var _isFunction2 = _interopRequireDefault(_isFunction); - var isObject = __webpack_require__(4); + var _isNumber = __webpack_require__(132); - /** Built-in value references. */ - var objectCreate = Object.create; + var _isNumber2 = _interopRequireDefault(_isNumber); - /** - * The base implementation of `_.create` without support for assigning - * properties to the created object. - * - * @private - * @param {Object} prototype The object to inherit from. - * @returns {Object} Returns the new object. - */ - function baseCreate(proto) { - return isObject(proto) ? objectCreate(proto) : {}; - } + var _isObject = __webpack_require__(10); - module.exports = baseCreate; + var _isObject2 = _interopRequireDefault(_isObject); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } -/***/ }, -/* 100 */ -/***/ function(module, exports, __webpack_require__) { + function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } - /* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(31), - stubFalse = __webpack_require__(102); + var mersenne = __webpack_require__(133); - /** Detect free variable `exports`. */ - var freeExports = typeof exports == 'object' && exports; + var chars = "abcdefghijklmnopqrstuvwxyz"; + var any = "0123456789" + chars; - /** Detect free variable `module`. */ - var freeModule = freeExports && typeof module == 'object' && module; + module.exports = function (locale) { + var self = this; + self.locale = locale; - /** Detect the popular CommonJS extension `module.exports`. */ - var moduleExports = freeModule && freeModule.exports === freeExports; + self.seed = function (seed) { + if ((0, _isArray2.default)(seed) && seed.length > 0) mersenne.seed_array(seed);else mersenne.seed(seed); + }; - /** Built-in value references. */ - var Buffer = moduleExports ? root.Buffer : undefined; + self.random = { + number: function number() { + var max = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 9999; + var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var precision = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; - /** - * 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 = !Buffer ? stubFalse : function(value) { - return value instanceof Buffer; - }; + if (min > max) { + var _ref = [max, min]; + min = _ref[0]; + max = _ref[1]; + } + max /= precision; + min /= precision; + return precision * Math.floor(mersenne.rand(max + 1, min)); + }, + boolean: function boolean() { + var likelihood = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 50; - module.exports = isBuffer; + return self.random.number(0, 100) <= likelihood; + }, + digit: function digit() { + return self.random.number(9); + }, + hex: function hex() { + var len = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) + var res = []; + for (var i = 0; i < len; i++) { + res.push(self.random.number(15).toString(16)); + }return res.join(""); + }, + letter: function letter() { + return self.random.arrayElement(chars); + }, + string: function string() { + var len = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; -/***/ }, -/* 101 */ -/***/ function(module, exports) { + var res = []; + if ((0, _isObject2.default)(len)) len = self.random.number(len.min || 5, len.max || 10); - module.exports = function(module) { - if(!module.webpackPolyfill) { - module.deprecate = function() {}; - module.paths = []; - // module.parent = undefined by default - module.children = []; - module.webpackPolyfill = 1; - } - return module; - } + for (var i = 0; i < len; i++) { + res.push(self.random.letter()); + }return res.join(""); + }, + arrayElement: function arrayElement(array) { + if (array && array.length > 0) return array[self.random.number(array.length - 1)]; + }, + objectElement: function objectElement(obj) { + if (!obj) return; + var key = self.random.arrayElement(Object.keys(obj)); + return _defineProperty({}, key, obj[key]); + }, + masked: function masked(format) { + if ((0, _isNil2.default)(format)) return; -/***/ }, -/* 102 */ -/***/ function(module, exports) { + var result = []; + for (var i = 0; i <= format.length; i++) { + if (format.charAt(i) === "9") result.push(self.random.number(9).toString());else if (format.charAt(i) === "a") result.push(self.random.arrayElement(chars));else if (format.charAt(i) === "A") result.push(self.random.arrayElement(chars).toUpperCase());else if (format.charAt(i) === "*") result.push(self.random.arrayElement(any));else result.push(format.charAt(i)); + } + return result.join(""); + } + }; - /** - * A method that returns `false`. - * - * @static - * @memberOf _ - * @since 4.13.0 - * @category Util - * @returns {boolean} Returns `false`. - * @example - * - * _.times(2, _.stubFalse); - * // => [false, false] - */ - function stubFalse() { - return false; - } + self.capitalize = _capitalize2.default; - module.exports = stubFalse; + self.slugify = function () { + var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ""; + return str.trim().replace(/ /g, "-").replace(/[^\w\.\-]+/g, ""); + }; -/***/ }, -/* 103 */ -/***/ function(module, exports, __webpack_require__) { + self.replaceSymbols = function (format) { + var numberSymbol = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "#"; + var alphaSymbol = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "\\?"; - var getPrototype = __webpack_require__(55), - isHostObject = __webpack_require__(28), - isObjectLike = __webpack_require__(65); + if (format) return format.replace(new RegExp(numberSymbol, "g"), self.random.digit).replace(new RegExp(alphaSymbol, "g"), self.random.letter); + }; - /** `Object#toString` result references. */ - var objectTag = '[object Object]'; + self.shuffle = function (o) { + if ((0, _isNil2.default)(o)) return; + for (var j, x, i = o.length - 1; i; j = self.random.number(i), x = o[--i], o[i] = o[j], o[j] = x) {} + return o; + }; - /** Used for built-in method references. */ - var objectProto = Object.prototype; + var maskRE = new RegExp(locale._meta.mask || "\#\{([A-Za-z0-9_\.]+)\}", "g"); - /** Used to resolve the decompiled source of functions. */ - var funcToString = Function.prototype.toString; + self.populate = function (format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; + if ((0, _isNil2.default)(format)) return; - /** Used to infer the `Object` constructor. */ - var objectCtorString = funcToString.call(Object); + var res = format; + res = format.replace(maskRE, function (match, cap) { + var part = (0, _get2.default)(self.locale, cap); + if (part) { + if ((0, _isFunction2.default)(part)) { + var _part; - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; + part = (_part = part).call.apply(_part, [self].concat(args)); + } - /** - * 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) || - objectToString.call(value) != objectTag || isHostObject(value)) { - 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); - } + if ((0, _isArray2.default)(part)) { + if (part.length == 0) return; - module.exports = isPlainObject; + return self.populate.apply(self, [self.random.arrayElement(part)].concat(args)); + } else if ((0, _isString2.default)(part)) return self.populate.apply(self, [part].concat(args));else if ((0, _isNumber2.default)(part) || (0, _isObject2.default)(part)) return part; + } + return match; + }); -/***/ }, -/* 104 */ -/***/ function(module, exports, __webpack_require__) { + if ((0, _isString2.default)(res)) res = self.replaceSymbols(res); - var isLength = __webpack_require__(64), - isObjectLike = __webpack_require__(65); + return res; + }; - /** `Object#toString` result references. */ - var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - boolTag = '[object Boolean]', - dateTag = '[object Date]', - errorTag = '[object Error]', - funcTag = '[object Function]', - mapTag = '[object Map]', - numberTag = '[object Number]', - objectTag = '[object Object]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - weakMapTag = '[object WeakMap]'; + self.times = function (func, n) { + var res = []; - 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]'; + if ((0, _isObject2.default)(n)) n = this.random.number(n.min || 1, n.max || 10); - /** 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; + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } - /** Used for built-in method references. */ - var objectProto = Object.prototype; + for (var i = 0; i < n; i++) { + res.push(func.call.apply(func, [self].concat(args))); + }return res; + }; - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; + self.utimes = function (func, n) { + var res = []; - /** - * 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 correctly classified, - * else `false`. - * @example - * - * _.isTypedArray(new Uint8Array); - * // => true - * - * _.isTypedArray([]); - * // => false - */ - function isTypedArray(value) { - return isObjectLike(value) && - isLength(value.length) && !!typedArrayTags[objectToString.call(value)]; - } + if ((0, _isObject2.default)(n)) n = this.random.number(n.min || 1, n.max || 10); - module.exports = isTypedArray; + var i = 0; + + for (var _len3 = arguments.length, args = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { + args[_key3 - 2] = arguments[_key3]; + } + + while (res.length < n && i < n * 5) { + var item = func.call.apply(func, [self].concat(args)); + if (res.indexOf(item) == -1) res.push(item); + + i++; + } + + return res; + }; + + self.generate = function (def) { + var res = void 0; + + for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { + args[_key4 - 1] = arguments[_key4]; + } + + if ((0, _isFunction2.default)(def)) { + res = def.call.apply(def, [self].concat(args)); + } else if ((0, _isArray2.default)(def)) { + if (def.length >= 0) res = self.random.arrayElement(def); + } else if ((0, _isString2.default)(def)) { + if (maskRE.test(def)) res = self.populate.apply(self, [def].concat(args));else return res = self.replaceSymbols(def); + } else if ((0, _isNumber2.default)(def) || (0, _isObject2.default)(def)) { + return def; + } + + if (res) return self.generate.apply(self, [res].concat(args)); + }; + + function createGeneratorMethods(obj, definitions, level) { + (0, _each2.default)(Object.keys(definitions), function (item) { + if (item === "_meta") return; + + var def = definitions[item]; + if ((0, _isObject2.default)(def) && !(0, _isArray2.default)(def) && !(0, _isFunction2.default)(def) && level < 10) { + obj[item] = {}; + createGeneratorMethods(obj[item], def, level + 1); + } else { + obj[item] = function () { + for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { + args[_key5] = arguments[_key5]; + } + + return self.generate.apply(self, [def].concat(args)); + }; + } + }); + } + + createGeneratorMethods(self, self.locale, 1); + return self; + }; /***/ }, -/* 105 */ +/* 100 */ /***/ function(module, exports, __webpack_require__) { - var copyObject = __webpack_require__(52), - keysIn = __webpack_require__(106); + var baseGet = __webpack_require__(101); /** - * Converts `value` to a plain object flattening inherited enumerable string - * keyed properties of `value` to own properties of the plain 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.0.0 - * @category Lang - * @param {*} value The value to convert. - * @returns {Object} Returns the converted plain object. + * @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 * - * function Foo() { - * this.b = 2; - * } + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; * - * Foo.prototype.c = 3; + * _.get(object, 'a[0].b.c'); + * // => 3 * - * _.assign({ 'a': 1 }, new Foo); - * // => { 'a': 1, 'b': 2 } + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 * - * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); - * // => { 'a': 1, 'b': 2, 'c': 3 } + * _.get(object, 'a.b.c', 'default'); + * // => 'default' */ - function toPlainObject(value) { - return copyObject(value, keysIn(value)); + function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; } - module.exports = toPlainObject; + module.exports = get; /***/ }, -/* 106 */ +/* 101 */ /***/ function(module, exports, __webpack_require__) { - var baseKeysIn = __webpack_require__(107), - indexKeys = __webpack_require__(57), - isIndex = __webpack_require__(67), - isPrototype = __webpack_require__(68); - - /** Used for built-in method references. */ - var objectProto = Object.prototype; - - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; + var castPath = __webpack_require__(102), + toKey = __webpack_require__(111); /** - * Creates an array of the own and inherited enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. + * The base implementation of `_.get` without support for default values. * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Object + * @private * @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) + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. */ - function keysIn(object) { - var index = -1, - isProto = isPrototype(object), - props = baseKeysIn(object), - propsLength = props.length, - indexes = indexKeys(object), - skipIndexes = !!indexes, - result = indexes || [], - length = result.length; + function baseGet(object, path) { + path = castPath(path, object); - while (++index < propsLength) { - var key = props[index]; - if (!(skipIndexes && (key == 'length' || isIndex(key, length))) && - !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { - result.push(key); - } + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; } - return result; + return (index && index == length) ? object : undefined; } - module.exports = keysIn; + module.exports = baseGet; /***/ }, -/* 107 */ +/* 102 */ /***/ function(module, exports, __webpack_require__) { - var Reflect = __webpack_require__(108), - iteratorToArray = __webpack_require__(109); - - /** Used for built-in method references. */ - var objectProto = Object.prototype; - - /** Built-in value references. */ - var enumerate = Reflect ? Reflect.enumerate : undefined, - propertyIsEnumerable = objectProto.propertyIsEnumerable; + var isArray = __webpack_require__(2), + isKey = __webpack_require__(103), + stringToPath = __webpack_require__(105), + toString = __webpack_require__(108); /** - * The base implementation of `_.keysIn` which doesn't skip the constructor - * property of prototypes or treat sparse arrays as dense. + * Casts `value` to a path array if it's not one. * * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. */ - function baseKeysIn(object) { - object = object == null ? object : Object(object); - - var result = []; - for (var key in object) { - result.push(key); + function castPath(value, object) { + if (isArray(value)) { + return value; } - return result; - } - - // Fallback for IE < 9 with es6-shim. - if (enumerate && !propertyIsEnumerable.call({ 'valueOf': 1 }, 'valueOf')) { - baseKeysIn = function(object) { - return iteratorToArray(enumerate(object)); - }; + return isKey(value, object) ? [value] : stringToPath(toString(value)); } - module.exports = baseKeysIn; + module.exports = castPath; /***/ }, -/* 108 */ +/* 103 */ /***/ function(module, exports, __webpack_require__) { - var root = __webpack_require__(31); - - /** Built-in value references. */ - var Reflect = root.Reflect; - - module.exports = Reflect; - + var isArray = __webpack_require__(2), + isSymbol = __webpack_require__(104); -/***/ }, -/* 109 */ -/***/ function(module, exports) { + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; /** - * Converts `iterator` to an array. + * Checks if `value` is a property name and not a property path. * * @private - * @param {Object} iterator The iterator to convert. - * @returns {Array} Returns the converted array. + * @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 iteratorToArray(iterator) { - var data, - result = []; - - while (!(data = iterator.next()).done) { - result.push(data.value); + function isKey(value, object) { + if (isArray(value)) { + return false; } - return result; + 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)); } - module.exports = iteratorToArray; + module.exports = isKey; /***/ }, -/* 110 */ +/* 104 */ /***/ function(module, exports, __webpack_require__) { - var isIterateeCall = __webpack_require__(111), - rest = __webpack_require__(112); + var baseGetTag = __webpack_require__(4), + isObjectLike = __webpack_require__(68); - /** - * Creates a function like `_.assign`. + /** `Object#toString` result references. */ + var symbolTag = '[object Symbol]'; + + /** + * Checks if `value` is classified as a `Symbol` primitive or object. * - * @private - * @param {Function} assigner The function to assign values. - * @returns {Function} Returns the new assigner function. + * @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 createAssigner(assigner) { - return rest(function(object, sources) { - var index = -1, - length = sources.length, - customizer = length > 1 ? sources[length - 1] : undefined, - guard = length > 2 ? sources[2] : undefined; + function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); + } - customizer = (assigner.length > 3 && typeof customizer == 'function') - ? (length--, customizer) - : undefined; + module.exports = isSymbol; - 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; + +/***/ }, +/* 105 */ +/***/ function(module, exports, __webpack_require__) { + + var memoizeCapped = __webpack_require__(106); + + /** Used to match property names within property paths. */ + var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * 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; + }); - module.exports = createAssigner; + module.exports = stringToPath; /***/ }, -/* 111 */ +/* 106 */ /***/ function(module, exports, __webpack_require__) { - var eq = __webpack_require__(12), - isArrayLike = __webpack_require__(61), - isIndex = __webpack_require__(67), - isObject = __webpack_require__(4); + var memoize = __webpack_require__(107); + + /** Used as the maximum memoize cache size. */ + var MAX_MEMOIZE_SIZE = 500; /** - * Checks if the given arguments are from an iteratee call. + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. * * @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`. + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. */ - 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; + 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; } - module.exports = isIterateeCall; + module.exports = memoizeCapped; /***/ }, -/* 112 */ +/* 107 */ /***/ function(module, exports, __webpack_require__) { - var apply = __webpack_require__(113), - toInteger = __webpack_require__(114); + var MapCache = __webpack_require__(34); - /** Used as the `TypeError` message for "Functions" methods. */ + /** Error message constants. */ var FUNC_ERROR_TEXT = 'Expected a function'; - /* Built-in method references for those with the same name as other `lodash` methods. */ - var nativeMax = Math.max; - /** - * Creates a function that invokes `func` with the `this` binding of the - * created function and arguments from `start` and beyond provided as - * an array. + * 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:** This method is based on the - * [rest parameter](https://mdn.io/rest_parameters). + * **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 4.0.0 + * @since 0.1.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. + * @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 say = _.rest(function(what, names) { - * return what + ' ' + _.initial(names).join(', ') + - * (_.size(names) > 1 ? ', & ' : '') + _.last(names); - * }); + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] * - * say('hello', 'fred', 'barney', 'pebbles'); - * // => 'hello fred, barney, & pebbles' + * 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 rest(func, start) { - if (typeof func != 'function') { + function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { throw new TypeError(FUNC_ERROR_TEXT); } - start = nativeMax(start === undefined ? (func.length - 1) : toInteger(start), 0); - return function() { + var memoized = function() { var args = arguments, - index = -1, - length = nativeMax(args.length - start, 0), - array = Array(length); + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; - while (++index < length) { - array[index] = args[start + index]; - } - switch (start) { - case 0: return func.call(this, array); - case 1: return func.call(this, args[0], array); - case 2: return func.call(this, args[0], args[1], array); - } - var otherArgs = Array(start + 1); - index = -1; - while (++index < start) { - otherArgs[index] = args[index]; + if (cache.has(key)) { + return cache.get(key); } - otherArgs[start] = array; - return apply(func, this, otherArgs); + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; } - module.exports = rest; - - -/***/ }, -/* 113 */ -/***/ function(module, exports) { - - /** - * 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) { - var length = args.length; - switch (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); - } + // Expose `MapCache`. + memoize.Cache = MapCache; - module.exports = apply; + module.exports = memoize; /***/ }, -/* 114 */ +/* 108 */ /***/ function(module, exports, __webpack_require__) { - var toFinite = __webpack_require__(115); + var baseToString = __webpack_require__(109); /** - * Converts `value` to an integer. - * - * **Note:** This method is loosely based on - * [`ToInteger`](http://www.ecma-international.org/ecma-262/6.0/#sec-tointeger). + * 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 {number} Returns the converted integer. + * @returns {string} Returns the converted string. * @example * - * _.toInteger(3.2); - * // => 3 - * - * _.toInteger(Number.MIN_VALUE); - * // => 0 + * _.toString(null); + * // => '' * - * _.toInteger(Infinity); - * // => 1.7976931348623157e+308 + * _.toString(-0); + * // => '-0' * - * _.toInteger('3.2'); - * // => 3 + * _.toString([1, 2, 3]); + * // => '1,2,3' */ - function toInteger(value) { - var result = toFinite(value), - remainder = result % 1; - - return result === result ? (remainder ? result - remainder : result) : 0; + function toString(value) { + return value == null ? '' : baseToString(value); } - module.exports = toInteger; + module.exports = toString; /***/ }, -/* 115 */ +/* 109 */ /***/ function(module, exports, __webpack_require__) { - var toNumber = __webpack_require__(116); + var Symbol = __webpack_require__(5), + arrayMap = __webpack_require__(110), + isArray = __webpack_require__(2), + isSymbol = __webpack_require__(104); /** Used as references for various `Number` constants. */ - var INFINITY = 1 / 0, - MAX_INTEGER = 1.7976931348623157e+308; + var INFINITY = 1 / 0; + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; /** - * 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 + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. * - * _.toFinite('3.2'); - * // => 3.2 + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. */ - function toFinite(value) { - if (!value) { - return value === 0 ? value : 0; + 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) + ''; } - value = toNumber(value); - if (value === INFINITY || value === -INFINITY) { - var sign = (value < 0 ? -1 : 1); - return sign * MAX_INTEGER; + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; } - return value === value ? value : 0; + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; } - module.exports = toFinite; + module.exports = baseToString; /***/ }, -/* 116 */ -/***/ function(module, exports, __webpack_require__) { - - var isFunction = __webpack_require__(3), - isObject = __webpack_require__(4), - isSymbol = __webpack_require__(117); - - /** Used as references for various `Number` constants. */ - var NAN = 0 / 0; - - /** Used to match leading and trailing whitespace. */ - var reTrim = /^\s+|\s+$/g; - - /** 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 octal string values. */ - var reIsOctal = /^0o[0-7]+$/i; - - /** Built-in method references without a dependency on `root`. */ - var freeParseInt = parseInt; +/* 110 */ +/***/ function(module, exports) { /** - * Converts `value` to a number. + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. * - * @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 + * @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; + } + + module.exports = arrayMap; + + +/***/ }, +/* 111 */ +/***/ function(module, exports, __webpack_require__) { + + var isSymbol = __webpack_require__(104); + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + + /** + * Converts `value` to a string key if it's not a string or symbol. * - * _.toNumber('3.2'); - * // => 3.2 + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. */ - function toNumber(value) { - if (typeof value == 'number') { + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { return value; } - if (isSymbol(value)) { - return NAN; - } - if (isObject(value)) { - var other = isFunction(value.valueOf) ? 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); + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; } - module.exports = toNumber; + module.exports = toKey; /***/ }, -/* 117 */ +/* 112 */ /***/ function(module, exports, __webpack_require__) { - var isObjectLike = __webpack_require__(65); + module.exports = __webpack_require__(113); - /** `Object#toString` result references. */ - var symbolTag = '[object Symbol]'; - /** Used for built-in method references. */ - var objectProto = Object.prototype; +/***/ }, +/* 113 */ +/***/ function(module, exports, __webpack_require__) { - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; + var arrayEach = __webpack_require__(114), + baseEach = __webpack_require__(115), + castFunction = __webpack_require__(121), + isArray = __webpack_require__(2); /** - * Checks if `value` is classified as a `Symbol` primitive or object. + * 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 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is correctly classified, - * else `false`. + * @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 * - * _.isSymbol(Symbol.iterator); - * // => true + * _.forEach([1, 2], function(value) { + * console.log(value); + * }); + * // => Logs `1` then `2`. * - * _.isSymbol('abc'); - * // => false + * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) { + * console.log(key); + * }); + * // => Logs 'a' then 'b' (iteration order is not guaranteed). */ - function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && objectToString.call(value) == symbolTag); + function forEach(collection, iteratee) { + var func = isArray(collection) ? arrayEach : baseEach; + return func(collection, castFunction(iteratee)); } - module.exports = isSymbol; + module.exports = forEach; /***/ }, -/* 118 */ -/***/ function(module, exports, __webpack_require__) { +/* 114 */ +/***/ function(module, exports) { - "use strict"; + /** + * 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; - var _get = __webpack_require__(119); + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } - var _get2 = _interopRequireDefault(_get); + module.exports = arrayEach; - var _each = __webpack_require__(128); - var _each2 = _interopRequireDefault(_each); +/***/ }, +/* 115 */ +/***/ function(module, exports, __webpack_require__) { - var _capitalize = __webpack_require__(157); + var baseForOwn = __webpack_require__(116), + createBaseEach = __webpack_require__(120); - var _capitalize2 = _interopRequireDefault(_capitalize); + /** + * 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); - var _isNil = __webpack_require__(1); + module.exports = baseEach; - var _isNil2 = _interopRequireDefault(_isNil); - var _isArray = __webpack_require__(2); +/***/ }, +/* 116 */ +/***/ function(module, exports, __webpack_require__) { - var _isArray2 = _interopRequireDefault(_isArray); + var baseFor = __webpack_require__(52), + keys = __webpack_require__(117); - var _isString = __webpack_require__(66); + /** + * 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); + } - var _isString2 = _interopRequireDefault(_isString); + module.exports = baseForOwn; - var _isFunction = __webpack_require__(3); - var _isFunction2 = _interopRequireDefault(_isFunction); +/***/ }, +/* 117 */ +/***/ function(module, exports, __webpack_require__) { - var _isNumber = __webpack_require__(164); + var arrayLikeKeys = __webpack_require__(84), + baseKeys = __webpack_require__(118), + isArrayLike = __webpack_require__(70); - var _isNumber2 = _interopRequireDefault(_isNumber); + /** + * 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); + } - var _isObject = __webpack_require__(4); + module.exports = keys; - var _isObject2 = _interopRequireDefault(_isObject); - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +/***/ }, +/* 118 */ +/***/ function(module, exports, __webpack_require__) { - function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } + var isPrototype = __webpack_require__(65), + nativeKeys = __webpack_require__(119); - var mersenne = __webpack_require__(165); + /** Used for built-in method references. */ + var objectProto = Object.prototype; - var chars = "abcdefghijklmnopqrstuvwxyz"; - var any = "0123456789" + chars; + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; - module.exports = function (locale) { - var self = this; - self.locale = locale; + /** + * 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; + } - self.seed = function (seed) { - if ((0, _isArray2.default)(seed) && seed.length > 0) mersenne.seed_array(seed);else mersenne.seed(seed); - }; + module.exports = baseKeys; - self.random = { - number: function number() { - var max = arguments.length <= 0 || arguments[0] === undefined ? 9999 : arguments[0]; - var min = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1]; - var precision = arguments.length <= 2 || arguments[2] === undefined ? 1 : arguments[2]; - if (min > max) { - var _ref = [max, min]; - min = _ref[0]; - max = _ref[1]; - } - max /= precision; - min /= precision; - return precision * Math.floor(mersenne.rand(max + 1, min)); - }, - boolean: function boolean() { - var likelihood = arguments.length <= 0 || arguments[0] === undefined ? 50 : arguments[0]; +/***/ }, +/* 119 */ +/***/ function(module, exports, __webpack_require__) { - return self.random.number(0, 100) <= likelihood; - }, - digit: function digit() { - return self.random.number(9); - }, - hex: function hex() { - var len = arguments.length <= 0 || arguments[0] === undefined ? 1 : arguments[0]; + var overArg = __webpack_require__(64); - var res = []; - for (var i = 0; i < len; i++) { - res.push(self.random.number(15).toString(16)); - }return res.join(""); - }, - letter: function letter() { - return self.random.arrayElement(chars); - }, - string: function string() { - var len = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeKeys = overArg(Object.keys, Object); - var res = []; - if ((0, _isObject2.default)(len)) len = self.random.number(len.min || 5, len.max || 10); + module.exports = nativeKeys; - for (var i = 0; i < len; i++) { - res.push(self.random.letter()); - }return res.join(""); - }, - arrayElement: function arrayElement(array) { - if (array && array.length > 0) return array[self.random.number(array.length - 1)]; - }, - objectElement: function objectElement(obj) { - if (!obj) return; - - var key = self.random.arrayElement(Object.keys(obj)); - return _defineProperty({}, key, obj[key]); - }, - masked: function masked(format) { - if ((0, _isNil2.default)(format)) return; - - var result = []; - for (var i = 0; i <= format.length; i++) { - if (format.charAt(i) === "9") result.push(self.random.number(9).toString());else if (format.charAt(i) === "a") result.push(self.random.arrayElement(chars));else if (format.charAt(i) === "A") result.push(self.random.arrayElement(chars).toUpperCase());else if (format.charAt(i) === "*") result.push(self.random.arrayElement(any));else result.push(format.charAt(i)); - } - return result.join(""); - } - }; - - self.capitalize = _capitalize2.default; - - self.slugify = function () { - var str = arguments.length <= 0 || arguments[0] === undefined ? "" : arguments[0]; - - return str.trim().replace(/ /g, "-").replace(/[^\w\.\-]+/g, ""); - }; - - self.replaceSymbols = function (format) { - var numberSymbol = arguments.length <= 1 || arguments[1] === undefined ? "#" : arguments[1]; - var alphaSymbol = arguments.length <= 2 || arguments[2] === undefined ? "\\?" : arguments[2]; - - if (format) return format.replace(new RegExp(numberSymbol, "g"), self.random.digit).replace(new RegExp(alphaSymbol, "g"), self.random.letter); - }; - - self.shuffle = function (o) { - if ((0, _isNil2.default)(o)) return; - for (var j, x, i = o.length - 1; i; j = self.random.number(i), x = o[--i], o[i] = o[j], o[j] = x) {} - return o; - }; - - var maskRE = new RegExp(locale._meta.mask || "\#\{([A-Za-z0-9_\.]+)\}", "g"); - - self.populate = function (format) { - for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - args[_key - 1] = arguments[_key]; - } - - if ((0, _isNil2.default)(format)) return; - - var res = format; - res = format.replace(maskRE, function (match, cap) { - var part = (0, _get2.default)(self.locale, cap); - if (part) { - if ((0, _isFunction2.default)(part)) { - var _part; - - part = (_part = part).call.apply(_part, [self].concat(args)); - } - - if ((0, _isArray2.default)(part)) { - if (part.length == 0) return; - - return self.populate.apply(self, [self.random.arrayElement(part)].concat(args)); - } else if ((0, _isString2.default)(part)) return self.populate.apply(self, [part].concat(args));else if ((0, _isNumber2.default)(part) || (0, _isObject2.default)(part)) return part; - } - - return match; - }); - - if ((0, _isString2.default)(res)) res = self.replaceSymbols(res); - - return res; - }; - - self.times = function (func, n) { - var res = []; - - if ((0, _isObject2.default)(n)) n = this.random.number(n.min || 1, n.max || 10); - - for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { - args[_key2 - 2] = arguments[_key2]; - } - - for (var i = 0; i < n; i++) { - res.push(func.call.apply(func, [self].concat(args))); - }return res; - }; - - self.utimes = function (func, n) { - var res = []; - - if ((0, _isObject2.default)(n)) n = this.random.number(n.min || 1, n.max || 10); - - var i = 0; - for (var _len3 = arguments.length, args = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { - args[_key3 - 2] = arguments[_key3]; - } - - while (res.length < n && i < n * 5) { - var item = func.call.apply(func, [self].concat(args)); - if (res.indexOf(item) == -1) res.push(item); - - i++; - } +/***/ }, +/* 120 */ +/***/ function(module, exports, __webpack_require__) { - return res; - }; + var isArrayLike = __webpack_require__(70); - self.generate = function (def) { - var res = void 0; + /** + * 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); - for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { - args[_key4 - 1] = arguments[_key4]; - } + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } - if ((0, _isFunction2.default)(def)) { - res = def.call.apply(def, [self].concat(args)); - } else if ((0, _isArray2.default)(def)) { - if (def.length >= 0) res = self.random.arrayElement(def); - } else if ((0, _isString2.default)(def)) { - if (maskRE.test(def)) res = self.populate.apply(self, [def].concat(args));else return res = self.replaceSymbols(def); - } else if ((0, _isNumber2.default)(def) || (0, _isObject2.default)(def)) { - return def; - } + module.exports = createBaseEach; - if (res) return self.generate.apply(self, [res].concat(args)); - }; - function createGeneratorMethods(obj, definitions, level) { - (0, _each2.default)(Object.keys(definitions), function (item) { - if (item === "_meta") return; +/***/ }, +/* 121 */ +/***/ function(module, exports, __webpack_require__) { - var def = definitions[item]; - if ((0, _isObject2.default)(def) && !(0, _isArray2.default)(def) && !(0, _isFunction2.default)(def) && level < 10) { - obj[item] = {}; - createGeneratorMethods(obj[item], def, level + 1); - } else { - obj[item] = function () { - for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) { - args[_key5] = arguments[_key5]; - } + var identity = __webpack_require__(91); - return self.generate.apply(self, [def].concat(args)); - }; - } - }); - } + /** + * 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; + } - createGeneratorMethods(self, self.locale, 1); + module.exports = castFunction; - return self; - }; /***/ }, -/* 119 */ +/* 122 */ /***/ function(module, exports, __webpack_require__) { - var baseGet = __webpack_require__(120); + var toString = __webpack_require__(108), + upperFirst = __webpack_require__(123); /** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is used in its place. + * Converts the first character of `string` to upper case and the remaining + * to lower case. * * @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. + * @since 3.0.0 + * @category String + * @param {string} [string=''] The string to capitalize. + * @returns {string} Returns the capitalized string. * @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' + * _.capitalize('FRED'); + * // => 'Fred' */ - function get(object, path, defaultValue) { - var result = object == null ? undefined : baseGet(object, path); - return result === undefined ? defaultValue : result; + function capitalize(string) { + return upperFirst(toString(string).toLowerCase()); } - module.exports = get; + module.exports = capitalize; /***/ }, -/* 120 */ +/* 123 */ /***/ function(module, exports, __webpack_require__) { - var castPath = __webpack_require__(121), - isKey = __webpack_require__(126), - toKey = __webpack_require__(127); + var createCaseFirst = __webpack_require__(124); /** - * The base implementation of `_.get` without support for default values. + * Converts the first character of `string` to upper case. * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. + * @static + * @memberOf _ + * @since 4.0.0 + * @category String + * @param {string} [string=''] The string to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.upperFirst('fred'); + * // => 'Fred' + * + * _.upperFirst('FRED'); + * // => 'FRED' */ - function baseGet(object, path) { - path = isKey(path, object) ? [path] : castPath(path); - - var index = 0, - length = path.length; - - while (object != null && index < length) { - object = object[toKey(path[index++])]; - } - return (index && index == length) ? object : undefined; - } + var upperFirst = createCaseFirst('toUpperCase'); - module.exports = baseGet; + module.exports = upperFirst; /***/ }, -/* 121 */ +/* 124 */ /***/ function(module, exports, __webpack_require__) { - var isArray = __webpack_require__(2), - stringToPath = __webpack_require__(122); + var castSlice = __webpack_require__(125), + hasUnicode = __webpack_require__(127), + stringToArray = __webpack_require__(128), + toString = __webpack_require__(108); /** - * Casts `value` to a path array if it's not one. + * Creates a function like `_.lowerFirst`. * * @private - * @param {*} value The value to inspect. - * @returns {Array} Returns the cast property path array. + * @param {string} methodName The name of the `String` case method to use. + * @returns {Function} Returns the new case function. */ - function castPath(value) { - return isArray(value) ? value : stringToPath(value); - } - - module.exports = castPath; - - -/***/ }, -/* 122 */ -/***/ function(module, exports, __webpack_require__) { + function createCaseFirst(methodName) { + return function(string) { + string = toString(string); - var memoize = __webpack_require__(123), - toString = __webpack_require__(124); + var strSymbols = hasUnicode(string) + ? stringToArray(string) + : undefined; - /** Used to match property names within property paths. */ - var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(\.|\[\])(?:\4|$))/g; + var chr = strSymbols + ? strSymbols[0] + : string.charAt(0); - /** Used to match backslashes in property paths. */ - var reEscapeChar = /\\(\\)?/g; + var trailing = strSymbols + ? castSlice(strSymbols, 1).join('') + : string.slice(1); - /** - * Converts `string` to a property path array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. - */ - var stringToPath = memoize(function(string) { - var result = []; - toString(string).replace(rePropName, function(match, number, quote, string) { - result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); - }); - return result; - }); + return chr[methodName]() + trailing; + }; + } - module.exports = stringToPath; + module.exports = createCaseFirst; /***/ }, -/* 123 */ +/* 125 */ /***/ function(module, exports, __webpack_require__) { - var MapCache = __webpack_require__(21); - - /** Used as the `TypeError` message for "Functions" methods. */ - var FUNC_ERROR_TEXT = 'Expected a function'; + var baseSlice = __webpack_require__(126); /** - * 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/6.0/#sec-properties-of-the-map-prototype-object) - * method interface of `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'] + * Casts `array` to a slice if it's needed. * - * // Replace `_.memoize.Cache`. - * _.memoize.Cache = WeakMap; + * @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 memoize(func, resolver) { - if (typeof func != 'function' || (resolver && 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); - return result; - }; - memoized.cache = new (memoize.Cache || MapCache); - return memoized; + function castSlice(array, start, end) { + var length = array.length; + end = end === undefined ? length : end; + return (!start && end >= length) ? array : baseSlice(array, start, end); } - // Assign cache to `_.memoize`. - memoize.Cache = MapCache; - - module.exports = memoize; + module.exports = castSlice; /***/ }, -/* 124 */ -/***/ function(module, exports, __webpack_require__) { - - var baseToString = __webpack_require__(125); +/* 126 */ +/***/ function(module, exports) { /** - * 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 process. - * @returns {string} Returns the string. - * @example - * - * _.toString(null); - * // => '' - * - * _.toString(-0); - * // => '-0' + * The base implementation of `_.slice` without an iteratee call guard. * - * _.toString([1, 2, 3]); - * // => '1,2,3' + * @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 toString(value) { - return value == null ? '' : baseToString(value); + 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; } - module.exports = toString; + module.exports = baseSlice; /***/ }, -/* 125 */ -/***/ function(module, exports, __webpack_require__) { +/* 127 */ +/***/ function(module, exports) { - var Symbol = __webpack_require__(96), - isSymbol = __webpack_require__(117); + /** Used to compose unicode character classes. */ + var rsAstralRange = '\\ud800-\\udfff', + rsComboMarksRange = '\\u0300-\\u036f', + reComboHalfMarksRange = '\\ufe20-\\ufe2f', + rsComboSymbolsRange = '\\u20d0-\\u20ff', + rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, + rsVarRange = '\\ufe0e\\ufe0f'; - /** Used as references for various `Number` constants. */ - var INFINITY = 1 / 0; + /** Used to compose unicode capture groups. */ + var rsZWJ = '\\u200d'; - /** Used to convert symbols to primitives and strings. */ - var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolToString = symbolProto ? symbolProto.toString : undefined; + /** 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 + ']'); /** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. + * Checks if `string` contains Unicode symbols. * * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. + * @param {string} string The string to inspect. + * @returns {boolean} Returns `true` if a symbol is found, else `false`. */ - function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == 'string') { - return value; - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : ''; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + function hasUnicode(string) { + return reHasUnicode.test(string); } - module.exports = baseToString; + module.exports = hasUnicode; /***/ }, -/* 126 */ +/* 128 */ /***/ function(module, exports, __webpack_require__) { - var isArray = __webpack_require__(2), - isSymbol = __webpack_require__(117); - - /** Used to match property names within property paths. */ - var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/; + var asciiToArray = __webpack_require__(129), + hasUnicode = __webpack_require__(127), + unicodeToArray = __webpack_require__(130); /** - * Checks if `value` is a property name and not a property path. + * Converts `string` to an array. * * @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`. + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. */ - 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)); + function stringToArray(string) { + return hasUnicode(string) + ? unicodeToArray(string) + : asciiToArray(string); } - module.exports = isKey; + module.exports = stringToArray; /***/ }, -/* 127 */ -/***/ function(module, exports, __webpack_require__) { - - var isSymbol = __webpack_require__(117); - - /** Used as references for various `Number` constants. */ - var INFINITY = 1 / 0; +/* 129 */ +/***/ function(module, exports) { /** - * Converts `value` to a string key if it's not a string or symbol. + * Converts an ASCII `string` to an array. * * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. */ - function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + function asciiToArray(string) { + return string.split(''); } - module.exports = toKey; + module.exports = asciiToArray; /***/ }, -/* 128 */ -/***/ function(module, exports, __webpack_require__) { - - module.exports = __webpack_require__(129); +/* 130 */ +/***/ function(module, exports) { + /** Used to compose unicode character classes. */ + var rsAstralRange = '\\ud800-\\udfff', + rsComboMarksRange = '\\u0300-\\u036f', + reComboHalfMarksRange = '\\ufe20-\\ufe2f', + rsComboSymbolsRange = '\\u20d0-\\u20ff', + rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, + rsVarRange = '\\ufe0e\\ufe0f'; -/***/ }, -/* 129 */ -/***/ function(module, exports, __webpack_require__) { - - var arrayEach = __webpack_require__(46), - baseEach = __webpack_require__(130), - baseIteratee = __webpack_require__(135), - isArray = __webpack_require__(2); - - /** - * 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 - * - * _([1, 2]).forEach(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, baseIteratee(iteratee, 3)); - } - - module.exports = forEach; - + /** Used to compose unicode capture groups. */ + var rsAstral = '[' + rsAstralRange + ']', + rsCombo = '[' + rsComboRange + ']', + rsFitz = '\\ud83c[\\udffb-\\udfff]', + rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', + rsNonAstral = '[^' + rsAstralRange + ']', + rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', + rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', + rsZWJ = '\\u200d'; -/***/ }, -/* 130 */ -/***/ function(module, exports, __webpack_require__) { + /** Used to compose unicode regexes. */ + var reOptMod = rsModifier + '?', + rsOptVar = '[' + rsVarRange + ']?', + rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', + rsSeq = rsOptVar + reOptMod + rsOptJoin, + rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; - var baseForOwn = __webpack_require__(131), - createBaseEach = __webpack_require__(134); + /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ + var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); /** - * The base implementation of `_.forEach` without support for iteratee shorthands. + * Converts a Unicode `string` to an array. * * @private - * @param {Array|Object} collection The collection to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array|Object} Returns `collection`. + * @param {string} string The string to convert. + * @returns {Array} Returns the converted array. */ - var baseEach = createBaseEach(baseForOwn); + function unicodeToArray(string) { + return string.match(reUnicode) || []; + } - module.exports = baseEach; + module.exports = unicodeToArray; /***/ }, /* 131 */ /***/ function(module, exports, __webpack_require__) { - var baseFor = __webpack_require__(132), - keys = __webpack_require__(53); + var baseGetTag = __webpack_require__(4), + isArray = __webpack_require__(2), + isObjectLike = __webpack_require__(68); + + /** `Object#toString` result references. */ + var stringTag = '[object String]'; /** - * The base implementation of `_.forOwn` without support for iteratee shorthands. + * Checks if `value` is classified as a `String` primitive or object. * - * @private - * @param {Object} object The object to iterate over. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Object} Returns `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 baseForOwn(object, iteratee) { - return object && baseFor(object, iteratee, keys); + function isString(value) { + return typeof value == 'string' || + (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag); } - module.exports = baseForOwn; + module.exports = isString; /***/ }, /* 132 */ /***/ function(module, exports, __webpack_require__) { - var createBaseFor = __webpack_require__(133); + var baseGetTag = __webpack_require__(4), + isObjectLike = __webpack_require__(68); + + /** `Object#toString` result references. */ + var numberTag = '[object Number]'; /** - * 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`. + * Checks if `value` is classified as a `Number` primitive or object. * - * @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`. + * **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 */ - var baseFor = createBaseFor(); + function isNumber(value) { + return typeof value == 'number' || + (isObjectLike(value) && baseGetTag(value) == numberTag); + } - module.exports = baseFor; + module.exports = isNumber; /***/ }, /* 133 */ /***/ function(module, exports) { - /** - * 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; - }; - } - - module.exports = createBaseFor; - + 'use strict'; -/***/ }, -/* 134 */ -/***/ function(module, exports, __webpack_require__) { + 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 isArrayLike = __webpack_require__(61); + function MersenneTwister19937() { + var N, M, MATRIX_A, UPPER_MASK, LOWER_MASK; - /** - * 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); + N = 624; + M = 397; + MATRIX_A = 0x9908b0df; + UPPER_MASK = 0x80000000; + LOWER_MASK = 0x7fffffff; + var mt = new Array(N); + var mti = N + 1; - while ((fromRight ? index-- : ++index < length)) { - if (iteratee(iterable[index], index, iterable) === false) { - break; - } - } - return collection; - }; - } + function unsigned32(n1) { + return n1 < 0 ? (n1 ^ UPPER_MASK) + UPPER_MASK : n1; + } - module.exports = createBaseEach; + function subtraction32(n1, n2) { + return n1 < n2 ? unsigned32(0x100000000 - (n2 - n1) & 0xffffffff) : n1 - n2; + } + function addition32(n1, n2) { + return unsigned32(n1 + n2 & 0xffffffff); + } -/***/ }, -/* 135 */ -/***/ function(module, exports, __webpack_require__) { + function multiplication32(n1, n2) { + var sum = 0; + for (var i = 0; i < 32; ++i) { + if (n1 >>> i & 0x1) { + sum = addition32(sum, unsigned32(n2 << i)); + } + } + return sum; + } - var baseMatches = __webpack_require__(136), - baseMatchesProperty = __webpack_require__(150), - identity = __webpack_require__(154), - isArray = __webpack_require__(2), - property = __webpack_require__(155); + this.init_genrand = function (s) { + mt[0] = unsigned32(s & 0xffffffff); + for (mti = 1; mti < N; mti++) { + mt[mti] = addition32(multiplication32(1812433253, unsigned32(mt[mti - 1] ^ mt[mti - 1] >>> 30)), mti); - /** - * 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); - } + mt[mti] = unsigned32(mt[mti] & 0xffffffff); + } + }; - module.exports = baseIteratee; + this.init_by_array = function (init_key, key_length) { + var i, j, k, dbg; + this.init_genrand(19650218); + i = 1;j = 0; + k = N > key_length ? N : key_length; + for (; k; k--) { + mt[i] = addition32(addition32(unsigned32(mt[i] ^ multiplication32(unsigned32(mt[i - 1] ^ mt[i - 1] >>> 30), 1664525)), init_key[j]), j); + mt[i] = unsigned32(mt[i] & 0xffffffff); + i++;j++; + if (i >= N) { + mt[0] = mt[N - 1];i = 1; + } + if (j >= key_length) j = 0; + } + for (k = N - 1; k; k--) { + mt[i] = subtraction32(unsigned32((dbg = mt[i]) ^ multiplication32(unsigned32(mt[i - 1] ^ mt[i - 1] >>> 30), 1566083941)), i); -/***/ }, -/* 136 */ -/***/ function(module, exports, __webpack_require__) { - - var baseIsMatch = __webpack_require__(137), - getMatchData = __webpack_require__(147), - matchesStrictComparable = __webpack_require__(149); - - /** - * 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); - }; - } - - module.exports = baseMatches; - - -/***/ }, -/* 137 */ -/***/ function(module, exports, __webpack_require__) { - - var Stack = __webpack_require__(7), - baseIsEqual = __webpack_require__(138); + mt[i] = unsigned32(mt[i] & 0xffffffff); + i++; + if (i >= N) { + mt[0] = mt[N - 1];i = 1; + } + } + mt[0] = 0x80000000; + }; - /** Used to compose bitmasks for comparison styles. */ - var UNORDERED_COMPARE_FLAG = 1, - PARTIAL_COMPARE_FLAG = 2; + var mag01 = [0x0, MATRIX_A]; - /** - * 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, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack) - : result - )) { - return false; - } - } - } - return true; - } + this.genrand_int32 = function () { + var y; - module.exports = baseIsMatch; + if (mti >= N) { + var kk; -/***/ }, -/* 138 */ -/***/ function(module, exports, __webpack_require__) { + if (mti == N + 1) this.init_genrand(5489); - var baseIsEqualDeep = __webpack_require__(139), - isObject = __webpack_require__(4), - isObjectLike = __webpack_require__(65); + for (kk = 0; kk < N - M; kk++) { + y = unsigned32(mt[kk] & UPPER_MASK | mt[kk + 1] & LOWER_MASK); + mt[kk] = unsigned32(mt[kk + M] ^ y >>> 1 ^ mag01[y & 0x1]); + } + for (; kk < N - 1; kk++) { + y = unsigned32(mt[kk] & UPPER_MASK | mt[kk + 1] & LOWER_MASK); + mt[kk] = unsigned32(mt[kk + (M - N)] ^ y >>> 1 ^ mag01[y & 0x1]); + } - /** - * 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 {Function} [customizer] The function to customize comparisons. - * @param {boolean} [bitmask] The bitmask of comparison flags. - * The bitmask may be composed of the following flags: - * 1 - Unordered comparison - * 2 - Partial comparison - * @param {Object} [stack] Tracks traversed `value` and `other` objects. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - */ - function baseIsEqual(value, other, customizer, bitmask, stack) { - if (value === other) { - return true; - } - if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) { - return value !== value && other !== other; - } - return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack); - } + y = unsigned32(mt[N - 1] & UPPER_MASK | mt[0] & LOWER_MASK); + mt[N - 1] = unsigned32(mt[M - 1] ^ y >>> 1 ^ mag01[y & 0x1]); + mti = 0; + } - module.exports = baseIsEqual; + y = mt[mti++]; + y = unsigned32(y ^ y >>> 11); + y = unsigned32(y ^ y << 7 & 0x9d2c5680); + y = unsigned32(y ^ y << 15 & 0xefc60000); + y = unsigned32(y ^ y >>> 18); -/***/ }, -/* 139 */ -/***/ function(module, exports, __webpack_require__) { + return y; + }; - var Stack = __webpack_require__(7), - equalArrays = __webpack_require__(140), - equalByTag = __webpack_require__(145), - equalObjects = __webpack_require__(146), - getTag = __webpack_require__(77), - isArray = __webpack_require__(2), - isHostObject = __webpack_require__(28), - isTypedArray = __webpack_require__(104); + this.genrand_int31 = function () { + return this.genrand_int32() >>> 1; + }; - /** Used to compose bitmasks for comparison styles. */ - var PARTIAL_COMPARE_FLAG = 2; + this.genrand_real1 = function () { + return this.genrand_int32() * (1.0 / 4294967295.0); + }; - /** `Object#toString` result references. */ - var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - objectTag = '[object Object]'; + this.genrand_real2 = function () { + return this.genrand_int32() * (1.0 / 4294967296.0); + }; - /** Used for built-in method references. */ - var objectProto = Object.prototype; + this.genrand_real3 = function () { + return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0); + }; - /** Used to check objects for own properties. */ - var hasOwnProperty = objectProto.hasOwnProperty; + this.genrand_res53 = function () { + var a = this.genrand_int32() >>> 5, + b = this.genrand_int32() >>> 6; + return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0); + }; + } - /** - * 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 {Function} equalFunc The function to determine equivalents of values. - * @param {Function} [customizer] The function to customize comparisons. - * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual` - * for more details. - * @param {Object} [stack] Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) { - var objIsArr = isArray(object), - othIsArr = isArray(other), - objTag = arrayTag, - othTag = arrayTag; - - if (!objIsArr) { - objTag = getTag(object); - objTag = objTag == argsTag ? objectTag : objTag; - } - if (!othIsArr) { - othTag = getTag(other); - othTag = othTag == argsTag ? objectTag : othTag; - } - var objIsObj = objTag == objectTag && !isHostObject(object), - othIsObj = othTag == objectTag && !isHostObject(other), - isSameTag = objTag == othTag; - - if (isSameTag && !objIsObj) { - stack || (stack = new Stack); - return (objIsArr || isTypedArray(object)) - ? equalArrays(object, other, equalFunc, customizer, bitmask, stack) - : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack); - } - if (!(bitmask & PARTIAL_COMPARE_FLAG)) { - var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), - othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + module.exports.MersenneTwister19937 = MersenneTwister19937; - if (objIsWrapped || othIsWrapped) { - var objUnwrapped = objIsWrapped ? object.value() : object, - othUnwrapped = othIsWrapped ? other.value() : other; + var gen = new MersenneTwister19937(); + gen.init_genrand(new Date().getTime() % 1000000000); - stack || (stack = new Stack); - return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack); - } - } - if (!isSameTag) { - return false; - } - stack || (stack = new Stack); - return equalObjects(object, other, equalFunc, customizer, bitmask, stack); - } + module.exports.rand = function (max, min) { + if (max === undefined) { + min = 0; + max = 32768; + } + return Math.floor(gen.genrand_real2() * (max - min) + min); + }; + module.exports.seed = function (S) { + if (typeof S != 'number') throw new Error("seed(S) must take numeric argument; is " + (typeof S === 'undefined' ? 'undefined' : _typeof(S))); - module.exports = baseIsEqualDeep; + gen.init_genrand(S); + }; + module.exports.seed_array = function (A) { + if ((typeof A === 'undefined' ? 'undefined' : _typeof(A)) != 'object') throw new Error("seed_array(A) must take array of numbers; is " + (typeof A === 'undefined' ? 'undefined' : _typeof(A))); + gen.init_by_array(A); + }; /***/ }, -/* 140 */ +/* 134 */ /***/ function(module, exports, __webpack_require__) { - var SetCache = __webpack_require__(141), - arraySome = __webpack_require__(144); - - /** Used to compose bitmasks for comparison styles. */ - var UNORDERED_COMPARE_FLAG = 1, - PARTIAL_COMPARE_FLAG = 2; - - /** - * 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 {Function} equalFunc The function to determine equivalents of values. - * @param {Function} customizer The function to customize comparisons. - * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` - * for more details. - * @param {Object} stack Tracks traversed `array` and `other` objects. - * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. - */ - function equalArrays(array, other, equalFunc, customizer, bitmask, stack) { - var isPartial = bitmask & PARTIAL_COMPARE_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) { - return stacked == other; - } - var index = -1, - result = true, - seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined; - - stack.set(array, other); - - // 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 (!seen.has(othIndex) && - (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) { - return seen.add(othIndex); - } - })) { - result = false; - break; - } - } else if (!( - arrValue === othValue || - equalFunc(arrValue, othValue, customizer, bitmask, stack) - )) { - result = false; - break; - } - } - stack['delete'](array); - return result; - } - - module.exports = equalArrays; + var map = { + "./cs-CZ/address/index": 135, + "./cs-CZ/company/index": 139, + "./cs-CZ/index": 140, + "./cs-CZ/internet/index": 147, + "./cs-CZ/names/index": 141, + "./cs-CZ/phone/index": 146, + "./de-DE/address/index": 148, + "./de-DE/company/index": 151, + "./de-DE/index": 152, + "./de-DE/internet/index": 158, + "./de-DE/names/index": 153, + "./de-DE/phone/index": 157, + "./default/address/index": 159, + "./default/company/index": 165, + "./default/date/index": 166, + "./default/entity/index": 168, + "./default/index": 169, + "./default/internet/index": 175, + "./default/lorem/index": 238, + "./default/misc/index": 241, + "./default/names/index": 170, + "./default/phone/index": 174, + "./en-AU/address/index": 247, + "./en-AU/company/index": 249, + "./en-AU/index": 250, + "./en-AU/internet/index": 255, + "./en-AU/names/index": 251, + "./en-AU/phone/index": 254, + "./en-CA/address/index": 256, + "./en-CA/index": 257, + "./en-CA/internet/index": 258, + "./en-CA/phone/index": 259, + "./es-ES/address/index": 260, + "./es-ES/company/index": 264, + "./es-ES/index": 265, + "./es-ES/internet/index": 270, + "./es-ES/names/index": 266, + "./es-ES/phone/index": 269, + "./fr-FR/address/index": 271, + "./fr-FR/company/index": 276, + "./fr-FR/index": 277, + "./fr-FR/internet/index": 282, + "./fr-FR/names/index": 278, + "./fr-FR/phone/index": 281, + "./hu-HU/address/index": 283, + "./hu-HU/company/index": 285, + "./hu-HU/index": 286, + "./hu-HU/internet/index": 292, + "./hu-HU/names/index": 287, + "./hu-HU/phone/index": 291, + "./it-IT/address/index": 293, + "./it-IT/company/index": 298, + "./it-IT/index": 299, + "./it-IT/internet/index": 304, + "./it-IT/names/index": 300, + "./it-IT/phone/index": 303, + "./nb-NO/address/index": 305, + "./nb-NO/company/index": 309, + "./nb-NO/index": 310, + "./nb-NO/internet/index": 316, + "./nb-NO/names/index": 311, + "./nb-NO/phone/index": 315, + "./pl-PL/address/index": 317, + "./pl-PL/company/index": 320, + "./pl-PL/index": 321, + "./pl-PL/internet/index": 326, + "./pl-PL/names/index": 322, + "./pl-PL/phone/index": 325, + "./pt-BR/address/index": 327, + "./pt-BR/company/index": 329, + "./pt-BR/date/index": 330, + "./pt-BR/index": 331, + "./pt-BR/internet/index": 332, + "./pt-BR/names/index": 333, + "./pt-BR/phone/index": 337, + "./ru-RU/address/index": 338, + "./ru-RU/company/index": 342, + "./ru-RU/index": 343, + "./ru-RU/internet/index": 352, + "./ru-RU/names/index": 344, + "./ru-RU/phone/index": 351, + "./sk-SK/address/index": 353, + "./sk-SK/company/index": 357, + "./sk-SK/index": 358, + "./sk-SK/internet/index": 365, + "./sk-SK/names/index": 359, + "./sk-SK/phone/index": 364, + "./sv-SE/address/index": 366, + "./sv-SE/company/index": 368, + "./sv-SE/index": 369, + "./sv-SE/internet/index": 375, + "./sv-SE/names/index": 370, + "./sv-SE/phone/index": 374 + }; + function webpackContext(req) { + return __webpack_require__(webpackContextResolve(req)); + }; + function webpackContextResolve(req) { + return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }()); + }; + webpackContext.keys = function webpackContextKeys() { + return Object.keys(map); + }; + webpackContext.resolve = webpackContextResolve; + module.exports = webpackContext; + webpackContext.id = 134; /***/ }, -/* 141 */ +/* 135 */ /***/ function(module, exports, __webpack_require__) { - var MapCache = __webpack_require__(21), - setCacheAdd = __webpack_require__(142), - setCacheHas = __webpack_require__(143); - - /** - * - * 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 ? values.length : 0; + "use strict"; - this.__data__ = new MapCache; - while (++index < length) { - this.add(values[index]); - } - } + var _countryWithCodes = __webpack_require__(136); - // Add methods to `SetCache`. - SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; - SetCache.prototype.has = setCacheHas; + var _countryWithCodes2 = _interopRequireDefault(_countryWithCodes); - module.exports = SetCache; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + module.exports = { + countryAndCode: function countryAndCode() { + var country = this.random.objectElement(_countryWithCodes2.default); + return { + code: Object.keys(country)[0], + name: country[Object.keys(country)[0]] + }; + }, -/***/ }, -/* 142 */ -/***/ function(module, exports) { - /** Used to stand-in for `undefined` hash values. */ - var HASH_UNDEFINED = '__lodash_hash_undefined__'; + state: [], - /** - * 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; - } + stateAbbr: [], - module.exports = setCacheAdd; + city: __webpack_require__(137), + street: ["#{address.streetName} #{address.buildingNumber}"], -/***/ }, -/* 143 */ -/***/ function(module, exports) { + streetName: __webpack_require__(138), - /** - * 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); - } + buildingNumber: ["#", "##", "###"], - module.exports = setCacheHas; + postCode: ["#####", "### ##", "###-##"] + }; /***/ }, -/* 144 */ +/* 136 */ /***/ function(module, exports) { - /** - * 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 ? array.length : 0; - - while (++index < length) { - if (predicate(array[index], index, array)) { - return true; - } - } - return false; - } - - module.exports = arraySome; - - -/***/ }, -/* 145 */ -/***/ function(module, exports, __webpack_require__) { - - var Symbol = __webpack_require__(96), - Uint8Array = __webpack_require__(85), - equalArrays = __webpack_require__(140), - mapToArray = __webpack_require__(90), - setToArray = __webpack_require__(94); - - /** Used to compose bitmasks for comparison styles. */ - var UNORDERED_COMPARE_FLAG = 1, - PARTIAL_COMPARE_FLAG = 2; + "use strict"; - /** `Object#toString` result references. */ - var boolTag = '[object Boolean]', - dateTag = '[object Date]', - errorTag = '[object Error]', - mapTag = '[object Map]', - numberTag = '[object Number]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]'; - - var arrayBufferTag = '[object ArrayBuffer]', - dataViewTag = '[object DataView]'; - - /** Used to convert symbols to primitives and strings. */ - var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; + module.exports = { + "AF": "Afgh\xE1nist\xE1n", + "AX": "\xC5landy", + "AL": "Alb\xE1nie", + "DZ": "Al\u017E\xEDrsko", + "AS": "Americk\xE1 Samoa", + "VI": "Americk\xE9 Panensk\xE9 ostrovy", + "AD": "Andorra", + "AO": "Angola", + "AI": "Anguilla", + "AQ": "Antarktida", + "AG": "Antigua a Barbuda", + "AR": "Argentina", + "AM": "Arm\xE9nie", + "AW": "Aruba", + "AC": "Ascension", + "AU": "Austr\xE1lie", + "AZ": "\xC1zerb\xE1jd\u017E\xE1n", + "BS": "Bahamy", + "BH": "Bahrajn", + "BD": "Banglad\xE9\u0161", + "BB": "Barbados", + "BE": "Belgie", + "BZ": "Belize", + "BY": "B\u011Blorusko", + "BJ": "Benin", + "BM": "Bermudy", + "BT": "Bh\xFAt\xE1n", + "BO": "Bol\xEDvie", + "BA": "Bosna a Hercegovina", + "BW": "Botswana", + "BR": "Braz\xEDlie", + "IO": "Britsk\xE9 indickooce\xE1nsk\xE9 \xFAzem\xED", + "VG": "Britsk\xE9 Panensk\xE9 ostrovy", + "BN": "Brunej", + "BG": "Bulharsko", + "BF": "Burkina Faso", + "BI": "Burundi", + "EA": "Ceuta a Melilla", + "CK": "Cookovy ostrovy", + "CW": "Cura\xE7ao", + "TD": "\u010Cad", + "ME": "\u010Cern\xE1 Hora", + "CZ": "\u010Cesk\xE1 republika", + "CN": "\u010C\xEDna", + "DK": "D\xE1nsko", + "DG": "Diego Garc\xEDa", + "DM": "Dominika", + "DO": "Dominik\xE1nsk\xE1 republika", + "DJ": "D\u017Eibutsko", + "EG": "Egypt", + "EC": "Ekv\xE1dor", + "ER": "Eritrea", + "EE": "Estonsko", + "ET": "Etiopie", + "FO": "Faersk\xE9 ostrovy", + "FK": "Falklandsk\xE9 ostrovy", + "FJ": "Fid\u017Ei", + "PH": "Filip\xEDny", + "FI": "Finsko", + "FR": "Francie", + "GF": "Francouzsk\xE1 Guyana", + "TF": "Francouzsk\xE1 ji\u017En\xED \xFAzem\xED", + "PF": "Francouzsk\xE1 Polyn\xE9sie", + "GA": "Gabon", + "GM": "Gambie", + "GH": "Ghana", + "GI": "Gibraltar", + "GD": "Grenada", + "GL": "Gr\xF3nsko", + "GE": "Gruzie", + "GP": "Guadeloupe", + "GU": "Guam", + "GT": "Guatemala", + "GG": "Guernsey", + "GN": "Guinea", + "GW": "Guinea-Bissau", + "GY": "Guyana", + "HT": "Haiti", + "HN": "Honduras", + "HK": "Hongkong \u2013 ZAO \u010C\xEDny", + "CL": "Chile", + "HR": "Chorvatsko", + "IN": "Indie", + "ID": "Indon\xE9sie", + "IQ": "Ir\xE1k", + "IR": "\xCDr\xE1n", + "IE": "Irsko", + "IS": "Island", + "IT": "It\xE1lie", + "IL": "Izrael", + "JM": "Jamajka", + "JP": "Japonsko", + "YE": "Jemen", + "JE": "Jersey", + "ZA": "Jihoafrick\xE1 republika", + "GS": "Ji\u017En\xED Georgie a Ji\u017En\xED Sandwichovy ostrovy", + "KR": "Ji\u017En\xED Korea", + "SS": "Ji\u017En\xED S\xFAd\xE1n", + "JO": "Jord\xE1nsko", + "KY": "Kajmansk\xE9 ostrovy", + "KH": "Kambod\u017Ea", + "CM": "Kamerun", + "CA": "Kanada", + "IC": "Kan\xE1rsk\xE9 ostrovy", + "CV": "Kapverdy", + "BQ": "Karibsk\xE9 Nizozemsko", + "QA": "Katar", + "KZ": "Kazachst\xE1n", + "KE": "Ke\u0148a", + "KI": "Kiribati", + "CC": "Kokosov\xE9 ostrovy", + "CO": "Kolumbie", + "KM": "Komory", + "CG": "Kongo \u2013 Brazzaville", + "CD": "Kongo \u2013 Kinshasa", + "XK": "Kosovo", + "CR": "Kostarika", + "CU": "Kuba", + "KW": "Kuvajt", + "CY": "Kypr", + "KG": "Kyrgyzst\xE1n", + "LA": "Laos", + "LS": "Lesotho", + "LB": "Libanon", + "LR": "Lib\xE9rie", + "LY": "Libye", + "LI": "Lichten\u0161tejnsko", + "LT": "Litva", + "LV": "Loty\u0161sko", + "LU": "Lucembursko", + "MO": "Macao \u2013 ZAO \u010C\xEDny", + "MG": "Madagaskar", + "HU": "Ma\u010Farsko", + "MK": "Makedonie", + "MY": "Malajsie", + "MW": "Malawi", + "MV": "Maledivy", + "ML": "Mali", + "MT": "Malta", + "MA": "Maroko", + "MH": "Marshallovy ostrovy", + "MQ": "Martinik", + "MU": "Mauricius", + "MR": "Maurit\xE1nie", + "YT": "Mayotte", + "UM": "Men\u0161\xED odlehl\xE9 ostrovy USA", + "MX": "Mexiko", + "FM": "Mikron\xE9sie", + "MD": "Moldavsko", + "MC": "Monako", + "MN": "Mongolsko", + "MS": "Montserrat", + "MZ": "Mosambik", + "MM": "Myanmar (Barma)", + "NA": "Namibie", + "NR": "Nauru", + "DE": "N\u011Bmecko", + "NP": "Nep\xE1l", + "NE": "Niger", + "NG": "Nig\xE9rie", + "NI": "Nikaragua", + "NU": "Niue", + "NL": "Nizozemsko", + "NF": "Norfolk", + "NO": "Norsko", + "NC": "Nov\xE1 Kaledonie", + "NZ": "Nov\xFD Z\xE9land", + "OM": "Om\xE1n", + "IM": "Ostrov Man", + "PK": "P\xE1kist\xE1n", + "PW": "Palau", + "PS": "Palestinsk\xE1 \xFAzem\xED", + "PA": "Panama", + "PG": "Papua-Nov\xE1 Guinea", + "PY": "Paraguay", + "PE": "Peru", + "PN": "Pitcairnovy ostrovy", + "CI": "Pob\u0159e\u017E\xED slonoviny", + "PL": "Polsko", + "PR": "Portoriko", + "PT": "Portugalsko", + "AT": "Rakousko", + "RE": "R\xE9union", + "GQ": "Rovn\xEDkov\xE1 Guinea", + "RO": "Rumunsko", + "RU": "Rusko", + "RW": "Rwanda", + "GR": "\u0158ecko", + "PM": "Saint-Pierre a Miquelon", + "SV": "Salvador", + "WS": "Samoa", + "SM": "San Marino", + "SA": "Sa\xFAdsk\xE1 Ar\xE1bie", + "SN": "Senegal", + "KP": "Severn\xED Korea", + "MP": "Severn\xED Mariany", + "SC": "Seychely", + "SL": "Sierra Leone", + "SG": "Singapur", + "SK": "Slovensko", + "SI": "Slovinsko", + "SO": "Som\xE1lsko", + "AE": "Spojen\xE9 arabsk\xE9 emir\xE1ty", + "US": "Spojen\xE9 st\xE1ty", + "RS": "Srbsko", + "LK": "Sr\xED Lanka", + "CF": "St\u0159edoafrick\xE1 republika", + "SD": "S\xFAd\xE1n", + "SR": "Surinam", + "SH": "Svat\xE1 Helena", + "LC": "Svat\xE1 Lucie", + "BL": "Svat\xFD Bartolom\u011Bj", + "KN": "Svat\xFD Kry\u0161tof a Nevis", + "MF": "Svat\xFD Martin (Francie)", + "SX": "Svat\xFD Martin (Nizozemsko)", + "ST": "Svat\xFD Tom\xE1\u0161 a Princ\u016Fv ostrov", + "VC": "Svat\xFD Vincenc a Grenadiny", + "SZ": "Svazijsko", + "SY": "S\xFDrie", + "SB": "\u0160alamounovy ostrovy", + "ES": "\u0160pan\u011Blsko", + "SJ": "\u0160picberky a Jan Mayen", + "SE": "\u0160v\xE9dsko", + "CH": "\u0160v\xFDcarsko", + "TJ": "T\xE1d\u017Eikist\xE1n", + "TZ": "Tanzanie", + "TH": "Thajsko", + "TW": "Tchaj-wan", + "TG": "Togo", + "TK": "Tokelau", + "TO": "Tonga", + "TT": "Trinidad a Tobago", + "TA": "Tristan da Cunha", + "TN": "Tunisko", + "TR": "Turecko", + "TM": "Turkmenist\xE1n", + "TC": "Turks a Caicos", + "TV": "Tuvalu", + "UG": "Uganda", + "UA": "Ukrajina", + "UY": "Uruguay", + "UZ": "Uzbekist\xE1n", + "CX": "V\xE1no\u010Dn\xED ostrov", + "VU": "Vanuatu", + "VA": "Vatik\xE1n", + "GB": "Velk\xE1 Brit\xE1nie", + "VE": "Venezuela", + "VN": "Vietnam", + "TL": "V\xFDchodn\xED Timor", + "WF": "Wallis a Futuna", + "ZM": "Zambie", + "EH": "Z\xE1padn\xED Sahara", + "ZW": "Zimbabwe" + }; - /** - * 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 {Function} equalFunc The function to determine equivalents of values. - * @param {Function} customizer The function to customize comparisons. - * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` - * for more details. - * @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, equalFunc, customizer, bitmask, stack) { - switch (tag) { - case dataViewTag: - if ((object.byteLength != other.byteLength) || - (object.byteOffset != other.byteOffset)) { - return false; - } - object = object.buffer; - other = other.buffer; +/***/ }, +/* 137 */ +/***/ function(module, exports) { - case arrayBufferTag: - if ((object.byteLength != other.byteLength) || - !equalFunc(new Uint8Array(object), new Uint8Array(other))) { - return false; - } - return true; - - case boolTag: - case dateTag: - // Coerce dates and booleans to numbers, dates to milliseconds and - // booleans to `1` or `0` treating invalid dates coerced to `NaN` as - // not equal. - return +object == +other; - - case errorTag: - return object.name == other.name && object.message == other.message; - - case numberTag: - // Treat `NaN` vs. `NaN` as equal. - return (object != +object) ? other != +other : object == +other; - - case regexpTag: - case stringTag: - // Coerce regexes to strings and treat strings, primitives and objects, - // as equal. See http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype.tostring - // for more details. - return object == (other + ''); - - case mapTag: - var convert = mapToArray; - - case setTag: - var isPartial = bitmask & PARTIAL_COMPARE_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 |= UNORDERED_COMPARE_FLAG; - stack.set(object, other); + "use strict"; - // Recursively compare objects (susceptible to call stack limits). - return equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack); + module.exports = ["Abertamy", "Adamov", "Andělská Hora", "Aš", "Bakov nad Jizerou", "Bavorov", "Bechyně", "Bečov nad Teplou", "Bělá nad Radbuzou", "Bělá pod Bezdězem", "Benátky nad Jizerou", "Benešov", "Benešov nad Ploučnicí", "Beroun", "Bezdružice", "Bílina", "Bílovec", "Blansko", "Blatná", "Blovice", "Blšany", "Bochov", "Bohumín", "Bohušovice nad Ohří", "Bojkovice", "Bor", "Borohrádek", "Borovany", "Boskovice", "Boží Dar", "Brandýs nad Labem-Stará Boleslav", "Brandýs nad Orlicí", "Brno", "Broumov", "Brtnice", "Brumov-Bylnice", "Bruntál", "Brušperk", "Břeclav", "Březnice", "Březová", "Březová nad Svitavou", "Břidličná", "Bučovice", "Budišov nad Budišovkou", "Budyně nad Ohří", "Buštěhrad", "Bystré", "Bystřice", "Bystřice nad Pernštejnem", "Bystřice pod Hostýnem", "Bzenec", "Chabařovice", "Cheb", "Chlumec", "Chlumec nad Cidlinou", "Choceň", "Chodov", "Chomutov", "Chotěboř", "Chrast", "Chrastava", "Chropyně", "Chrudim", "Chřibská", "Chvaletice", "Chýnov", "Chyše", "Cvikov", "Čáslav", "Čelákovice", "Černošice", "Černošín", "Černovice", "Červená Řečice", "Červený Kostelec", "Česká Kamenice", "Česká Lípa", "Česká Skalice", "Česká Třebová", "České Budějovice", "České Velenice", "Český Brod", "Český Dub", "Český Krumlov", "Český Těšín", "Dačice", "Dašice", "Děčín", "Desná", "Deštná", "Dobrovice", "Dobruška", "Dobřany", "Dobřichovice", "Dobříš", "Doksy", "Dolní Benešov", "Dolní Bousov", "Dolní Kounice", "Dolní Poustevna", "Domažlice", "Dubá", "Dubí", "Dubňany", "Duchcov", "Dvůr Králové nad Labem", "Františkovy Lázně", "Frenštát pod Radhoštěm", "Frýdek-Místek", "Frýdlant", "Frýdlant nad Ostravicí", "Fryšták", "Fulnek", "Golčův Jeníkov", "Habartov", "Habry", "Hanušovice", "Harrachov", "Hartmanice", "Havířov", "Havlíčkův Brod", "Hejnice", "Heřmanův Městec", "Hlinsko", "Hluboká nad Vltavou", "Hlučín", "Hluk", "Hodkovice nad Mohelkou", "Hodonín", "Holešov", "Holice", "Holýšov", "Hora Svaté Kateřiny", "Horažďovice", "Horní Benešov", "Horní Blatná", "Horní Bříza", "Horní Cerekev", "Horní Jelení", "Horní Jiřetín", "Horní Planá", "Horní Slavkov", "Horšovský Týn", "Hořice", "Hořovice", "Hostinné", "Hostivice", "Hostomice", "Hostouň", "Hoštka", "Hradec Králové", "Hradec nad Moravicí", "Hrádek", "Hrádek nad Nisou", "Hranice (okres Cheb)", "Hranice (okres Přerov)", "Hrob", "Hrochův Týnec", "Hronov", "Hrotovice", "Hroznětín", "Hrušovany nad Jevišovkou", "Hulín", "Humpolec", "Husinec", "Hustopeče", "Ivančice", "Ivanovice na Hané", "Jablonec nad Jizerou", "Jablonec nad Nisou", "Jablonné nad Orlicí", "Jablonné v Podještědí", "Jablunkov", "Jáchymov", "Janov", "Janovice nad Úhlavou", "Janské Lázně", "Jaroměř", "Jaroměřice nad Rokytnou", "Javorník", "Jemnice", "Jesenice (okres Rakovník)", "Jeseník", "Jevíčko", "Jevišovice", "Jičín", "Jihlava", "Jilemnice", "Jílové", "Jílové u Prahy", "Jindřichův Hradec", "Jirkov", "Jiříkov", "Jistebnice", "Kadaň", "Kamenice nad Lipou", "Kamenický Šenov", "Kaplice", "Kardašova Řečice", "Karlovy Vary", "Karolinka", "Karviná", "Kasejovice", "Kašperské Hory", "Kaznějov", "Kdyně", "Kelč", "Kladno", "Kladruby", "Klášterec nad Ohří", "Klatovy", "Klecany", "Klimkovice", "Klobouky u Brna", "Kojetín", "Kolín", "Konice", "Kopidlno", "Kopřivnice", "Koryčany", "Kosmonosy", "Kostelec na Hané", "Kostelec nad Černými lesy", "Kostelec nad Labem", "Kostelec nad Orlicí", "Košťany", "Kouřim", "Kožlany", "Králíky", "Kralovice", "Kralupy nad Vltavou", "Králův Dvůr", "Kraslice", "Krásná Hora nad Vltavou", "Krásná Lípa", "Krásné Údolí", "Krásno", "Kravaře", "Krnov", "Kroměříž", "Krupka", "Kryry", "Kunovice", "Kunštát", "Kuřim", "Kutná Hora", "Kyjov", "Kynšperk nad Ohří", "Lanškroun", "Lanžhot", "Lázně Bělohrad", "Lázně Bohdaneč", "Lázně Kynžvart", "Ledeč nad Sázavou", "Ledvice", "Letohrad", "Letovice", "Libáň", "Libčice nad Vltavou", "Liběchov", "Liberec", "Libochovice", "Libušín", "Lipník nad Bečvou", "Lišov", "Litoměřice", "Litomyšl", "Litovel", "Litvínov", "Loket", "Lom", "Lomnice nad Lužnicí", "Lomnice nad Popelkou", "Loštice", "Loučná pod Klínovcem", "Louny", "Lovosice", "Luby", "Lučany nad Nisou", "Luhačovice", "Luže", "Lysá nad Labem", "Manětín", "Mariánské Lázně", "Mašťov", "Měčín", "Mělník", "Městec Králové", "Město Albrechtice", "Město Touškov", "Meziboří", "Meziměstí", "Mikulášovice", "Mikulov", "Miletín", "Milevsko", "Milovice", "Mimoň", "Miroslav", "Mirošov", "Mirotice", "Mirovice", "Mladá Boleslav", "Mladá Vožice", "Mnichovice", "Mnichovo Hradiště", "Mníšek pod Brdy", "Modřice", "Mohelnice", "Moravská Třebová", "Moravské Budějovice", "Moravský Beroun", "Moravský Krumlov", "Morkovice-Slížany", "Most", "Mšeno", "Mýto", "Náchod", "Nalžovské Hory", "Náměšť nad Oslavou", "Napajedla", "Nasavrky", "Nechanice", "Nejdek", "Němčice nad Hanou", "Nepomuk", "Neratovice", "Netolice", "Neveklov", "Nová Bystřice", "Nová Paka", "Nová Role", "Nová Včelnice", "Nové Hrady", "Nové Město na Moravě", "Nové Město nad Metují", "Nové Město pod Smrkem", "Nové Sedlo", "Nové Strašecí", "Nový Bor", "Nový Bydžov", "Nový Jičín", "Nový Knín", "Nymburk", "Nýrsko", "Nýřany", "Odolena Voda", "Odry", "Olešnice", "Olomouc", "Oloví", "Opava", "Opočno", "Orlová", "Osečná", "Osek", "Oslavany", "Ostrava", "Ostrov", "Otrokovice", "Pacov", "Pardubice", "Paskov", "Pec pod Sněžkou", "Pečky", "Pelhřimov", "Petřvald", "Pilníkov", "Písek", "Planá", "Planá nad Lužnicí", "Plánice", "Plasy", "Plesná", "Plumlov", "Plzeň", "Poběžovice", "Počátky", "Podbořany", "Poděbrady", "Podivín", "Pohořelice", "Police nad Metují", "Polička", "Polná", "Postoloprty", "Potštát", "Prachatice", "Praha", "Proseč", "Prostějov", "Protivín", "Přebuz", "Přelouč", "Přerov", "Přeštice", "Příbor", "Příbram", "Přibyslav", "Přimda", "Pyšely", "Rabí", "Radnice", "Rájec-Jestřebí", "Rajhrad", "Rakovník", "Ralsko", "Raspenava", "Rejštejn", "Rokycany", "Rokytnice nad Jizerou", "Rokytnice v Orlických horách", "Ronov nad Doubravou", "Rosice", "Rotava", "Roudnice nad Labem", "Rousínov", "Rovensko pod Troskami", "Roztoky", "Rožďalovice", "Rožmberk nad Vltavou", "Rožmitál pod Třemšínem", "Rožnov pod Radhoštěm", "Rtyně v Podkrkonoší", "Rudná", "Rudolfov", "Rumburk", "Rychnov nad Kněžnou", "Rychnov u Jablonce nad Nisou", "Rychvald", "Rýmařov", "Řevnice", "Říčany", "Sadská", "Sázava", "Seč", "Sedlčany", "Sedlec-Prčice", "Sedlice", "Semily", "Sezemice", "Sezimovo Ústí", "Skalná", "Skuteč", "Slaný", "Slatiňany", "Slavičín", "Slavkov u Brna", "Slavonice", "Slušovice", "Smečno", "Smiřice", "Smržovka", "Soběslav", "Sobotka", "Sokolov", "Solnice", "Spálené Poříčí", "Staňkov", "Staré Město (okres Šumperk)", "Staré Město (okres Uherské Hradiště)", "Stárkov", "Starý Plzenec", "Stochov", "Stod", "Strakonice", "Stráž nad Nežárkou", "Stráž pod Ralskem", "Strážnice", "Strážov", "Strmilov", "Stříbro", "Studénka", "Suchdol nad Lužnicí", "Sušice", "Světlá nad Sázavou", "Svitavy", "Svoboda nad Úpou", "Svratka", "Šenov", "Šlapanice", "Šluknov", "Špindlerův Mlýn", "Šternberk", "Štětí", "Štíty", "Štramberk", "Šumperk", "Švihov", "Tábor", "Tachov", "Tanvald", "Telč", "Teplá", "Teplice", "Teplice nad Metují", "Terezín", "Tišnov", "Toužim", "Tovačov", "Trhové Sviny", "Trhový Štěpánov", "Trmice", "Trutnov", "Třebechovice pod Orebem", "Třebenice", "Třebíč", "Třeboň", "Třemošná", "Třemošnice", "Třešť", "Třinec", "Turnov", "Týn nad Vltavou", "Týnec nad Labem", "Týnec nad Sázavou", "Týniště nad Orlicí", "Uherské Hradiště", "Uherský Brod", "Uherský Ostroh", "Uhlířské Janovice", "Újezd u Brna", "Unhošť", "Uničov", "Úpice", "Úsov", "Ústí nad Labem", "Ústí nad Orlicí", "Úštěk", "Úterý", "Úvaly", "Valašské Klobouky", "Valašské Meziříčí", "Valtice", "Vamberk", "Varnsdorf", "Vejprty", "Velešín", "Velká Bíteš", "Velká Bystřice", "Velké Bílovice", "Velké Hamry", "Velké Meziříčí", "Velké Opatovice", "Velké Pavlovice", "Velký Šenov", "Veltrusy", "Velvary", "Verneřice", "Veselí nad Lužnicí", "Veselí nad Moravou", "Vidnava", "Vimperk", "Vítkov", "Vizovice", "Vlachovo Březí", "Vlašim", "Vodňany", "Volary", "Volyně", "Votice", "Vracov", "Vratimov", "Vrbno pod Pradědem", "Vrchlabí", "Vroutek", "Vsetín", "Všeruby", "Výsluní", "Vysoké Mýto", "Vysoké nad Jizerou", "Vysoké Veselí", "Vyškov", "Vyšší Brod", "Zábřeh", "Zákupy", "Zásmuky", "Zbiroh", "Zbýšov", "Zdice", "Zlaté Hory", "Zlín", "Zliv", "Znojmo", "Zruč nad Sázavou", "Zubří", "Žacléř", "Žamberk", "Žandov", "Žatec", "Ždánice", "Žďár nad Sázavou", "Ždírec nad Doubravou", "Žebrák", "Železná Ruda", "Železnice", "Železný Brod", "Židlochovice", "Žirovnice", "Žlutice", "Žulová"]; - case symbolTag: - if (symbolValueOf) { - return symbolValueOf.call(object) == symbolValueOf.call(other); - } - } - return false; - } +/***/ }, +/* 138 */ +/***/ function(module, exports, __webpack_require__) { - module.exports = equalByTag; + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + module["exports"] = ["17. Listopadu", "17. Listopadu", "28. Pluku", "28. Října", "28. Října", "5. Května", "5. Května", "5. Máje", "7. Května", "8. Listopadu", "9. Května", "Achátová", "Adamova", "Adamovská", "Adélčina", "Africká", "Akademická", "Aksamitova", "Akátová", "Alabastrová", "Albertov", "Albrechtická", "Albánská", "Albíny Hochové", "Aldašínská", "Alej Českých Exulantů", "Aleny Santarové", "Aloisovská", "Aloisovská", "Aloisovská", "Altajská", "Alšovo Nábř.", "Alšovo Nábřeží", "Alšovy Sady", "Alžírská", "Ambrožova", "Americká", "Ametystová", "Amforová", "Amortova", "Ampérova", "Amurská", "Anastázova", "Anderleho", "Andersenova", "Andrštova", "Andělova", "Anenská", "Anenské Nám.", "Anenské Náměstí", "Anežky Malé", "Anežská", "Angelovova", "Anglická", "Angolská", "Anhaltova", "Ankarská", "Anny Drabíkové", "Anny Letenské", "Anny Rybníčkové", "Anny Čížkové", "Anny Čížkové", "Antala Staška", "Antonína Hodného", "Antonína Čermáka", "Antonínská", "Anýzová", "Apolinářská", "Arabská", "Aranžérská", "Arbesovo Nám.", "Arbesovo Náměstí", "Archangelská", "Archeologická", "Archimédova", "Archivní", "Argentinská", "Aristotelova", "Arkalycká", "Armádní", "Armádního Sboru", "Armády", "Arménská", "Arnošta Valenty", "Astlova", "Athénská", "Atletická", "Aubrechtové", "Augustinova", "Augustova", "Austova", "Aviatická", "Axmanova", "Azalková", "Azuritová", "Ašská", "Baarova", "Babická", "Babiččina", "Babočková", "Babská", "Babylonská", "Babákova", "Bachmačské Nám.", "Bachmačské Náměstí", "Bachova", "Bacháčkova", "Badeniho", "Badeniho", "Bajgarova", "Bajkalská", "Bajkonurská", "Bakalářská", "Bakovská", "Bakurinova", "Balabánova", "Balbínova", "Banskobystrická", "Baranova", "Barchovická", "Barešova", "Barrandova", "Barrandovská", "Bartolomějská", "Bartoňkova", "Bartoňova", "Bartoškova", "Bartoškova", "Bartoškova", "Bartákova", "Bartůňkova", "Barunčina", "Barvířská", "Barákova", "Basilejské Nám.", "Basilejské Náměstí", "Bassova", "Batelovská", "Batličkova", "Bavorovská", "Bavorská", "Bazalková", "Bazovského", "Bačetínská", "Baňská", "Baškirská", "Bašteckého", "Baštýřská", "Bažantní", "Beaufortova", "Bechlínská", "Bechyňova", "Bechyňská", "Beckovská", "Bedlová", "Bednářská", "Bedrnova", "Bedřichovská", "Beethovenova", "Beldova", "Belgická", "Bellova", "Bellušova", "Bendlova", "Bendova", "Benecká", "Benediktská", "Benešovská", "Benická", "Benkova", "Benákova", "Benátská", "Benáčanova", "Beníškové", "Beranových", "Bergerova", "Bergmanova", "Berkovská", "Berlínská", "Bermanova", "Bernartická", "Bernolákova", "Berounská", "Bertrámová", "Berylová", "Besední", "Beskydská", "Betlémská", "Betlémské Nám.", "Betlémské Náměstí", "Betáňská", "Bezdrevská", "Bezděkovská", "Bezinková", "Bezová", "Bezprašná", "Bečovská", "Bečvářova", "Bečvářská", "Bečvářská", "Beřkovická", "Bešťákova", "Bieblova", "Binarova", "Biskupcova", "Biskupská", "Biskupský Dvůr", "Blachutova", "Blahníkova", "Blahoslavova", "Blanická", "Blatenská", "Blatnická", "Blatovská", "Blatská", "Blattného", "Blažimská", "Blažkova", "Blažíčkova", "Blešnovská", "Blodkova", "Bludovická", "Blériotova", "Blšanecká", "Bobkova", "Bochovská", "Bodláková", "Bohdalec", "Bohdalec", "Bohdalecká", "Bohdalecká", "Bohdanečská", "Bohdašínská", "Bohnická", "Bohrova", "Bohumínská", "Bohuslava Martinů", "Bohuslava Martinů", "Bohuslava Ze Švamberka", "Bohuslavická", "Bohušovická", "Bohušovická", "Boháčova", "Bohúňova", "Bojanovická", "Bojasova", "Bojetická", "Boješická", "Bojkovická", "Bojovská", "Bojínková", "Bojčenkova", "Bolebořská", "Boleratická", "Boleslavova", "Boleslavská", "Boletická", "Bolevecká", "Bolinská", "Boloňská", "Bolzanova", "Bolívarova", "Borecká", "Borečkova", "Borodinská", "Borotínská", "Borovanská", "Borovanského", "Borovnická", "Borovská", "Borová", "Borošova", "Borská", "Borského", "Boršov", "Boršovská", "Borůvková", "Boseňská", "Botevova", "Botičská", "Botičská", "Boudova", "Bousovská", "Boučkova", "Bouřilova", "Boušova", "Bozděchova", "Boční I", "Boční Ii", "Bořanovická", "Bořetická", "Bořetínská", "Bořivojova", "Bořivojova", "Boříkova", "Bošická", "Bošilecká", "Bošínská", "Božanovská", "Božecká", "Božejovická", "Boženy Hofmeisterové", "Boženy Jandlové", "Boženy Němcové", "Boženy Němcové", "Boženy Stárkové", "Božetická", "Božetěchova", "Božkova", "Božkovská", "Božídarská", "Brabcova", "Bramboříková", "Branaldova", "Brandejsova", "Brandejsovo Nám.", "Brandejsovo Náměstí", "Brandlova", "Brandýská", "Branická", "Branická", "Branické Nám.", "Branické Náměstí", "Branislavova", "Branišovská", "Branská", "Bratislavská", "Bratranců Veverkových", "Bratří Dohalských", "Bratří Venclíků", "Bratří Čapků", "Bratříkovská", "Braunerova", "Braunova", "Braškovská", "Brdecká", "Brdičkova", "Brdlíkova", "Brechtova", "Brechtova", "Brehmova", "Breitcetlova", "Brichtova", "Brigádnická", "Brigádníků", "Brixiho", "Brodecká", "Brodecká", "Brodského", "Bromova", "Bronzová", "Broskvoňová", "Broumarská", "Broumovská", "Brozánská", "Brožíkova", "Brtecká", "Brtnická", "Brumovická", "Brunclíkova", "Brunelova", "Brunnerova", "Bruselská", "Brusinková", "Bruslařská", "Bryksova", "Brzická", "Brzorádových", "Brázdimská", "Brňovská", "Bubenečská", "Bubenečská", "Bubenská", "Bubenské Nábř.", "Bubenské Nábřeží", "Bubeníčkova", "Bublavská", "Bublíkova", "Bubnova", "Bucharova", "Buchlovská", "Buchovcova", "Budapešťská", "Budečská", "Budilova", "Budilovská", "Budovatelská", "Budyňská", "Budyšínská", "Budínova", "Budčická", "Budějovická", "Budějovická", "Bukolská", "Bukovecká", "Bukovinská", "Buková", "Bulharská", "Buližníková", "Bulovka", "Burdova", "Burešova", "Burianova", "Butovická", "Butovická", "Buzulucká", "Buštěhradská", "Bydhošťská", "Bydžovská", "Bydžovského", "Bylanská", "Bystrá", "Bystřická", "Bystřičná", "Byšická", "Byškovická", "Bzenecká", "Bártlova", "Bášťská", "Bílenecké Nám.", "Bílenecké Náměstí", "Bílinská", "Bílkova", "Bílkova", "Bílovská", "Bílá", "Bílčická", "Bínova", "Bítovská", "Böhmova", "Býšovská", "Běchorská", "Běchovická", "Běhounkova", "Bělehradská", "Bělehradská", "Bělehradská", "Bělečská", "Bělinského", "Bělocerkevská", "Bělocká", "Bělohorská", "Bělohorská", "Bělomlýnská", "Bělomlýnská", "Běloveská", "Běluňská", "Bělušická", "Bělásková", "Bělčická", "Bělčická", "Běžecká", "Běžná", "Břeclavská", "Břehová", "Břehová", "Břetislavova", "Břevnovská", "Březanova", "Březecká", "Březenská", "Březinova", "Březiněveská", "Březnická", "Březnová", "Březovická", "Březovského", "Březová", "Břečťanová", "Břežanská", "Břežánecká", "Břidlicová", "Břidličná", "Břízova", "Bříšťanská", "Cafourkova", "Cedrová", "Celetná", "Celniční", "Celsiova", "Cementářská", "Ceplechova", "Cerhenická", "Cerhýnská", "Cetyňská", "Chabařovická", "Chaberská", "Chabeřická", "Chabská", "Chalabalova", "Chaloupeckého", "Chaloupky", "Chaltická", "Chalupkova", "Chalupnická", "Chaplinovo Nám.", "Chaplinovo Náměstí", "Charkovská", "Charlese De Gaulla", "Charvátova", "Chatařská", "Chatová", "Chebská", "Chelčického", "Chemická", "Chilská", "Chittussiho", "Chladírenská", "Chlebovická", "Chlumecká", "Chlumecká", "Chlumecká", "Chlumova", "Chlumínská", "Chlumčanského", "Chlupova", "Chlupáčova", "Chládkova", "Chmelařská", "Chmelická", "Chmelová", "Chmelířova", "Choceradská", "Choceňská", "Chocholouškova", "Chocholova", "Chodecká", "Chodovecké Nám.", "Chodovecké Náměstí", "Chodovická", "Chodovská", "Chodovská", "Chodovská", "Chodská", "Cholupická", "Chomutovická", "Chomutovská", "Chopinova", "Choratická", "Chorošová", "Chorušická", "Chorvatská", "Chotečská", "Chotkova", "Chotouchovská", "Chotouňská", "Chotovická", "Chotutická", "Chotěbuzská", "Chotěnovská", "Chotětovská", "Chotěšovská", "Chovatelská", "Chrastavská", "Chrobolská", "Chrpová", "Chrudimská", "Chráněná", "Chrášťanská", "Chuchelská", "Chudenická", "Chudoměřická", "Churnajevova", "Churáňovská", "Chvaletická", "Chvaletická", "Chvalečská", "Chvalkovická", "Chvalova", "Chvalská", "Chvalská", "Chvalšovická", "Chvatěrubská", "Chvojenecká", "Chyjická", "Chýnická", "Chýnovská", "Chýňská", "Chřibská", "Cibulka", "Cidlinská", "Cigánkova", "Cihelná", "Cihlářova", "Cihlářská", "Cimburkova", "Ciolkovského", "Cirkusová", "Cisterciácká", "Citolibská", "Coriových", "Ctiborova", "Ctiněveská", "Ctiradova", "Ctěnická", "Cukerní", "Cukrovarnická", "Cukrovarská", "Cuřínova", "Cvikovská", "Cvičebná", "Cvrčkova", "Cvrčkova", "Cvrčkova", "Cyprichova", "Cíglerova", "Cílkova", "Cínovecká", "Církova", "Církvická", "Církvičná", "Císařská Louka", "Císařský Ostrov", "Císařský Ostrov", "Císařský Ostrov", "Cítovská", "Daimlerova", "Dalejská", "Dalejská", "Dalešická", "Daliborova", "Dalimilova", "Dalovická", "Dandova", "Danielova", "Dany Medřické", "Darwinova", "Dasnická", "Davelská", "Davidovičova", "Davídkova", "Davídkova", "Dačická", "Dačického", "Daňkova", "Dašická", "Daškova", "Dehtínská", "Dejvická", "Dejvická", "Demlova", "Demoliční", "Desenská", "Destinnové", "Destinové", "Devonská", "Deylova", "Deštná", "Dešťová", "Diabasová", "Diamantová", "Diblíkova", "Diblíkova", "Dienzenhoferovy Sady", "Dieselova", "Diskařská", "Diskařská", "Dismanova", "Dittrichova", "Divadelní", "Divadelní", "Divecká", "Diviznová", "Divišova", "Divišovská", "Divoká Šárka", "Divoká Šárka", "Dlabačov", "Dlabačov", "Dlouhá", "Dlážděná", "Do Blatin", "Do Borovin", "Do Chuchle", "Do Dolnic", "Do Dubin", "Do Dubče", "Do Hlinek", "Do Klukovic", "Do Kopečka", "Do Koutů", "Do Koutů", "Do Lipan", "Do Lipin", "Do Lipin", "Do Luk", "Do Panenek", "Do Podkovy", "Do Polí", "Do Potoků", "Do Píšovic", "Do Roklí", "Do Rybníčků", "Do Svépravic", "Do Vozovny", "Do Vrchu", "Do Vršku", "Do Zahrádek I", "Do Zahrádek I", "Do Zahrádek I", "Do Zahrádek Ii", "Do Zahrádek Ii", "Do Zátiší", "Do Údolí", "Do Újezda", "Do Čertous", "Do Čtvrti", "Do Říčan", "Dobevská", "Dobnerova", "Dobratická", "Dobronická", "Dobronická", "Dobropolská", "Dobrovická", "Dobrovolného", "Dobrovolského", "Dobrovského", "Dobrovízská", "Dobročovická", "Dobrošovská", "Dobrušská", "Dobřanská", "Dobřejovická", "Dobřenická", "Dobřichovská", "Dobšická", "Dobšínská", "Dohalická", "Doksanská", "Dolanská", "Dolejškova", "Doležalova", "Dolina", "Dolnobranská", "Dolnobřežanská", "Dolnocholupická", "Dolnojirčanská", "Dolnokrčská", "Dolnokřeslická", "Dolnomlýnská", "Dolnoměcholupská", "Dolnoměcholupská", "Dolnopočernická", "Dolnočernošická", "Dolní", "Dolní", "Dolní Chaloupky", "Dolomitová", "Dolská", "Dolákova", "Dolínecká", "Dolňanská", "Domanovická", "Domašínská", "Domažlická", "Dominova", "Dominínská", "Domkovská", "Domkářská", "Domousnická", "Donatellova", "Donovalská", "Donská", "Donátova", "Donínská", "Dopplerova", "Dopravní", "Dopraváků", "Dopraváků", "Dostihová", "Dostojevského", "Doubecká", "Doubická", "Doubravická", "Doubravská", "Doubravínova", "Doubravčická", "Doudlebská", "Doudova", "Doupovská", "Dr. Marodyho", "Dr. Zikmunda Wintra", "Dr.Zikmunda Wintra", "Dragounská", "Drahanská", "Drahanská", "Drahelická", "Drahelčická", "Drahobejlova", "Drahorádova", "Drahotická", "Drahotínská", "Drahovská", "Drahovská", "Drahoňovského", "Draženovská", "Draženovská", "Dražetická", "Dražická", "Dražického", "Dražického Nám.", "Dražického Náměstí", "Dražkovská", "Dreyerova", "Drimlova", "Drnovská", "Drobná", "Drtikolova", "Drtinova", "Druhanická", "Druhého Odboje", "Družicová", "Družnosti", "Družná", "Družstevní", "Družstevní Ochoz", "Družstevní Ochoz", "Drážní", "Drůbežnická", "Drůbežářská", "Dubanská", "Dubenecká", "Dubečská", "Dubečské Horky", "Dubinská", "Dubnická", "Dubnova", "Dubovická", "Dubová", "Dubrovnická", "Dubská", "Duchcovská", "Duchoslávka", "Dudkova", "Dudínská", "Duhová", "Dukelská", "Dukelských Hrdinů", "Dunajevského", "Dunajská", "Dunická", "Dunovského", "Durychova", "Durychova", "Dusíkova", "Duškova", "Duškova", "Dušní", "Dušní", "Dvorecká", "Dvorecké Nám.", "Dvorecké Náměstí", "Dvorní", "Dvorská", "Dvoudílná", "Dvouletky", "Dvouramenná", "Dvořeckého", "Dvořišťská", "Dvořákova", "Dvořákovo Nábř.", "Dvořákovo Nábřeží", "Dygrýnova", "Dyjská", "Dykova", "Dářská", "Dürerova", "Dýšinská", "Děbolínská", "Dědická", "Dědinova", "Dědinská", "Děkanská", "Děkanská Vinice I", "Děkanská Vinice Ii", "Dělená", "Dělnická", "Dělostřelecká", "Dětenická", "Dětská", "Dětský Ostrov", "Děvínská", "Děčínská", "Děčínská", "Dřevařská", "Dřevnická", "Dřevná", "Dřevčická", "Dřínovská", "Dřínová", "Dřítenská", "Eberlova", "Ebrova", "Edisonova", "Edvardova", "Egyptská", "Eichlerova", "Einsteinova", "Ejpovická", "Ekonomická", "Eledrova", "Elektrárenská", "Eliášova", "Eliášova", "Elišky Junkové", "Elišky Krásnohorské", "Elišky Krásnohorské", "Elišky Peškové", "Elišky Přemyslovny", "Ellnerové", "Elsnicovo Náměstí", "Emilie Hyblerové", "Emlerova", "Engelmüllerova", "Engelova", "Engelova", "Englerova", "Erbenova", "Erbenova", "Estonská", "Etiopská", "Euklidova", "Evropská", "Evropská", "Evropská", "Evropská", "Evropská", "Evy Olmerové", "Exnárova", "F.V.Veselého", "Fabiánova", "Fabiánská", "Fadějevova", "Fajmanové", "Fajtlova", "Falcká", "Faltysova", "Famfulíkova", "Fantova", "Faradayova", "Farkašova", "Farní", "Farská", "Farského", "Fastrova", "Federova", "Fejfarova", "Felberova", "Fenyklová", "Fetrovská", "Feřtekova", "Fialková", "Fibichova", "Fikerova", "Filipova", "Filipovského", "Filipíny Welserové", "Fillova", "Filmařská", "Filosofská", "Fingerova", "Finkovská", "Finská", "Firkušného", "Fischlova", "Fišerova", "Flemingovo Nám.", "Flemingovo Náměstí", "Flájská", "Flöglova", "Foerstrova", "Folmavská", "Formanská", "Formánkova", "Fořtova", "Fragnerova", "Francouzská", "Francouzská", "Francouzská", "Františka Diviše", "Františka Jansy", "Františka Kadlece", "Františka Křížka", "Františka Černého", "Františka Červeného", "Františka Šimáčka", "Františkova", "Franty Kocourka", "Frančíkova", "Freiwaldova", "Freyova", "Frimlova", "Fričova", "Froncova", "Frostova", "Froňkova", "Frydrychova", "Fryčovická", "Fráni Šrámka", "Frézařská", "Frýdecká", "Frýdlantská", "Fuchsova", "Fügnerovo Nám.", "Fügnerovo Náměstí", "Gabinova", "Gabčíkova", "Gagarinova", "Galandova", "Galileova", "Gallašova", "Galvaniho", "Gaussova", "Gdaňská", "Generála Janouška", "Generála Mejstříka", "Generála Píky", "Generála Šišky", "Generála Šišky", "Gensovská", "Geologická", "Gercenova", "Gerstnerova", "Ginzova", "Glazunovova", "Glinkova", "Glowackého", "Goetheho", "Gogolova", "Golfová", "Gollova", "Golčova", "Gončarenkova", "Gončarenkova", "Gorazdova", "Gotthardská", "Goyova", "Gočárova", "Grafická", "Grafitová", "Grammova", "Granátová", "Gregorova", "Grussova", "Gruzínská", "Gutfreundova", "Gutova", "Gymnasijní", "Gymnastická", "Habartická", "Habartická", "Habartovská", "Haberfeldova", "Habrovská", "Habrová", "Habřická", "Habřická", "Hackerova", "Hadovitá", "Hadravská", "Hajní", "Hakenova", "Halasova", "Halenkovská", "Halštatská", "Hamerská", "Hamplova", "Hamrová", "Hamsíkova", "Hankova", "Hanouškova", "Hanusova", "Hanušova", "Hanzelkova", "Hanzlíkova", "Harantova", "Harcovská", "Harlacherova", "Harmonická", "Harrachovská", "Hartenberská", "Hasičská", "Hasičů", "Hasova", "Hastrmanská", "Haunerova", "Hauptova", "Hausmannova", "Havanská", "Havelská", "Havelská Ulička", "Havlovického", "Havlovického", "Havlovská", "Havlínova", "Havlíčkova", "Havlíčkovo Nám.", "Havlíčkovo Náměstí", "Havlíčkovy Sady", "Havlůjové", "Havlůjové", "Havranická", "Havraní", "Havránkova", "Havířovská", "Havířská", "Haškova", "Hašlerova", "Haštalská", "Haštalské Nám.", "Haštalské Náměstí", "Heckelova", "Heineho", "Heinemannova", "Hejnická", "Hejnická", "Hejplíkova", "Hejtmanská", "Hejtmánkova", "Hekova", "Hekrova", "Heldova", "Heleny Malířové", "Hellichova", "Helmova", "Helsinská", "Helénská", "Hennerova", "Heranova", "Herbenova", "Herdovská", "Herlíkovická", "Hermanická", "Hermelínská", "Hermíny Týrlové", "Heroldovy Sady", "Herrmannova", "Herrova", "Hertzova", "Herálecká I", "Herálecká Ii", "Herálecká Iii", "Herálecká Iv", "Herčíkova", "Hevlínská", "Heydukova", "Heyrovského Nám.", "Heyrovského Nám.", "Heyrovského Náměstí", "Heyrovského Náměstí", "Hečkova", "Heřmanova", "Heřmánková", "Hildy Čihákové", "Hillebrantova", "Hilmarova", "Hiršlova", "Hlavatého", "Hlavenecká", "Hlavní", "Hlavova", "Hlaváčkova", "Hlaváčova", "Hlaďova", "Hledíková", "Hlinská", "Hlivická", "Hlohová", "Hloubětínská", "Hloubětínská", "Hlubocká", "Hluboká", "Hlubočepská", "Hlušičkova", "Hládkov", "Hládkov", "Hlávkova", "Hněvkovská", "Hněvkovského", "Hnězdenská", "Hoblířská", "Hodkovická", "Hodkovská", "Hodonínská", "Hodčina", "Hodějovská", "Hodějovská", "Hoděšovická", "Hofbauerova", "Hoffmannova", "Hokejová", "Hokešovo Nám.", "Hokešovo Náměstí", "Holandská", "Holekova", "Holenická", "Holenská", "Holečkova", "Holečkova", "Holešovické Nábřeží", "Holešovický Přístav", "Holická", "Hollarovo Nám.", "Hollarovo Náměstí", "Holohlavská", "Holotínská", "Holoubkova", "Holoubkovská", "Holubická", "Holubinková", "Holubkova", "Holubova", "Holubí", "Holušická", "Holyňská", "Holátova", "Holínská", "Holýšovská", "Holčovická", "Holšická", "Homolová", "Homérova", "Honzíkova", "Hornická", "Hornocholupická", "Hornocholupická", "Hornofova", "Hornokrčská", "Hornokřeslická", "Hornomlýnská", "Hornoměcholupská", "Hornoměcholupská", "Hornopočernická", "Horní", "Horní Chaloupky", "Horní Hrdlořezská", "Horní Stromky", "Horníčkova", "Horolezecká", "Horoměřická", "Horoměřická", "Horoušanská", "Horoušanská", "Horovo Nám.", "Horovo Náměstí", "Horská", "Horusická", "Horymírovo Nám.", "Horymírovo Náměstí", "Horákova", "Horáčkova", "Horčičkova", "Horňátecká", "Horšovská", "Horšovská", "Hospodářská", "Hostavická", "Hostavická", "Hostinského", "Hostivařská", "Hostivařské Nám.", "Hostivařské Náměstí", "Hostivická", "Hostivítova", "Hostišovská", "Hostouňská", "Hostošova", "Hostýnská", "Hostýnská", "Houbařská", "Houdova", "Hovorčovická", "Hořanská", "Hořejší Náb.", "Hořejší Nábřeží", "Hořejšího", "Hořelická", "Hořická", "Hořovského", "Hořínecká", "Hoškova", "Hoštická", "Hošťálkova", "Hrabačovská", "Hrabákova", "Hrachovská", "Hrad I. Nádvoří", "Hrad Ii. Nádvoří", "Hrad Iii. Nádvoří", "Hradební", "Hradecká", "Hradeckých", "Hradečkova", "Hradešínská", "Hradčanské Nám.", "Hradčanské Náměstí", "Hraniční", "Hrazanská", "Hrazanská", "Hrdinova", "Hrdličkova", "Hrdlořezská", "Hrdoňovická", "Hroncova", "Hronovská", "Hronětická", "Hrozenkovská", "Hroznová", "Hrozného", "Hrubého", "Hrubínova", "Hrudičkova", "Hrusická", "Hruškovská", "Hruškovská", "Hrušovanské Nám.", "Hrušovanské Náměstí", "Hrušovická", "Hrušovská", "Hrušínského", "Hrušňová", "Hrušňová", "Hrádková", "Hráského", "Huberova", "Hubičkova", "Hubáčkova", "Hudcova", "Hudební", "Hudečkova", "Hudečkova", "Hugo Haase", "Hulanova", "Hulická", "Humenecká", "Humpolecká", "Huntířovská", "Hurbanova", "Husařská", "Husinecká", "Husitská", "Husitská", "Husníkova", "Husova", "Husovo Nám.", "Husovo Náměstí", "Hustopečská", "Hutnická", "Huťská", "Hviezdoslavova", "Hviezdoslavova", "Hvozdecká", "Hvozdnická", "Hvozdíková", "Hvožďanská", "Hvězdonická", "Hvězdova", "Hvězdářská", "Hyacintová", "Hybernská", "Hybešova", "Hynaisova", "Hypšmanova", "Hábova", "Hájecká", "Hájenská", "Hájkova", "Hájovna U Podjezdu", "Hájovna V Šárce", "Hájová", "Hájíčkova", "Hájčí", "Hákova", "Hálkova", "Hálova", "Hálův Statek", "Högerova", "Hübnerové", "Hřbitovní", "Hřebenová", "Hřebíkova", "Hřenská", "Hřibojedská", "Hřibská", "Hříbková", "Hřídelecká", "Hůlkova", "Hůlkova", "Hůrská", "Ibsenova", "Imrychova", "Ingrišova", "Internacionální", "Irkutská", "Irská", "Irvingova", "Italská", "Italská", "Italská", "Ivančická", "Izraelská", "Izraelská", "Jabkenická", "Jablonecká", "Jablonecká", "Jablonského", "Jabloňová", "Jablunkovská", "Jagellonská", "Jagellonská", "Jahodnická", "Jahodová", "Jakobiho", "Jakubovská", "Jakubská", "Jakutská", "Jalodvorská", "Jalovcová", "Jaltská", "Jamborova", "Jamská", "Jana Bílka", "Jana Jindřicha", "Jana Karafiáta", "Jana Kašpara", "Jana Marka", "Jana Masaryka", "Jana Ouřady", "Jana Přibíka", "Jana Růžičky", "Jana Srba", "Jana Zajíce", "Jana Čerstvého", "Jana Želivského", "Janderova", "Jandova", "Janečkova", "Jankovcova", "Jankovská", "Janouchova", "Janouškova", "Janovická", "Janovská", "Janovského", "Jansenova", "Janského", "Jansova", "Jantarová", "Janákova", "Janáčkovo Nábř.", "Janáčkovo Nábř.", "Janáčkovo Nábřeží", "Janáčkovo Nábřeží", "Janýrova", "Jančova", "Jarešova", "Jarkovská", "Jarmily Novotné", "Jarní", "Jarníkova", "Jaromíra Jindry", "Jaromíra Vejvody", "Jaromírova", "Jaroměřská", "Jaroslava Foglara", "Jaroslava Švehly", "Jaroslavická", "Jasanová", "Jaselská", "Jaselská", "Jasenická", "Jasenná", "Jasmínová", "Jasná I", "Jasná Ii", "Jaspisová", "Jateční", "Jaurisova", "Jaurisova", "Javorenská", "Javornická", "Javorová", "Javorská", "Javořická", "Jašíkova", "Jažlovická", "Jedlová", "Jednostranná", "Jednostranná", "Jednotného Zemědělského Družstva", "Jednořadá", "Jelenovská", "Jelení", "Jelínkova", "Jemenská", "Jemnická", "Jenerálka", "Jenečská", "Jenišovská", "Jenská", "Jeníkovická", "Jenštejnská", "Jeremenkova", "Jeremenkova", "Jeremenkova", "Jeremiášova", "Jeremiášova", "Jerevanská", "Jeronýmova", "Jeruzalémská", "Jesenická", "Jeseniova", "Jestřebická", "Jetelová", "Jetřichovická", "Jevanská", "Jezdecká", "Jezdovická", "Jezerní", "Jezerská", "Jezevčí", "Ječná", "Jeřabinová", "Jeřabinová", "Jeřická", "Jeřábkova", "Jeřábnická", "Jeřábová", "Ješetická", "Ještědská", "Ježdíkova", "Ježkova", "Ježovická", "Ježovická", "Ježovská", "Jihlavská", "Jihovýchodní I", "Jihovýchodní Ii", "Jihovýchodní Iii", "Jihovýchodní Iv", "Jihovýchodní Ix", "Jihovýchodní V", "Jihovýchodní Vi", "Jihovýchodní Vii", "Jihovýchodní Viii", "Jihozápadní I", "Jihozápadní Ii", "Jihozápadní Iii", "Jihozápadní Iv", "Jihozápadní V", "Jihozápadní Vi", "Jihočeská", "Jilemnická", "Jilemnická", "Jilemnického", "Jilmová", "Jilská", "Jindrova", "Jindřicha Jindřicha", "Jindřicha Plachty", "Jindřichova", "Jindřišská", "Jinolická", "Jinonická", "Jinonická", "Jinočanská", "Jirenská", "Jirečkova", "Jirkovská", "Jirsákova", "Jirsíkova", "Jiránkova", "Jiráskovo Nám.", "Jiráskovo Náměstí", "Jirčanská", "Jiskrova", "Jistebnická", "Jitkovská", "Jitravská", "Jitravská", "Jitrocelová", "Jitřní", "Jivenská", "Jizerská", "Jičínská", "Jičínská", "Jiřická", "Jiřinková", "Jiřiny Štěpničkové", "Jiřská", "Jiřího Jandy", "Jiřího Mašína", "Jiřího Ze Vtelna", "Jiříčkova", "Jiříčkové", "Jižní I", "Jižní Ii", "Jižní Iii", "Jižní Iv", "Jižní Ix", "Jižní Nám.", "Jižní Náměstí", "Jižní Spojka", "Jižní Spojka", "Jižní Spojka", "Jižní Spojka", "Jižní V", "Jižní Vi", "Jižní Vii", "Jižní Viii", "Jižní Xi", "Jižní Xii", "Jižní Xiii", "Jižní Xiv", "Jižní Xv", "Jižní Xvi", "Jižní Xvii", "Johanitská", "Jordana Jovkova", "Jordánská", "Josefa Bíbrdlíka", "Josefa Houdka", "Josefa Houdka", "Josefa Kočího", "Josefa Němce", "Josefa Vašíčka", "Josefa Šimůnka", "Josefská", "José Martího", "Juarézova", "Jugoslávská", "Jugoslávských Partyzánů", "Jugoslávských Partyzánů", "Jungmannova", "Jungmannova", "Jungmannovo Náměstí", "Junácká", "Jupiterova", "Jurkovičova", "Juárezova", "Jzd", "Jáchymova", "Jáchymova", "Jáchymovská", "Jánošíkova", "Jánská", "Jánský Vršek", "Jíchova", "Jílkova", "Jílovická", "Jílovišťská", "Jílovská", "Jílovská", "Jílová", "Jírova", "Jírovcovo Nám.", "Jírovcovo Náměstí", "Jívanská", "Jívová", "K Austisu", "K Avii", "K Barrandovu", "K Bateriím", "K Bažantnici", "K Belvederu", "K Berance", "K Beranovu", "K Berounce", "K Beránku", "K Betonárně", "K Betáni", "K Blatovu", "K Bohnicím", "K Borovíčku", "K Botiči", "K Brance", "K Brnkám", "K Brusce", "K Brusce", "K Brůdku", "K Bílému Vrchu", "K Běchovicům", "K Březince", "K Březiněvsi", "K Břečkám", "K Celinám", "K Cementárně", "K Chabům", "K Chabům", "K Chaloupce", "K Chaloupkám", "K Chatám", "K Chmelnici", "K Chumberku", "K Cihelně", "K Cikánce", "K Cíli", "K Dalejím", "K Dobré Vodě", "K Dobré Vodě", "K Dolům", "K Drahani", "K Drahani", "K Drazdům", "K Drsnici", "K Dubinám", "K Dubovému Mlýnu", "K Dubu", "K Dubči", "K Dálnici", "K Dálnici", "K Dýmači", "K Děrám", "K Fantovu Mlýnu", "K Farkám", "K Fialce", "K Fišpance", "K Habrovce", "K Habru", "K Haltýři", "K Havlínu", "K Hluboké Cestě", "K Hlásku", "K Holyni", "K Holému Vrchu", "K Holému Vrchu", "K Homolce", "K Horkám", "K Horkám", "K Horkám", "K Horním Počernicím", "K Horoměřicům", "K Hořavce", "K Hradišti", "K Hrnčířům", "K Hrušovu", "K Hrušovu", "K Hrázi", "K Hutím", "K Hutím", "K Hutím", "K Hádku", "K Háječku", "K Háji", "K Háji", "K Hájku", "K Hájovně", "K Hájovně", "K Hájovně", "K Hájům", "K Hárunce", "K Interně", "K Jalovce", "K Jasánkám", "K Jelenu", "K Jelenám", "K Jezeru", "K Jezeru", "K Jezu", "K Jezírku", "K Jihu", "K Jihu", "K Jinočanům", "K Jinočanům", "K Jižnímu Městu", "K Juliáně", "K Jízdárně", "K Labeškám", "K Ladům", "K Lahovičkám", "K Lahovské", "K Lažance", "K Lesoparku", "K Lesu", "K Lesu", "K Lesíku", "K Letišti", "K Letňanům", "K Libuši", "K Lindě", "K Lipanům", "K Lipinám", "K Lipám", "K Lochkovu", "K Lomu", "K Louži", "K Luhu", "K Lukám", "K Lučinám", "K Lužinám", "K Ládví", "K Ládví", "K Lánu", "K Lávce", "K Lázním", "K Lípě", "K Markétě", "K Matěji", "K Mejtu", "K Metru", "K Metru", "K Milíčovu", "K Mlíčníku", "K Mlýnu", "K Modřanskému Nádraží", "K Mohyle", "K Moravině", "K Moravině", "K Mostku", "K Mostu", "K Motelu", "K Motolu", "K Mírám", "K Měcholupům", "K Měchurce", "K Nedvězí", "K Netlukám", "K Noskovně", "K Nouzovu", "K Nové Vsi", "K Nové Vsi", "K Nové Škole", "K Novému Dvoru", "K Novému Hradu", "K Novému Sídlišti", "K Novým Domkům", "K Nádraží", "K Nádrži", "K Náhonu", "K Náměstí", "K Náplavce", "K Náplavce", "K Návrší", "K Návrší", "K Návsi", "K Obci", "K Obecním Hájovnám", "K Oboře", "K Obsinám", "K Ochozu", "K Ohradě", "K Okrouhlíku", "K Olympiku", "K Opatřilce", "K Opatřilce", "K Oplocení", "K Orionce", "K Osmidomkům", "K Otočce", "K Ovčínu", "K Ovčínu", "K Padesátníku", "K Palečku", "K Panenkám", "K Parku", "K Pastvinám", "K Pazderkám", "K Pekárně", "K Peluňku", "K Petrově Komoře", "K Pitkovicům", "K Podchodu", "K Podjezdu", "K Podjezdu", "K Polím", "K Pomníku", "K Popelce", "K Popelce", "K Potoku", "K Poště", "K Pramenu", "K Prelátům", "K Prádelně", "K Průhonicům", "K Průhonu", "K Průmstavu", "K Pyramidce", "K Pérovně", "K Pískovně", "K Písnici", "K Přehradám", "K Přejezdu", "K Přístavišti", "K Přívozu", "K Radhošti", "K Radonicům", "K Radotínu", "K Radotínu", "K Remízku", "K Rokli", "K Rokytce", "K Rotundě", "K Rovinám", "K Rozkoši", "K Rozmezí", "K Roztokům", "K Rozvodně", "K Rukavičkárně", "K Rybníku", "K Rybníčku", "K Rybníčkům", "K Rybárně", "K Ryšánce", "K Ryšánce", "K Sadu", "K Safině", "K Samoobsluze", "K Samotě", "K Sedlišti", "K Sibřině", "K Sokolovně", "K Sopce", "K Sopce", "K Starému Bubenči", "K Starému Lomu", "K Stavebninám", "K Sukovu", "K Sádkám", "K Sádkám", "K Sídlišti", "K Sídlišti", "K Teplárně", "K Topolům", "K Topírně", "K Transformátoru", "K Trati", "K Trninám", "K Trnkám", "K Trníčku", "K Truhlářce", "K Tržišti", "K Tuchoměřicům", "K Táboru", "K Třebonicům", "K Třešňovce", "K Tůni", "K Ubytovnám", "K Uhříněvsi", "K Uhříněvsi", "K Učilišti", "K Valu", "K Vejvoďáku", "K Velké Ohradě", "K Velké Ohradě", "K Velkému Dvoru", "K Verneráku", "K Viaduktu", "K Vidouli", "K Vilkám", "K Vinici", "K Vinicím", "K Vinoři", "K Vizerce", "K Višňovce", "K Višňovce", "K Višňovému Sadu", "K Vltavě", "K Vlásence", "K Vodici", "K Vodojemu", "K Vodárně", "K Vodě", "K Vrbičkám", "K Vrbě", "K Vrcholu", "K Vrtilce", "K Vršíčku", "K Vyhlídce", "K Vysoké Cestě", "K Vystrkovu", "K Václavce", "K Vápence", "K Váze", "K Výboru", "K Výtopně", "K Výzkumným Ústavům", "K Větrolamu", "K Zabrkům", "K Zadní Kopanině", "K Zadní Kopanině", "K Zahradnictví", "K Zahradám", "K Zahrádkám", "K Zastávce", "K Zatáčce", "K Zelené Louce", "K Zeleným Domkům", "K Zelenči", "K Zámku", "K Zátiší", "K Závodišti", "K Závorám", "K Závěrce", "K Závětinám", "K Údolí", "K Údolí Hvězd", "K Újezdu", "K Ústavu", "K Úvozu", "K Černošicím", "K Červenému Dvoru", "K Červenému Dvoru", "K Červenému Dvoru", "K Červenému Vrchu", "K Čestlicům", "K Čihadlům", "K Ďáblicům", "K Řece", "K Řeporyjím", "K Řeporyjím", "K Říčanům", "K Šafránce", "K Šafránce", "K Šancím", "K Šeberovu", "K Šeberáku", "K Šedivce", "K Šubrtce", "K Železnici", "K Žižkovu", "Kabeláčova", "Kabešova", "Kabátové", "Kadaňská", "Kadeřávkovská", "Kafkova", "Kahovská", "Kaizlovy Sady", "Kakosova", "Kakostová", "Kalabisova", "Kalašova", "Kalinová", "Kališnická", "Kališťská", "Kalská", "Kalvodova", "Kamelova", "Kamencová", "Kamenická", "Kamenická", "Kamenitá", "Kamenná", "Kameníků", "Kamerunská", "Kampanova", "Kamzíková", "Kamýcká", "Kamýcká", "Kamýcká", "Kanadská", "Kandertova", "Kanovnická", "Kapitulská", "Kaplanova", "Kaplická", "Kapraďová", "Kaprova", "Kaprova", "Kapucínská", "Karafiátová", "Karasova", "Karasovská", "Kardausova", "Kardašovská", "Kardašovská", "Karenova", "Karfíkova", "Karla Engliše", "Karla Hlaváčka", "Karla Kryla", "Karla Křížka", "Karla Michala", "Karla Rachůnka", "Karla Tomáše", "Karla Zicha", "Karla Černého", "Karlická", "Karlova", "Karlovarská", "Karlovarská", "Karlovická", "Karlovo Nám.", "Karlovo Nám.", "Karlovo Náměstí", "Karlovo Náměstí", "Karlínské Nám.", "Karlínské Náměstí", "Karlštejnská", "Karmelitská", "Karolinská", "Karoliny Světlé", "Karpatská", "Kartounářů", "Kartouzská", "Kasalická", "Kateřinská", "Kateřinské Nám.", "Kateřinské Náměstí", "Katovická", "Katusická", "Kavkazská", "Kazaňská", "Kazašská", "Kazimírova", "Kaznějovská", "Kazín", "Kazínská", "Kačerovská", "Kačínská", "Kaňkova", "Kaňkovského", "Kaňovská", "Kašeho", "Kaškova", "Kašovická", "Kašparovo Nám.", "Kašparovo Náměstí", "Kašperská", "Kaštanová", "Kbelská", "Kbelská", "Kbelská", "Kbelská", "Kdoulová", "Ke Březině", "Ke Břvům", "Ke Cvičišti", "Ke Dračkám", "Ke Dráze", "Ke Dvoru", "Ke Džbánu", "Ke Garážím", "Ke Golfu", "Ke Goniu", "Ke Hlásce", "Ke Hrádku", "Ke Hrázi", "Ke Hrázi", "Ke Hřbitovu", "Ke Hřišti", "Ke Kablu", "Ke Kablu", "Ke Kalvárii", "Ke Kaménce", "Ke Kamínce", "Ke Kamýku", "Ke Kapličce", "Ke Kapslovně", "Ke Karlovu", "Ke Kateřinkám", "Ke Kazínu", "Ke Kašně", "Ke Kinu", "Ke Kladivům", "Ke Klimentce", "Ke Klubovně", "Ke Klínku", "Ke Klínku", "Ke Klíčovu", "Ke Koh-I-Nooru", "Ke Kolodějskému Zámku", "Ke Kolodějům", "Ke Kolonii", "Ke Konstruktivě", "Ke Kopečku", "Ke Korunce", "Ke Kostelu", "Ke Kostelíčku", "Ke Kotlářce", "Ke Koulce", "Ke Koupališti", "Ke Kovárně", "Ke Kozím Hřbetům", "Ke Královicům", "Ke Krči", "Ke Krčské Stráni", "Ke Kulišce", "Ke Kulturnímu Domu", "Ke Kurtům", "Ke Kyjovu", "Ke Kálku", "Ke Křížku", "Ke Křížkám", "Ke Lhoteckému Lesu", "Ke Mlýnku", "Ke Mlýnu", "Ke Mlýnu", "Ke Schodům", "Ke Skalce", "Ke Skalkám", "Ke Skladům", "Ke Sklárně", "Ke Skále", "Ke Slatinám", "Ke Slivenci", "Ke Smrčině", "Ke Smíchovu", "Ke Smíchovu", "Ke Splávku", "Ke Spofě", "Ke Spořilovu", "Ke Spálence", "Ke Srážku", "Ke Stadionu", "Ke Stanici", "Ke Starému Hřišti", "Ke Starým Rybníkům", "Ke Stinkovskému Rybníku", "Ke Strašnické", "Ke Strouze", "Ke Stráni", "Ke Strži", "Ke Studni", "Ke Studni", "Ke Studánce", "Ke Stupicím", "Ke Stáčírně", "Ke Stírce", "Ke Střelnici", "Ke Střelnici", "Ke Sv. Izidoru", "Ke Třem Mostům", "Ke Xaverovu", "Ke Zbraslavi", "Ke Zbrojnici", "Ke Zbuzanům", "Ke Zdibům", "Ke Zdravotnímu Středisku", "Ke Zděři", "Ke Zlatému Kopci", "Ke Zličínu", "Ke Znaku", "Ke Zvonici", "Ke Zvoničce", "Ke Školce", "Ke Škole", "Ke Šmejkalu", "Ke Štvanici", "Ke Štítu", "Ke Štěpcům", "Ke Štěrkovně", "Ke Švestkovce", "Kecova", "Kejhova", "Kejnická", "Kellnerova", "Keltská", "Keltů", "Kelvinova", "Kemrova", "Keplerova", "Keplerova", "Keramická", "Kesnerka", "Kestřanská", "Keteňská", "Kettnerova", "Keřová", "Khodlova", "Kischova", "Kišiněvská", "Kladenská", "Kladenská", "Kladenská", "Kladinovská", "Kladrubská", "Kladská", "Klamovka", "Klapkova", "Klapálkova", "Klatovská", "Klausova", "Klecandova", "Klecanská", "Klenečská", "Klenovická", "Klenovská", "Klenová", "Klečkova", "Klečákova", "Klešická", "Klicperova", "Klidná", "Klihařská", "Klikatá", "Klikatá", "Klimentská", "Klivarova", "Kloboukova", "Kloboučnická", "Kloknerova", "Klokotská", "Klostermannova", "Klouzková", "Kludských", "Klukovická", "Klánova", "Klánova", "Klánova", "Klánovická", "Klánovická", "Klárov", "Klášterecká", "Klášterská", "Klášterského", "Klímova", "Klímova", "Klínecká", "Klínovecká", "Klínová", "Klírova", "Klíčanská", "Klíčova", "Klíčovská", "Klíčovská", "Kmochova", "Knínická", "Kněževeská", "Kněžická", "Koberkova", "Kobrova", "Kobyliská", "Kobyliské Nám.", "Kobyliské Náměstí", "Kobylákova", "Kochanova", "Kocianova", "Koclířova", "Kocourova", "Kodaňská", "Kodicilova", "Kodymova", "Kohoutovská", "Kohoutových", "Kojetická", "Kojická", "Kokořínská", "Kolbenova", "Kolbenova", "Kolbenova", "Koldínova", "Kolejní", "Kolektivní", "Kolešovská", "Kollárova", "Kolmistrova", "Kolmá", "Kolocova", "Kolodějská", "Kolonie U Obecní Cihelny", "Kolonka", "Kolovečská", "Kolovratská", "Kolová", "Kolátorova", "Koláčkova", "Koláře Kaliny", "Kolářova", "Kolínova", "Kolínská", "Kolčavka", "Komenského Nám.", "Komenského Náměstí", "Komornická", "Komořanská", "Komořanská", "Komořanská", "Komunardů", "Komárkova", "Komárovská", "Koncová", "Konecchlumského", "Konečná", "Kongresová", "Konojedská", "Konopišťská", "Konopova", "Konopáskova", "Konstantinova", "Konvalinková", "Konviktská", "Konzumní", "Konzumní", "Koníčkovo Nám.", "Koníčkovo Náměstí", "Konětopská", "Koněvova", "Konšelská", "Konžská", "Kopalova", "Kopanina", "Kopanská", "Kopeckého", "Koperníkova", "Kopečná", "Kopretinová", "Kopřivnická", "Korandova", "Korandova", "Korunní", "Korunní", "Korunní", "Korunovační", "Korunovační", "Korybutova", "Korycanská", "Korytná", "Kosatcová", "Kosařova", "Kosmická", "Kosmonoská", "Kosova", "Kosořická", "Kosořská", "Kostelecká", "Kostelecká", "Kostelní", "Kostelní Náměstí", "Kostečná", "Kostková", "Kostlivého", "Kostnické Nám.", "Kostnické Náměstí", "Kostomlatská", "Kostrbova", "Kostřínská", "Kosárkovo Nábř.", "Kosárkovo Nábřeží", "Kosí", "Koterovská", "Koterovská", "Kotevní", "Kotlaska", "Kotlářka", "Kotorská", "Kotovka", "Kotrčová", "Kotršálova", "Kotíkova", "Kotěrova", "Koubkova", "Koubkova", "Koubova", "Koukolová", "Koulka", "Koulova", "Kounická", "Kounovská", "Koutská", "Kouřimská", "Kovanecká", "Kovařovicova", "Kovriginova", "Kováků", "Kovárenská", "Kovářova", "Kovářská", "Kováříkova", "Kozinova", "Kozinovo Náměstí", "Kozlova", "Kozlovská", "Kozmíkova", "Kozomínská", "Kozácká", "Kozákovská", "Kozáková", "Kozí", "Kočova", "Kořenského", "Košařova", "Košická", "Koštířova", "Košátecká", "Košíkářská", "Košířské Nám.", "Košířské Náměstí", "Košťálkova", "Koťátkova", "Koželužská", "Kožlanská", "Kožná", "Kožíškova", "Kpt. Nálepky", "Kpt. Stránského", "Krabošická", "Krahulčí", "Krajanská", "Krajní", "Krajová", "Krajánkova", "Krakovská", "Kralická", "Kralupská", "Krameriova", "Kramlova", "Kramolná", "Kramolínská", "Kramperova", "Kraslická", "Krasnická", "Krasnojarská", "Kratochvílova", "Krausova", "Krbická", "Krchlebská", "Krejnická", "Krejčího", "Kremličkova", "Kremnická", "Kremnická", "Krhanická", "Krhanická", "Kristiánova", "Kriváňská", "Krkonošská", "Krnovská", "Krnská", "Krocínova", "Krocínovská", "Kroftova", "Krohova", "Krokova", "Krolmusova", "Kropáčkova", "Krosenská", "Kroupova", "Kroupova", "Krouzova", "Krovova", "Krteňská", "Kruhová", "Krumlovská", "Krupkovo Nám.", "Krupkovo Náměstí", "Krupná", "Krupská", "Krušovická", "Kružberská", "Krylovecká", "Krylovecká", "Krymská", "Krynická", "Krystalová", "Kryšpínova", "Kryštofova", "Krále Václava Iv.", "Králodvorská", "Králova", "Královická", "Královny Žofie", "Královská Obora", "Královská Obora", "Krásnolipská", "Krásného", "Krásova", "Krátká", "Krátká", "Krátkého", "Krátký Lán", "Krčmářovská", "Krčská", "Krčínovo Nám.", "Krčínovo Náměstí", "Krčínská", "Krňovická", "Krškova", "Kubatova", "Kubaštova", "Kubelíkova", "Kubišova", "Kubištova", "Kubova", "Kubánské Nám.", "Kubánské Náměstí", "Kubíkova", "Kubínova", "Kuchařská", "Kudeříkové", "Kudrnova", "Kukelská", "Kukelská", "Kukulova", "Kukulova", "Kukučínova", "Kulhavého", "Kulhánkovská", "Kuncova", "Kundratka", "Kunešova", "Kunická", "Kunratická", "Kunratická Spojka", "Kunratická Spojka", "Kuní", "Kuní", "Kunínova", "Kunčická", "Kunětická", "Kupeckého", "Kupkova", "Kurandové", "Kurkova", "Kurta Konráda", "Kurzova", "Kurčatovova", "Kusá", "Kusého", "Kutilova", "Kutnauerovo Náměstí", "Kutnohorská", "Kutnohorská", "Kutrovická", "Kuttelwascherova", "Kutvirtova", "Kučerova", "Kučerové", "Kuťatská", "Kuželova", "Kvapilova", "Kvasinská", "Kvestorská", "Květinková", "Květinářská", "Květnická", "Květnová", "Květnového Povstání", "Květnového Povstání", "Květnového Vítězství", "Květnového Vítězství", "Květná", "Květoslavova", "Květová", "Kyjevská", "Kyjevská", "Kyjovská", "Kyjská", "Kyjská", "Kykalova", "Kymrova", "Kynická", "Kyselova", "Kyslíková", "Kysucká", "Kysúcká", "Kytlická", "Kytínská", "Kácovská", "Kádnerova", "Kálikova", "Kálmánova", "Káranská", "Křejpského", "Křelovická", "Křemelná", "Křemencova", "Křemenná", "Křemenáčová", "Křemílkova", "Křenická", "Křenova", "Křepelčí", "Křepelčí", "Křesadlova", "Křesanovská", "Křeslická", "Křesomyslova", "Křešínská", "Křimická", "Křimovská", "Křivatcová", "Křivenická", "Křivoklátská", "Křivá", "Křičkova", "Křišťanova", "Křišťálová", "Křižovnická", "Křižovnické Nám.", "Křižovnické Náměstí", "Křižíkova", "Křižíkova", "Křovinovo Nám.", "Křovinovo Náměstí", "Křtinská", "Kříženeckého Nám.", "Kříženeckého Náměstí", "Křížkovského", "Křížová", "Křížová", "Labská", "Labětínská", "Ladislava Coňka", "Ladova", "Laglerové", "Lahovská", "Lahovská", "Lamačova", "Langweilova", "Lannova", "Lanýžová", "Lanžhotská", "Lanžovská", "Laténská", "Laubova", "Laudonova", "Laudova", "Laurinova", "Lazarská", "Lazarská", "Lačnovská", "Lažanská", "Lažanská", "Lažanského", "Lebeděvova", "Ledařská", "Ledecká", "Ledečská", "Ledkovská", "Lednická", "Lednová", "Ledvická", "Ledvinova", "Ledč", "Ledčická", "Legerova", "Legerova", "Legerova", "Legerova", "Legionářů", "Lehárova", "Leitzova", "Leknínová", "Leopoldova", "Leskovecká", "Lesnická", "Lesného", "Lesní", "Lessnerova", "Lesáků", "Letců", "Letecká", "Letenská", "Letenské Nám.", "Letenské Nám.", "Letenské Náměstí", "Letenské Náměstí", "Letenské Sady", "Letní", "Letohradská", "Letovská", "Letňanská", "Letňanská", "Levandulová", "Levobřežní", "Levského", "Levá", "Lexova", "Lečkova", "Lešanská", "Lešenská", "Lešetínská", "Lešovská", "Leštínská", "Lhenická", "Lhotecká", "Lhotecká", "Lhotská", "Lhotákova", "Liberecká", "Liberijská", "Libečkova", "Libeňská", "Libeňský Ostrov", "Libeňský Ostrov", "Libeřská", "Libichovská", "Libická", "Libišanská", "Libišská", "Libkovská", "Liblická", "Liblická", "Libochovická", "Libocká", "Liborova", "Libotovská", "Libovická", "Libočanská", "Liboňovská", "Libošovická", "Libuňská", "Libušina", "Libušská", "Libušská", "Libušská", "Libušská", "Libáňská", "Libínská", "Libčanská", "Libčická", "Liběchovská", "Libědická", "Liběšická", "Libřická", "Lichá", "Lidečská", "Lidická", "Lidického", "Lihovarská", "Liliová", "Lilková", "Limuzská", "Limuzská", "Lindavská", "Lindleyova", "Lindnerova", "Linhartova", "Linhartská", "Lipanská", "Lipecká", "Lipenecká", "Lipenská", "Lipenská", "Lipenské Nám.", "Lipenské Náměstí", "Lipnická", "Lipoltická", "Lipovická", "Lipovská", "Lipová Alej", "Lipové Náměstí", "Lipského", "Lipí", "Lisabonská", "Lisabonská", "Listopadová", "Lisztova", "Litavská", "Litevská", "Litická", "Litochlebská", "Litoměřická", "Litoměřická", "Litovická", "Litošická", "Litošická", "Litožnická", "Litvínovská", "Litvínovská", "Livornská", "Lišanská", "Lišická", "Liškova", "Lišovická", "Liščí", "Liščí", "Lnářská", "Lobečská", "Lochenická", "Lochkovská", "Lochotínská", "Lodecká", "Lodní Mlýny", "Loděnická", "Lodžská", "Lodžská", "Lohenická", "Lohniského", "Lojovická", "Lojovická", "Lojovická", "Lolkova", "Lomařská", "Lomecká", "Lomená", "Lomnická", "Lomnického", "Lomová", "Londýnská", "Loosova", "Lopatecká", "Lopatecká", "Lopuchová", "Loretánská", "Loretánské Nám.", "Loretánské Náměstí", "Losinská", "Lotyšská", "Loucká", "Loudova", "Lounská", "Lounských", "Loutkářská", "Loučanská", "Loučimská", "Loučná", "Louňovická", "Lovecká", "Lovosická", "Lovosická", "Lovosická", "Lovčenská", "Lovčická", "Lozická", "Lošetická", "Lošáková", "Lstibořská", "Lubenecká", "Lublaňská", "Lublaňská", "Lublinská", "Lubnická", "Lucemburská", "Lucemburská", "Lucinková", "Ludmilina", "Ludvíkova", "Luhovská", "Lukavecká", "Lukavského", "Lukešova", "Lukešova", "Lukovská", "Lukášova", "Lumiérů", "Lumírova", "Lumírova", "Luníkovská", "Lupenická", "Lupáčova", "Lutínská", "Luční", "Luštěnická", "Lužanská", "Lužecká", "Lužická", "Lužnická", "Lužná", "Lužní", "Lužská", "Lvovská", "Lysinská", "Lysolajská", "Lysolajské Údolí", "Lyčkovo Nám.", "Lyčkovo Náměstí", "Lyžařská", "Ládevská", "Lánovská", "Lánská", "Lásenická", "Láskova", "Lázeňská", "Lékařská", "Lékořicová", "Líbalova", "Líbeznická", "Lípová", "Lískovická", "Lísková", "Líšnická", "Lýskova", "M. J. Lermontova", "Macešková", "Macharovo Nám.", "Macharovo Náměstí", "Machatého", "Machkova", "Machnova", "Machovcova", "Machovická", "Machovská", "Machuldova", "Macháčkova", "Madarova", "Madaťjanova", "Madridská", "Magd. Rettigové", "Magdalény Rettigové", "Magistrů", "Magnitogorská", "Mahenova", "Mahlerovy Sady", "Mahulenina", "Maiselova", "Maiselova", "Majerové", "Majerského", "Makedonská", "Makovská", "Makovského", "Maková", "Malachitová", "Malebná", "Malenická", "Malešická", "Malešická", "Malešická", "Malešické Nám.", "Malešické Náměstí", "Malešovská", "Malinová", "Maličká", "Malkovského", "Malletova", "Malletova", "Malobřevnovská", "Malostranské Nábř.", "Malostranské Nábřeží", "Malostranské Náměstí", "Malotická", "Malovická", "Maltézské Nám.", "Maltézské Náměstí", "Malá", "Malá Bylanská", "Malá Houdova", "Malá Klášterní", "Malá Lada", "Malá Michnovka", "Malá Plynární", "Malá Skloněná", "Malá Smidarská", "Malá Tyršovka", "Malá Xaveriova", "Malá Štupartská", "Malá Štěpánská", "Malátova", "Malé Nám.", "Malé Náměstí", "Malého", "Malínská", "Malířská", "Malý Dvůr", "Malý Okrouhlík", "Malšovická", "Malšovské Nám.", "Malšovské Náměstí", "Mandloňová", "Mandova", "Mansfeldova", "Manská Zahrada", "Mantovská", "Manželů Dostálových", "Manželů Kotrbových", "Manželů Lyčkových", "Marciho", "Marešova", "Marie Cibulkové", "Marie Podvalové", "Mariánská", "Mariánská", "Mariánské Hradby", "Mariánské Hradby", "Mariánské Nám.", "Mariánské Náměstí", "Markova", "Markupova", "Markušova", "Markvartická", "Markyta", "Markétská", "Maroldova", "Martinelliho", "Martinická", "Martinova", "Martinovská", "Martinská", "Marty Krásové", "Marvanova", "Maršovská", "Masarykovo Nábř.", "Masarykovo Nábř.", "Masarykovo Nábřeží", "Masarykovo Nábřeží", "Masná", "Matek", "Matenská", "Maternova", "Mateřská", "Mateřídoušková", "Matjuchinova", "Matoušova", "Mattioliho", "Matúškova", "Matěchova", "Matějkova", "Matějovského", "Matějská", "Maxovská", "Mazancova", "Mazovská", "Mazurská", "Maďarská", "Maňákova", "Mařatkova", "Mařákova", "Maříkova", "Mašatova", "Maškova", "Mašovická", "Maštěřovského", "Mašínova", "Mechovka", "Mechová", "Medinská", "Medkova", "Medlovská", "Medová", "Meduňková", "Meinlinova", "Mejstříkova", "Melantrichova", "Meliorační", "Melodická", "Melounová", "Menclova", "Mendelova", "Mendíků", "Menšíkova", "Menšíkovská", "Merhoutova", "Merkurova", "Meruňková", "Meskářova", "Meteorologická", "Meteorologická", "Metodějova", "Metujská", "Mexická", "Mezi Chatami", "Mezi Domky", "Mezi Domy", "Mezi Humny", "Mezi Lysinami", "Mezi Lány", "Mezi Poli", "Mezi Potoky", "Mezi Rolemi", "Mezi Rybníky", "Mezi Sklady", "Mezi Stráněmi", "Mezi Vodami", "Mezi Úvozy", "Mezi Školami", "Mezibranská", "Mezihorská", "Mezihoří", "Mezilehlá", "Mezilesní", "Mezilesí", "Meziluží", "Mezipolí", "Mezitraťová", "Mezitraťová", "Mezitraťová", "Mezivrší", "Meziškolská", "Mečislavova", "Mečovská", "Mečíková", "Michalovicova", "Michalská", "Michelangelova", "Michelská", "Michelská", "Michnova", "Michnovka", "Mickiewiczova", "Mikanova", "Mikova", "Mikovcova", "Mikovická", "Mikulandská", "Mikuleckého", "Mikulova", "Mikulovická", "Mikuláše Z Husi", "Mikulášská", "Mikulčická", "Mikšovského", "Milady Horákové", "Milady Horákové", "Milady Horákové", "Milady Horákové", "Milady Horákové", "Milana Kadlece", "Milenovská", "Milerova", "Miletická", "Miletínská", "Milevská", "Milevská", "Milešovská", "Milotická", "Milovická", "Milovická", "Milánská", "Milínská", "Milíčova", "Milíčovská", "Mimoňská", "Minaříkova", "Minerální", "Minická", "Minská", "Miranova", "Miroslava Hajna", "Miroslava Hamra", "Mirotická", "Mirotická", "Mirovická", "Mirošovická", "Mirošovská", "Mistrovská", "Mistřínská", "Miřetická", "Miškovická", "Mladenovova", "Mladoboleslavská", "Mladoboleslavská", "Mladoboleslavská", "Mladoboleslavská", "Mladoboleslavská", "Mladotická", "Mladotova", "Mladých", "Mladých Běchovic", "Mladčina", "Mladějovská", "Mlynářská", "Mládeže", "Mládežnická", "Mládkova", "Mládí", "Mlázovická", "Mlékárenská", "Mlýnská", "Mlýnská", "Mnichovická", "Mochovská", "Mochovská", "Modenská", "Modlanská", "Modletická", "Modletínská", "Modravská", "Modrá", "Modrého", "Modřanská", "Modřanská", "Modřanská", "Modřanská", "Modřínová", "Mohelnická", "Mohylová", "Mojmírova", "Mokrá", "Mokřanská", "Moldavská", "Molitorovská", "Molákova", "Mongolská", "Moravanská", "Moravanů", "Moravská", "Morseova", "Morstadtova", "Morušová", "Morušová", "Morávkova", "Moskevská", "Mostecká", "Motolská", "Moulíkova", "Moysesova", "Mozambická", "Mozartova", "Mošnova", "Možného", "Mramorová", "Mratínská", "Mračnická", "Mrkosova", "Mrkvičkova", "Mrákovská", "Mrázkova", "Mrázovka", "Mráčkova", "Mrštíkova", "Mrštíkova", "Muchomůrková", "Muchova", "Mukařovská", "Mukařovského", "Murgašova", "Murmanská", "Musilova", "Musorgského", "Musílkova", "Mutěnínská", "Muzejní", "Muzikova", "Muškova", "Mydlářka", "Myjavská", "Mylnerovka", "Myslbekova", "Myslbekova", "Myslivecká", "Myslivečkova", "Myslíkova", "Myslíkova", "Myšlínská", "Máchova", "Máchova", "Mádrova", "Májovková", "Májová", "Málkovská", "Mánesova", "Márova", "Máslova", "Máslovická", "Mátová", "Mílovská", "Mílová", "Mírová", "Mírového Hnutí", "Mírového Hnutí", "Místecká", "Míčova", "Míšeňská", "Míšovická", "Münzbergerových", "Mýtní", "Měchenická", "Měcholupská", "Měděnecká", "Mělická", "Mělnická", "Městská", "Měsíčková", "Měsíční", "Měšická", "Měšínská", "Mšecká", "Mšenská", "N. A. Někrasova", "Na Babách", "Na Babě", "Na Bahnech", "Na Balkáně", "Na Balkáně", "Na Bambouzku", "Na Baních", "Na Barikádách", "Na Bartoňce", "Na Bateriích", "Na Bateriích", "Na Bačálkách", "Na Baště Sv. Jiří", "Na Baště Sv. Ludmily", "Na Baště Sv. Tomáše", "Na Bendovce", "Na Benátkách", "Na Beránce", "Na Betonce", "Na Bečvářce", "Na Bitevní Pláni", "Na Blanici", "Na Blanseku", "Na Blatech", "Na Bluku", "Na Bohdalci", "Na Bojišti", "Na Boleslavce", "Na Borovém", "Na Botiči", "Na Botě", "Na Božkovně", "Na Brabenci", "Na Brázdě", "Na Bučance", "Na Bělici", "Na Bělidle", "Na Bělohorské Pláni", "Na Břehu", "Na Břevnovské Pláni", "Na Březince", "Na Celné", "Na Cestě", "Na Chmelnici", "Na Chobotě", "Na Chodovci", "Na Chvalce", "Na Chvalské Tvrzi", "Na Cihelně", "Na Cihlářce", "Na Cikorce", "Na Cikánce", "Na Cimbále", "Na Cípu", "Na Císařce", "Na Dionysce", "Na Dlouhé Mezi", "Na Dlouhé Mezi", "Na Dlouhé Mezi", "Na Dlouhé Mezi", "Na Dlouhém Lánu", "Na Dlážděnce", "Na Dlážděnce", "Na Dlážděnce", "Na Dlážděnce", "Na Dobešce", "Na Dobré Vodě", "Na Dolinách", "Na Dolinách", "Na Dolnici", "Na Dolíku", "Na Domovině", "Na Doubkové", "Na Drahách", "Na Dračkách", "Na Dračkách", "Na Dražkách", "Na Dubině", "Na Dvorcích", "Na Dyrince", "Na Dílcích", "Na Dílech", "Na Dědince", "Na Dědinách", "Na Děkance", "Na Děkance", "Na Dělostřílnách", "Na Džbánu", "Na Fabiánce", "Na Farkách", "Na Farkáně I", "Na Farkáně Ii", "Na Farkáně Iii", "Na Farkáně Iv", "Na Fialce I", "Na Fialce Ii", "Na Fidlovačce", "Na Fišerce", "Na Florenci", "Na Florenci", "Na Floře", "Na Folimance", "Na Formance", "Na Františku", "Na Groši", "Na Habrovce", "Na Habrové", "Na Hanspaulce", "Na Harfě", "Na Havránce", "Na Hlavní", "Na Hlinách", "Na Hloubětínské Vinici", "Na Hlídce", "Na Holém Vrchu", "Na Homolce", "Na Homoli", "Na Horce", "Na Horkách", "Na Hradním Vodovodu", "Na Hranicích", "Na Hranicích", "Na Hrobci", "Na Hroudě", "Na Hroudě", "Na Hrádku", "Na Hrázi", "Na Hubálce", "Na Humnech", "Na Hupech", "Na Hutmance", "Na Hutích", "Na Hutích", "Na Hvížďalce", "Na Hvězdárně", "Na Hádku", "Na Hájku", "Na Hřebenech I", "Na Hřebenech Ii", "Na Hřebenech Ii", "Na Hřebenkách", "Na Hůrce", "Na Jabloňce", "Na Jabloňce", "Na Jahodách", "Na Jarově", "Na Jelenách", "Na Jelenách", "Na Jetelce", "Na Jetelce", "Na Jezerce", "Na Jezerách", "Na Jitřence", "Na Jivinách", "Na Julisce", "Na Jílech", "Na Jílu", "Na Kameni", "Na Kampě", "Na Kapličce", "Na Karlovce", "Na Kavčích Horách", "Na Kazance", "Na Kačence", "Na Kačerově", "Na Kindlovce", "Na Klaudiánce", "Na Klaudiánce", "Na Kleovce", "Na Klikovce", "Na Klimentce", "Na Klášterním", "Na Klínech", "Na Klínech", "Na Klínku", "Na Knížce", "Na Kocourkách", "Na Kocínce", "Na Kodymce", "Na Kolejním Statku", "Na Komořsku", "Na Komořsku", "Na Konci", "Na Konečné", "Na Konvářce", "Na Kopanině", "Na Kopci", "Na Kopečku", "Na Kopytářce", "Na Korunce", "Na Korábě", "Na Korálově", "Na Kotlářce", "Na Koupaliště", "Na Kovárně", "Na Kozačce", "Na Kozinci", "Na Košince", "Na Košíku", "Na Kraji", "Na Krocínce", "Na Krutci", "Na Královce", "Na Královně", "Na Krčské Stráni", "Na Kuthence", "Na Kvintusce", "Na Květnici", "Na Kyjově", "Na Křemínku", "Na Křenkově", "Na Křečku", "Na Křivce", "Na Křivce", "Na Křivce", "Na Křivině", "Na Křtině", "Na Křídle", "Na Labuťce", "Na Labuťce I", "Na Labuťce Ii", "Na Labuťce Iii", "Na Labuťce Iv", "Na Ladách", "Na Lahovské", "Na Laurové", "Na Lepším", "Na Lhotech", "Na Lhotkách", "Na Libušince", "Na Losách", "Na Louce", "Na Loukoti", "Na Louži", "Na Loužku", "Na Luka", "Na Lukách", "Na Luzích", "Na Lučinách", "Na Lužci", "Na Lysinách", "Na Lysině", "Na Ládví", "Na Lánech", "Na Lávce", "Na Lázeňce", "Na Líše", "Na Malovance", "Na Malé Šárce", "Na Malém Klínu", "Na Maninách", "Na Manoušce", "Na Markvartce", "Na Marně", "Na Mezi", "Na Mlejnku", "Na Moklině", "Na Mokřině", "Na Moráni", "Na Močále", "Na Mrázovce", "Na Musilech", "Na Mírách", "Na Míčánce", "Na Míčánkách", "Na Mýtě", "Na Můstku", "Na Neklance", "Na Nežárce", "Na Nivách", "Na Novině", "Na Nové Silnici", "Na Náspu", "Na Návrati", "Na Návrší", "Na Návsi", "Na Obrátce", "Na Obrátce", "Na Odbočce", "Na Ohradě", "Na Okraji", "Na Okraji", "Na Okrouhlíku", "Na Okruhu", "Na Opyši", "Na Opyši", "Na Ostrohu", "Na Ostrově", "Na Ostrůvku", "Na Ovesníku", "Na Ovčinách", "Na Ovčáckém", "Na Ovčíně", "Na Ořechovce", "Na Padesátníku I", "Na Padesátníku Ii", "Na Padesátníku Iii", "Na Padesátníku Iv", "Na Padesátníku V", "Na Padesátém", "Na Pahorku", "Na Pahoubce", "Na Palouku", "Na Paloučku", "Na Pankráci", "Na Panorámě", "Na Parcelách", "Na Parkáně", "Na Parukářce", "Na Pasece", "Na Pasece", "Na Pastvinách", "Na Pavím Vrchu", "Na Pazderce", "Na Pecích", "Na Pernikářce", "Na Perštýně", "Na Petynce", "Na Petynce", "Na Petřinách", "Na Petřinách", "Na Placích", "Na Planině", "Na Plužině", "Na Plzeňce", "Na Plácku", "Na Pláni", "Na Plískavě", "Na Podkovce", "Na Pokraji", "Na Pokraji", "Na Poli", "Na Polníku", "Na Pomezí", "Na Pomezí", "Na Popelce", "Na Popelce", "Na Potůčku", "Na Poustkách", "Na Pozorce", "Na Poříčním Právu", "Na Poříčí", "Na Poříčí", "Na Požáru", "Na Požáru", "Na Pramenech", "Na Pramenech", "Na Prosecké Vyhlídce", "Na Proseku", "Na Prostřední Cestě", "Na Proutcích", "Na Provaznici", "Na Průhonu", "Na Průseku", "Na Pučálce", "Na Pískovně", "Na Písku", "Na Pískách", "Na Pěkné Vyhlídce", "Na Pěšinách", "Na Pěšinách", "Na Pěšině", "Na Předevsi", "Na Přesypu", "Na Přesypu", "Na Přídole", "Na Příkopě", "Na Příkopě", "Na Přívozích", "Na Příčce", "Na Příčné Mezi", "Na Radosti", "Na Radosti", "Na Rampách", "Na Rejdišti", "Na Roháčku", "Na Rokytce", "Na Rolích", "Na Rovinách", "Na Rovině", "Na Rovni", "Na Rovnosti", "Na Rovném", "Na Rozcestí", "Na Rozdílu", "Na Rozdílu", "Na Rozhledu", "Na Rozhraní", "Na Rozhraní", "Na Rozvodí", "Na Ročkově", "Na Rybníčku", "Na Rybářce", "Na Rybářce", "Na Rymáni", "Na Rynku", "Na Salabce", "Na Samotě", "Na Schodech", "Na Schůdkách", "Na Sedlišti", "Na Sekyrce", "Na Selském", "Na Seníku", "Na Skalce", "Na Skalách", "Na Sklonku", "Na Skále", "Na Slatince", "Na Slatinách", "Na Slatinách", "Na Slatinách", "Na Slavíkově", "Na Slovance", "Na Slupi", "Na Slupi", "Na Smetance", "Na Souvrati", "Na Souvrati", "Na Spojce", "Na Spádu", "Na Spáleništi", "Na Srpečku", "Na Srázu", "Na Srážku", "Na Staré", "Na Staré Cestě", "Na Staré Návsi", "Na Staré Silnici", "Na Staré Vinici", "Na Stezce", "Na Stezce", "Na Struze", "Na Stráni", "Na Stráňkách", "Na Stráži", "Na Stráži", "Na Strži", "Na Strži", "Na Stupních", "Na Stárce", "Na Stírce", "Na Střelnici", "Na Svahu", "Na Svěcence", "Na Sychrově", "Na Sychrově", "Na Sypkém", "Na Sypčině", "Na Sádce", "Na Terase", "Na Topolce", "Na Topolce", "Na Truhlářce", "Na Tržišti", "Na Tykačce", "Na Táboře", "Na Třebešíně", "Na Třebešíně", "Na Universitním Statku", "Na Usedlosti", "Na Vackově", "Na Valech", "Na Valentince", "Na Vartě", "Na Vaňhově", "Na Veselí", "Na Vidouli", "Na Viktorce", "Na Vinici", "Na Viničce", "Na Viničkách", "Na Viničních Horách", "Na Vinobraní", "Na Vinohradu", "Na Višňovce", "Na Vlasačce", "Na Vlastní Půdě", "Na Vlastním", "Na Vlku", "Na Vlčovce", "Na Volánové", "Na Vrchmezí", "Na Vrchmezí", "Na Vrchmezí", "Na Vrcholu", "Na Vrchu", "Na Vrchu", "Na Vrchách", "Na Vrchách", "Na Vrstevnici", "Na Vrstvách", "Na Vršku", "Na Vrškách", "Na Vrších", "Na Vrších", "Na Vydrholci", "Na Vyhlídce", "Na Vypichu", "Na Vypichu", "Na Vysoké I", "Na Vysoké I", "Na Vysoké Ii", "Na Vysočanských Vinicích", "Na Vysočině", "Na Václavce", "Na Vápence", "Na Vápenném", "Na Vítězné Pláni", "Na Výběžku", "Na Výhledech", "Na Výhonku", "Na Výrovně", "Na Výsledku I", "Na Výsledku Ii", "Na Výsluní", "Na Výspě", "Na Výspě", "Na Výstupu", "Na Výtoni", "Na Výši", "Na Výšince", "Na Výšinách", "Na Výšině", "Na Věnečku", "Na Větrníku", "Na Větrníku", "Na Větrově", "Na Větru", "Na Zahrádkách", "Na Zatlance", "Na Zavadilce", "Na Zbořenci", "Na Zderaze", "Na Zedníkové", "Na Zelené Louce", "Na Zemance", "Na Zkratce", "Na Zlatnici", "Na Zlaté", "Na Zlíchově", "Na Zlíchově", "Na Zmrzlíku", "Na Znělci", "Na Zvoničce", "Na Zábradlí", "Na Záhonech", "Na Zájezdu", "Na Zámecké", "Na Zámkách", "Na Zámyšli", "Na Zástřelu", "Na Zástřelu", "Na Zátorce", "Na Zátorách", "Na Závěji", "Na Úbočí", "Na Úhoru", "Na Úlehli", "Na Úseku", "Na Úspěchu", "Na Černé Hoře", "Na Černé Strouze", "Na Černém Vrchu", "Na Července", "Na Čečeličce", "Na Čihadle", "Na Čisté", "Na Říháku", "Na Šabatce", "Na Šachtě", "Na Šafránce", "Na Šancích", "Na Šedivé", "Na Šejdru", "Na Šejdru", "Na Šmukýřce", "Na Špejcharu", "Na Špitálce", "Na Špitálsku", "Na Štamberku", "Na Štěpnici", "Na Šubě", "Na Šumavě", "Na Šutce", "Na Švihance", "Na Šťáhlavce", "Na Žertvách", "Na Žvahově", "Naardenská", "Nad Akcízem", "Nad Akáty", "Nad Alejí", "Nad Belvederem", "Nad Belárií", "Nad Berounkou", "Nad Bertramkou", "Nad Botičem", "Nad Bořislavkou", "Nad Bořislavkou", "Nad Branickým Pivovarem", "Nad Brůdkem", "Nad Brůdkem", "Nad Buďánkami I", "Nad Buďánkami Ii", "Nad Buďánkami Iii", "Nad Cementárnou", "Nad Chaloupkami", "Nad Chuchlí", "Nad Cihelnou", "Nad Dalejským Údolím", "Nad Doly", "Nad Dolíky", "Nad Drahou", "Nad Dubovým Mlýnem", "Nad Dvorem", "Nad Dálnicí", "Nad Elektrárnou", "Nad Elektrárnou", "Nad Flajšnerkou", "Nad Habrovkou", "Nad Havlem", "Nad Helmrovkou", "Nad Hercovkou", "Nad Hercovkou", "Nad Hliníkem", "Nad Hliníkem", "Nad Horizontem", "Nad Hradním Potokem", "Nad Hradním Vodojemem", "Nad Husovými Sady", "Nad Hutěmi", "Nad Hutěmi", "Nad Hájem", "Nad Hřištěm", "Nad Jenerálkou", "Nad Jetelkou", "Nad Jezem", "Nad Jezerkou", "Nad Jordánkem", "Nad Kajetánkou", "Nad Kamínkou", "Nad Kaplankou", "Nad Kapličkou", "Nad Kavalírkou", "Nad Kazankou", "Nad Kazínem", "Nad Kelerkou", "Nad Kesnerkou", "Nad Klamovkou", "Nad Klikovkou", "Nad Klíčovem", "Nad Kolonií", "Nad Kolčavkou", "Nad Komornickou", "Nad Konečnou", "Nad Konvářkou", "Nad Kostelem", "Nad Kotlaskou I", "Nad Kotlaskou Ii", "Nad Kotlaskou Iii", "Nad Kotlaskou Iv", "Nad Kotlaskou V", "Nad Koulkou", "Nad Koupadly", "Nad Koupalištěm", "Nad Košinkou", "Nad Košíkem", "Nad Krocínkou", "Nad Krocínkou", "Nad Královskou Oborou", "Nad Kuliškou", "Nad Kundratkou", "Nad Kundratkou", "Nad Kundratkou", "Nad Křížkem", "Nad Laurovou", "Nad Lesem", "Nad Lesním Divadlem", "Nad Lesíkem", "Nad Libeňským Nádražím", "Nad Libeřským Potokem", "Nad Libušským Potokem", "Nad Libří", "Nad Lomem", "Nad Lomy", "Nad Lukami", "Nad Lávkou", "Nad Malým Mýtem", "Nad Manovkou", "Nad Markytou", "Nad Mazankou", "Nad Meandry", "Nad Mlynářkou", "Nad Mlýnem", "Nad Mlýnským Potokem", "Nad Mohylou", "Nad Mokřinou", "Nad Mostem", "Nad Motolskou Nemocnicí", "Nad Motolskou Nemocnicí", "Nad Mrázovkou", "Nad Mušlovkou", "Nad Mušlovkou", "Nad Novou Libní", "Nad Nuslemi", "Nad Nádražím", "Nad Nádrží", "Nad Náhonem", "Nad Náměstím", "Nad Návsí", "Nad Obcí I", "Nad Obcí Ii", "Nad Octárnou", "Nad Odbočkou", "Nad Ohradou", "Nad Okrouhlíkem", "Nad Olšinami", "Nad Olšinami", "Nad Ondřejovem", "Nad Opatovem", "Nad Ostrovem", "Nad Pahorkem", "Nad Palatou", "Nad Panenskou", "Nad Parkem", "Nad Parkánem", "Nad Paťankou", "Nad Pentlovkou", "Nad Petruskou", "Nad Petynkou", "Nad Plynovodem", "Nad Podbabskou Skálou", "Nad Pomníkem", "Nad Popelkou", "Nad Popelářkou", "Nad Potůčkem", "Nad Prahou", "Nad Pramenem", "Nad Primaskou", "Nad Primaskou", "Nad Propustí", "Nad Pruhy", "Nad Pískovnou", "Nad Přehradou", "Nad Přívozem", "Nad Radotínem", "Nad Rohatci", "Nad Roklí", "Nad Rokoskou", "Nad Rokytkou", "Nad Rybníkem", "Nad Rybníkem", "Nad Rybníčky", "Nad Ryšánkou", "Nad Rážákem", "Nad Sadem", "Nad Sady", "Nad Santoškou", "Nad Schody", "Nad Skálou", "Nad Slávií", "Nad Slávií", "Nad Smetankou", "Nad Sokolovnou", "Nad Soutokem", "Nad Soutokem", "Nad Splavem", "Nad Spádem", "Nad Spáleným Mlýnem", "Nad Stanicí", "Nad Starou Pískovnou", "Nad Statkem", "Nad Strakovkou", "Nad Strouhou", "Nad Strání", "Nad Strání", "Nad Studánkou", "Nad Svahem", "Nad Sýpkou", "Nad Tejnkou", "Nad Teplárnou", "Nad Topoly", "Nad Tratí", "Nad Trnkovem", "Nad Trojou", "Nad Turbovou", "Nad Třebešínem I", "Nad Třebešínem Ii", "Nad Třebešínem Ii", "Nad Třebešínem Iii", "Nad Třebešínem Iii", "Nad Vavrouškou", "Nad Vernerákem", "Nad Vinicí", "Nad Vinným Potokem", "Nad Vinným Potokem", "Nad Vinným Potokem", "Nad Vinohradem", "Nad Višňovkou", "Nad Vltavou", "Nad Vodovodem", "Nad Vodovodem", "Nad Vojenským Hřbitovem", "Nad Vokolky", "Nad Volyňkou", "Nad Vrbami", "Nad Vrstvami", "Nad Vršovskou Horou", "Nad Vsí", "Nad Vysočany", "Nad Václavkou", "Nad Výpustí", "Nad Výšinkou", "Nad Zahradnictvím", "Nad Zatáčkou", "Nad Zavážkou", "Nad Zbraslaví", "Nad Zbrojnicí", "Nad Zemankou", "Nad Zemankou", "Nad Zlatnicí", "Nad Zlíchovem", "Nad Záložnou", "Nad Zámečkem", "Nad Zámečnicí", "Nad Zátiším", "Nad Závodištěm", "Nad Závěrkou", "Nad Údolím", "Nad Údolím Hvězd", "Nad Úpadem", "Nad Úvozem", "Nad Úžlabinou", "Nad Úžlabinou", "Nad Šafránkou", "Nad Šancemi", "Nad Šauerovými Sady", "Nad Šeberákem", "Nad Šejdrem", "Nad Šestikopy", "Nad Šetelkou", "Nad Štolou", "Nad Šutkou", "Nad Šálkovnou", "Nad Šárkou", "Nad Želivkou", "Nad Žlábkem", "Nademlejnská", "Nadějovská", "Narcisová", "Naskové", "Natanaelka", "Navarova", "Navigátorů", "Navrátilova", "Načeradecká", "Načešická", "Neapolská", "Nebeského", "Nebovidská", "Nebozízek-Sady", "Nebušická", "Nechanická", "Nechanského", "Nechvalická", "Nechvílova", "Nechybova", "Nedašovská", "Nedbalova", "Nedokončená", "Nedokončená", "Nedošínské", "Nedražická", "Nedvědická", "Nedvědovo Nám.", "Nedvědovo Náměstí", "Nedvězská", "Neffova", "Nefritová", "Neherovská", "Nehvizdská", "Nehvizdská", "Nejdkova", "Neklanova", "Nekvasilova", "Nekázanka", "Nemocniční", "Nemošická", "Nepasické Nám.", "Nepasické Náměstí", "Nepelova", "Nepilova", "Nepomucká", "Nepomuckých", "Nepovolená", "Nepravidelná", "Neprůjezdná", "Nepálská", "Neratovická", "Nerudova", "Nerudova", "Nesměřická", "Nespecká", "Nesvadbova", "Netlucká", "Netluky", "Netolická", "Netušilská", "Netínská", "Netřebická", "Netřebská", "Neumannova", "Neustupného", "Neužilova", "Nevanova", "Neveklovská", "Newtonova", "Nezamyslova", "Nezdova", "Nezvalova", "Nečova", "Nešporova", "Nežárská", "Nickerleho", "Niederleho", "Nikodémova", "Nikoly Tesly", "Nikoly Vapcarova", "Niská", "Nitranská", "Nitranská", "Nivnická", "Nobelova", "Norbertov", "Norská", "Nosická", "Nosticova", "Notečská", "Noutonická", "Nouzov", "Nouzovské Nám.", "Nouzovské Náměstí", "Nouzová", "Novgorodská", "Novobohdalecká", "Novoborská", "Novoborská", "Novochuchelská", "Novodvorská", "Novodvorská", "Novodvorská", "Novodvorská", "Novohradská", "Novohrádecká", "Novohrádecká", "Novolhotská", "Novolipanská", "Novomeského", "Novomeského", "Novomlýnská", "Novopacká", "Novopetrovická", "Novorossijská", "Novosibřinská", "Novostrašnická", "Novosuchdolská", "Novosvětská", "Novotného Lávka", "Novoveská", "Novoveská", "Novovysočanská", "Novovysočanská", "Novovysočanská", "Novozámecká", "Novozámecká", "Novoškolská", "Novoštěrboholská", "Nová", "Nová Cesta", "Nová Kolonie", "Nová Ves", "Nová Ves", "Nová Šárka", "Novákovo Nám.", "Novákovo Náměstí", "Novákových", "Nové Domy", "Nové Dvory", "Nové Mlýny", "Nové Náměstí", "Nového", "Nový Lesík", "Nový Svět", "Nový Zlíchov", "Nový Zlíchov", "Nupacká", "Nuselská", "Nuselská", "Nučická", "Nušlova", "Nymburská", "Nábř. Edvarda Beneše", "Nábř. Edvarda Beneše", "Nábř. Edvarda Beneše", "Nábř. Kapitána Jaroše", "Nábř. Kapitána Jaroše", "Nábřežní", "Nábřeží Edvarda Beneše", "Nábřeží Edvarda Beneše", "Nábřeží Edvarda Beneše", "Nábřeží Kapitána Jaroše", "Nábřeží Ludvíka Svobody", "Náchodská", "Nádražní", "Nádražní", "Nádvorní", "Náhorní", "Nákupní", "Nám. 14. Října", "Nám. 25. Března", "Nám. Antonína Pecáka", "Nám. Barikád", "Nám. Bořislavka", "Nám. Bratří Synků", "Nám. Chuchelských Bojovníků", "Nám. Chuchleských Bojovníků", "Nám. Curieových", "Nám. Dr. V. Holého", "Nám. Franze Kafky", "Nám. Generála Kutlvašra", "Nám. Hrdinů", "Nám. I. P. Pavlova", "Nám. Interbrigády", "Nám. Jana Palacha", "Nám. Jana Palacha", "Nám. Jiřího Berana", "Nám. Jiřího Z Lobkovic", "Nám. Jiřího Z Poděbrad", "Nám. Jiřího Z Poděbrad", "Nám. Josefa Machka", "Nám. Kinských", "Nám. Kinských", "Nám. Mezi Zahrádkami", "Nám. Na Balabence", "Nám. Na Farkáně", "Nám. Na Lužinách", "Nám. Na Santince", "Nám. Na Stráži", "Nám. Omladiny", "Nám. Osvoboditelů", "Nám. Padlých", "Nám. Pod Kaštany", "Nám. Pod Lípou", "Nám. Prezidenta Masaryka", "Nám. Před Bateriemi", "Nám. Republiky", "Nám. Smiřických", "Nám. Svatopluka Čecha", "Nám. Svobody", "Nám. U Lva", "Nám. U Lípy Svobody", "Nám. U Svatého Jiří", "Nám. Winstona Churchilla", "Nám. Českého Povstání", "Nám.Organizace Spojených Národ", "Nám.Plukovníka Vlčka", "Náměstí 14. Října", "Náměstí 25. Března", "Náměstí Antonína Pecáka", "Náměstí Barikád", "Náměstí Bořislavka", "Náměstí Bořislavka", "Náměstí Bratří Jandusů", "Náměstí Bratří Synků", "Náměstí Chuchelských Bojovníků", "Náměstí Curieových", "Náměstí Dr. Václava Holého", "Náměstí Generála Kutlvašra", "Náměstí Hrdinů", "Náměstí I. P. Pavlova", "Náměstí Interbrigády", "Náměstí Jana Palacha", "Náměstí Jana Palacha", "Náměstí Jiřího Berana", "Náměstí Jiřího Z Lobkovic", "Náměstí Jiřího Z Poděbrad", "Náměstí Jiřího Z Poděbrad", "Náměstí Josefa Machka", "Náměstí Junkových", "Náměstí Kinských", "Náměstí Kinských", "Náměstí Kosmonautů", "Náměstí Mezi Zahrádkami", "Náměstí Míru", "Náměstí Na Balabence", "Náměstí Na Farkáně", "Náměstí Na Lužinách", "Náměstí Na Santince", "Náměstí Na Stráži", "Náměstí Omladiny", "Náměstí Organizace Spojených Národů", "Náměstí Osvoboditelů", "Náměstí Padlých", "Náměstí Plukovníka Vlčka", "Náměstí Pod Emauzy", "Náměstí Pod Kaštany", "Náměstí Pod Lípou", "Náměstí Prezidenta Masaryka", "Náměstí Protifašistických Bojovníků", "Náměstí Před Bateriemi", "Náměstí Přátelství", "Náměstí Republiky", "Náměstí Republiky", "Náměstí Smiřických", "Náměstí Sv. Petra A Pavla", "Náměstí Svatopluka Čecha", "Náměstí Svobody", "Náměstí U Lva", "Náměstí U Lípy Svobody", "Náměstí U Svatého Jiří", "Náměstí Winstona Churchilla", "Náměstí Zdenky Braunerové", "Náměstí Českého Povstání", "Náplavní", "Náprstkova", "Národní", "Národní", "Národní Obrany", "Národních Hrdinů", "Nárožní", "Násirovo Nám.", "Násirovo Náměstí", "Nástrojářská", "Návazná", "Návršní", "Návětrná", "Návětrná", "Názovská", "Nýdecká", "Nýrská", "Nýřanská", "Němčická", "Něvská", "Obchodní", "Obchodní Nám.", "Obchodní Náměstí", "Obilní", "Objízdná", "Oblouková", "Obora Hvězda", "Oborská", "Obrataňská", "Obrovského", "Obsiny", "Obslužná", "Obvodová", "Obědovická", "Obětí 6. Května", "Obětí 6.Května", "Ocelkova", "Ocelářská", "Ocelářská", "Ocelíkova", "Ochozská", "Ochranovská", "Od Rozcestí", "Od Vysoké", "Od Školy", "Odboje", "Odborů", "Odbočná", "Oddechová", "Oddělená", "Oderská", "Odlehlá", "Ohmova", "Ohnivcova", "Ohnišťanská", "Ohradní", "Ohradní", "Ohradská", "Ohradské Nám.", "Ohradské Náměstí", "Ohrobecká", "Okenská", "Okořská", "Okrajní", "Okrajová", "Okrajová", "Okrasná", "Okrouhlická", "Okrouhlíkova", "Okrová", "Okruhová", "Okružní", "Okružní", "Okřínecká", "Olbrachtova", "Olbramovická", "Oldřichova", "Olešnická", "Olešská", "Olgy Havlové", "Olivova", "Olomoucká", "Olympijská", "Olšanská", "Olšanské Nám.", "Olšanské Náměstí", "Olšovická", "Olšová", "Olštýnská", "Omladinářů", "Omská", "Ondřejovská", "Ondříčkova", "Ondříčkova", "Onšovecká", "Opata Konráda", "Opatovická", "Opatovská", "Opatovská", "Opatřilka", "Opatřilka", "Opařanská", "Oplanská", "Opletalova", "Opolská", "Opočenská", "Opočínská", "Opravářská", "Opuková", "Opálkova", "Opálová", "Oravská", "Ordovická", "Orebitská", "Orelská", "Orlická", "Ortenovo Náměstí", "Osadní", "Osamocená", "Osecká", "Osetá", "Osická", "Osiková", "Osinalická", "Osluněná", "Osmého Listopadu", "Osnická", "Osnická", "Osnická", "Ostravická", "Ostravská", "Ostromečská", "Ostrov Štvanice", "Ostrovní", "Ostrovského", "Ostruženská", "Ostružinová", "Ostrá", "Ostrčilovo Nám.", "Ostrčilovo Náměstí", "Ostředecká", "Ostřicová", "Osvobození", "Osvětová", "Otakara Vrby", "Otakarova", "Otavova", "Otavova", "Otavská", "Otevřená", "Otická", "Otlíkovská", "Otopašská", "Otovická", "Otradovická", "Ottova", "Otvovická", "Oty Pavla", "Otínská", "Otěšínská", "Ouholická", "Ouhrabkova", "Ovenecká", "Ovenecká", "Ovesná", "Ovocná", "Ovocnářská", "Ovocný Trh", "Ovsíková", "Oválová", "Ovčárská", "Ovčí Hájek", "Ořechová", "Ořešská", "Paběnická", "Paběnická", "Pacajevova", "Paceřická", "Pacholíkova", "Pacovská", "Paculova", "Padovská", "Pajerova", "Pakoměřická", "Palackého", "Palackého Nám.", "Palackého Náměstí", "Palmetová", "Palmovka", "Paláskova", "Pampelišková", "Pancířova", "Panelová", "Panenky", "Panenská", "Pankrácké Náměstí", "Panská", "Panská Zahrada", "Panský Dvůr", "Panuškova", "Paprsková", "Papírenská", "Papírníkova", "Parašutistů", "Pardubická", "Park Přátelství", "Parková", "Parléřova", "Parléřova", "Parmská", "Paroplavební", "Partyzánská", "Pasecká", "Pasteurova", "Pastevců", "Patočkova", "Patočkova", "Patočkova", "Pavelkova", "Pavla Beneše", "Pavla Švandy Ze Semčic", "Pavlická", "Pavlišovská", "Pavlovická", "Pavlovská", "Pavlíkova", "Pavrovského", "Paříkova", "Pařízkova", "Pařížská", "Pařížská", "Paškova", "Paťanka", "Peceradská", "Pecharova", "Pechlátova", "Pechlátova", "Pecháčkova", "Peckova", "Pejevové", "Pekařova", "Pekařova", "Pekařská", "Pekárenská", "Pekárkova", "Pelclova", "Pelechovská", "Pelhřimovská", "Pelikánova", "Pelléova", "Pelléova", "Pelnářova", "Pelušková", "Pelyňková", "Pelzova", "Penízovková", "Perlitová", "Perlitová", "Perlová", "Pernerova", "Pernerova", "Peroutkova", "Peroutkova", "Peroutkova", "Peroutkova", "Perspektivní", "Pertoldova", "Perucká", "Perunova", "Perštejnská", "Petra Bezruče", "Petra Rezka", "Petra Slezáka", "Petrbokova", "Petrklíčová", "Petrohradská", "Petrovická", "Petrovská", "Petrská", "Petrské Nám.", "Petrské Náměstí", "Petráčkova", "Petržílkova", "Petržílova", "Petýrkova", "Petříkova", "Petříkovská", "Petřínská", "Petřínská", "Petřínské Sady", "Petřínské Sady", "Pevnostní", "Pečárková", "Pešinova", "Peškova", "Pešlova", "Pešova", "Peštukova", "Pešákova", "Picassova", "Pickova", "Pihelská", "Pikovická", "Pikrtova", "Pilařská", "Pilníkovská", "Pilotů", "Pilovská", "Pilovská", "Pilská", "Pirinská", "Pirnerova", "Pitkovická", "Pitterova", "Pivcova", "Pivovarnická", "Pivovarská", "Pivoňková", "Pištěkova", "Placina", "Placina", "Plajnerova", "Plamínkové", "Plaská", "Platanová", "Platnéřská", "Platónova", "Plavecká", "Plavínová", "Plačická", "Plaňanská", "Plevenská", "Plečnikova", "Plhovská", "Plickova", "Plkovská", "Plojharova", "Ploskovická", "Ploučnická", "Plovdivská", "Plošná", "Ploštilova", "Plukovníka Mráze", "Plumlovská", "Plutova", "Plynární", "Plzeňská", "Plzeňská", "Plzeňská", "Plzeňská", "Plzeňská", "Plánická", "Pláničkova", "Poberova", "Pobočná", "Pobořská", "Poběžovická", "Pobřežní", "Pobřežní Cesta", "Pod Akáty", "Pod Altánem", "Pod Altánem", "Pod Andělkou", "Pod Areálem", "Pod Aritmou", "Pod Ateliéry", "Pod Bahnivkou", "Pod Balkánem", "Pod Barvířkou", "Pod Bateriemi", "Pod Baštami", "Pod Belvederem", "Pod Belárií", "Pod Beránkem", "Pod Beránkou", "Pod Betání", "Pod Bohdalcem I", "Pod Bohdalcem I", "Pod Bohdalcem Ii", "Pod Brentovou", "Pod Bruskou", "Pod Buďánkou", "Pod Bání", "Pod Březinou", "Pod Chaloupkami", "Pod Chodovem", "Pod Cihelnou", "Pod Cihelnou", "Pod Cukrákem", "Pod Císařkou", "Pod Dlážděnkou", "Pod Domky", "Pod Drinopolem", "Pod Dráhou", "Pod Duby", "Pod Dvorem", "Pod Dálnicí", "Pod Děkankou", "Pod Děkankou", "Pod Děvínem", "Pod Farou", "Pod Fialkou", "Pod Formankou", "Pod Fořtem", "Pod Garážemi", "Pod Habrovkou", "Pod Habrovou", "Pod Haltýřem", "Pod Harfou", "Pod Havlínem", "Pod Havránkou", "Pod Havránkou", "Pod Hliništěm", "Pod Hloubětínskou Zastávkou", "Pod Hláskem", "Pod Homolkou", "Pod Hotelem", "Pod Hořavkou", "Pod Hrachovkou", "Pod Hradbami", "Pod Hradem", "Pod Hranicí", "Pod Hrází", "Pod Hvězdou", "Pod Hvězdárnou", "Pod Hvězdárnou", "Pod Hybšmankou", "Pod Hájem", "Pod Hájkem", "Pod Hájovnou", "Pod Hřbitovem", "Pod Hřištěm", "Pod Jalovým Dvorem", "Pod Jankovem", "Pod Jarovem", "Pod Javory", "Pod Jiráskovou Čtvrtí", "Pod Juliskou", "Pod Kamínkou", "Pod Kapličkou", "Pod Kapličkou", "Pod Karlovarskou Silnicí", "Pod Karlovem", "Pod Kavalírkou", "Pod Kaštany", "Pod Kaštany", "Pod Kesnerkou", "Pod Kladenskou Silnicí", "Pod Klamovkou", "Pod Klapicí", "Pod Klaudiánkou", "Pod Klikovkou", "Pod Kopcem", "Pod Kostelem", "Pod Kotlaskou", "Pod Kotlářkou", "Pod Kotlářkou", "Pod Kotlářkou", "Pod Krejcárkem", "Pod Krocínkou", "Pod Královkou", "Pod Krčským Lesem", "Pod Kulturním Domem", "Pod Kynclovkou", "Pod Křížem", "Pod Křížkem", "Pod Labuťkou", "Pod Lahovskou", "Pod Lesem", "Pod Lesíkem", "Pod Letištěm", "Pod Lečí", "Pod Lipami", "Pod Lipkami", "Pod Lisem", "Pod Lisem", "Pod Lochkovem", "Pod Lomem", "Pod Lysinami", "Pod Lázní", "Pod Marjánkou", "Pod Markétou", "Pod Martinem", "Pod Meliškou", "Pod Mlýnkem", "Pod Mohylou", "Pod Mostem", "Pod Napětím", "Pod Nouzovem", "Pod Novou Školou", "Pod Novým Lesem", "Pod Novým Lesem", "Pod Nuselskými Schody", "Pod Náměstím", "Pod Náplavkou", "Pod Náplavkou", "Pod Náspem", "Pod Návsí", "Pod Oborou", "Pod Ovčínem", "Pod Ořechovkou", "Pod Palatou", "Pod Palírkou", "Pod Parukářkou", "Pod Paťankou", "Pod Paťankou", "Pod Pekařkou", "Pod Pekárnami", "Pod Petřinami", "Pod Plynojemem", "Pod Plynojemem", "Pod Plynojemem", "Pod Plískavou", "Pod Poštou", "Pod Pramenem", "Pod Prodejnou", "Pod Průsekem", "Pod Písečnou", "Pod Přehradou", "Pod Přesypem", "Pod Radnicí", "Pod Rapidem", "Pod Rapidem", "Pod Rapidem", "Pod Remízkem", "Pod Rovinou", "Pod Rozvodnou", "Pod Rybníkem", "Pod Rybníčkem", "Pod Sady", "Pod Salabkou", "Pod Sirénou", "Pod Skalkou", "Pod Skalou", "Pod Sklenářkou", "Pod Slovany", "Pod Smetankou", "Pod Sokolovnou", "Pod Soutratím", "Pod Spalovnou", "Pod Spiritkou", "Pod Spravedlností", "Pod Srázem", "Pod Stadiony", "Pod Stanicí", "Pod Starou Školou", "Pod Starákem", "Pod Statky", "Pod Strašnickou Vinicí", "Pod Strojírnami", "Pod Strání", "Pod Studánkou", "Pod Stupni", "Pod Stárkou", "Pod Stárkou", "Pod Stírkou", "Pod Svahem", "Pod Sychrovem I", "Pod Sychrovem I", "Pod Sychrovem I", "Pod Sychrovem Ii", "Pod Sídlištěm", "Pod Terasami", "Pod Terebkou", "Pod Topoly", "Pod Tratí", "Pod Turnovskou Tratí", "Pod Turnovskou Tratí", "Pod Táborem", "Pod Táborem", "Pod Třebešínem", "Pod Třešněmi", "Pod Třešňovkou", "Pod Urnovým Hájem", "Pod Valem", "Pod Vartou", "Pod Vavřincem", "Pod Velkým Hájem", "Pod Viaduktem", "Pod Vidoulí", "Pod Viktorkou", "Pod Vilami", "Pod Vinicemi", "Pod Vinicí", "Pod Vinohradem", "Pod Višňovkou", "Pod Vlachovkou", "Pod Vlastním Krovem", "Pod Vlkem", "Pod Vodojemem", "Pod Vodovodem", "Pod Vodárenskou Věží", "Pod Vrchem", "Pod Vrcholem", "Pod Vrstevnicí", "Pod Vrškem", "Pod Vrškem", "Pod Vršovickou Vodárnou I", "Pod Vršovickou Vodárnou Ii", "Pod Vršovickou Vodárnou Iii", "Pod Vsí", "Pod Vyhlídkou", "Pod Vysokou", "Pod Vysokou Mezí", "Pod Vysílačkou", "Pod Vyšehradem", "Pod Václavem", "Pod Vítkovem", "Pod Výtopnou", "Pod Výšinkou", "Pod Větrolamem", "Pod Větrovem", "Pod Věží", "Pod Zahradami", "Pod Zahrádkami", "Pod Zastávkou", "Pod Zatáčkou", "Pod Zbuzany", "Pod Zemankou", "Pod Zličínem", "Pod Zvonařkou", "Pod Zvoničkou", "Pod Zámečkem", "Pod Závěrkou", "Pod Útesy", "Pod Čertovou Skalou", "Pod Čihadlem", "Pod Čimickým Hájem", "Pod Šancemi", "Pod Školou", "Pod Šmukýřkou", "Pod Špejcharem", "Pod Špitálem", "Pod Štěpem", "Pod Žvahovem", "Podbabská", "Podbabská", "Podbělohorská", "Podbělová", "Podchýšská", "Podedvorská", "Podhajská Pole", "Podholí", "Podhorská", "Podhořská", "Podivínská", "Podjavorinské", "Podjezd", "Podkovářská", "Podkrkonošská", "Podkrkonošských Tkalců", "Podle Kačerova", "Podle Lomu", "Podle Lomu", "Podle Náhonu", "Podle Náhonu", "Podle Sadů", "Podle Trati", "Podlesek", "Podleská", "Podlesní", "Podlešínská", "Podlibská", "Podlipného", "Podlišovská", "Podlužanská", "Podléšková", "Podnikatelská", "Podnádražní", "Podohradská", "Podolanská", "Podolská", "Podolská", "Podolské Nábř.", "Podolské Nábřeží", "Podolské Schody", "Podpěrova", "Podskalská", "Podsychrovská", "Podvinný Mlýn", "Podvinný Mlýn", "Podzámecká", "Podéšťova", "Poděbradova", "Poděbradova", "Poděbradská", "Poděbradská", "Poděbradská", "Podůlší", "Pohledná", "Pohnertova", "Pohořelec", "Pohořelec", "Pokojná", "Pokorného", "Pokřivená", "Polabská", "Polabská", "Polaneckého", "Polední", "Polední", "Polenská", "Polepská", "Poleradská", "Polesná", "Polešovická", "Politických Vězňů", "Poličanská", "Poljanovova", "Polní", "Polovnická", "Polská", "Polygrafická", "Polákova", "Poláčkova", "Políkenská", "Polívkova", "Pomezní", "Pomněnková", "Pomořanská", "Ponrepova", "Poplužní", "Popovická", "Popovova", "Poslední", "Pospíchalova", "Pospíšilova", "Postlova", "Postranní", "Postupická", "Postřekovská", "Postřižínská", "Postřižínská", "Potocká", "Potoční", "Pouchova", "Poupětova", "Poustka", "Povltavská", "Povltavská", "Povltavská", "Povodňová", "Pozdeňská", "Poznaňská", "Počeradská", "Počernická", "Počernická", "Počátecká", "Počátecká", "Poříčanská", "Poříčanská", "Poříčská", "Pošepného Nám.", "Pošepného Náměstí", "Poštovská", "Požárnická", "Pplk. Nováčka", "Pplk. Sochora", "Prachatická", "Prachnerova", "Prachovická", "Prachovská", "Pramenná", "Pramenná", "Pravoúhlá", "Pravská", "Pravá", "Prašná", "Pražská", "Pražského", "Pražského Povstání", "Pražský Okruh", "Pražákovská", "Prefátova", "Preislerova", "Preláta", "Prelátská", "Preslova", "Primátorská", "Probluzská", "Proboštská", "Procházkova", "Prodloužená", "Prokofjevova", "Prokopka", "Prokopova", "Prokopovo Nám.", "Prokopovo Náměstí", "Prokopových", "Prokopská", "Prokopské Údolí", "Prokopské Údolí", "Prorektorská", "Prosecká", "Prosecká", "Prosecká", "Prosincová", "Prosluněná", "Prosná", "Prostřední", "Proti Proudu", "Protilehlá", "Protivínská", "Proutěná", "Prouzova", "Provaznická", "Provozní", "Prunéřovská", "Prusická", "Prusíkova", "Prušánecká", "Prvního Pluku", "Prvního Pluku", "Prvomájová", "Prácheňská", "Práčská", "Průběžná", "Průchodní", "Průchova", "Průhledová", "Průhonek", "Průhonek", "Průhonická", "Průhonská", "Průjezdná", "Průmyslová", "Průmyslová", "Průmyslová", "Průmyslová", "Průtažní", "Průčelní", "Průškova", "Psohlavců", "Pstružná", "Psárská", "Ptáčnická", "Puchmajerova", "Puchmajerova", "Pujmanové", "Pujmanové", "Pujmanové", "Purkrabská", "Purkyňova", "Putimská", "Pučova", "Puškinovo Nám.", "Puškinovo Náměstí", "Pyšelská", "Pálavská", "Pálkařská", "Pámelníková", "Pánkova", "Pátkova", "Pávovské Náměstí", "Písecká", "Píseckého", "Písečná", "Pískařská", "Pískovcová", "Pískovna", "Písková", "Písnická", "Písnická", "Písnické Zahrady", "Písčitá", "Píškova", "Píšovická", "Pöslova", "Púchovská", "Púchovská", "Pýchavková", "Pýrová", "Pěnkaví", "Pěstitelská", "Pětidomí", "Pětipeského", "Pěší", "Přecechtělova", "Přechodní", "Před Cibulkami", "Před Dráhou", "Před Mosty", "Před Nádražím", "Před Oborou", "Před Rybníkem", "Před Skalkami I", "Před Skalkami Ii", "Před Skálou", "Před Sokolovnou", "Před Tratí", "Před Ústavem", "Předbořská", "Předměřická", "Přední", "Předpolní", "Předposlední", "Předvoje", "Předvoje", "Předškolní", "Přeletová", "Přeloučská", "Přemyslova", "Přemyslovská", "Přemyslovská", "Přemyšlenská", "Přerušená", "Přesličková", "Přespolní", "Přetlucká", "Přeučilova", "Převoznická", "Přezletická", "Přeštická", "Přeštínská", "Přeťatá", "Při Hranici", "Při Hranici", "Při Trati", "Přibyslavská", "Přibíkova", "Přistoupimská", "Přádova", "Přátelství", "Příborská", "Příbramská", "Příběnická", "Příchovická", "Přídolská", "Příkrá", "Přílepská", "Přímské Nám.", "Přímské Náměstí", "Přímá", "Přímětická", "Přípotoční", "Přípřežní", "Přírodní", "Přístavní", "Přívorská", "Přívozní", "Příčka", "Příčná", "Pšeničná", "Pšenčíkova", "Pšovanská", "Pštrossova", "Půdova", "Půlkruhová", "Půlnoční", "Půtova", "R.A. Dvorského", "Rabasova", "Rabyňská", "Rackova", "Rackova Zahrada", "Radbuzská", "Radechovská", "Radešovská", "Radhošťská", "Radhošťská", "Radimova", "Radimovická", "Radimská", "Radiová", "Radiová", "Radistů", "Radkovská", "Radlická", "Radlická", "Radlická", "Radnické Schody", "Radomská", "Radonická", "Radostavická", "Radostná", "Radotínská", "Radotínská", "Radouňova", "Radouňova", "Radouňova", "Radova", "Radovská", "Radošovická", "Radvanická", "Radúzova", "Radčina", "Radějovská", "Raffaelova", "Raichlova", "Raisova", "Rajhradská", "Rajmonova", "Rajská", "Rakousova", "Rakovnická", "Rakovského", "Randova", "Ranská", "Ratajova", "Ratajská", "Ratbořská", "Ratibořická", "Ratibořská", "Ratibořská", "Ravennská", "Račická", "Račiněveská", "Rašilovova", "Rašova", "Rašovická", "Rašovská", "Rašínovo Nábř.", "Rašínovo Nábř.", "Rašínovo Nábřeží", "Rašínovo Nábřeží", "Rašínská", "Ražická", "Reinerova", "Rejchova", "Rejskova", "Rekreační", "Rektorská", "Rembrandtova", "Remízková", "Renoirova", "Resslova", "Revoluce", "Revoluční", "Revoluční", "Rezedová", "Rezlerova", "Rečkova", "Richtrova", "Riegrova", "Riegrovy Sady", "Rilská", "Ringhofferova", "Ringhofferova", "Rižská", "Roblínská", "Rochovská", "Rochovská", "Rodopská", "Rodovská", "Rodvinovská", "Roentgenova", "Rohanovská", "Rohanské Nábřeží", "Rohanský Ostrov", "Rohatecká", "Rohenická", "Rohlovská", "Rohová", "Rohozecká", "Rohožnická", "Roháčova", "Roithova", "Rojická", "Roklova", "Rokycanova", "Rokycanská", "Rokytnická", "Rokytná", "Rolnická", "Rolní", "Romaina Rollanda", "Romana Blahníka", "Ronalda Reagana", "Ronešova", "Ronkova", "Ronovská", "Rooseveltova", "Rorýsová", "Rosečská", "Rosická", "Rostislavova", "Rostoklatská", "Rostovská", "Rotavská", "Rotenská", "Roudnická", "Rousovická", "Rousínovská", "Rovenská", "Rovnoběžná", "Rovná", "Rozdělená", "Rozdělovská", "Rozhovická", "Rozkošného", "Rozkošská", "Rozmarýnová", "Rozrazilová", "Roztocká", "Roztylská", "Roztylské Náměstí", "Roztylské Sady", "Rozvadovská", "Rozvodova", "Rozvojová", "Rozárčina", "Rozýnova", "Rozšířená", "Ročovská", "Rošických", "Roškotova", "Rošovická", "Rožmberská", "Rožmitálská", "Rožnovská", "Rožďalovická", "Rtyňská", "Rubensova", "Rubeška", "Rubešova", "Rubličova", "Rubínová", "Rudečská", "Rudníkovská", "Rudolfa Holeky", "Rudoltická", "Rudoltická", "Rujanská", "Rumburská", "Rumunská", "Rumunská", "Ruprechtická", "Ruská", "Ruská", "Ruzyňská", "Ruzyňská", "Ruzyňské Schody", "Ružinovská", "Rybalkova", "Rybalkova", "Rybalkova", "Rybničná", "Rybná", "Rybova", "Rybářská", "Rybízová", "Rychnovská", "Rychtáře Petříka", "Rychtáře Šimona", "Rychtářská", "Rypkova", "Rytířova", "Rytířská", "Ryzcová", "Ryzlinková", "Ryšánkova", "Rájecká", "Rámová", "Rápošovská", "Rážova", "Révová", "Rýmařovská", "Rýnská", "Rýznerova", "Růženínová", "Růženínská", "Růženínská", "Růžová", "S. K. Neumanna", "Sabinova", "Sadařská", "Sadová", "Sadská", "Sadská", "Sady Bratří Čapků", "Safírová", "Salabova", "Salačova", "Salmovská", "Salvátorská", "Samcova", "Samohelova", "Samota U Podleského Rybníka", "Sarajevská", "Saratovská", "Sartoriova", "Sasanková", "Saská", "Satalická", "Saturnova", "Saudkova", "Sauerova", "Saveljevova", "Savojská", "Sazečská", "Sazečská", "Sazovická", "Sbíhavá I", "Sbíhavá Ii", "Schnirchova", "Schodišťová", "Schodová", "Schoellerova", "Schoellerova", "Schulhoffova", "Schwaigerova", "Schwarzenberská", "Schöfflerova", "Sdružení", "Sechterova", "Sedlecká", "Sedlovická", "Sedloňovská", "Sedlčanská", "Sedmidomky", "Sedmidomky", "Sedmikrásková", "Sedmnáctého Listopadu", "Seidlova", "Seifertova", "Sekaninova", "Sekeřická", "Sekorova", "Selmická", "Selská", "Selských Baterií", "Semanského", "Semická", "Semilská", "Semilská", "Seminární", "Seminářská", "Seminářská Zahrada", "Semonická", "Semtínská", "Semčická", "Sendražická", "Senegalská", "Senohrabská", "Senovážná", "Senovážné Nám.", "Senovážné Náměstí", "Senožatská", "Sestupná", "Sestupná", "Setbová", "Sevastopolská", "Severní I", "Severní Ii", "Severní Iii", "Severní Iv", "Severní Ix", "Severní V", "Severní Vi", "Severní Vii", "Severní Viii", "Severní X", "Severní Xi", "Severovýchodní I", "Severovýchodní Ii", "Severovýchodní Iii", "Severovýchodní Iv", "Severovýchodní V", "Severovýchodní Vi", "Severozápadní I", "Severozápadní Ii", "Severozápadní Iii", "Severozápadní Iv", "Severozápadní V", "Severozápadní Vi", "Severýnova", "Sevřená", "Seydlerova", "Sezemická", "Sezemínská", "Sezimova", "Sečská", "Sibeliova", "Sibiřské Nám.", "Sibiřské Náměstí", "Sicherova", "Sichrovského", "Siemensova", "Silurská", "Sinkulova", "Sinkulova", "Sitteho", "Siwiecova", "Skalecká", "Skalnatá", "Skalnická", "Skalní", "Skalská", "Skaláků", "Skandinávská", "Skandinávská", "Skautská", "Sklenská", "Skloněná", "Sklářská", "Skokanská", "Skorkovská", "Skorkovská", "Skotská", "Skořepka", "Skořicová", "Skryjská", "Skupova", "Skuteckého", "Skálova", "Skřivanova", "Skřivanská", "Skřivánčí", "Sladkovského Nám.", "Sladkovského Náměstí", "Sladovnická", "Slancova", "Slaná", "Slapská", "Slatinová", "Slatinská", "Slatiny", "Slatiňanská", "Slavatova", "Slaviborské Nám.", "Slaviborské Náměstí", "Slavická", "Slavičí", "Slavičínská", "Slavníkova", "Slavojova", "Slavonická", "Slavíkova", "Slavíkova", "Slavíkova", "Slavínského", "Slavíčkova", "Slavětínská", "Slepá I", "Slepá Ii", "Slezanů", "Slezská", "Slezská", "Sliačská", "Sliačská", "Slibná", "Slinková", "Slivenecká", "Slovanský Ostrov", "Slovačíkova", "Slovenská", "Slovenská", "Slovinská", "Slunečnicová", "Slunečná", "Sluneční", "Sluneční Nám.", "Sluneční Náměstí", "Slunná", "Sluštická", "Služeb", "Služeb", "Služská", "Sládkova", "Sládkovičova", "Slámova", "Slánská", "Slávy Horníka", "Slévačská", "Slévačská", "Slévačská", "Slídová", "Slívová", "Smaragdová", "Smetanovo Nábř.", "Smetanovo Nábřeží", "Smetáčkova", "Smidarská", "Smikova", "Smiřická", "Smiřického", "Smolenská", "Smolkova", "Smolíkova", "Smotlachova", "Smotlachova", "Smrková", "Smrčinská", "Smržovská", "Smržová", "Smíchovská", "Smíchovská", "Smíchovská", "Smírná", "Snopkova", "Sněmovní", "Sněženková", "Sněžná", "Sobolákova", "Soborská", "Sobotecká", "Sobínská", "Soběslavova", "Soběslavská", "Sobětická", "Sobětušská", "Soběšínská", "Sochařská", "Socháňova", "Sodomkova", "Sofijské Nám.", "Sofijské Náměstí", "Sojkovská", "Sojovická", "Sojčí", "Sojčí", "Sokolovská", "Sokolovská", "Sokolovská", "Sokolovská", "Sokolská", "Sokratova", "Solidarity", "Solnická", "Solná", "Sopotská", "Sosnovecká", "Souběžná I", "Souběžná Ii", "Souběžná Iii", "Souběžná Iv", "Soudní", "Soukalova", "Soukenická", "Soumarská", "Sousední", "Sousední", "Sousedská", "Sousedíkova", "Soustružnická", "Soustružnická", "Souvratní", "Součkova", "Sovenická", "Sovova", "Sovákova", "Soví Vršek", "Spinozova", "Spiritka", "Splavná", "Spodní", "Spojařů", "Spojenců", "Spojená", "Spojná", "Spojovací", "Spojovací", "Spojovací", "Spojovací", "Spojová", "Společná", "Spolská", "Spolupráce", "Sportovců", "Sportovců", "Sportovní", "Spotřebitelská", "Spořická", "Spořilovská", "Spytihněvova", "Spádná", "Spádová", "Spálená", "Spálená", "Spálený Mlýn", "Srbova", "Srbská", "Srbínská", "Srnečkova", "Srnčí", "Srnčí", "Srpnová", "Srázná", "Stachova", "Stadická", "Stadionová", "Stadiónová", "Stallichova", "Stamicova", "Staniční", "Starobylá", "Starochodovská", "Starochuchelská", "Starodejvická", "Starodubečská", "Starodvorská", "Staroklánovická", "Starokolínská", "Starokošířská", "Starolázeňská", "Staromlýnská", "Staromodřanská", "Staroměstské Nám.", "Staroměstské Náměstí", "Staropacká", "Staropramenná", "Starostrašnická", "Starostřešovická", "Starosuchdolská", "Staroújezdská", "Staročeská", "Stará Cesta", "Stará Náves", "Stará Obec", "Stará Spojovací", "Stará Stodůlecká", "Staré Nám.", "Staré Náměstí", "Staré Zámecké Schody", "Staré Zámecké Schody", "Starého", "Starý Lis", "Statenická", "Statková", "Stavbařů", "Stavební", "Stavitelská", "Stavovská", "Staňkova", "Staňkovka", "Staňkovská", "Stehlíkova", "Steinerova", "Stejskalova", "Stiessova", "Stinkovská", "Stochovská", "Stodůlecká", "Stojická", "Stoličkova", "Stoliňská", "Stoupající", "Stoupající", "Stradonická", "Strahovská", "Strahovské Nádvoří", "Strakatého", "Strakonická", "Strakonická", "Strakonická", "Strakonická", "Strakonická", "Strakonická", "Strakošová", "Strančická", "Stratovská", "Strašnická", "Strašnická", "Strašovská", "Strašínská", "Strmá", "Strmý Vrch", "Strnadova", "Strnady", "Strojická", "Strojnická", "Strojírenská", "Stromovka", "Stromovka", "Stropnická", "Stropnická", "Stropnická", "Strossmayerovo Nám.", "Strossmayerovo Náměstí", "Strouhalova", "Stroupežnického", "Struhařovská", "Strunkovská", "Stružky", "Stružná", "Strážkovická", "Strážnická", "Strážní", "Strážovská", "Stržná", "Studenecká", "Studentská", "Studená", "Studnická", "Studničkova", "Studniční", "Studánková", "Stulíková", "Stupická", "Stupkova", "Stupská", "Stupňová", "Stádlecká", "Stárkova", "Stýblova", "Střední", "Středohorská", "Středová", "Střekovská", "Střelecký Ostrov", "Střelečská", "Střelničná", "Střelničná", "Střemchová", "Střešovická", "Střešovická", "Střimelická", "Stříbrná", "Stříbrského", "Stříbrského", "Střížkovská", "Střížkovská", "Střížkovská", "Suchardova", "Suchdolská", "Suchdolská", "Suchdolská", "Suchdolské Nám.", "Suchdolské Náměstí", "Suchý Vršek", "Sudkova", "Sudoměřská", "Sudějovická", "Sukova", "Sulanského", "Sulická", "Sulická", "Sulova", "Sulovická", "Sumova", "Suppého", "Suttnerové", "Sušická", "Sušilova", "Svahová", "Svatavina", "Svatojánská", "Svatoplukova", "Svatoslavova", "Svatovítská", "Svatovítská", "Svatoňovická", "Svažitá", "Svijanská", "Svitavská", "Svitákova", "Svobodova", "Svobodova", "Svojetická", "Svojsíkova", "Svojšická", "Svojšovická", "Svornosti", "Svratecká", "Svárovská", "Svátkova", "Svážná", "Svépomoci", "Svépomocná", "Svépravická", "Svépravická", "Svídnická", "Svěceného", "Světická", "Světova", "Světská", "Sychrovská", "Symfonická", "Synkovická", "Synkovská", "Syrská", "Sádky", "Sádovská", "Sámova", "Sárská", "Sárská", "Sárská", "Sázavská", "Sáňkařská", "Sídlištní", "Sídlištní", "Sídliště", "Súdánská", "Sýkorčí", "Sýkovecká", "Tachlovická", "Tachovská", "Tachovské Nám.", "Tachovské Náměstí", "Tadrova", "Tajovského", "Talafúsova", "Talichova", "Talmberská", "Tanvaldská", "Tasovská", "Tatarkova", "Tatranská", "Tauerova", "Tauferova", "Taussigova", "Tavolníková", "Tařicová", "Taškentská", "Technická", "Technologická", "Tehovská", "Tejnická", "Tejnka", "Telčská", "Templová", "Tenisová", "Teplická", "Teplárenská", "Teplárenská", "Terasovitá", "Tererova", "Terezínská", "Terronská", "Tesaříkova", "Tetínská", "Theinova", "Thomayerova", "Thunovská", "Thurnova", "Thákurova", "Thámova", "Tibetská", "Tichnova", "Tichnova", "Tichonická", "Tichá", "Tichého", "Tigridova", "Tikovská", "Tilleho Nám.", "Tilleho Náměstí", "Tilschové", "Tiskařská", "Tismická", "Tišická", "Tlumačovská", "Tlustého", "Tobrucká", "Tolstého", "Tomanova", "Tomická", "Tomkova", "Tomsova", "Tomáškova", "Tomášská", "Tomíčkova", "Topasová", "Topolová", "Toruňská", "Toulovská", "Toušeňská", "Toušická", "Toužimská", "Toužimská", "Tovarova", "Tovačovského", "Tovární", "Točenská", "Točitá", "Trabantská", "Trachtova", "Trampotova", "Travnatá", "Travná", "Travná", "Trenčínská", "Trhanovské Náměstí", "Trmická", "Trnavská", "Trnavská", "Trnitá", "Trnkovo Nám.", "Trnkovo Náměstí", "Trnková", "Trnovanská", "Trní", "Trocnovská", "Troilova", "Trojanova", "Trojanův Mlýn", "Trojdílná", "Trojická", "Trojmezní", "Trojmezní", "Trojská", "Trojská", "Trojská", "Trojská", "Troskovická", "Trousilova", "Truhlářka", "Truhlářova", "Truhlářská", "Trutnovská", "Tryskovická", "Tryskovická", "Trytova", "Trávnická", "Trávníčkova", "Tréglova", "Tržiště", "Tuchoměřická", "Tuchorazská", "Tuchotická", "Tuháňská", "Tuklatská", "Tulešická", "Tulipánová", "Tulkova", "Tulská", "Tunelářů", "Tuniská", "Tupolevova", "Turgeněvova", "Turistická", "Turkmenská", "Turkovická", "Turkovská", "Turnovská", "Turnovského", "Turská", "Turínská", "Tusarova", "Tuřická", "Tušimická", "Tužebníková", "Tvrdonická", "Tvrdého", "Tychonova", "Tylišovská", "Tylovická", "Tylovo Nám.", "Tylovo Náměstí", "Tymiánová", "Tyrkysová", "Tyršova", "Táboritská", "Táborská", "Tádžická", "Táhlá", "Tálínská", "Türkova", "Týmlova", "Týmlova", "Týn", "Týnecká", "Týnská", "Týnská Ulička", "Týřovická", "Tělovýchovná", "Těšnov", "Těšovická", "Těšíkova", "Těšínská", "Třanovského", "Třebanická", "Třebechovická", "Třebenická", "Třebešovská", "Třebihošťská", "Třebohostická", "Třebonická", "Třeboradická", "Třebotovská", "Třeboňská", "Třebízského", "Třebějická", "Třebětínská", "Třešňová", "Třešňová", "Třešňová", "Třinecká", "Třtinová", "Třídomá", "Třístoličná", "Tůmova", "U Akademie", "U Akátů", "U Albrechtova Vrchu", "U Andělky", "U Arborky", "U Bakaláře", "U Balabenky", "U Bazénu", "U Bažantnice", "U Berounky", "U Beránky", "U Besedy", "U Blaženky", "U Boroviček", "U Botiče", "U Botiče", "U Božích Bojovníků", "U Branek", "U Bruských Kasáren", "U Brusnice", "U Brusnice", "U Bubce", "U Bulhara", "U Bulhara", "U Bílého Mlýnku", "U Břehu", "U Chaloupek", "U Chmelnice", "U Chodovského Hřbitova", "U Cibulky", "U Cihelny", "U Cikánky", "U Cukrovaru", "U Císařské Cesty", "U Dejvického Rybníčku", "U Demartinky", "U Divadla", "U Divadla", "U Dobešky", "U Dobráků", "U Dobráků", "U Dobřenských", "U Domu Služeb", "U Drahaně", "U Druhé Baterie", "U Druhé Baterie", "U Drupolu", "U Družstev", "U Družstva Ideál", "U Družstva Klid", "U Družstva Práce", "U Družstva Práce", "U Družstva Repo", "U Družstva Tempo", "U Družstva Život", "U Dráhy", "U Dráhy", "U Drážky", "U Drůbežárny", "U Dubečské Tvrze", "U Dubu", "U Dvojdomů", "U Dvora", "U Dvou Srpů", "U Dálnice", "U Dívčích Hradů", "U Dívčích Hradů", "U Děkanky", "U Dělnického Cvičiště", "U Dětského Domova", "U Dětského Hřiště", "U Elektry", "U Elektry", "U Elektrárny", "U Floriána", "U Fořta", "U Gabrielky", "U Garáží", "U Golfu", "U Gymnázia", "U Habeše", "U Habrovky", "U Hadovky", "U Harfy", "U Hasičské Zbrojnice", "U Hasičské Zbrojnice", "U Havlíčkových Sadů", "U Hellady", "U Hercovky", "U Hliníku", "U Hodin", "U Homolky", "U Hostavického Potoka", "U Hostivařského Nádraží", "U Hostivařského Nádraží", "U Hotelu", "U Hranic", "U Hrnčířského Rybníka", "U Hrocha", "U Hrušky", "U Hráze", "U Hudební Školy", "U Hvozdu", "U Hvězdy", "U Hvězdy", "U Háje", "U Hájku", "U Hájovny", "U Házů", "U Hřbitovů", "U Hřiště", "U Invalidovny", "U Jamské", "U Jankovky", "U Javoru", "U Jedličkova Ústavu", "U Jednoty", "U Jeslí", "U Jezera", "U Jezerky", "U Jezu", "U Jezírka", "U Jinonického Rybníčka", "U Jirkovské", "U Jizby", "U Járku", "U Jízdárny", "U Kabelovny", "U Kabelovny", "U Kaménky", "U Kamýku", "U Kanálky", "U Kapliček", "U Kapličky", "U Karlova Stánku", "U Kasáren", "U Kavalírky", "U Kazína", "U Kašny", "U Kaštanu", "U Kempinku", "U Kina", "U Klavírky", "U Klikovky", "U Klimentky", "U Kloubových Domů", "U Klubovny", "U Klubu", "U Kněžské Louky", "U Kola", "U Kolejí", "U Kolejí", "U Koloděj", "U Kolonie", "U Koloniálu", "U Kombinátu", "U Konečné", "U Koní", "U Kosinů", "U Kostela", "U Kostrounku", "U Kotlářky", "U Koupadel", "U Košíku", "U Krbu", "U Krbu", "U Krelovy Studánky", "U Kruhovky", "U Královské Louky", "U Krčské Vodárny", "U Krčského Nádraží", "U Kublova", "U Kunratického Lesa", "U Křižovatky", "U Kříže", "U Kříže", "U Křížku", "U Laboratoře", "U Ladronky", "U Lanové Dráhy", "U Ledáren", "U Lesa", "U Lesa", "U Lesíka", "U Letenského Sadu", "U Letiště", "U Letohrádku Královny Anny", "U Libeňského Pivovaru", "U Libeňského Zámku", "U Libušiných Lázní", "U Libušské Sokolovny", "U Lidového Domu", "U Lip", "U Lipové Aleje", "U Lisu", "U Loděnice", "U Lomu", "U Loskotů", "U Louky", "U Lužického Semináře", "U Lázeňky", "U Lázní", "U Lékárny", "U Líhní", "U Lípy", "U Malvazinky", "U Malé Řeky", "U Markéty", "U Mateřské Školy", "U Matěje", "U Maří Magdaleny", "U Meteoru", "U Mezníku", "U Michelské Školy", "U Michelského Lesa", "U Michelského Lesa", "U Michelského Mlýna", "U Milosrdných", "U Mlýna", "U Mlýna", "U Mlýnského Rybníka", "U Modré Školy", "U Modřanské Školy", "U Močálu", "U Mrázovky", "U Mydlárny", "U Myslivny", "U Městských Domů", "U Měšťanského Pivovaru", "U Měšťanských Škol", "U Nadýmače", "U Nemocenské Pojišťovny", "U Nemocnice", "U Nesypky", "U Nikolajky", "U Nové Dálnice", "U Nové Louky", "U Nové Školy", "U Nového Dvora", "U Nového Suchdola", "U Nového Suchdola", "U Nových Domů I", "U Nových Domů Ii", "U Nových Domů Iii", "U Nových Vil", "U Nádražní Lávky", "U Nádraží", "U Nádrže", "U Náhonu", "U Náhonu", "U Nákladového Nádraží", "U Nákladového Nádraží", "U Národní Galerie", "U Nás", "U Obce", "U Obecního Domu", "U Obecního Dvora", "U Obory", "U Okrouhlíku", "U Olšiček", "U Opatrovny", "U Ovčína", "U Palaty", "U Paliárky", "U Paloučku", "U Památníku", "U Panské Zahrady", "U Papírny", "U Parku", "U Parkánu", "U Parního Mlýna", "U Pastoušky", "U Pavilónu", "U Pazderek", "U Pejřárny", "U Pekařky", "U Pekáren", "U Pentlovky", "U Pergamenky", "U Pernikářky", "U Pernštejnských", "U Petřin", "U Pily", "U Plovárny", "U Plynárny", "U Plynárny", "U Plátenice", "U Podchodu", "U Podjezdu", "U Podolského Hřbitova", "U Podolského Sanatoria", "U Pohádky", "U Polikliniky", "U Pomníku", "U Potoka", "U Poustek", "U Poštovky", "U Pošty", "U Pramene", "U Prašné Brány", "U Prašného Mostu", "U Prašného Mostu", "U Pražských Lomů", "U Prefy", "U Prioru", "U Prknovky", "U Prodejny", "U Propusti", "U Prosecké Školy", "U Proseckého Kostela", "U První Baterie", "U První Baterie", "U Prádelny", "U Průhonu", "U Průseku", "U Pumpy", "U Párníků", "U Páté Baterie", "U Páté Baterie", "U Písecké Brány", "U Pískovny", "U Přechodu", "U Přehrady", "U Přejezdu", "U Půjčovny", "U Radiály", "U Radnice", "U Rajské Zahrady", "U Rakovky", "U Roháčových Kasáren", "U Rokytky", "U Rokytky", "U Rokytky", "U Rozkoše", "U Roztockého Háje", "U Rybníka", "U Rybníčka", "U Rybářství", "U Rychty", "U Rychty", "U Ryšánky", "U Ryšánky", "U Sadu", "U Sanatoria", "U Sanopzu", "U Santošky", "U Schodů", "U Sedlecké Školy", "U Seřadiště", "U Sila", "U Silnice", "U Silnice", "U Skalky", "U Skladu", "U Skládky", "U Skopců", "U Skály", "U Sladovny", "U Slavie", "U Sloupu", "U Slovanky", "U Slovanské Pojišťovny", "U Sluncové", "U Slévárny", "U Smaltovny", "U Smetanky", "U Smolnic", "U Smíchovského Hřbitova", "U Sokolovny", "U Soutoku", "U Sovových Mlýnů", "U Sparty", "U Splavu", "U Spojky", "U Spojů", "U Společenské Zahrady", "U Sportoviště", "U Spořitelny", "U Stanice", "U Staré Cihelny", "U Staré Plynárny", "U Staré Pošty", "U Staré Skládky", "U Staré Sokolovny", "U Staré Studánky", "U Staré Tvrze", "U Staré Školy", "U Staré Školy", "U Starého Hřbitova", "U Starého Hřiště", "U Starého Mlýna", "U Starého Nádraží", "U Starého Splavu", "U Starého Stadionu", "U Starého Stadiónu", "U Starého Židovského Hřbitova", "U Starého Židovského Hřbitova", "U Statku", "U Stavoservisu", "U Stojanu", "U Strouhy", "U Strže", "U Studny", "U Studánky", "U Studánky", "U Stárovny", "U Státní Dráhy", "U Státní Dráhy", "U Stírky", "U Střediska", "U Střešovických Hřišť", "U Sušičky", "U Svahu", "U Svatého Ducha", "U Svobodárny", "U Svodnice", "U Svornosti", "U Svépomoci", "U Světličky", "U Synagogy", "U Sádek", "U Sídliště", "U Tabulky", "U Technoplynu", "U Tenisu", "U Teplárny", "U Topíren", "U Továren", "U Transformační Stanice", "U Transformátoru", "U Trati", "U Trativodu", "U Trezorky", "U Trojice", "U Trojského Zámku", "U Trpce", "U Tržnice", "U Tvrze", "U Tyrše", "U Tyršovky", "U Tyršovy Školy", "U Třetí Baterie", "U Třešňovky", "U Třešňového Sadu", "U Tůně", "U Uhříněveské Obory", "U Uranie", "U Učiliště", "U Valu", "U Velké Skály", "U Vesny", "U Viktorky", "U Vinice", "U Viniček", "U Vinné Révy", "U Vinných Sklepů", "U Vinohradské Nemocnice", "U Vinohradského Hřbitova", "U Vinohradského Hřbitova", "U Vizerky", "U Višňovky", "U Višňovky", "U Vlachovky", "U Vlasačky", "U Vlečky", "U Vlečky", "U Vltavy", "U Voborníků", "U Vodice", "U Vodojemu", "U Vodojemu", "U Vodotoku", "U Vody", "U Vodárny", "U Vojanky", "U Vojenské Nemocnice", "U Vojtěšky", "U Vokovické Školy", "U Vorlíků", "U Vozovny", "U Vrbiček", "U Vrby", "U Vrtilky", "U Vršovického Hřbitova", "U Vršovického Hřbitova", "U Vršovického Nádraží", "U Vysočanského Cukrovaru", "U Vysočanského Pivovaru", "U Václava", "U Váhy", "U Vápenice", "U Vápenky", "U Vápenné Skály", "U Výkupního Střediska", "U Výstavby", "U Výstaviště", "U Výstaviště", "U Výzkumu", "U Včely", "U Větrníku", "U Větrolamu", "U Větrolamu", "U Věže", "U Waltrovky", "U Zahradnictví", "U Zahradního Města", "U Zahrady", "U Zahrádek", "U Zahrádkářské Kolonie", "U Zastávky", "U Zbrojnice", "U Zdravotního Ústavu", "U Zeleného Ptáka", "U Zemníku", "U Zeměpisného Ústavu", "U Zlaté Studně", "U Zličína", "U Zličína", "U Zličínského Hřiště", "U Zvonařky", "U Zvoničky", "U Záběhlického Zámku", "U Zájezdku", "U Zákrutu", "U Zámeckého Parku", "U Zámečku", "U Zámečnice", "U Zásobní Zahrady", "U Zátiší", "U Závodiště", "U Závor", "U Úlů", "U Čekárny", "U Černé Rokle", "U Červeného Mlýnku", "U Červeného Mlýnku", "U Českých Loděnic", "U Čihadel", "U Čističky", "U Čokoládoven", "U Čtvrté Baterie", "U Čtyř Domů", "U Řempa", "U Říčanky", "U Šalamounky", "U Šalamounky", "U Šesté Baterie", "U Šesté Baterie", "U Školičky", "U Školky", "U Školního Pole", "U Školské Zahrady", "U Školy", "U Štěpu", "U Šumavy", "U Šumavěnky", "U Šálkovny", "U Šíchů", "U Šípků", "U Železnice", "U Železničního Mostu", "U Železné Lávky", "U Želivky", "U Židovského Hřbitova", "U Žlábku", "U Županských", "Uhelný Trh", "Uherská", "Uhříněveská", "Ukončená", "Ukrajinská", "Uljanovská", "Ulrychova", "Ulčova", "Umělecká", "Ungarova", "Unhošťská", "Univerzitní", "Upolínová", "Upravená", "Uralská", "Urbanická", "Urbanova", "Urbánkova", "Urešova", "Uruguayská", "Urxova", "Utěšilova", "Uzavřená", "Uzbecká", "Uzoučká", "Učitelská", "Učňovská", "Užocká", "V Aleji", "V Alejích", "V Americe", "V Babyku", "V Bambouskách", "V Bažinách", "V Benátkách", "V Bezpečí", "V Bokách I", "V Bokách Ii", "V Bokách Iii", "V Borovičkách", "V Botanice", "V Brance", "V Brůdku", "V Brůdku", "V Bytovkách", "V Bílce", "V Březinkách", "V Březině", "V Březí", "V Břízkách", "V Celnici", "V Cestičkách", "V Cestkách", "V Chaloupkách", "V Chaloupkách", "V Chatách", "V Chotejně", "V Cibulkách", "V Cihelně", "V Cípu", "V Dolinách", "V Dolině", "V Dolině", "V Dolích", "V Domcích", "V Domově", "V Doubcích", "V Dílcích", "V Edenu", "V Haltýři", "V Hliništi", "V Hluboké", "V Hodkovičkách", "V Holešovičkách", "V Honu", "V Horkách", "V Horní Stromce", "V Hrobech", "V Humenci", "V Humenci", "V Humnech", "V Háji", "V Hájkách", "V Hájích", "V Hůrkách", "V Jahodách", "V Javorech", "V Javoříčku", "V Jehličině", "V Jehličí", "V Jezerách", "V Jezevčinách", "V Jezírkách", "V Jirchářích", "V Jámě", "V Kališti", "V Kališti", "V Kapslovně", "V Klukovicích", "V Kole", "V Kolkovně", "V Korytech", "V Korytech", "V Kotcích", "V Koutku", "V Koutě", "V Kratinách", "V Kruhu", "V Kuťatech", "V Kálku", "V Křepelkách", "V Křovinách", "V Křížkách", "V Ladech", "V Lesíčku", "V Lipinách", "V Lipinách", "V Lipkách", "V Lipách", "V Listnáčích", "V Lomech", "V Louce", "V Luhu", "V Lukách", "V Lučinách", "V Lužích", "V Lánech", "V Lázních", "V Lískách", "V Malých Domech I", "V Malých Domech Ii", "V Malých Domech Iii", "V Mezihoří", "V Milíři", "V Mokřinách", "V Mydlinkách", "V Nové Hostivaři", "V Nové Vsi", "V Nové Vsi", "V Nové Čtvrti", "V Novém Hloubětíně", "V Novém Hloubětíně", "V Nových Bohnicích", "V Nových Domcích", "V Nových Vokovicích", "V Náklích", "V Násypu", "V Nížinách", "V Oblouku", "V Občanském Domově", "V Obůrkách", "V Ochozu", "V Ohradě", "V Ohybu", "V Okruží", "V Okálech", "V Olšinách", "V Olšinách", "V Olšině", "V Ondřejově", "V Opatově", "V Osikách", "V Ostružiní", "V Oudolku", "V Ořeší", "V Pachmance", "V Padolině", "V Parcelách", "V Parku", "V Parníku", "V Pačátkách", "V Pařezinách", "V Pevnosti", "V Pevnosti", "V Pitkovičkách", "V Planinách", "V Platýzu", "V Pláni", "V Podbabě", "V Podhoří", "V Podhájí", "V Podhájí", "V Podluží", "V Podskalí", "V Podvrší", "V Podzámčí", "V Poli", "V Polích", "V Potokách", "V Potočinách", "V Potočkách", "V Prutinách", "V Průhledu", "V Průčelí", "V Pátém", "V Pískovně", "V Pěšinkách", "V Předním Hloubětíně", "V Předním Veleslavíně", "V Předpolí", "V Předpolí", "V Přelomu", "V Přístavu", "V Remízku", "V Rohožníku", "V Rohu", "V Roháčích", "V Rokli", "V Roklích", "V Rovinách", "V Rovinách", "V Rybníkách", "V Rybníčkách", "V Ráji", "V Ráji", "V Rákosí", "V Sadech", "V Sedlci", "V Sedlci", "V Slavětíně", "V Soudním", "V Stráni", "V Středu", "V Sudech", "V Sídlišti", "V Tehovičkách", "V Tišině", "V Trninách", "V Třešňovce", "V Tůních", "V Uličce", "V Uličkách", "V Zahradní Čtvrti", "V Zahradách", "V Zahrádkách", "V Zatáčce", "V Zeleni", "V Zeleném Údolí", "V Záhorském", "V Záhybu", "V Zákopech", "V Zákoutí", "V Zálesí", "V Zálomu", "V Zámcích", "V Zápolí", "V Zátiší", "V Zátočce", "V Závitu", "V Závětří", "V Zářezu", "V Údolí", "V Údolí Hvězd", "V Úhlu", "V Úhoru", "V Úvalu", "V Úvoze", "V Úzké", "V Úžlabině", "V Úžlabině", "V Čeňku", "V Štíhlách", "V Šáreckém Údolí", "V Žabokřiku", "V Žáčku", "V. P. Čkalova", "V. P. Čkalova", "Vachkova", "Vackova", "Vacovská", "Vacínova", "Vacínovská", "Vajdova", "Vajgarská", "Valcířská", "Valdická", "Valdovská", "Valdštejnská", "Valdštejnské Nám.", "Valdštejnské Náměstí", "Valentinská", "Valentinská", "Valentova", "Valečovská", "Valská", "Valtická", "Valtínovská", "Valčíkova", "Valšovská", "Vamberská", "Vanická", "Vaníčkova", "Vaníčkova", "Varhulíkové", "Varnsdorfská", "Varšavská", "Vavákova", "Vavřenova", "Vavřinecká", "Vazovova", "Vačkářova", "Vaňkova", "Vaňkova", "Vašátkova", "Ve Dvoře", "Ve Lhotce", "Ve Lhotce", "Ve Skalkách", "Ve Skalách", "Ve Skále", "Ve Slatinách", "Ve Smečkách", "Ve Smrčině", "Ve Stromořadí", "Ve Struhách", "Ve Struhách", "Ve Stráni", "Ve Studeném", "Ve Stínu", "Ve Střešovičkách", "Ve Střešovičkách", "Ve Svahu", "Ve Vilkách", "Ve Vilách", "Ve Višňovce", "Ve Vratech", "Ve Vrbách", "Ve Vrchu", "Ve Vrších", "Ve Výhledu", "Ve Výhledu", "Ve Výrech", "Ve Zliči", "Ve Štěpnici", "Ve Žlíbku", "Vedlejší", "Vehlovická", "Vejražkova", "Vejvanovského", "Vejvodova", "Velebného", "Velehradská", "Velemínská", "Velemínská", "Velenická", "Velenovského", "Veleslavínova", "Veleslavínská", "Veleslavínská", "Veletovská", "Veletržní", "Veletržní", "Veleňská", "Velešínská", "Velfloviců", "Velflíkova", "Velhartická", "Velichovská", "Velimská", "Velkoborská", "Velkoosecká", "Velkopřevorské Nám.", "Velkopřevorské Náměstí", "Velká Lada", "Velká Lada", "Velká Skála", "Velké Kunratické", "Veltruská", "Veltěžská", "Velvarská", "Velínská", "Venušina", "Verdiho", "Verdunská", "Verneřická", "Verneřická", "Vernéřovská", "Veronské Nám.", "Veselská", "Veská", "Veslařský Ostrov", "Vestavěná", "Vestecká", "Veverkova", "Večerní", "Vidimova", "Vidimská", "Vidlicová", "Vidlák", "Vidonická", "Vidoulská", "Vidovická", "Vietnamská", "Viklefova", "Vikova", "Viktora Huga", "Viktorinova", "Viktorčina", "Vikářská", "Vilová", "Vilímkova", "Vilímovská", "Vimperské Náměstí", "Vinařického", "Vinařská", "Viničná", "Vinohradská", "Vinohradská", "Vinohradská", "Vinohradská", "Vinohradská", "Vinohradská", "Vinohradská", "Vinohrady", "Vinopalnická", "Vinořská", "Vinořské Nám.", "Vinořské Náměstí", "Vinšova", "Violková", "Vitošská", "Vitíkova", "Vitějovská", "Vizovická", "Višňovka", "Višňovka", "Višňová", "Vlachova", "Vladimírova", "Vladislava Vančury", "Vladislavova", "Vladivostocká", "Vladycká", "Vlastibořská", "Vlastina", "Vlastina", "Vlastislavova", "Vlasty Buriana", "Vlasty Hilské", "Vlasty Průchové", "Vlasákova", "Vlašimská", "Vlašská", "Vlašská", "Vlaštovčí", "Vlkanovská", "Vlkova", "Vlkovická", "Vlnitá", "Vltavanů", "Vltavanů", "Vltavanů", "Vltavická", "Vltavská", "Vltavínová", "Vlárská", "Vlásenická", "Vlčická", "Vlčkova", "Vlčnovská", "Vnislavova", "Vnitřní", "Vnoučkova", "Vnější", "Voborského", "Vobrubova", "Vocelova", "Voctářova", "Voctářova", "Vodická", "Vodičkova", "Vodičkova", "Vodnická", "Vodní", "Vodochodská", "Vodojemská", "Vodácká", "Vodárenská", "Voděradská", "Vodňanská", "Vodňanského", "Vojenova", "Vojetická", "Vojická", "Vojkovická", "Vojslavická", "Vojtova", "Vojtíškova", "Vojtěšská", "Vojáčkova", "Vokovická", "Vokovická", "Vokrojova", "Vokáčova", "Vokřínská", "Volarská", "Volavkova", "Voleníkova", "Volkova", "Volkovova", "Voltova", "Volutová", "Volyňská", "Volšovská", "Volšovská", "Vondroušova", "Vorařská", "Voroněžská", "Voroněžská", "Voráčovská", "Voršilská", "Voskova", "Voskovcova", "Vosmíkových", "Vostrovská", "Vostrého", "Vosátkova", "Votavova", "Votická", "Votočkova", "Votrubova", "Votuzská", "Vozová", "Vozová", "Voňkova", "Voříškova", "Vošahlíkova", "Vožická", "Vrabčí", "Vranická", "Vranovská", "Vranská", "Vratimovská", "Vratislavova", "Vratislavská", "Vratičová", "Vraňanská", "Vrbenského", "Vrbická", "Vrbková", "Vrbova", "Vrbčanská", "Vrchlabská", "Vrchlického", "Vrchlického Sady", "Vrchovinská", "Vrátenská", "Vrátkovská", "Vrázova", "Vrážská", "Vrútecká", "Vršní", "Vršovická", "Vršovické Nám.", "Vršovické Náměstí", "Vršovka", "Vsetínská", "Vstavačová", "Vstupní", "Vybíralova", "Vycpálkova", "Vyderská", "Vydrova", "Vyhlídkova", "Vykoukových", "Vykáňská", "Vyskočilova", "Vysokovská", "Vysokoškolská", "Vysoká Cesta", "Vysočanská", "Vysočanská", "Vysočanská", "Vysočanské Nám.", "Vysočanské Náměstí", "Vyvýšená", "Vyšebrodská", "Vyšehradská", "Vyšší", "Vyžlovská", "Vzdušná", "Vzdálená", "Vzestupná", "Vzpoury", "Váchalova", "Václava Balého", "Václava Kovaříka", "Václava Rady", "Václava Trojana", "Václava Špačka", "Václavická", "Václavkova", "Václavská", "Václavské Nám.", "Václavské Náměstí", "Vágnerova", "Vánková", "Vápencová", "Vápenná", "Vápeníkova", "Vášova", "Vážská", "Vídeňská", "Vídeňská", "Vídeňská", "Vírská", "Víta Nejedlého", "Vítkova", "Vítkovická", "Vítovcova", "Vítovcova", "Vítězná", "Vítězná", "Vítězné Nám.", "Vítězné Nám.", "Vítězné Náměstí", "Vítězné Náměstí", "Východní", "Východní Nám.", "Východní Náměstí", "Výchozí", "Výhledová", "Výhledské Nám.", "Výhledské Náměstí", "Výjezdní", "Výjezdová", "Výletní", "Výletní", "Výmarova", "Výmolova", "Výpadová", "Výpadová", "Výravská", "Výrobní", "Výstaviště", "Výstavní", "Výstupní", "Výtoňská", "Výtvarnická", "Výtvarná", "Výzkumníků", "Včelařská", "Včelničná", "Věkova", "Věstonická", "Větrná", "Větrovcova", "Větrová", "Větrušická", "Vězeňská", "Vězeňská", "Věštínská", "Věšínova", "Věžická", "Vřesovická", "Vřesová", "Všehrdova", "Všejanská", "Všelipská", "Všerubská", "Všestarská", "Všetatská", "Všeňská", "Wagnerova", "Waldesova", "Washingtonova", "Wassermannova", "Wattova", "Weberova", "Weberova", "Weilova", "Weissova", "Wenzigova", "Wenzigova", "Werichova", "Wichterlova", "Wiedermannova", "Wiesenthalova", "Wilsonova", "Wilsonova", "Winklerova", "Wolfova", "Wolkerova", "Wuchterlova", "Xaveriova", "Xaverovská", "Za Archivem", "Za Arielem", "Za Avií", "Za Bažantnicí", "Za Botičem", "Za Brankou", "Za Brumlovkou", "Za Brůdkem", "Za Břízami", "Za Chalupami", "Za Cukrovarem", "Za Císařským Mlýnem", "Za Dolejšákem", "Za Drahou", "Za Dvorem", "Za Dálnicí", "Za Dálnicí", "Za Elektrárnou", "Za Elektrárnou", "Za Farou", "Za Fořtem", "Za Hanspaulkou", "Za Haštalem", "Za Hládkovem", "Za Horou", "Za Horou", "Za Hospodou", "Za Hrází", "Za Humny", "Za Hájem", "Za Hájem", "Za Hájovnou", "Za Hřbitovem", "Za Invalidovnou", "Za Jalovým Dvorem", "Za Jednotou", "Za Kajetánkou", "Za Kapličkou", "Za Karlínským Přístavem", "Za Kačabkou", "Za Klíčovem", "Za Knotkem", "Za Knotkem", "Za Kostelem", "Za Kovárnou", "Za Kovářským Rybníkem", "Za Křížem", "Za Křížkem", "Za Lesíkem", "Za Lidovým Domem", "Za Luhem", "Za Lužinami", "Za Lány", "Za Lázeňkou", "Za Mlýnem", "Za Mosty", "Za Mosty", "Za Mototechnou", "Za Můstkem", "Za Nadýmačem", "Za Novákovou Zahradou", "Za Návsí", "Za Obecním Úřadem", "Za Oborou", "Za Opravnou", "Za Opusem", "Za Ovčínem", "Za Papírnou", "Za Parkem", "Za Pavilónem", "Za Pekařkou", "Za Pekárnou", "Za Pivovarem", "Za Ploty", "Za Podjezdem", "Za Pohořelcem", "Za Pohádkou", "Za Potokem", "Za Poříčskou Branou", "Za Poříčskou Bránou", "Za Poštou", "Za Poštovskou Zahradou", "Za Poštovskou Zahradou", "Za Prodejnou", "Za Pruhy", "Za Průsekem", "Za Pískovnou", "Za Radostí", "Za Rokytkou", "Za Rybníkem", "Za Rybníčky", "Za Rybářstvím", "Za Rájem", "Za Sadem", "Za Sedmidomky", "Za Skalkou", "Za Skalkou", "Za Slatinami", "Za Slovankou", "Za Sokolovnou", "Za Stadionem", "Za Statkem", "Za Statky", "Za Stodolami", "Za Stodolou", "Za Strahovem", "Za Strašnickou Vozovnou", "Za Strašnickou Vozovnou", "Za Strojírnami", "Za Studánkou", "Za Střelnicí", "Za Sídlištěm", "Za Teplárnou", "Za Tratí", "Za Tratí", "Za Třebešínem", "Za Vackovem", "Za Valem", "Za Viaduktem", "Za Vinicí", "Za Vlasačkou", "Za Vodárnou", "Za Vokovickou Vozovnou", "Za Vokovickou Vozovnou", "Za Větrem", "Za Zahradami", "Za Zahradou", "Za Zastávkou", "Za Zelenou Liškou", "Za Zámečkem", "Za Černým Mostem", "Za Černým Mostem", "Za Černým Mostem", "Za Školkou", "Za Školou", "Za Šmatlíkem", "Za Železnicí", "Za Ženskými Domovy", "Za Žižkovskou Vozovnou", "Zacharská", "Zachova", "Zadní", "Zahrada Na Baště", "Zahradnická", "Zahradní", "Zahradníčkova", "Zahradníčkova", "Zahrádecká", "Zahrádecká", "Zahrádkářská", "Zahrádkářů", "Zaječická", "Zaječí", "Zaječí", "Zakouřilova", "Zakrytá", "Zakšínská", "Zalešanská", "Zalinská", "Zamašská", "Zamenhofova", "Zapadlá", "Zapomenutá", "Zapova", "Zapských", "Zastavěná", "Zastrčená", "Zavadilova", "Zavátá", "Zaříčanská", "Zbečenská", "Zborovská", "Zborovská", "Zbraslavská", "Zbraslavská", "Zbraslavské Nám.", "Zbraslavské Náměstí", "Zbrojnická", "Zbudovská", "Zbuzanská", "Zbuzkova", "Zbynická", "Zbyslavská", "Zbytinská", "Zbýšovská", "Zdaru", "Zdařilá", "Zderazská", "Zdeňky Nyplové", "Zdibská", "Zdická", "Zdiměřická", "Zdislavická", "Zdobnická", "Zdoňovská", "Zdíkovská", "Zelenečská", "Zelenečská", "Zelenkova", "Zelenky-Hajského", "Zelenohorská", "Zelená", "Zelená", "Zelená Louka", "Zelený Pruh", "Zelený Pruh", "Zelený Pruh", "Zelinářská", "Zemanka", "Zemské Právo", "Zemědělská", "Zengrova", "Zenklova", "Zenklova", "Zeyerova Alej", "Zhořelecká", "Zikova", "Zimova", "Zimákova", "Zkrácená", "Zlatnice", "Zlatnická", "Zlatokorunská", "Zlatá", "Zlatá Ulička U Daliborky", "Zlenická", "Zlešická", "Zlivská", "Zličínská", "Zličínská", "Zlonická", "Zlonínská", "Zlončická", "Zlíchovská", "Znojemská", "Zoubkova", "Zrzavého", "Ztracená", "Zubatého", "Zubrnická", "Zvolenská", "Zvolská", "Zvolská", "Zvonařova", "Zvonařovská", "Zvonařská", "Zvoncovitá", "Zvonická", "Zvonková", "Zvoníčkova", "Zvánovická", "Zvíkovská", "Záblatská", "Záblatská", "Zábranská", "Zábrodí", "Záběhlická", "Zádražanská", "Záhornická", "Záhorského", "Záhořanská", "Záhořanského", "Záhřebská", "Zájezdní", "Zákolanská", "Zákostelní", "Zákupská", "Zálesí", "Zálesí", "Zálesí", "Záluské", "Zálužanského", "Zálužická", "Zálužská", "Zálužská", "Zámecká", "Zámecké Schody", "Zámezí", "Zámišova", "Zámělská", "Západní", "Zápasnická", "Zápolská", "Zápotoční", "Zápská", "Zárubova", "Zárybnická", "Zárybničná", "Zárybská", "Zásadská", "Zásmucká", "Zátišská", "Zátiší", "Zátopkova", "Zátoňská", "Závadova", "Záveská", "Závist", "Závišova", "Závišova", "Závodní", "Závrchy", "Závěrka", "Zázvorkova", "Zářijová", "Zítkova", "Zívrova", "Zúžená", "Údlická", "Údolní", "Údolní", "Údolí Hvězd", "Úhlavská", "Úhlová", "Újezd", "Újezd", "Újezdská", "Úlibická", "Únorová", "Únětická", "Únětická", "Úpická", "Úprkova", "Úpská", "Úslavská", "Ústavní", "Ústecká", "Ústecká", "Ústřední", "Útulná", "Útulná", "Úvalská", "Úvoz", "Úvoz", "Úvozová", "Úzká", "Čajkovského", "Čakovická", "Čakovická", "Čankovská", "Čapkova", "Častavina", "Častonická", "Čechova", "Čechtická", "Čechurova", "Čedičová", "Čejetická", "Čejkovická", "Čekanková", "Čekanková", "Čekanovská", "Čelakovského Sady", "Čelakovského Sady", "Čeljabinská", "Čelkovická", "Čelná", "Čelákovická", "Čenkovská", "Čenovická", "Čentická", "Čenětická", "Čeperská", "Čeradická", "Čerchovská", "Čermákova", "Černická", "Černilovská", "Černičná", "Černochova", "Černockého", "Černohorského", "Černokostelecká", "Černokostelecká", "Černokostelecká", "Černomořská", "Černotínská", "Černovická", "Černošická", "Černá", "Černého", "Černínova", "Černínská", "Čerpadlová", "Čertouská", "Čertouská", "Čertův Vršek", "Červencová", "Červenkova", "Červená", "Červená Báň", "Červený Mlýn", "Červeňanského", "Červnová", "Čerčanská", "Českobratrská", "Českobrodská", "Českobrodská", "Českobrodská", "Českobrodská", "Českobrodská", "Českobrodská", "Českobrodská", "Českobrodská", "Českodubská", "Českolipská", "Českolipská", "Českomalínská", "Českomoravská", "Českomoravská", "Československého Exilu", "Československého Exilu", "Česká", "České Družiny", "Českého Červeného Kříže", "Čestlická", "Čestmírova", "Česákova", "Čečelická", "Čeňkova", "Češovská", "Čibuzská", "Čihákova", "Čiklova", "Čiklova", "Čimelická", "Čimická", "Čimická", "Čimická", "Čimická", "Čirůvková", "Čistovická", "Čmelická", "Čs. Armády", "Čs. Tankistů", "Čtyřdílná", "Čtyřkolská", "Čumpelíkova", "Čuprova", "Čábelecká", "Čápova", "Čáslavská", "Čílova", "Čílova", "Čínská", "Čínská", "Čížovská", "Ďáblická", "Ďáblická", "Ďáblická", "Řadová", "Řehořova", "Řepečská", "Řepná", "Řeporyjská", "Řeporyjská", "Řeporyjská", "Řeporyjské Náměstí", "Řepová", "Řepská", "Řepíková", "Řepínská", "Řepčická", "Řepčická", "Řetězokovářů", "Řetězová", "Řevnická", "Řevnická", "Řeznická", "Řezáčovo Nám.", "Řezáčovo Náměstí", "Řečického", "Řešetovská", "Řešovská", "Řipská", "Řipská", "Řásnovka", "Říjnová", "Římovská", "Římovská", "Římská", "Říčanova", "Říčanská", "Říční", "Šachovská", "Šafaříkova", "Šafránecká", "Šafránkova", "Šafránová", "Šafářova", "Šakvická", "Šaldova", "Šalounova", "Šalvějová", "Šanovská", "Šantrochova", "Šatrova", "Šatrova", "Šebelova", "Šeberovská", "Šebestiánská", "Šebkova", "Šedivého", "Šedova", "Šejbalové", "Šemberova", "Šenovská", "Šermířská", "Šermířská", "Šestajovická", "Šestajovická", "Šestidomí", "Šetelíkova", "Ševce Matouše", "Ševčenkova", "Ševčíkova", "Šeříková", "Šeříková", "Šibřinská", "Šikmá", "Šimanovská", "Šimkova", "Šimonova", "Šimáčkova", "Šimůnkova", "Šircova", "Široká", "Široká", "Šiškova", "Školní", "Školská", "Škroupovo Nám.", "Škroupovo Náměstí", "Škrétova", "Škvorecká", "Škábova", "Šlechtitelská", "Šlejnická", "Šlikova", "Šlitrova", "Šluknovská", "Šmeralova", "Šmilovského", "Šmolíkova", "Šolínova", "Šostakovičovo Nám.", "Šostakovičovo Náměstí", "Španielova", "Španělská", "Špačkova", "Špeciánova", "Šperlova", "Špirkova", "Špitálská", "Šplechnerova", "Šporkova", "Špotzova", "Špálova", "Šrobárova", "Šrobárova", "Šromova", "Štamberk", "Štefkova", "Štefánikova", "Štemberova", "Šternberkova", "Šternova", "Šternovská", "Štichova", "Štiplova", "Štičkova", "Štiřínská", "Štochlova", "Štolbova", "Štolcova", "Štolmířská", "Štolmířská", "Štorchova", "Štorkánova", "Štramberská", "Štulcova", "Štupartská", "Štursova", "Štverákova", "Štychova", "Štychova", "Štíbrova", "Štíhlická", "Štítného", "Štítová", "Štúrova", "Štúrova", "Štěchovická", "Štěpanická", "Štěpařská", "Štěpničná", "Štěpánkova", "Štěpánovská", "Štěpánská", "Štěpánská", "Štěrboholská", "Štěrková", "Štětkova", "Štětínská", "Šubertova", "Šulcova", "Šultysova", "Šumavská", "Šumavského", "Šumberova", "Šumenská", "Šumická", "Šumperská", "Šustova", "Švabinského", "Švecova", "Švehlova", "Švehlova", "Švejcarovo Náměstí", "Švestková", "Švestková", "Švestková", "Švihovská", "Švábky", "Švábova", "Švédská", "Šárecká", "Šárovo Kolo", "Šárčina", "Šátalská", "Šífařská", "Šímova", "Šípková", "Šítkova", "Šťastného", "Šůrova", "Žabovřeská", "Žacléřská", "Žalanského", "Žalmanova", "Žalovská", "Žamberská", "Žampašská", "Žampiónová", "Žandovská", "Žatecká", "Žatecká", "Žateckých", "Ždírnická", "Žehuňská", "Žehušická", "Želetavská", "Železniční", "Železničářů", "Železnobrodská", "Železná", "Želivecká", "Želivka", "Želivská", "Želkovická", "Želnavská", "Ženíškova", "Žeretická", "Žermanická", "Žernosecká", "Žernovská", "Žerotínova", "Žherská", "Žichlínská", "Židlického", "Žilinská", "Žilovská", "Žinkovská", "Žirovnická", "Žitavská", "Žitavského", "Žitná", "Žitná", "Žitomírská", "Živanická", "Živcová", "Živcových", "Živonínská", "Žiželická", "Žižkova", "Žižkovo Nám.", "Žižkovo Náměstí", "Žlebská", "Žluťásková", "Žofie Podlipské", "Žufanova", "Žukovského", "Žukovského", "Žulová", "Županovická", "Žvahovská", "Žábova", "Žákovská", "Žárovická", "Žíšovská", "Žďárská"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) /***/ }, -/* 146 */ -/***/ function(module, exports, __webpack_require__) { +/* 139 */ +/***/ function(module, exports) { - var baseHas = __webpack_require__(54), - keys = __webpack_require__(53); + "use strict"; - /** Used to compose bitmasks for comparison styles. */ - var PARTIAL_COMPARE_FLAG = 2; + module.exports = { + name: ["#{names.lastName} #{company.suffix}", "#{names.lastName} #{company.suffix}", "#{names.lastName} a #{names.lastName} #{company.suffix}"], - /** - * 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 {Function} equalFunc The function to determine equivalents of values. - * @param {Function} customizer The function to customize comparisons. - * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual` - * for more details. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ - function equalObjects(object, other, equalFunc, customizer, bitmask, stack) { - var isPartial = bitmask & PARTIAL_COMPARE_FLAG, - objProps = keys(object), - objLength = objProps.length, - othProps = keys(other), - othLength = othProps.length; - - if (objLength != othLength && !isPartial) { - return false; - } - var index = objLength; - while (index--) { - var key = objProps[index]; - if (!(isPartial ? key in other : baseHas(other, key))) { - return false; - } - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked) { - return stacked == other; - } - var result = true; - stack.set(object, other); - - 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, customizer, bitmask, stack)) - : compared - )) { - result = false; - break; - } - skipCtor || (skipCtor = key == 'constructor'); - } - if (result && !skipCtor) { - var objCtor = object.constructor, - othCtor = other.constructor; + suffix: ["s.r.o.", "a.s.", "v.o.s."] + }; - // 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); - return result; - } +/***/ }, +/* 140 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; - module.exports = equalObjects; + module.exports = { + _meta: { + id: "cs-CZ", + fallback: null, + language: "Czech", + country: "Česká republika", + countryCode: "CZ" + }, + names: __webpack_require__(141), + phone: __webpack_require__(146), + address: __webpack_require__(135), + company: __webpack_require__(139), + internet: __webpack_require__(147) + }; /***/ }, -/* 147 */ +/* 141 */ /***/ function(module, exports, __webpack_require__) { - var isStrictComparable = __webpack_require__(148), - keys = __webpack_require__(53); - - /** - * 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; + "use strict"; - while (length--) { - var key = result[length], - value = object[key]; + module.exports = { + firstNameM: __webpack_require__(142), - result[length] = [key, value, isStrictComparable(value)]; - } - return result; - } + firstNameF: __webpack_require__(143), - module.exports = getMatchData; + lastNameM: __webpack_require__(144), + lastNameF: __webpack_require__(145), -/***/ }, -/* 148 */ -/***/ function(module, exports, __webpack_require__) { + prefix: ["Ing.", "Mgr.", "JUDr.", "MUDr."], - var isObject = __webpack_require__(4); + suffix: ["Phd."], - /** - * 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); - } + nameM: ["#{names.prefix} #{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM} #{names.suffix}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}"], - module.exports = isStrictComparable; + nameF: ["#{names.prefix} #{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF} #{names.suffix}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}"] + }; /***/ }, -/* 149 */ +/* 142 */ /***/ function(module, exports) { - /** - * 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))); - }; - } - - module.exports = matchesStrictComparable; - - -/***/ }, -/* 150 */ -/***/ function(module, exports, __webpack_require__) { - - var baseIsEqual = __webpack_require__(138), - get = __webpack_require__(119), - hasIn = __webpack_require__(151), - isKey = __webpack_require__(126), - isStrictComparable = __webpack_require__(148), - matchesStrictComparable = __webpack_require__(149), - toKey = __webpack_require__(127); - - /** Used to compose bitmasks for comparison styles. */ - var UNORDERED_COMPARE_FLAG = 1, - PARTIAL_COMPARE_FLAG = 2; - - /** - * 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, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG); - }; - } - - module.exports = baseMatchesProperty; - - -/***/ }, -/* 151 */ -/***/ function(module, exports, __webpack_require__) { - - var baseHasIn = __webpack_require__(152), - hasPath = __webpack_require__(153); - - /** - * 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); - } - - module.exports = hasIn; + "use strict"; + module.exports = ["Abadon", "Abdon", "Ábel", "Abelard", "Abraham", "Abrahám", "Absolon", "Absolón", "Adalbert", "Adam", "Adin", "Adolf", "Adrian", "Adrián", "Agaton", "Achil", "Achiles", "Alan", "Alban", "Albert", "Albín", "Albrecht", "Aldo", "Alen", "Aleš", "Alexandr", "Alexej", "Alfons", "Alfréd", "Alois", "Alojz", "Alva", "Alvar", "Alvin", "Amadeus", "Amand", "Amát", "Ambrož", "Amos", "Ámos", "Anastáz", "Anatol", "Anděl", "Andělín", "Andrej", "Anselm", "Antal", "Antonín", "Aram", "Ariel", "Aristid", "Arkád", "Armand", "Armin", "Arne", "Arnold", "Arnošt", "Áron", "Árón", "Arpád", "Arsen", "Artur", "Artuš", "Arzen", "Atanas", "Atanáš", "Atila", "August", "Augustin", "Augustýn", "Aurel", "Aurelián", "Axel", "Baltazar", "Barnabáš", "Bartoloměj", "Basil", "Bazil", "Beatus", "Bedřich", "Benedikt", "Benjamin", "Benjamín", "Bernard", "Bertold", "Bertram", "Bivoj", "Blahomil", "Blahomír", "Blahoslav", "Blažej", "Bohdan", "Bohuchval", "Bohumil", "Bohumír", "Bohun", "Bohuslav", "Bohuš", "Bojan", "Bolemír", "Boleslav", "Bonifác", "Borek", "Boris", "Borislav", "Bořek", "Bořislav", "Bořivoj", "Božetěch", "Božidar", "Božislav", "Branimír", "Branislav", "Bratislav", "Bret", "Brian", "Brit", "Bronislav", "Bruno", "Břetislav", "Budimír", "Budislav", "Budivoj", "Cecil", "Cedrik", "Celestin", "Celestýn", "César", "Cézar", "Ctibor", "Ctirad", "Ctislav", "Cyprián", "Cyril", "Čeněk", "Čestmír", "Čistoslav", "Dag", "Dalibor", "Dalimil", "Dalimír", "Damián", "Dan", "Daniel", "Darek", "Darius", "David", "Denis", "Děpold", "Dětmar", "Dětřich", "Dezider", "Dimitrij", "Dino", "Dionýz", "Dionýzos", "Diviš", "Dluhoš", "Dobromil", "Dobromír", "Dobroslav", "Dominik", "Donald", "Donát", "Dorian", "Dorián", "Drahomil", "Drahomír", "Drahoň", "Drahoslav", "Drahoš", "Drahotín", "Drahutin", "Dušan", "Edgar", "Edmond", "Edmund", "Eduard", "Edvard", "Edvin", "Edvín", "Egmont", "Egon", "Eliáš", "Elizej", "Elizeus", "Elmar", "Elvis", "Emanuel", "Emanuel", "Emerich", "Emil", "Emilián", "Engelbert", "Erazim", "Erazmus", "Erhard", "Erich", "Erik", "Ernest", "Ernst", "Ervín", "Eugen", "Eusebius", "Evald", "Evan", "Evarist", "Evžen", "Ezechiel", "Ezra", "Fabián", "Faust", "Faustin", "Faustýn", "Fedor", "Felicián", "Felix", "Ferdinand", "Fidel", "Fidelius", "Filemon", "Filibert", "Filip", "Filomen", "Flavián", "Flavius", "Florentin", "Florentýn", "Florián", "Fortunát", "Fráňa", "Franc", "František", "Fridolín", "Gabin", "Gabriel", "Gál", "Garik", "Gaston", "Gedeon", "Gejza", "Genadij", "Gerald", "Gerard", "Gerazim", "Gerhard", "Géza", "Gilbert", "Gleb", "Glen", "Gorazd", "Gordon", "Gothard", "Gracián", "Grant", "Gunter", "Gűnter", "Gustav", "Hanuš", "Harald", "Harold", "Haštal", "Havel", "Helmut", "Herbert", "Herman", "Heřman", "Hilar", "Hilarius", "Hjalmar", "Homér", "Honor", "Honorius", "Horác", "Horst", "Horymír", "Hostimil", "Hostimír", "Hostislav", "Hostivít", "Hovard", "Hubert", "Hugo", "Hvězdoslav", "Hyacint", "Hynek", "Hypolit", "Chrabroš", "Chraniboj", "Chranibor", "Chranislav", "Chrudoš", "Chval", "Ignác", "Ignát", "Igor", "Ilja", "Inocenc", "Irenej", "Ireneus", "Irvin", "Isidor", "Ivan", "Ivar", "Ivo", "Ivor", "Izaiáš", "Izák", "Izidor", "Izmael", "Jacek", "Jáchym", "Jakub", "Jan", "Jarmil", "Jarolím", "Jaromil", "Jaromír", "Jaroslav", "Jason", "Jasoň", "Jeremiáš", "Jeroným", "Jiljí", "Jimram", "Jindřich", "Jiří", "Job", "Joel", "Jonáš", "Jonatan", "Jonathan", "Jordan", "Josef", "Jošt", "Jozef", "Jozue", "Juda", "Julián", "Julius", "Justin", "Justýn", "Kajetán", "Kamil", "Karel", "Kasián", "Kastor", "Kašpar", "Kazimír", "Kilián", "Kim", "Klaudián", "Klaudius", "Klement", "Kliment", "Knut", "Koloman", "Kolombín", "Kolumbán", "Kolumbín", "Konrád", "Konstantin", "Konstantýn", "Kornel", "Kornelius", "Kosma", "Kosmas", "Krasomil", "Krasoslav", "Kristián", "Kryšpín", "Kryštof", "Křesomysl", "Křišťan", "Kurt", "Květoň", "Květoslav", "Květoš", "Kvido", "Ladislav", "Lambert", "Lars", "Laurenc", "Lazar", "Leander", "Leandr", "Leo", "Leodegar", "Leon", "Leonard", "Leonid", "Leontýn", "Leopold", "Leoš", "Lešek", "Lev", "Libor", "Liboslav", "Lionel", "Livius", "Lorenc", "Lotar", "Lothar", "Lubomír", "Lubor", "Luboslav", "Luboš", "Lucián", "Lucius", "Luděk", "Ludivoj", "Ludomír", "Ludoslav", "Ludvík", "Lukáš", "Lukrecius", "Lumír", "Lutibor", "Lutobor", "Magnus", "Makar", "Manfred", "Manfréd", "Mansvet", "Manuel", "Marcel", "Marek", "Marian", "Marián", "Marin", "Mario", "Marius", "Martin", "Matěj", "Matouš", "Matyáš", "Max", "Maxim", "Maximilián", "Maxmilián", "Mečislav", "Medard", "Melichar", "Merlin", "Mervin", "Metod", "Metoděj", "Michael", "Michal", "Mikoláš", "Mikuláš", "Milan", "Milíč", "Milík", "Milivoj", "Miloň", "Milorad", "Miloslav", "Miloš", "Milota", "Milouš", "Milovan", "Milovín", "Milutín", "Mirek", "Mirko", "Miromil", "Miron", "Miroslav", "Mirtil", "Mlad", "Mladen", "Mnata", "Mnislav", "Modest", "Mojmír", "Mojžíš", "Morgan", "Moric", "Moris", "Mořic", "Mstislav", "Myron", "Myrtil", "Napoleon", "Narcis", "Natan", "Natanael", "Nathan", "Nathanael", "Něhoslav", "Neklan", "Nepomuk", "Nezamysl", "Nikita", "Nikodém", "Nikola", "Nikolas", "Norbert", "Norman", "Odolen", "Odon", "Oktavián", "Oktavius", "Olaf", "Olbram", "Oldřich", "Oleg", "Oliver", "Omar", "Ondřej", "Orest", "Oskar", "Osvald", "Ota", "Otakar", "Otmar", "Oto", "Otokar", "Otomar", "Ovidius", "Palmiro", "Pankrác", "Pantaleon", "Paris", "Parsival", "Paskal", "Patrik", "Pavel", "Pavlín", "Pelhřim", "Perikles", "Petr", "Petronius", "Pius", "Platon", "Platón", "Polykarp", "Pravdomil", "Pravomil", "Prokop", "Prosper", "Přemysl", "Přibyslav", "Radan", "Radegast", "Radek", "Radhost", "Radim", "Radimír", "Radislav", "Radivoj", "Radko", "Radmil", "Radomil", "Radomír", "Radoslav", "Radoš", "Radovan", "Radúz", "Radvan", "Rafael", "Raimund", "Rainald", "Rainer", "Rainhard", "Rainold", "Rajko", "Ralf", "Ramon", "Randolf", "Ranek", "Ranko", "Rastislav", "Ratibor", "Ratmír", "Redmond", "Reginald", "Remig", "Remus", "Renát", "René", "Richard", "Robert", "Robin", "Robinson", "Rodan", "Roderik", "Rodrigo", "Roger", "Roch", "Roland", "Rolf", "Roman", "Romeo", "Romuald", "Romul", "Romulus", "Ronald", "Rostislav", "Ruben", "Rudolf", "Rufus", "Rupert", "Ruprecht", "Ruslan", "Řehoř", "Sába", "Sámo", "Samson", "Samuel", "Saturnin", "Saul", "Sáva", "Sebastian", "Sebastián", "Sebestian", "Sedrik", "Serafín", "Serenus", "Sergej", "Servác", "Severín", "Sidon", "Sigfríd", "Silvan", "Silván", "Silvestr", "Silvius", "Simeon", "Simon", "Sinkler", "Sixt", "Sixtus", "Slávek", "Slaviboj", "Slavibor", "Slavoboj", "Slavoj", "Slavomil", "Slavomír", "Smil", "Soběslav", "Sokrat", "Soter", "Spytihněv", "Stanimír", "Stanislav", "Stojan", "Stojmír", "Svatoboj", "Svatobor", "Svatomír", "Svatopluk", "Svatoslav", "Sven", "Svetozar", "Šalamoun", "Šalomoun", "Šavel", "Šebastián", "Šimon", "Šťasta", "Štefan", "Štěpán", "Tadeáš", "Tankred", "Taras", "Teobald", "Teodor", "Teodorik", "Teodoz", "Teofan", "Teofil", "Terenc", "Terencius", "Theobald", "Theodor", "Theodorik", "Theofan", "Theofil", "Tiber", "Tiberius", "Tibor", "Tiburcius", "Tichomil", "Tichomír", "Tichon", "Timon", "Timotej", "Timoteus", "Timur", "Titus", "Tobiáš", "Tomáš", "Tomislav", "Tor", "Torkvát", "Torsten", "Tristan", "Udo", "Ulrich", "Upton", "Urban", "Uve", "Václav", "Vadim", "Valdemar", "Valentin", "Valentýn", "Valerián", "Valter", "Valtr", "Vasil", "Vavřinec", "Veleslav", "Velimír", "Velislav", "Věnceslav", "Vendelín", "Věnek", "Verner", "Věroslav", "Vidor", "Viktor", "Viktorin", "Viktorín", "Vilém", "Vilibald", "Vilmar", "Vincenc", "Virgil", "Virgin", "Vít", "Vítězslav", "Vitold", "Vítoslav", "Vivian", "Vladan", "Vladimír", "Vladislav", "Vladivoj", "Vlastimil", "Vlastimír", "Vlastislav", "Vlk", "Vojen", "Vojmil", "Vojmír", "Vojslav", "Vojtěch", "Vok", "Volfgang", "Vratislav", "Vsevolod", "Všeboj", "Všebor", "Všerad", "Všeslav", "Xaver", "Xaverius", "Záboj", "Zachar", "Zachariáš", "Záviš", "Zbislav", "Zbyhněv", "Zbyněk", "Zbyslav", "Zbyšek", "Zdeněk", "Zderad", "Zdeslav", "Zdík", "Zdirad", "Zdislav", "Zeno", "Zenon", "Zikmund", "Zlatan", "Zlatko", "Zlatomír", "Zoltán", "Zoran", "Zoroslav", "Zosim", "Zvonimír", "Žarko", "Ždan", "Želibor", "Želimír", "Želislav", "Želmír", "Žitomír", "Žitoslav", "Živan"]; /***/ }, -/* 152 */ +/* 143 */ /***/ function(module, exports) { - /** - * 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); - } - - module.exports = baseHasIn; + "use strict"; + module.exports = ["Abigail", "Ada", "Adalberta", "Adéla", "Adelaida", "Adina", "Adolfa", "Adolfína", "Adriana", "Adriána", "Adriena", "Afra", "Agáta", "Aglaja", "Aida", "Alana", "Albena", "Alberta", "Albertina", "Albertýna", "Albína", "Alena", "Aleška", "Alexandra", "Alfréda", "Alice", "Alida", "Alina", "Alma", "Aloisie", "Alojzije", "Alžběta", "Amálie", "Amanda", "Amáta", "Amélie", "Anabela", "Anastázie", "Anatázie", "Anatolie", "Anatólie", "Anděla", "Andělína", "Andrea", "Aneta", "Anežka", "Angela", "Angelika", "Anita", "Anna", "Anselma", "Antonie", "Apolena", "Arabela", "Aranka", "Areta", "Ariadna", "Ariana", "Ariela", "Arleta", "Armida", "Arna", "Arnolda", "Arnoštka", "Astrid", "Astrida", "Atanázie", "Augusta", "Augustina", "Augustýna", "Aura", "Aurélie", "Aurora", "Babeta", "Barbara", "Barbora", "Beáta", "Beatrice", "Bedřiška", "Bela", "Běla", "Belinda", "Benedikta", "Berenika", "Berit", "Bernarda", "Berta", "Bertolda", "Bianka", "Bibiana", "Birgit", "Birgita", "Blahomila", "Blahomíra", "Blahoslava", "Blanka", "Blažena", "Bohdana", "Bohumila", "Bohumíra", "Bohuna", "Bohuslava", "Bohuše", "Bojana", "Bojislava", "Boleslava", "Borislava", "Bořislava", "Božena", "Božetěcha", "Božidara", "Branimíra", "Branislava", "Bratislava", "Brenda", "Brigita", "Brita", "Bronislava", "Bruna", "Brunhilda", "Břetislava", "Cecilie", "Cecílie", "Celestina", "Celestýna", "Celie", "Celina", "Ctibora", "Ctirada", "Ctislava", "Cyntie", "Cyrila", "Čeňka", "Čestmíra", "Čistoslava", "Dagmar", "Dagmara", "Dalibora", "Dalida", "Dalie", "Dalila", "Dalimila", "Dalimíra", "Damaris", "Damiana", "Damiána", "Dana", "Danica", "Daniela", "Danuše", "Danuta", "Daria", "Darie", "Darina", "Darja", "Davida", "Debora", "Delie", "Denisa", "Diana", "Dina", "Dita", "Diviška", "Dobrava", "Dobromila", "Dobromíra", "Dobroslava", "Dominika", "Donalda", "Donáta", "Dora", "Doris", "Dorota", "Doubrava", "Doubravka", "Drahomila", "Drahomíra", "Drahoslava", "Drahotína", "Drahuše", "Dulcinea", "Dušana", "Edita", "Eduarda", "Edvarda", "Egona", "Ela", "Elektra", "Elena", "Eleonora", "Elfrída", "Eliška", "Elsa", "Elvíra", "Elza", "Ema", "Emanuela", "Emilie", "Emílie", "Erika", "Erna", "Ervína", "Estela", "Ester", "Estera", "Etela", "Eufrozina", "Eufrozína", "Eugenie", "Eulálie", "Eunika", "Eusebie", "Eva", "Evelina", "Evelína", "Evženie", "Fabiána", "Fabie", "Fatima", "Faustina", "Faustýna", "Féba", "Fedora", "Felicie", "Felície", "Felicita", "Ferdinanda", "Fidelie", "Filipa", "Filoména", "Flavie", "Flora", "Flóra", "Florentina", "Florentýna", "Františka", "Frída", "Gabriela", "Gaja", "Gajana", "Galina", "Garika", "Gema", "Geralda", "Geraldina", "Gerarda", "Gerardina", "Gerda", "Gerharda", "Gertruda", "Gilberta", "Gina", "Gisela", "Gita", "Gizela", "Glorie", "Gordana", "Graciána", "Gracie", "Grácie", "Gražina", "Gréta", "Griselda", "Grizelda", "Gudrun", "Gustava", "Gvendolina", "Gvendolína", "Halina", "Hana", "Háta", "Havla", "Heda", "Hedvika", "Heidrun", "Helena", "Helga", "Herberta", "Hermína", "Herta", "Hilda", "Hortensie", "Hortenzie", "Horymíra", "Hostimila", "Hostimíra", "Hostislava", "Hvězdoslava", "Hyacinta", "Chranislava", "Iboja", "Ida", "Ignácie", "Ignáta", "Ildika", "Iljana", "Ilona", "Ilsa", "Ilza", "Ines", "Inesa", "Inéz", "Ingeborg", "Ingeborga", "Ingrid", "Ingrida", "Inka", "Irena", "Iris", "Irma", "Isabela", "Isidora", "Isolda", "Iva", "Ivana", "Iveta", "Ivona", "Izabela", "Izidora", "Izolda", "Jadrana", "Jadranka", "Jakuba", "Jakubka", "Jana", "Jarmila", "Jarolíma", "Jaromíra", "Jaroslava", "Jasmína", "Jasna", "Jasněna", "Jelena", "Jenovéfa", "Jesika", "Jindra", "Jindřiška", "Jiřina", "Jitka", "Johana", "Jolana", "Jolanta", "Jordana", "Jorga", "Josefa", "Josefína", "Jovana", "Jozefa", "Jozefína", "Judita", "Juliana", "Juliána", "Julie", "Justina", "Justýna", "Juta", "Kamila", "Karin", "Karina", "Karla", "Karmela", "Karmen", "Karolina", "Karolína", "Kateřina", "Katrin", "Katrina", "Kazi", "Kazimíra", "Kira", "Klára", "Klaudie", "Klementina", "Klementýna", "Kleopatra", "Klotylda", "Koleta", "Kolombína", "Kolumbína", "Konstance", "Konstancie", "Konsuela", "Konzuela", "Kora", "Kordula", "Korina", "Kornélie", "Krasava", "Krasomila", "Kristina", "Kristýna", "Kunhuta", "Květa", "Květoslava", "Květuše", "Lada", "Ladislava", "Larisa", "Laura", "Laurencie", "Lea", "Léda", "Leila", "Lejla", "Lena", "Lenka", "Leokádie", "Leona", "Leonora", "Leontina", "Leontýna", "Leopolda", "Leopoldina", "Leopoldýna", "Leticie", "Lia", "Liana", "Liběna", "Libora", "Liboslava", "Libuše", "Lidmila", "Liliana", "Lina", "Linda", "Livie", "Ljuba", "Lola", "Loreta", "Lorna", "Lota", "Lubomíra", "Luboslava", "Luciána", "Lucie", "Ludiše", "Luďka", "Ludmila", "Ludomíra", "Ludoslava", "Ludvika", "Ludvíka", "Luisa", "Lujza", "Lukrécie", "Lumíra", "Lydie", "Lýdie", "Mabel", "Mabela", "Magda", "Magdalena", "Magdaléna", "Mahulena", "Maja", "Mája", "Malvína", "Manon", "Manona", "Manuela", "Marcela", "Marcelína", "Margit", "Margita", "Mariana", "Marie", "Marieta", "Marika", "Marilyn", "Marina", "Mariola", "Marion", "Marisa", "Marita", "Markéta", "Marlena", "Marta", "Martina", "Matylda", "Maud", "Maxima", "Mečislava", "Medea", "Médea", "Melánie", "Melinda", "Melisa", "Melita", "Mercedes", "Michaela", "Michala", "Milada", "Milana", "Milena", "Miloslava", "Milred", "Miluše", "Mína", "Mira", "Mirabela", "Miranda", "Mirela", "Miriam", "Mirjam", "Mirka", "Miromila", "Miroslava", "Mnislava", "Mona", "Monika", "Muriel", "Muriela", "Myrna", "Naďa", "Naděžda", "Naneta", "Narcisa", "Natalie", "Natálie", "Nataša", "Neda", "Nela", "Nevena", "Nika", "Niké", "Nikodéma", "Nikol", "Nikola", "Nila", "Nina", "Noema", "Noemi", "Nona", "Nora", "Norberta", "Norma", "Odeta", "Ofélie", "Oktavie", "Oktávie", "Oldřiška", "Olga", "Oliva", "Olivie", "Olympie", "Ondřejka", "Otakara", "Otilie", "Otýlie", "Oxana", "Palmira", "Pamela", "Paskala", "Patricie", "Pavla", "Pavlína", "Pelagie", "Penelopa", "Perla", "Persida", "Perzida", "Petra", "Petrana", "Petronela", "Petronila", "Petruše", "Petula", "Pilar", "Polyxena", "Pravdomila", "Pravomila", "Pravoslav", "Pravoslava", "Priscila", "Priska", "Prokopa", "Přibyslava", "Radana", "Radimíra", "Radislava", "Radka", "Radmila", "Radomila", "Radomíra", "Radoslava", "Radovana", "Radslava", "Rafaela", "Ráchel", "Raisa", "Rajsa", "Ramona", "Rastislava", "Rebeka", "Regina", "Regína", "Renata", "Renáta", "René", "Ria", "Riana", "Richarda", "Rina", "Rita", "Roberta", "Robina", "Romana", "Rosa", "Rosalinda", "Rosamunda", "Rosana", "Rostislava", "Rovena", "Roxana", "Róza", "Rozálie", "Rozalinda", "Rozamunda", "Rozana", "Rozina", "Rozita", "Rozvita", "Rudolfa", "Rudolfina", "Rudolfína", "Rut", "Rút", "Růžena", "Řehořka", "Sabina", "Sabrina", "Salomea", "Salomena", "Samuela", "Sandra", "Sára", "Saskia", "Saskie", "Saxona", "Selena", "Selma", "Senta", "Serafína", "Serena", "Scholastika", "Sibyla", "Sidonie", "Silvána", "Silvie", "Simeona", "Simona", "Skarlet", "Skarleta", "Slavěna", "Slávka", "Slavomila", "Slavomíra", "Soběslava", "Sofie", "Sofronie", "Solveig", "Solveiga", "Soňa", "Sotira", "Stanislava", "Stáza", "Stela", "Svatava", "Svatoslava", "Světla", "Světlana", "Světluše", "Sylva", "Sylvie", "Sylvie", "Šárka", "Šarlota", "Šimona", "Štěpána", "Štěpánka", "Tamara", "Táňa", "Taťána", "Tea", "Tekla", "Teodora", "Teodozie", "Teofila", "Tereza", "Terezie", "Thea", "Theodora", "Theodosie", "Theofila", "Tomáška", "Toska", "Ulrika", "Una", "Uršula", "Václava", "Valburga", "Valdemara", "Valentina", "Valentýna", "Valerie", "Valérie", "Vanda", "Vanesa", "Věduna", "Veleslava", "Velislava", "Věnceslava", "Vendelína", "Vendula", "Vendulka", "Věnka", "Venuše", "Věra", "Verona", "Veronika", "Věroslava", "Věslava", "Vesna", "Viktorie", "Viléma", "Vilemína", "Vilma", "Vincencie", "Viola", "Violeta", "Virginie", "Virgínie", "Víta", "Vítězslava", "Viviana", "Vladana", "Vladěna", "Vladimíra", "Vladislava", "Vlasta", "Vlastimila", "Vlastimíra", "Vlastislava", "Vojmíra", "Vojslava", "Vojtěška", "Voršila", "Vratislava", "Xaverie", "Xenie", "Zaida", "Zaira", "Zbyhněva", "Zbyňka", "Zbyslava", "Zbyška", "Zdena", "Zdenka", "Zdeňka", "Zdeslava", "Zdislava", "Zenobie", "Zina", "Zinaida", "Zita", "Zlata", "Zlatomíra", "Zlatuše", "Zoe", "Zoja", "Zora", "Zoroslava", "Zuzana", "Zvonimíra", "Žakelina", "Žakelína", "Žaneta", "Ždana", "Želimíra", "Želislava", "Želmíra", "Žitomíra", "Žitoslava", "Živa", "Živana", "Žofie"]; /***/ }, -/* 153 */ -/***/ function(module, exports, __webpack_require__) { - - var castPath = __webpack_require__(121), - isArguments = __webpack_require__(59), - isArray = __webpack_require__(2), - isIndex = __webpack_require__(67), - isKey = __webpack_require__(126), - isLength = __webpack_require__(64), - isString = __webpack_require__(66), - toKey = __webpack_require__(127); - - /** - * 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 = isKey(path, object) ? [path] : castPath(path); - - var result, - index = -1, - length = path.length; - - while (++index < length) { - var key = toKey(path[index]); - if (!(result = object != null && hasFunc(object, key))) { - break; - } - object = object[key]; - } - if (result) { - return result; - } - var length = object ? object.length : 0; - return !!length && isLength(length) && isIndex(key, length) && - (isArray(object) || isString(object) || isArguments(object)); - } +/* 144 */ +/***/ function(module, exports) { - module.exports = hasPath; + "use strict"; + module.exports = ["Adam", "Adamec", "Adámek", "Albrecht", "Ambrož", "Anděl", "Andrle", "Antoš", "Bajer", "Baláž", "Balcar", "Balog", "Baloun", "Barák", "Baran", "Bareš", "Bárta", "Barták", "Bartoň", "Bartoš", "Bartošek", "Bartůněk", "Bašta", "Bauer", "Bayer", "Bažant", "Bečka", "Bečvář", "Bednář", "Bednařík", "Bělohlávek", "Benda", "Beneš", "Beran", "Beránek", "Berger", "Berka", "Berky", "Bernard", "Bezděk", "Bílek", "Bílý", "Bína", "Bittner", "Blaha", "Bláha", "Blažek", "Blecha", "Bobek", "Boček", "Boháč", "Boháček", "Böhm", "Borovička", "Bouček", "Bouda", "Bouška", "Brabec", "Brabenec", "Brada", "Bradáč", "Braun", "Brázda", "Brázdil", "Brejcha", "Březina", "Bříza", "Brož", "Brožek", "Brychta", "Bubeník", "Buček", "Buchta", "Burda", "Bureš", "Burian", "Buriánek", "Byrtus", "čada", "Caha", "čáp", "čapek", "čech", "čejka", "čermák", "černík", "černoch", "černohorský", "černý", "červeňák", "červenka", "červený", "červinka", "Chaloupka", "Chalupa", "Charvát", "Chládek", "Chlup", "Chmelař", "Chmelík", "Chovanec", "Chromý", "Chudoba", "Chvátal", "Chvojka", "Chytil", "Cibulka", "čihák", "Cihlář", "Císař", "čížek", "čonka", "Coufal", "čurda", "Daněk", "Daniel", "Daniš", "David", "Dědek", "Demeter", "Dittrich", "Diviš", "Dlouhý", "Dobeš", "Dobiáš", "Dobrovolný", "Dočekal", "Dočkal", "Dohnal", "Dokoupil", "Doleček", "Dolejš", "Dolejší", "Doležal", "Doležel", "Doskočil", "Dostál", "Doubek", "Doubrava", "Douša", "Drábek", "Drozd", "Dubský", "Duchoň", "Duda", "Dudek", "Dufek", "Dunka", "Dušek", "Dvořáček", "Dvořák", "Dvorský", "Eliáš", "Erben", "Fabián", "Fanta", "Farkaš", "Fejfar", "Fencl", "Ferenc", "Ferko", "Fiala", "Fiedler", "Filip", "Fischer", "Fišer", "Florián", "Fojtík", "Foltýn", "Forman", "Formánek", "Fořt", "Fousek", "Franc", "Franěk", "Frank", "Fridrich", "Frydrych", "Fuchs", "Fučík", "Fuksa", "Gábor", "Gabriel", "Gajdoš", "Gaži", "Gottwald", "Gregor", "Gruber", "Grundza", "Grygar", "Hájek", "Hajný", "Hála", "Hampl", "Hána", "Hanáček", "Hanák", "Hanousek", "Hanus", "Hanuš", "Hanzal", "Hanzl", "Hanzlík", "Hartman", "Hašek", "Havel", "Havelka", "Havlíček", "Havlík", "Havránek", "Heczko", "Heger", "Hejda", "Hejduk", "Hejl", "Hejna", "Hendrych", "Herman", "Heřman", "Heřmánek", "Hladík", "Hladký", "Hlaváč", "Hlaváček", "Hlavatý", "Hlávka", "Hloušek", "Hoffmann", "Hofman", "Holan", "Holas", "Holec", "Holeček", "Holík", "Holoubek", "Holub", "Holý", "Homola", "Homolka", "Hora", "Horáček", "Horák", "Hořejší", "Horký", "Horňák", "Horníček", "Horník", "Horský", "Horvát", "Horváth", "Hošek", "Houdek", "Houška", "Hovorka", "Hrabal", "Hrabovský", "Hradecký", "Hradil", "Hrbáček", "Hrbek", "Hrdina", "Hrdlička", "Hrdý", "Hrnčíř", "Hroch", "Hromádka", "Hron", "Hrubeš", "Hrubý", "Hruška", "Hrůza", "Hubáček", "Hudec", "Hudeček", "Hůlka", "Huml", "Husák", "Hušek", "Hýbl", "Hynek", "Jahoda", "Jakeš", "Jakl", "Jakoubek", "Jakubec", "Janáček", "Janák", "Janata", "Janča", "Jančík", "Janda", "Janeček", "Janečka", "Janíček", "Janík", "Janků", "Janota", "Janoušek", "Janovský", "Jansa", "Jánský", "Janů", "Jareš", "Jaroš", "Jašek", "Javůrek", "Jech", "Jedlička", "Jelen", "Jelínek", "Jeníček", "Jeřábek", "Jež", "Ježek", "Jílek", "Jindra", "Jíra", "Jirák", "Jiránek", "Jirásek", "Jiřík", "Jirka", "Jirků", "Jiroušek", "Jirsa", "John", "Jonáš", "Junek", "Jurčík", "Jurečka", "Juřica", "Juřík", "Kabát", "Kačírek", "Kadeřábek", "Kadlec", "Kafka", "Kaiser", "Kala", "Kaláb", "Kalaš", "Kalina", "Kalivoda", "Kalous", "Kalousek", "Kameník", "Kaňa", "Káňa", "Kaňka", "Kantor", "Kaplan", "Karas", "Karásek", "Karban", "Karel", "Karlík", "Kasal", "Kašík", "Kašpar", "Kašpárek", "Kavka", "Kazda", "Kindl", "Klečka", "Klein", "Klement", "Klíma", "Kliment", "Klimeš", "Klouček", "Klouda", "Knap", "Knotek", "Koch", "Kočí", "Kocián", "Kocman", "Kocourek", "Kohout", "Kohoutek", "Koláček", "Kolář", "Kolařík", "Kolek", "Kolman", "Komárek", "Komínek", "Konečný", "Koníček", "Kopal", "Kopeček", "Kopecký", "Kopečný", "Kopřiva", "Korbel", "Kořínek", "Kos", "Kosík", "Kosina", "Košťál", "Kostka", "Kotas", "Kotek", "Kotlár", "Kotrba", "Kouba", "Koubek", "Koudela", "Koudelka", "Koukal", "Kouřil", "Koutný", "Kováč", "Kovář", "Kovařík", "Kovářík", "Kozák", "Kozel", "Krajíček", "Král", "Králíček", "Králík", "Krátký", "Kratochvíl", "Kraus", "Krčmář", "Křeček", "Krejčí", "Krejčík", "Krejčíř", "Křenek", "Krištof", "Křivánek", "Kříž", "Křížek", "Kropáček", "Kroupa", "Krupa", "Krupička", "Krupka", "Kuba", "Kubánek", "Kubát", "Kubec", "Kubelka", "Kubeš", "Kubica", "Kubíček", "Kubík", "Kubín", "Kubiš", "Kuča", "Kučera", "Kuchař", "Kuchta", "Kudláček", "Kudrna", "Kukla", "Kulhánek", "Kulhavý", "Kunc", "Kuneš", "Kupec", "Kupka", "Kurka", "Kužel", "Kvapil", "Kvasnička", "Kyncl", "Kysela", "Lacina", "Lacko", "Lakatoš", "Landa", "Lang", "Langer", "Langr", "Látal", "Lavička", "Le", "Lebeda", "Levý", "Líbal", "Linhart", "Liška", "Lorenc", "Louda", "Ludvík", "Lukáč", "Lukáš", "Lukášek", "Lukeš", "Macák", "Macek", "Mach", "Mácha", "Machač", "Macháč", "Macháček", "Machala", "Machálek", "Macura", "Majer", "Maleček", "Málek", "Malík", "Malina", "Malý", "Maňák", "Mareček", "Marek", "Mareš", "Mařík", "Maršálek", "Maršík", "Martinec", "Martinek", "Martínek", "Mašek", "Masopust", "Matějíček", "Matějka", "Matouš", "Matoušek", "Matula", "Matuška", "Matyáš", "Matys", "Maxa", "Mayer", "Mazánek", "Medek", "Melichar", "Mencl", "Menšík", "Merta", "Michal", "Michalec", "Michálek", "Michalík", "Michna", "Mička", "Mika", "Míka", "Mikeš", "Miko", "Mikula", "Mikulášek", "Minář", "Minařík", "Mirga", "Mládek", "Mlčoch", "Mlejnek", "Mojžíš", "Mokrý", "Molnár", "Moravec", "Morávek", "Motl", "Motyčka", "Moučka", "Moudrý", "Mráček", "Mráz", "Mrázek", "Mrkvička", "Mucha", "Müller", "Műller", "Musil", "Mužík", "Myška", "Nagy", "Najman", "Navrátil", "Nečas", "Nedbal", "Nedoma", "Nedvěd", "Nejedlý", "Němec", "Němeček", "Nešpor", "Nesvadba", "Neubauer", "Neuman", "Neumann", "Nguyen", "Nguyen van", "Nosek", "Nováček", "Novák", "Novosad", "Novotný", "Nový", "Odehnal", "Oláh", "Oliva", "Ondra", "Ondráček", "Orság", "Otáhal", "Paleček", "Pánek", "Papež", "Pařízek", "Pašek", "Pátek", "Patočka", "Paul", "Pavel", "Pavelek", "Pavelka", "Pavlas", "Pavlica", "Pavlíček", "Pavlík", "Pavlů", "Pazdera", "Pech", "Pecha", "Pecháček", "Pecka", "Pekař", "Pekárek", "Pelc", "Pelikán", "Peřina", "Pernica", "Peroutka", "Pešek", "Peška", "Pešta", "Peterka", "Petr", "Petrák", "Petráš", "Petříček", "Petřík", "Petrů", "Pham", "Pícha", "Pilař", "Pilát", "Píša", "Pivoňka", "Plaček", "Plachý", "Plšek", "Pluhař", "Podzimek", "Pohl", "Pokorný", "Poláček", "Polách", "Polák", "Polanský", "Polášek", "Polívka", "Popelka", "Pospíchal", "Pospíšil", "Potůček", "Pour", "Prachař", "Prášek", "Pražák", "Prchal", "Přibyl", "Příhoda", "Přikryl", "Procházka", "Prokeš", "Prokop", "Prošek", "Provazník", "Průcha", "Průša", "Pšenička", "Ptáček", "Rác", "Rada", "Rak", "Rambousek", "Raška", "Rataj", "řeháček", "řehák", "řehoř", "Remeš", "řezáč", "Rezek", "řezníček", "Richter", "Richtr", "říha", "Roubal", "Rous", "Rozsypal", "Rudolf", "Růžek", "Růžička", "Ryba", "Rybář", "Rýdl", "Ryšavý", "Sadílek", "šafář", "šafařík", "šafránek", "šálek", "Samek", "šanda", "šašek", "Schejbal", "Schmidt", "Schneider", "Schwarz", "šebek", "šebela", "šebesta", "šeda", "šedivý", "Sedláček", "Sedlák", "Sedlář", "Sehnal", "Seidl", "Seifert", "Sekanina", "Semerád", "šenk", "šesták", "ševčík", "Severa", "Sikora", "šilhavý", "šíma", "šimáček", "šimák", "šimánek", "šimčík", "šimeček", "šimek", "šimon", "šimůnek", "šindelář", "šindler", "šíp", "šípek", "šír", "široký", "šiška", "Sivák", "Skácel", "Skala", "Skála", "Skalický", "Sklenář", "škoda", "Skopal", "Skořepa", "škrabal", "Skřivánek", "Slabý", "Sládek", "Sladký", "Sláma", "Slanina", "Slavíček", "Slavík", "šlechta", "Slezák", "Slováček", "Slovák", "Sluka", "Smejkal", "šmejkal", "Smékal", "šmerda", "Smetana", "šmíd", "Smola", "Smolík", "Smolka", "Smrčka", "Smrž", "Smutný", "šnajdr", "Sobek", "Sobotka", "Sochor", "Sojka", "Sokol", "šolc", "Sommer", "Souček", "Soukup", "Sova", "špaček", "Spáčil", "špička", "šplíchal", "Spurný", "šrámek", "Srb", "Staněk", "Stárek", "Starý", "šťastný", "štefan", "štefek", "štefl", "Stehlík", "Steiner", "Stejskal", "štěpán", "štěpánek", "štěrba", "Stibor", "Stoklasa", "Straka", "Stránský", "Strejček", "Strnad", "Strouhal", "Stuchlík", "Studený", "Studnička", "Stupka", "šubrt", "Suchánek", "Suchomel", "Suchý", "Suk", "šulc", "šustr", "šváb", "Svačina", "švanda", "švarc", "Svatoň", "Svatoš", "švec", "švehla", "švejda", "švestka", "Světlík", "Sviták", "Svoboda", "Svozil", "Sýkora", "Synek", "Syrový", "Táborský", "Tancoš", "Teplý", "Tesař", "Tichý", "Toman", "Tománek", "Tomáš", "Tomášek", "Tomeček", "Tomek", "Tomeš", "Tóth", "Tran", "Trávníček", "Trčka", "Tříska", "Trnka", "Trojan", "Truhlář", "Tuček", "Tůma", "Tureček", "Turek", "Tvrdík", "Tvrdý", "Uher", "Uhlíř", "Ulrich", "Urban", "Urbanec", "Urbánek", "Vacek", "Vácha", "Václavek", "Václavík", "Vaculík", "Vágner", "Vala", "Valášek", "Válek", "Valenta", "Valeš", "Váňa", "Vančura", "Vaněček", "Vaněk", "Vaníček", "Varga", "Vašák", "Vašek", "Vašíček", "Vávra", "Vavřík", "Večeřa", "Vejvoda", "Verner", "Veselý", "Veverka", "Vícha", "Vilímek", "Vinš", "Víšek", "Vít", "Vitásek", "Vítek", "Vlach", "Vlasák", "Vlček", "Vlk", "Vobořil", "Vodák", "Vodička", "Vodrážka", "Vojáček", "Vojta", "Vojtěch", "Vojtek", "Vojtíšek", "Vokoun", "Volek", "Volf", "Volný", "Vondra", "Vondráček", "Vondrák", "Voráček", "Vorel", "Voříšek", "Vorlíček", "Votava", "Votruba", "Vrabec", "Vrána", "Vrba", "Vrzal", "Vybíral", "Vydra", "Vymazal", "Vyskočil", "Vysloužil", "Wagner", "Walter", "Weber", "Weiss", "Winkler", "Wolf", "Zábranský", "žáček", "Zach", "Zahrádka", "Zahradník", "Zajíc", "Zajíček", "žák", "Zálešák", "Zámečník", "Zapletal", "Záruba", "Zatloukal", "Zavadil", "Zavřel", "Zbořil", "žďárský", "Zdražil", "Zedník", "Zelenka", "Zelený", "Zelinka", "Zeman", "Zemánek", "žemlička", "Zezula", "žídek", "žiga", "Zíka", "Zikmund", "Zima", "žižka", "Zlámal", "Zoubek", "Zouhar", "žůrek", "Zvěřina"]; /***/ }, -/* 154 */ +/* 145 */ /***/ function(module, exports) { - /** - * This method returns the first argument given to it. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Util - * @param {*} value Any value. - * @returns {*} Returns `value`. - * @example - * - * var object = { 'user': 'fred' }; - * - * console.log(_.identity(object) === object); - * // => true - */ - function identity(value) { - return value; - } - - module.exports = identity; + "use strict"; + module.exports = ["Adamová", "Adamcová", "Adámková", "Albrechtová", "Ambrožová", "Andělová", "Andrleová", "Antošová", "Bajrová", "Balážová", "Balcarová", "Balogová", "Balounová", "Baráková", "Baranová", "Barešová", "Bártová", "Bartáková", "Bartoňová", "Bartošová", "Bartošková", "Bartůněková", "Baštová", "Baurová", "Bayrová", "Bažantová", "Bečková", "Bečvářová", "Bednářová", "Bednaříková", "Bělohlávková", "Bendová", "Benešová", "Beranová", "Beránková", "Bergrová", "Berková", "Berkyová", "Bernardová", "Bezděková", "Bílková", "Bílýová", "Bínová", "Bittnrová", "Blahová", "Bláhová", "Blažková", "Blechová", "Bobková", "Bočková", "Boháčová", "Boháčková", "Böhmová", "Borovičková", "Boučková", "Boudová", "Boušková", "Brabcová", "Brabencová", "Bradová", "Bradáčová", "Braunová", "Brázdová", "Brázdilová", "Brejchová", "Březinová", "Břízová", "Brožová", "Brožková", "Brychtová", "Bubeníková", "Bučková", "Buchtová", "Burdová", "Burešová", "Burianová", "Buriánková", "Byrtusová", "čadová", "Cahová", "čápová", "čapková", "čechová", "čejková", "čermáková", "černíková", "černochová", "černohorskýová", "černýová", "červeňáková", "červenková", "červenýová", "červinková", "Chaloupková", "Chalupová", "Charvátová", "Chládková", "Chlupová", "Chmelařová", "Chmelíková", "Chovancová", "Chromýová", "Chudobová", "Chvátalová", "Chvojková", "Chytilová", "Cibulková", "čiháková", "Cihlářová", "Císařová", "čížková", "čonková", "Coufalová", "čurdová", "Daněková", "Danilová", "Danišová", "Davidová", "Dědková", "Demetrová", "Dittrichová", "Divišová", "Dlouhýová", "Dobešová", "Dobiášová", "Dobrovolnýová", "Dočekalová", "Dočkalová", "Dohnalová", "Dokoupilová", "Dolečková", "Dolejšová", "Dolejšíová", "Doležalová", "Doležlová", "Doskočilová", "Dostálová", "Doubková", "Doubravová", "Doušová", "Drábková", "Drozdová", "Dubskýová", "Duchoňová", "Dudová", "Dudková", "Dufková", "Dunková", "Dušková", "Dvořáčková", "Dvořáková", "Dvorskýová", "Eliášová", "Erbnová", "Fabiánová", "Fantová", "Farkašová", "Fejfarová", "Fenclová", "Ferencová", "Ferkoová", "Fialová", "Fiedlrová", "Filipová", "Fischrová", "Fišrová", "Floriánová", "Fojtíková", "Foltýnová", "Formanová", "Formánková", "Fořtová", "Fousková", "Francová", "Franěková", "Franková", "Fridrichová", "Frydrychová", "Fuchsová", "Fučíková", "Fuksová", "Gáborová", "Gabrilová", "Gajdošová", "Gažiová", "Gottwaldová", "Gregorová", "Grubrová", "Grundzová", "Grygarová", "Hájková", "Hajnýová", "Hálová", "Hamplová", "Hánová", "Hanáčková", "Hanáková", "Hanousková", "Hanusová", "Hanušová", "Hanzalová", "Hanzlová", "Hanzlíková", "Hartmanová", "Hašková", "Havlová", "Havelková", "Havlíčková", "Havlíková", "Havránková", "Heczkoová", "Hegrová", "Hejdová", "Hejduková", "Hejlová", "Hejnová", "Hendrychová", "Hermanová", "Heřmanová", "Heřmánková", "Hladíková", "Hladkýová", "Hlaváčová", "Hlaváčková", "Hlavatýová", "Hlávková", "Hloušková", "Hoffmannová", "Hofmanová", "Holanová", "Holasová", "Holcová", "Holečková", "Holíková", "Holoubková", "Holubová", "Holýová", "Homolová", "Homolková", "Horová", "Horáčková", "Horáková", "Hořejšíová", "Horkýová", "Horňáková", "Horníčková", "Horníková", "Horskýová", "Horvátová", "Horváthová", "Hošková", "Houdková", "Houšková", "Hovorková", "Hrabalová", "Hrabovskýová", "Hradeckýová", "Hradilová", "Hrbáčková", "Hrbková", "Hrdinová", "Hrdličková", "Hrdýová", "Hrnčířová", "Hrochová", "Hromádková", "Hronová", "Hrubešová", "Hrubýová", "Hrušková", "Hrůzová", "Hubáčková", "Hudcová", "Hudečková", "Hůlková", "Humlová", "Husáková", "Hušková", "Hýblová", "Hynková", "Jahodová", "Jakešová", "Jaklová", "Jakoubková", "Jakubcová", "Janáčková", "Janáková", "Janatová", "Jančová", "Jančíková", "Jandová", "Janečková", "Janečková", "Janíčková", "Janíková", "Jankůová", "Janotová", "Janoušková", "Janovskýová", "Jansová", "Jánskýová", "Janůová", "Jarešová", "Jarošová", "Jašková", "Javůrková", "Jechová", "Jedličková", "Jelnová", "Jelínková", "Jeníčková", "Jeřábková", "Ježová", "Ježková", "Jílková", "Jindrová", "Jírová", "Jiráková", "Jiránková", "Jirásková", "Jiříková", "Jirková", "Jirkůová", "Jiroušková", "Jirsová", "Johnová", "Jonášová", "Junková", "Jurčíková", "Jurečková", "Juřicová", "Juříková", "Kabátová", "Kačírková", "Kadeřábková", "Kadlcová", "Kafková", "Kaisrová", "Kalová", "Kalábová", "Kalašová", "Kalinová", "Kalivodová", "Kalousová", "Kalousková", "Kameníková", "Kaňová", "Káňová", "Kaňková", "Kantorová", "Kaplanová", "Karasová", "Karásková", "Karbanová", "Karlová", "Karlíková", "Kasalová", "Kašíková", "Kašparová", "Kašpárková", "Kavková", "Kazdová", "Kindlová", "Klečková", "Kleinová", "Klementová", "Klímová", "Klimentová", "Klimešová", "Kloučková", "Kloudová", "Knapová", "Knotková", "Kochová", "Kočíová", "Kociánová", "Kocmanová", "Kocourková", "Kohoutová", "Kohoutková", "Koláčková", "Kolářová", "Kolaříková", "Kolková", "Kolmanová", "Komárková", "Komínková", "Konečnýová", "Koníčková", "Kopalová", "Kopečková", "Kopeckýová", "Kopečnýová", "Kopřivová", "Korblová", "Kořínková", "Kosová", "Kosíková", "Kosinová", "Košťálová", "Kostková", "Kotasová", "Kotková", "Kotlárová", "Kotrbová", "Koubová", "Koubková", "Koudelová", "Koudelková", "Koukalová", "Kouřilová", "Koutnýová", "Kováčová", "Kovářová", "Kovaříková", "Kováříková", "Kozáková", "Kozlová", "Krajíčková", "Králová", "Králíčková", "Králíková", "Krátkýová", "Kratochvílová", "Krausová", "Krčmářová", "Křečková", "Krejčíová", "Krejčíková", "Krejčířová", "Křenková", "Krištofová", "Křivánková", "Křížová", "Křížková", "Kropáčková", "Kroupová", "Krupová", "Krupičková", "Krupková", "Kubová", "Kubánková", "Kubátová", "Kubcová", "Kubelková", "Kubešová", "Kubicová", "Kubíčková", "Kubíková", "Kubínová", "Kubišová", "Kučová", "Kučerová", "Kuchařová", "Kuchtová", "Kudláčková", "Kudrnová", "Kuklová", "Kulhánková", "Kulhavýová", "Kuncová", "Kunešová", "Kupcová", "Kupková", "Kurková", "Kužlová", "Kvapilová", "Kvasničková", "Kynclová", "Kyselová", "Lacinová", "Lackoová", "Lakatošová", "Landová", "Langová", "Langrová", "Langrová", "Látalová", "Lavičková", "Leová", "Lebedová", "Levýová", "Líbalová", "Linhartová", "Lišková", "Lorencová", "Loudová", "Ludvíková", "Lukáčová", "Lukášová", "Lukášková", "Lukešová", "Macáková", "Macková", "Machová", "Máchová", "Machačová", "Macháčová", "Macháčková", "Machalová", "Machálková", "Macurová", "Majrová", "Malečková", "Málková", "Malíková", "Malinová", "Malýová", "Maňáková", "Marečková", "Marková", "Marešová", "Maříková", "Maršálková", "Maršíková", "Martincová", "Martinková", "Martínková", "Mašková", "Masopustová", "Matějíčková", "Matějková", "Matoušová", "Matoušková", "Matulová", "Matušková", "Matyášová", "Matysová", "Maxová", "Mayrová", "Mazánková", "Medková", "Melicharová", "Menclová", "Menšíková", "Mertová", "Michalová", "Michalcová", "Michálková", "Michalíková", "Michnová", "Mičková", "Miková", "Míková", "Mikešová", "Mikoová", "Mikulová", "Mikulášková", "Minářová", "Minaříková", "Mirgová", "Mládková", "Mlčochová", "Mlejnková", "Mojžíšová", "Mokrýová", "Molnárová", "Moravcová", "Morávková", "Motlová", "Motyčková", "Moučková", "Moudrýová", "Mráčková", "Mrázová", "Mrázková", "Mrkvičková", "Muchová", "Müllrová", "Műllrová", "Musilová", "Mužíková", "Myšková", "Nagyová", "Najmanová", "Navrátilová", "Nečasová", "Nedbalová", "Nedomová", "Nedvědová", "Nejedlýová", "Němcová", "Němečková", "Nešporová", "Nesvadbová", "Neubaurová", "Neumanová", "Neumannová", "Nguynová", "Nguyen vanová", "Nosková", "Nováčková", "Nováková", "Novosadová", "Novotnýová", "Novýová", "Odehnalová", "Oláhová", "Olivová", "Ondrová", "Ondráčková", "Orságová", "Otáhalová", "Palečková", "Pánková", "Papežová", "Pařízková", "Pašková", "Pátková", "Patočková", "Paulová", "Pavlová", "Pavelková", "Pavelková", "Pavlasová", "Pavlicová", "Pavlíčková", "Pavlíková", "Pavlůová", "Pazderová", "Pechová", "Pechová", "Pecháčková", "Pecková", "Pekařová", "Pekárková", "Pelcová", "Pelikánová", "Peřinová", "Pernicová", "Peroutková", "Pešková", "Pešková", "Peštová", "Peterková", "Petrová", "Petráková", "Petrášová", "Petříčková", "Petříková", "Petrůová", "Phamová", "Píchová", "Pilařová", "Pilátová", "Píšová", "Pivoňková", "Plačková", "Plachýová", "Plšková", "Pluhařová", "Podzimková", "Pohlová", "Pokornýová", "Poláčková", "Poláchová", "Poláková", "Polanskýová", "Polášková", "Polívková", "Popelková", "Pospíchalová", "Pospíšilová", "Potůčková", "Pourová", "Prachařová", "Prášková", "Pražáková", "Prchalová", "Přibylová", "Příhodová", "Přikrylová", "Procházková", "Prokešová", "Prokopová", "Prošková", "Provazníková", "Průchová", "Průšová", "Pšeničková", "Ptáčková", "Rácová", "Radová", "Raková", "Rambousková", "Rašková", "Ratajová", "řeháčková", "řeháková", "řehořová", "Remešová", "řezáčová", "Rezková", "řezníčková", "Richtrová", "Richtrová", "říhová", "Roubalová", "Rousová", "Rozsypalová", "Rudolfová", "Růžková", "Růžičková", "Rybová", "Rybářová", "Rýdlová", "Ryšavýová", "Sadílková", "šafářová", "šafaříková", "šafránková", "šálková", "Samková", "šandová", "šašková", "Schejbalová", "Schmidtová", "Schneidrová", "Schwarzová", "šebková", "šebelová", "šebestová", "šedová", "šedivýová", "Sedláčková", "Sedláková", "Sedlářová", "Sehnalová", "Seidlová", "Seifertová", "Sekaninová", "Semerádová", "šenková", "šestáková", "ševčíková", "Severová", "Sikorová", "šilhavýová", "šímová", "šimáčková", "šimáková", "šimánková", "šimčíková", "šimečková", "šimková", "šimonová", "šimůnková", "šindelářová", "šindlrová", "šípová", "šípková", "šírová", "širokýová", "šišková", "Siváková", "Skáclová", "Skalová", "Skálová", "Skalickýová", "Sklenářová", "škodová", "Skopalová", "Skořepová", "škrabalová", "Skřivánková", "Slabýová", "Sládková", "Sladkýová", "Slámová", "Slaninová", "Slavíčková", "Slavíková", "šlechtová", "Slezáková", "Slováčková", "Slováková", "Sluková", "Smejkalová", "šmejkalová", "Smékalová", "šmerdová", "Smetanová", "šmídová", "Smolová", "Smolíková", "Smolková", "Smrčková", "Smržová", "Smutnýová", "šnajdrová", "Sobková", "Sobotková", "Sochorová", "Sojková", "Sokolová", "šolcová", "Sommrová", "Součková", "Soukupová", "Sovová", "špačková", "Spáčilová", "špičková", "šplíchalová", "Spurnýová", "šrámková", "Srbová", "Staněková", "Stárková", "Starýová", "šťastnýová", "štefanová", "štefková", "šteflová", "Stehlíková", "Steinrová", "Stejskalová", "štěpánová", "štěpánková", "štěrbová", "Stiborová", "Stoklasová", "Straková", "Stránskýová", "Strejčková", "Strnadová", "Strouhalová", "Stuchlíková", "Studenýová", "Studničková", "Stupková", "šubrtová", "Suchánková", "Suchomlová", "Suchýová", "Suková", "šulcová", "šustrová", "švábová", "Svačinová", "švandová", "švarcová", "Svatoňová", "Svatošová", "švcová", "švehlová", "švejdová", "švestková", "Světlíková", "Svitáková", "Svobodová", "Svozilová", "Sýkorová", "Synková", "Syrovýová", "Táborskýová", "Tancošová", "Teplýová", "Tesařová", "Tichýová", "Tomanová", "Tománková", "Tomášová", "Tomášková", "Tomečková", "Tomková", "Tomešová", "Tóthová", "Tranová", "Trávníčková", "Trčková", "Třísková", "Trnková", "Trojanová", "Truhlářová", "Tučková", "Tůmová", "Turečková", "Turková", "Tvrdíková", "Tvrdýová", "Uhrová", "Uhlířová", "Ulrichová", "Urbanová", "Urbancová", "Urbánková", "Vacková", "Váchová", "Václavková", "Václavíková", "Vaculíková", "Vágnrová", "Valová", "Valášková", "Válková", "Valentová", "Valešová", "Váňová", "Vančurová", "Vaněčková", "Vaněková", "Vaníčková", "Vargová", "Vašáková", "Vašková", "Vašíčková", "Vávrová", "Vavříková", "Večeřová", "Vejvodová", "Vernrová", "Veselýová", "Veverková", "Víchová", "Vilímková", "Vinšová", "Víšková", "Vítová", "Vitásková", "Vítková", "Vlachová", "Vlasáková", "Vlčková", "Vlková", "Vobořilová", "Vodáková", "Vodičková", "Vodrážková", "Vojáčková", "Vojtová", "Vojtěchová", "Vojtková", "Vojtíšková", "Vokounová", "Volková", "Volfová", "Volnýová", "Vondrová", "Vondráčková", "Vondráková", "Voráčková", "Vorlová", "Voříšková", "Vorlíčková", "Votavová", "Votrubová", "Vrabcová", "Vránová", "Vrbová", "Vrzalová", "Vybíralová", "Vydrová", "Vymazalová", "Vyskočilová", "Vysloužilová", "Wagnrová", "Waltrová", "Webrová", "Weissová", "Winklrová", "Wolfová", "Zábranskýová", "žáčková", "Zachová", "Zahrádková", "Zahradníková", "Zajícová", "Zajíčková", "žáková", "Zálešáková", "Zámečníková", "Zapletalová", "Zárubová", "Zatloukalová", "Zavadilová", "Zavřlová", "Zbořilová", "žďárskýová", "Zdražilová", "Zedníková", "Zelenková", "Zelenýová", "Zelinková", "Zemanová", "Zemánková", "žemličková", "Zezulová", "žídková", "žigová", "Zíková", "Zikmundová", "Zimová", "žižková", "Zlámalová", "Zoubková", "Zouharová", "žůrková", "Zvěřinová"]; /***/ }, -/* 155 */ -/***/ function(module, exports, __webpack_require__) { - - var baseProperty = __webpack_require__(63), - basePropertyDeep = __webpack_require__(156), - isKey = __webpack_require__(126), - toKey = __webpack_require__(127); - - /** - * Creates a function that returns the value at `path` of a given object. - * - * @static - * @memberOf _ - * @since 2.4.0 - * @category Util - * @param {Array|string} path The path of the property to get. - * @returns {Function} Returns the new accessor function. - * @example - * - * var objects = [ - * { 'a': { 'b': 2 } }, - * { 'a': { 'b': 1 } } - * ]; - * - * _.map(objects, _.property('a.b')); - * // => [2, 1] - * - * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b'); - * // => [1, 2] - */ - function property(path) { - return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path); - } +/* 146 */ +/***/ function(module, exports) { - module.exports = property; + "use strict"; + module.exports = { + number: ["601 ### ###", "737 ### ###", "736 ### ###", "### ### ###", "+420 ### ### ###", "00420 ### ### ###"] + }; /***/ }, -/* 156 */ -/***/ function(module, exports, __webpack_require__) { +/* 147 */ +/***/ function(module, exports) { - var baseGet = __webpack_require__(120); + "use strict"; - /** - * 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); - }; - } + module.exports = { + tld: ["cz", "com", "net", "eu", "org"], - module.exports = basePropertyDeep; + emailDomain: ["gmail.com", "seznam.cz", "centrum.cz", "volny.cz", "atlas.cz"] + }; /***/ }, -/* 157 */ +/* 148 */ /***/ function(module, exports, __webpack_require__) { - var toString = __webpack_require__(124), - upperFirst = __webpack_require__(158); - - /** - * 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()); - } - - module.exports = capitalize; + "use strict"; + var _countryWithCodes = __webpack_require__(149); -/***/ }, -/* 158 */ -/***/ function(module, exports, __webpack_require__) { + var _countryWithCodes2 = _interopRequireDefault(_countryWithCodes); - var createCaseFirst = __webpack_require__(159); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } - /** - * Converts the first character of `string` to upper case. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category String - * @param {string} [string=''] The string to convert. - * @returns {string} Returns the converted string. - * @example - * - * _.upperFirst('fred'); - * // => 'Fred' - * - * _.upperFirst('FRED'); - * // => 'FRED' - */ - var upperFirst = createCaseFirst('toUpperCase'); + module.exports = { + countryAndCode: function countryAndCode() { + var country = this.random.objectElement(_countryWithCodes2.default); + return { + code: Object.keys(country)[0], + name: country[Object.keys(country)[0]] + }; + }, - module.exports = upperFirst; + state: ["Baden-Württemberg", "Bayern", "Berlin", "Brandenburg", "Bremen", "Hamburg", "Hessen", "Mecklenburg-Vorpommern", "Niedersachsen", "Nordrhein-Westfalen", "Rheinland-Pfalz", "Saarland", "Sachsen", "Sachsen-Anhalt", "Schleswig-Holstein", "Thüringen"], + stateAbbr: ["BW", "BY", "BE", "BB", "HB", "HH", "HE", "MV", "NI", "NW", "RP", "SL", "SN", "ST", "SH", "TH"], -/***/ }, -/* 159 */ -/***/ function(module, exports, __webpack_require__) { + city: ["#{address.cityPrefix} #{names.firstName}#{address.citySuffix}", "#{address.cityPrefix} #{names.firstName}", "#{names.firstName}#{address.citySuffix}", "#{names.lastName}#{address.citySuffix}"], - var castSlice = __webpack_require__(160), - reHasComplexSymbol = __webpack_require__(162), - stringToArray = __webpack_require__(163), - toString = __webpack_require__(124); + cityPrefix: ["Nord", "Ost", "West", "Süd", "Neu", "Alt", "Bad"], - /** - * 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); + citySuffix: ["stadt", "dorf", "land", "scheid", "burg"], - var strSymbols = reHasComplexSymbol.test(string) - ? stringToArray(string) - : undefined; + street: ["#{address.streetName} #{address.buildingNumber}"], - var chr = strSymbols - ? strSymbols[0] - : string.charAt(0); + streetName: __webpack_require__(150), - var trailing = strSymbols - ? castSlice(strSymbols, 1).join('') - : string.slice(1); + streetSuffix: [], - return chr[methodName]() + trailing; - }; - } + buildingNumber: ["###", "##", "#", "##a", "##b", "##c"], - module.exports = createCaseFirst; + postCode: ["#####"] + }; /***/ }, -/* 160 */ -/***/ function(module, exports, __webpack_require__) { - - var baseSlice = __webpack_require__(161); - - /** - * 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); - } - - module.exports = castSlice; +/* 149 */ +/***/ function(module, exports) { + "use strict"; -/***/ }, -/* 161 */ + module.exports = { + "AF": "Afghanistan", + "EG": "\xC4gypten", + "AX": "\xC5land-Inseln", + "AL": "Albanien", + "DZ": "Algerien", + "UM": "Amerikanisch-Ozeanien", + "AS": "Amerikanisch-Samoa", + "VI": "Amerikanische Jungferninseln", + "AD": "Andorra", + "AO": "Angola", + "AI": "Anguilla", + "AQ": "Antarktis", + "AG": "Antigua und Barbuda", + "GQ": "\xC4quatorialguinea", + "AR": "Argentinien", + "AM": "Armenien", + "AW": "Aruba", + "AC": "Ascension", + "AZ": "Aserbaidschan", + "ET": "\xC4thiopien", + "AU": "Australien", + "BS": "Bahamas", + "BH": "Bahrain", + "BD": "Bangladesch", + "BB": "Barbados", + "BY": "Belarus", + "BE": "Belgien", + "BZ": "Belize", + "BJ": "Benin", + "BM": "Bermuda", + "BT": "Bhutan", + "BO": "Bolivien", + "BA": "Bosnien und Herzegowina", + "BW": "Botsuana", + "BR": "Brasilien", + "VG": "Britische Jungferninseln", + "IO": "Britisches Territorium im Indischen Ozean", + "BN": "Brunei Darussalam", + "BG": "Bulgarien", + "BF": "Burkina Faso", + "BI": "Burundi", + "EA": "Ceuta und Melilla", + "CL": "Chile", + "CN": "China", + "CK": "Cookinseln", + "CR": "Costa Rica", + "CI": "C\xF4te d\u2019Ivoire", + "CW": "Cura\xE7ao", + "DK": "D\xE4nemark", + "KP": "Demokratische Volksrepublik Korea", + "DE": "Deutschland", + "DG": "Diego Garcia", + "DM": "Dominica", + "DO": "Dominikanische Republik", + "DJ": "Dschibuti", + "EC": "Ecuador", + "SV": "El Salvador", + "ER": "Eritrea", + "EE": "Estland", + "FK": "Falklandinseln", + "FO": "F\xE4r\xF6er", + "FJ": "Fidschi", + "FI": "Finnland", + "FR": "Frankreich", + "GF": "Franz\xF6sisch-Guayana", + "PF": "Franz\xF6sisch-Polynesien", + "TF": "Franz\xF6sische S\xFCd- und Antarktisgebiete", + "GA": "Gabun", + "GM": "Gambia", + "GE": "Georgien", + "GH": "Ghana", + "GI": "Gibraltar", + "GD": "Grenada", + "GR": "Griechenland", + "GL": "Gr\xF6nland", + "GP": "Guadeloupe", + "GU": "Guam", + "GT": "Guatemala", + "GG": "Guernsey", + "GN": "Guinea", + "GW": "Guinea-Bissau", + "GY": "Guyana", + "HT": "Haiti", + "HN": "Honduras", + "IN": "Indien", + "ID": "Indonesien", + "IQ": "Irak", + "IR": "Iran", + "IE": "Irland", + "IS": "Island", + "IM": "Isle of Man", + "IL": "Israel", + "IT": "Italien", + "JM": "Jamaika", + "JP": "Japan", + "YE": "Jemen", + "JE": "Jersey", + "JO": "Jordanien", + "KY": "Kaimaninseln", + "KH": "Kambodscha", + "CM": "Kamerun", + "CA": "Kanada", + "IC": "Kanarische Inseln", + "CV": "Kap Verde", + "BQ": "Karibische Niederlande", + "KZ": "Kasachstan", + "QA": "Katar", + "KE": "Kenia", + "KG": "Kirgisistan", + "KI": "Kiribati", + "CC": "Kokosinseln", + "CO": "Kolumbien", + "KM": "Komoren", + "CG": "Kongo-Brazzaville", + "CD": "Kongo-Kinshasa", + "XK": "Kosovo", + "HR": "Kroatien", + "CU": "Kuba", + "KW": "Kuwait", + "LA": "Laos", + "LS": "Lesotho", + "LV": "Lettland", + "LB": "Libanon", + "LR": "Liberia", + "LY": "Libyen", + "LI": "Liechtenstein", + "LT": "Litauen", + "LU": "Luxemburg", + "MG": "Madagaskar", + "MW": "Malawi", + "MY": "Malaysia", + "MV": "Malediven", + "ML": "Mali", + "MT": "Malta", + "MA": "Marokko", + "MH": "Marshallinseln", + "MQ": "Martinique", + "MR": "Mauretanien", + "MU": "Mauritius", + "YT": "Mayotte", + "MK": "Mazedonien", + "MX": "Mexiko", + "FM": "Mikronesien", + "MC": "Monaco", + "MN": "Mongolei", + "ME": "Montenegro", + "MS": "Montserrat", + "MZ": "Mosambik", + "MM": "Myanmar", + "NA": "Namibia", + "NR": "Nauru", + "NP": "Nepal", + "NC": "Neukaledonien", + "NZ": "Neuseeland", + "NI": "Nicaragua", + "NL": "Niederlande", + "NE": "Niger", + "NG": "Nigeria", + "NU": "Niue", + "MP": "N\xF6rdliche Marianen", + "NF": "Norfolkinsel", + "NO": "Norwegen", + "OM": "Oman", + "AT": "\xD6sterreich", + "PK": "Pakistan", + "PS": "Pal\xE4stinensische Autonomiegebiete", + "PW": "Palau", + "PA": "Panama", + "PG": "Papua-Neuguinea", + "PY": "Paraguay", + "PE": "Peru", + "PH": "Philippinen", + "PN": "Pitcairninseln", + "PL": "Polen", + "PT": "Portugal", + "PR": "Puerto Rico", + "KR": "Republik Korea", + "MD": "Republik Moldau", + "RE": "R\xE9union", + "RW": "Ruanda", + "RO": "Rum\xE4nien", + "RU": "Russische F\xF6deration", + "SB": "Salomonen", + "ZM": "Sambia", + "WS": "Samoa", + "SM": "San Marino", + "ST": "S\xE3o Tom\xE9 und Pr\xEDncipe", + "SA": "Saudi-Arabien", + "SE": "Schweden", + "CH": "Schweiz", + "SN": "Senegal", + "RS": "Serbien", + "SC": "Seychellen", + "SL": "Sierra Leone", + "ZW": "Simbabwe", + "SG": "Singapur", + "SX": "Sint Maarten", + "SK": "Slowakei", + "SI": "Slowenien", + "SO": "Somalia", + "MO": "Sonderverwaltungsregion Macau", + "HK": "Sonderverwaltungszone Hongkong", + "ES": "Spanien", + "LK": "Sri Lanka", + "BL": "St. Barth\xE9lemy", + "SH": "St. Helena", + "KN": "St. Kitts und Nevis", + "LC": "St. Lucia", + "MF": "St. Martin", + "PM": "St. Pierre und Miquelon", + "VC": "St. Vincent und die Grenadinen", + "ZA": "S\xFCdafrika", + "SD": "Sudan", + "GS": "S\xFCdgeorgien und die S\xFCdlichen Sandwichinseln", + "SS": "S\xFCdsudan", + "SR": "Suriname", + "SJ": "Svalbard und Jan Mayen", + "SZ": "Swasiland", + "SY": "Syrien", + "TJ": "Tadschikistan", + "TW": "Taiwan", + "TZ": "Tansania", + "TH": "Thailand", + "TL": "Timor-Leste", + "TG": "Togo", + "TK": "Tokelau", + "TO": "Tonga", + "TT": "Trinidad und Tobago", + "TA": "Tristan da Cunha", + "TD": "Tschad", + "CZ": "Tschechische Republik", + "TN": "Tunesien", + "TR": "T\xFCrkei", + "TM": "Turkmenistan", + "TC": "Turks- und Caicosinseln", + "TV": "Tuvalu", + "UG": "Uganda", + "UA": "Ukraine", + "HU": "Ungarn", + "UY": "Uruguay", + "UZ": "Usbekistan", + "VU": "Vanuatu", + "VA": "Vatikanstadt", + "VE": "Venezuela", + "AE": "Vereinigte Arabische Emirate", + "US": "Vereinigte Staaten", + "GB": "Vereinigtes K\xF6nigreich", + "VN": "Vietnam", + "WF": "Wallis und Futuna", + "CX": "Weihnachtsinsel", + "EH": "Westsahara", + "CF": "Zentralafrikanische Republik", + "CY": "Zypern" + }; + +/***/ }, +/* 150 */ /***/ function(module, exports) { - /** - * 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; + "use strict"; - 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; + module.exports = ["Ackerweg", "Adalbert-Stifter-Str.", "Adalbertstr.", "Adolf-Baeyer-Str.", "Adolf-Kaschny-Str.", "Adolf-Reichwein-Str.", "Adolfsstr.", "Ahornweg", "Ahrstr.", "Akazienweg", "Albert-Einstein-Str.", "Albert-Schweitzer-Str.", "Albertus-Magnus-Str.", "Albert-Zarthe-Weg", "Albin-Edelmann-Str.", "Albrecht-Haushofer-Str.", "Aldegundisstr.", "Alexanderstr.", "Alfred-Delp-Str.", "Alfred-Kubin-Str.", "Alfred-Stock-Str.", "Alkenrather Str.", "Allensteiner Str.", "Alsenstr.", "Alt Steinbücheler Weg", "Alte Garten", "Alte Heide", "Alte Landstr.", "Alte Ziegelei", "Altenberger Str.", "Altenhof", "Alter Grenzweg", "Altstadtstr.", "Am Alten Gaswerk", "Am Alten Schafstall", "Am Arenzberg", "Am Benthal", "Am Birkenberg", "Am Blauen Berg", "Am Borsberg", "Am Brungen", "Am Büchelter Hof", "Am Buttermarkt", "Am Ehrenfriedhof", "Am Eselsdamm", "Am Falkenberg", "Am Frankenberg", "Am Gesundheitspark", "Am Gierlichshof", "Am Graben", "Am Hagelkreuz", "Am Hang", "Am Heidkamp", "Am Hemmelrather Hof", "Am Hofacker", "Am Hohen Ufer", "Am Höllers Eck", "Am Hühnerberg", "Am Jägerhof", "Am Junkernkamp", "Am Kemperstiegel", "Am Kettnersbusch", "Am Kiesberg", "Am Klösterchen", "Am Knechtsgraben", "Am Köllerweg", "Am Köttersbach", "Am Kreispark", "Am Kronefeld", "Am Küchenhof", "Am Kühnsbusch", "Am Lindenfeld", "Am Märchen", "Am Mittelberg", "Am Mönchshof", "Am Mühlenbach", "Am Neuenhof", "Am Nonnenbruch", "Am Plattenbusch", "Am Quettinger Feld", "Am Rosenhügel", "Am Sandberg", "Am Scherfenbrand", "Am Schokker", "Am Silbersee", "Am Sonnenhang", "Am Sportplatz", "Am Stadtpark", "Am Steinberg", "Am Telegraf", "Am Thelenhof", "Am Vogelkreuz", "Am Vogelsang", "Am Vogelsfeldchen", "Am Wambacher Hof", "Am Wasserturm", "Am Weidenbusch", "Am Weiher", "Am Weingarten", "Am Werth", "Amselweg", "An den Irlen", "An den Rheinauen", "An der Bergerweide", "An der Dingbank", "An der Evangelischen Kirche", "An der Evgl. Kirche", "An der Feldgasse", "An der Fettehenne", "An der Kante", "An der Laach", "An der Lehmkuhle", "An der Lichtenburg", "An der Luisenburg", "An der Robertsburg", "An der Schmitten", "An der Schusterinsel", "An der Steinrütsch", "An St. Andreas", "An St. Remigius", "Andreasstr.", "Ankerweg", "Annette-Kolb-Str.", "Apenrader Str.", "Arnold-Ohletz-Str.", "Atzlenbacher Str.", "Auerweg", "Auestr.", "Auf dem Acker", "Auf dem Blahnenhof", "Auf dem Bohnbüchel", "Auf dem Bruch", "Auf dem End", "Auf dem Forst", "Auf dem Herberg", "Auf dem Lehn", "Auf dem Stein", "Auf dem Weierberg", "Auf dem Weiherhahn", "Auf den Reien", "Auf der Donnen", "Auf der Grieße", "Auf der Ohmer", "Auf der Weide", "Auf'm Berg", "Auf'm Kamp", "Augustastr.", "August-Kekulé-Str.", "A.-W.-v.-Hofmann-Str.", "Bahnallee", "Bahnhofstr.", "Baltrumstr.", "Bamberger Str.", "Baumberger Str.", "Bebelstr.", "Beckers Kämpchen", "Beerenstr.", "Beethovenstr.", "Behringstr.", "Bendenweg", "Bensberger Str.", "Benzstr.", "Bergische Landstr.", "Bergstr.", "Berliner Platz", "Berliner Str.", "Bernhard-Letterhaus-Str.", "Bernhard-Lichtenberg-Str.", "Bernhard-Ridder-Str.", "Bernsteinstr.", "Bertha-Middelhauve-Str.", "Bertha-von-Suttner-Str.", "Bertolt-Brecht-Str.", "Berzeliusstr.", "Bielertstr.", "Biesenbach", "Billrothstr.", "Birkenbergstr.", "Birkengartenstr.", "Birkenweg", "Bismarckstr.", "Bitterfelder Str.", "Blankenburg", "Blaukehlchenweg", "Blütenstr.", "Boberstr.", "Böcklerstr.", "Bodelschwinghstr.", "Bodestr.", "Bogenstr.", "Bohnenkampsweg", "Bohofsweg", "Bonifatiusstr.", "Bonner Str.", "Borkumstr.", "Bornheimer Str.", "Borsigstr.", "Borussiastr.", "Bracknellstr.", "Brahmsweg", "Brandenburger Str.", "Breidenbachstr.", "Breslauer Str.", "Bruchhauser Str.", "Brückenstr.", "Brucknerstr.", "Brüder-Bonhoeffer-Str.", "Buchenweg", "Bürgerbuschweg", "Burgloch", "Burgplatz", "Burgstr.", "Burgweg", "Bürriger Weg", "Burscheider Str.", "Buschkämpchen", "Butterheider Str.", "Carl-Duisberg-Platz", "Carl-Duisberg-Str.", "Carl-Leverkus-Str.", "Carl-Maria-von-Weber-Platz", "Carl-Maria-von-Weber-Str.", "Carlo-Mierendorff-Str.", "Carl-Rumpff-Str.", "Carl-von-Ossietzky-Str.", "Charlottenburger Str.", "Christian-Heß-Str.", "Claasbruch", "Clemens-Winkler-Str.", "Concordiastr.", "Cranachstr.", "Dahlemer Str.", "Daimlerstr.", "Damaschkestr.", "Danziger Str.", "Debengasse", "Dechant-Fein-Str.", "Dechant-Krey-Str.", "Deichtorstr.", "Dhünnberg", "Dhünnstr.", "Dianastr.", "Diedenhofener Str.", "Diepental", "Diepenthaler Str.", "Dieselstr.", "Dillinger Str.", "Distelkamp", "Dohrgasse", "Domblick", "Dönhoffstr.", "Dornierstr.", "Drachenfelsstr.", "Dr.-August-Blank-Str.", "Dresdener Str.", "Driescher Hecke", "Drosselweg", "Dudweilerstr.", "Dünenweg", "Dünfelder Str.", "Dünnwalder Grenzweg", "Düppeler Str.", "Dürerstr.", "Dürscheider Weg", "Düsseldorfer Str.", "Edelrather Weg", "Edmund-Husserl-Str.", "Eduard-Spranger-Str.", "Ehrlichstr.", "Eichenkamp", "Eichenweg", "Eidechsenweg", "Eifelstr.", "Eifgenstr.", "Eintrachtstr.", "Elbestr.", "Elisabeth-Langgässer-Str.", "Elisabethstr.", "Elisabeth-von-Thadden-Str.", "Elisenstr.", "Elsa-Brändström-Str.", "Elsbachstr.", "Else-Lasker-Schüler-Str.", "Elsterstr.", "Emil-Fischer-Str.", "Emil-Nolde-Str.", "Engelbertstr.", "Engstenberger Weg", "Entenpfuhl", "Erbelegasse", "Erftstr.", "Erfurter Str.", "Erich-Heckel-Str.", "Erich-Klausener-Str.", "Erich-Ollenhauer-Str.", "Erlenweg", "Ernst-Bloch-Str.", "Ernst-Ludwig-Kirchner-Str.", "Erzbergerstr.", "Eschenallee", "Eschenweg", "Esmarchstr.", "Espenweg", "Euckenstr.", "Eulengasse", "Eulenkamp", "Ewald-Flamme-Str.", "Ewald-Röll-Str.", "Fährstr.", "Farnweg", "Fasanenweg", "Faßbacher Hof", "Felderstr.", "Feldkampstr.", "Feldsiefer Weg", "Feldsiefer Wiesen", "Feldstr.", "Feldtorstr.", "Felix-von-Roll-Str.", "Ferdinand-Lassalle-Str.", "Fester Weg", "Feuerbachstr.", "Feuerdornweg", "Fichtenweg", "Fichtestr.", "Finkelsteinstr.", "Finkenweg", "Fixheider Str.", "Flabbenhäuschen", "Flensburger Str.", "Fliederweg", "Florastr.", "Florianweg", "Flotowstr.", "Flurstr.", "Föhrenweg", "Fontanestr.", "Forellental", "Fortunastr.", "Franz-Esser-Str.", "Franz-Hitze-Str.", "Franz-Kail-Str.", "Franz-Marc-Str.", "Freiburger Str.", "Freiheitstr.", "Freiherr-vom-Stein-Str.", "Freudenthal", "Freudenthaler Weg", "Fridtjof-Nansen-Str.", "Friedenberger Str.", "Friedensstr.", "Friedhofstr.", "Friedlandstr.", "Friedlieb-Ferdinand-Runge-Str.", "Friedrich-Bayer-Str.", "Friedrich-Bergius-Platz", "Friedrich-Ebert-Platz", "Friedrich-Ebert-Str.", "Friedrich-Engels-Str.", "Friedrich-List-Str.", "Friedrich-Naumann-Str.", "Friedrich-Sertürner-Str.", "Friedrichstr.", "Friedrich-Weskott-Str.", "Friesenweg", "Frischenberg", "Fritz-Erler-Str.", "Fritz-Henseler-Str.", "Fröbelstr.", "Fürstenbergplatz", "Fürstenbergstr.", "Gabriele-Münter-Str.", "Gartenstr.", "Gebhardstr.", "Geibelstr.", "Gellertstr.", "Georg-von-Vollmar-Str.", "Gerhard-Domagk-Str.", "Gerhart-Hauptmann-Str.", "Gerichtsstr.", "Geschwister-Scholl-Str.", "Gezelinallee", "Gierener Weg", "Ginsterweg", "Gisbert-Cremer-Str.", "Glücksburger Str.", "Gluckstr.", "Gneisenaustr.", "Goetheplatz", "Goethestr.", "Golo-Mann-Str.", "Görlitzer Str.", "Görresstr.", "Graebestr.", "Graf-Galen-Platz", "Gregor-Mendel-Str.", "Greifswalder Str.", "Grillenweg", "Gronenborner Weg", "Große Kirchstr.", "Grunder Wiesen", "Grundermühle", "Grundermühlenhof", "Grundermühlenweg", "Grüner Weg", "Grunewaldstr.", "Grünstr.", "Günther-Weisenborn-Str.", "Gustav-Freytag-Str.", "Gustav-Heinemann-Str.", "Gustav-Radbruch-Str.", "Gut Reuschenberg", "Gutenbergstr.", "Haberstr.", "Habichtgasse", "Hafenstr.", "Hagenauer Str.", "Hahnenblecher", "Halenseestr.", "Halfenleimbach", "Hallesche Str.", "Halligstr.", "Hamberger Str.", "Hammerweg", "Händelstr.", "Hannah-Höch-Str.", "Hans-Arp-Str.", "Hans-Gerhard-Str.", "Hans-Sachs-Str.", "Hans-Schlehahn-Str.", "Hans-von-Dohnanyi-Str.", "Hardenbergstr.", "Haselweg", "Hauptstr.", "Haus-Vorster-Str.", "Hauweg", "Havelstr.", "Havensteinstr.", "Haydnstr.", "Hebbelstr.", "Heckenweg", "Heerweg", "Hegelstr.", "Heidberg", "Heidehöhe", "Heidestr.", "Heimstättenweg", "Heinrich-Böll-Str.", "Heinrich-Brüning-Str.", "Heinrich-Claes-Str.", "Heinrich-Heine-Str.", "Heinrich-Hörlein-Str.", "Heinrich-Lübke-Str.", "Heinrich-Lützenkirchen-Weg", "Heinrichstr.", "Heinrich-Strerath-Str.", "Heinrich-von-Kleist-Str.", "Heinrich-von-Stephan-Str.", "Heisterbachstr.", "Helenenstr.", "Helmestr.", "Hemmelrather Weg", "Henry-T.-v.-Böttinger-Str.", "Herderstr.", "Heribertstr.", "Hermann-Ehlers-Str.", "Hermann-Hesse-Str.", "Hermann-König-Str.", "Hermann-Löns-Str.", "Hermann-Milde-Str.", "Hermann-Nörrenberg-Str.", "Hermann-von-Helmholtz-Str.", "Hermann-Waibel-Str.", "Herzogstr.", "Heymannstr.", "Hindenburgstr.", "Hirzenberg", "Hitdorfer Kirchweg", "Hitdorfer Str.", "Höfer Mühle", "Höfer Weg", "Hohe Str.", "Höhenstr.", "Höltgestal", "Holunderweg", "Holzer Weg", "Holzer Wiesen", "Hornpottweg", "Hubertusweg", "Hufelandstr.", "Hufer Weg", "Humboldtstr.", "Hummelsheim", "Hummelweg", "Humperdinckstr.", "Hüscheider Gärten", "Hüscheider Str.", "Hütte", "Ilmstr.", "Im Bergischen Heim", "Im Bruch", "Im Buchenhain", "Im Bühl", "Im Burgfeld", "Im Dorf", "Im Eisholz", "Im Friedenstal", "Im Frohental", "Im Grunde", "Im Hederichsfeld", "Im Jücherfeld", "Im Kalkfeld", "Im Kirberg", "Im Kirchfeld", "Im Kreuzbruch", "Im Mühlenfeld", "Im Nesselrader Kamp", "Im Oberdorf", "Im Oberfeld", "Im Rosengarten", "Im Rottland", "Im Scheffengarten", "Im Staderfeld", "Im Steinfeld", "Im Weidenblech", "Im Winkel", "Im Ziegelfeld", "Imbach", "Imbacher Weg", "Immenweg", "In den Blechenhöfen", "In den Dehlen", "In der Birkenau", "In der Dasladen", "In der Felderhütten", "In der Hartmannswiese", "In der Höhle", "In der Schaafsdellen", "In der Wasserkuhl", "In der Wüste", "In Holzhausen", "Insterstr.", "Jacob-Fröhlen-Str.", "Jägerstr.", "Jahnstr.", "Jakob-Eulenberg-Weg", "Jakobistr.", "Jakob-Kaiser-Str.", "Jenaer Str.", "Johannes-Baptist-Str.", "Johannes-Dott-Str.", "Johannes-Popitz-Str.", "Johannes-Wislicenus-Str.", "Johannisburger Str.", "Johann-Janssen-Str.", "Johann-Wirtz-Weg", "Josefstr.", "Jüch", "Julius-Doms-Str.", "Julius-Leber-Str.", "Kaiserplatz", "Kaiserstr.", "Kaiser-Wilhelm-Allee", "Kalkstr.", "Kämpchenstr.", "Kämpenwiese", "Kämper Weg", "Kamptalweg", "Kanalstr.", "Kandinskystr.", "Kantstr.", "Kapellenstr.", "Karl-Arnold-Str.", "Karl-Bosch-Str.", "Karl-Bückart-Str.", "Karl-Carstens-Ring", "Karl-Friedrich-Goerdeler-Str.", "Karl-Jaspers-Str.", "Karl-König-Str.", "Karl-Krekeler-Str.", "Karl-Marx-Str.", "Karlstr.", "Karl-Ulitzka-Str.", "Karl-Wichmann-Str.", "Karl-Wingchen-Str.", "Käsenbrod", "Käthe-Kollwitz-Str.", "Katzbachstr.", "Kerschensteinerstr.", "Kiefernweg", "Kieler Str.", "Kieselstr.", "Kiesweg", "Kinderhausen", "Kleiberweg", "Kleine Kirchstr.", "Kleingansweg", "Kleinheider Weg", "Klief", "Kneippstr.", "Knochenbergsweg", "Kochergarten", "Kocherstr.", "Kockelsberg", "Kolberger Str.", "Kolmarer Str.", "Kölner Gasse", "Kölner Str.", "Kolpingstr.", "Königsberger Platz", "Konrad-Adenauer-Platz", "Köpenicker Str.", "Kopernikusstr.", "Körnerstr.", "Köschenberg", "Köttershof", "Kreuzbroicher Str.", "Kreuzkamp", "Krummer Weg", "Kruppstr.", "Kuhlmannweg", "Kump", "Kumper Weg", "Kunstfeldstr.", "Küppersteger Str.", "Kursiefen", "Kursiefer Weg", "Kurtekottenweg", "Kurt-Schumacher-Ring", "Kyllstr.", "Langenfelder Str.", "Längsleimbach", "Lärchenweg", "Legienstr.", "Lehner Mühle", "Leichlinger Str.", "Leimbacher Hof", "Leinestr.", "Leineweberstr.", "Leipziger Str.", "Lerchengasse", "Lessingstr.", "Libellenweg", "Lichstr.", "Liebigstr.", "Lindenstr.", "Lingenfeld", "Linienstr.", "Lippe", "Löchergraben", "Löfflerstr.", "Loheweg", "Lohrbergstr.", "Lohrstr.", "Löhstr.", "Lortzingstr.", "Lötzener Str.", "Löwenburgstr.", "Lucasstr.", "Ludwig-Erhard-Platz", "Ludwig-Girtler-Str.", "Ludwig-Knorr-Str.", "Luisenstr.", "Lupinenweg", "Lurchenweg", "Lützenkirchener Str.", "Lycker Str.", "Maashofstr.", "Manforter Str.", "Marc-Chagall-Str.", "Maria-Dresen-Str.", "Maria-Terwiel-Str.", "Marie-Curie-Str.", "Marienburger Str.", "Mariendorfer Str.", "Marienwerderstr.", "Marie-Schlei-Str.", "Marktplatz", "Markusweg", "Martin-Buber-Str.", "Martin-Heidegger-Str.", "Martin-Luther-Str.", "Masurenstr.", "Mathildenweg", "Maurinusstr.", "Mauspfad", "Max-Beckmann-Str.", "Max-Delbrück-Str.", "Max-Ernst-Str.", "Max-Holthausen-Platz", "Max-Horkheimer-Str.", "Max-Liebermann-Str.", "Max-Pechstein-Str.", "Max-Planck-Str.", "Max-Scheler-Str.", "Max-Schönenberg-Str.", "Maybachstr.", "Meckhofer Feld", "Meisenweg", "Memelstr.", "Menchendahler Str.", "Mendelssohnstr.", "Merziger Str.", "Mettlacher Str.", "Metzer Str.", "Michaelsweg", "Miselohestr.", "Mittelstr.", "Mohlenstr.", "Moltkestr.", "Monheimer Str.", "Montanusstr.", "Montessoriweg", "Moosweg", "Morsbroicher Str.", "Moselstr.", "Moskauer Str.", "Mozartstr.", "Mühlenweg", "Muhrgasse", "Muldestr.", "Mülhausener Str.", "Mülheimer Str.", "Münsters Gäßchen", "Münzstr.", "Müritzstr.", "Myliusstr.", "Nachtigallenweg", "Nauener Str.", "Neißestr.", "Nelly-Sachs-Str.", "Netzestr.", "Neuendriesch", "Neuenhausgasse", "Neuenkamp", "Neujudenhof", "Neukronenberger Str.", "Neustadtstr.", "Nicolai-Hartmann-Str.", "Niederblecher", "Niederfeldstr.", "Nietzschestr.", "Nikolaus-Groß-Str.", "Nobelstr.", "Norderneystr.", "Nordstr.", "Ober dem Hof", "Obere Lindenstr.", "Obere Str.", "Oberölbach", "Odenthaler Str.", "Oderstr.", "Okerstr.", "Olof-Palme-Str.", "Ophovener Str.", "Opladener Platz", "Opladener Str.", "Ortelsburger Str.", "Oskar-Moll-Str.", "Oskar-Schlemmer-Str.", "Oststr.", "Oswald-Spengler-Str.", "Otto-Dix-Str.", "Otto-Grimm-Str.", "Otto-Hahn-Str.", "Otto-Müller-Str.", "Otto-Stange-Str.", "Ottostr.", "Otto-Varnhagen-Str.", "Otto-Wels-Str.", "Ottweilerstr.", "Oulustr.", "Overfeldweg", "Pappelweg", "Paracelsusstr.", "Parkstr.", "Pastor-Louis-Str.", "Pastor-Scheibler-Str.", "Pastorskamp", "Paul-Klee-Str.", "Paul-Löbe-Str.", "Paulstr.", "Peenestr.", "Pescher Busch", "Peschstr.", "Pestalozzistr.", "Peter-Grieß-Str.", "Peter-Joseph-Lenné-Str.", "Peter-Neuenheuser-Str.", "Petersbergstr.", "Peterstr.", "Pfarrer-Jekel-Str.", "Pfarrer-Klein-Str.", "Pfarrer-Röhr-Str.", "Pfeilshofstr.", "Philipp-Ott-Str.", "Piet-Mondrian-Str.", "Platanenweg", "Pommernstr.", "Porschestr.", "Poststr.", "Potsdamer Str.", "Pregelstr.", "Prießnitzstr.", "Pützdelle", "Quarzstr.", "Quettinger Str.", "Rat-Deycks-Str.", "Rathenaustr.", "Ratherkämp", "Ratiborer Str.", "Raushofstr.", "Regensburger Str.", "Reinickendorfer Str.", "Renkgasse", "Rennbaumplatz", "Rennbaumstr.", "Reuschenberger Str.", "Reusrather Str.", "Reuterstr.", "Rheinallee", "Rheindorfer Str.", "Rheinstr.", "Rhein-Wupper-Platz", "Richard-Wagner-Str.", "Rilkestr.", "Ringstr.", "Robert-Blum-Str.", "Robert-Koch-Str.", "Robert-Medenwald-Str.", "Rolandstr.", "Romberg", "Röntgenstr.", "Roonstr.", "Ropenstall", "Ropenstaller Weg", "Rosenthal", "Rostocker Str.", "Rotdornweg", "Röttgerweg", "Rückertstr.", "Rudolf-Breitscheid-Str.", "Rudolf-Mann-Platz", "Rudolf-Stracke-Str.", "Ruhlachplatz", "Ruhlachstr.", "Rüttersweg", "Saalestr.", "Saarbrücker Str.", "Saarlauterner Str.", "Saarstr.", "Salamanderweg", "Samlandstr.", "Sanddornstr.", "Sandstr.", "Sauerbruchstr.", "Schäfershütte", "Scharnhorststr.", "Scheffershof", "Scheidemannstr.", "Schellingstr.", "Schenkendorfstr.", "Schießbergstr.", "Schillerstr.", "Schlangenhecke", "Schlebuscher Heide", "Schlebuscher Str.", "Schlebuschrath", "Schlehdornstr.", "Schleiermacherstr.", "Schloßstr.", "Schmalenbruch", "Schnepfenflucht", "Schöffenweg", "Schöllerstr.", "Schöne Aussicht", "Schöneberger Str.", "Schopenhauerstr.", "Schubertplatz", "Schubertstr.", "Schulberg", "Schulstr.", "Schumannstr.", "Schwalbenweg", "Schwarzastr.", "Sebastianusweg", "Semmelweisstr.", "Siebelplatz", "Siemensstr.", "Solinger Str.", "Sonderburger Str.", "Spandauer Str.", "Speestr.", "Sperberweg", "Sperlingsweg", "Spitzwegstr.", "Sporrenberger Mühle", "Spreestr.", "St. Ingberter Str.", "Starenweg", "Stauffenbergstr.", "Stefan-Zweig-Str.", "Stegerwaldstr.", "Steglitzer Str.", "Steinbücheler Feld", "Steinbücheler Str.", "Steinstr.", "Steinweg", "Stephan-Lochner-Str.", "Stephanusstr.", "Stettiner Str.", "Stixchesstr.", "Stöckenstr.", "Stralsunder Str.", "Straßburger Str.", "Stresemannplatz", "Strombergstr.", "Stromstr.", "Stüttekofener Str.", "Sudestr.", "Sürderstr.", "Syltstr.", "Talstr.", "Tannenbergstr.", "Tannenweg", "Taubenweg", "Teitscheider Weg", "Telegrafenstr.", "Teltower Str.", "Tempelhofer Str.", "Theodor-Adorno-Str.", "Theodor-Fliedner-Str.", "Theodor-Gierath-Str.", "Theodor-Haubach-Str.", "Theodor-Heuss-Ring", "Theodor-Storm-Str.", "Theodorstr.", "Thomas-Dehler-Str.", "Thomas-Morus-Str.", "Thomas-von-Aquin-Str.", "Tönges Feld", "Torstr.", "Treptower Str.", "Treuburger Str.", "Uhlandstr.", "Ulmenweg", "Ulmer Str.", "Ulrichstr.", "Ulrich-von-Hassell-Str.", "Umlag", "Unstrutstr.", "Unter dem Schildchen", "Unterölbach", "Unterstr.", "Uppersberg", "Van\\'t-Hoff-Str.", "Veit-Stoß-Str.", "Vereinsstr.", "Viktor-Meyer-Str.", "Vincent-van-Gogh-Str.", "Virchowstr.", "Voigtslach", "Volhardstr.", "Völklinger Str.", "Von-Brentano-Str.", "Von-Diergardt-Str.", "Von-Eichendorff-Str.", "Von-Ketteler-Str.", "Von-Knoeringen-Str.", "Von-Pettenkofer-Str.", "Von-Siebold-Str.", "Wacholderweg", "Waldstr.", "Walter-Flex-Str.", "Walter-Hempel-Str.", "Walter-Hochapfel-Str.", "Walter-Nernst-Str.", "Wannseestr.", "Warnowstr.", "Warthestr.", "Weddigenstr.", "Weichselstr.", "Weidenstr.", "Weidfeldstr.", "Weiherfeld", "Weiherstr.", "Weinhäuser Str.", "Weißdornweg", "Weißenseestr.", "Weizkamp", "Werftstr.", "Werkstättenstr.", "Werner-Heisenberg-Str.", "Werrastr.", "Weyerweg", "Widdauener Str.", "Wiebertshof", "Wiehbachtal", "Wiembachallee", "Wiesdorfer Platz", "Wiesenstr.", "Wilhelm-Busch-Str.", "Wilhelm-Hastrich-Str.", "Wilhelm-Leuschner-Str.", "Wilhelm-Liebknecht-Str.", "Wilhelmsgasse", "Wilhelmstr.", "Willi-Baumeister-Str.", "Willy-Brandt-Ring", "Winand-Rossi-Str.", "Windthorststr.", "Winkelweg", "Winterberg", "Wittenbergstr.", "Wolf-Vostell-Str.", "Wolkenburgstr.", "Wupperstr.", "Wuppertalstr.", "Wüstenhof", "Yitzhak-Rabin-Str.", "Zauberkuhle", "Zedernweg", "Zehlendorfer Str.", "Zehntenweg", "Zeisigweg", "Zeppelinstr.", "Zschopaustr.", "Zum Claashäuschen", "Zündhütchenweg", "Zur Alten Brauerei", "Zur alten Fabrik"]; - var result = Array(length); - while (++index < length) { - result[index] = array[index + start]; - } - return result; - } +/***/ }, +/* 151 */ +/***/ function(module, exports) { - module.exports = baseSlice; + "use strict"; + module.exports = { + name: ["#{names.lastName} #{company.suffix}", "#{names.lastName}-#{names.lastName}", "#{names.lastName}, #{names.lastName} und #{names.lastName}"], + + suffix: ["GmbH", "AG", "Gruppe", "KG", "GmbH & Co. KG", "UG", "OHG"] + }; /***/ }, -/* 162 */ -/***/ function(module, exports) { +/* 152 */ +/***/ function(module, exports, __webpack_require__) { - /** Used to compose unicode character classes. */ - var rsAstralRange = '\\ud800-\\udfff', - rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23', - rsComboSymbolsRange = '\\u20d0-\\u20f0', - rsVarRange = '\\ufe0e\\ufe0f'; + "use strict"; - /** Used to compose unicode capture groups. */ - var rsZWJ = '\\u200d'; + module.exports = { + _meta: { + id: "de-DE", + fallback: null, + language: "German", + country: "Germany", + countryCode: "DE" + }, - /** 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 reHasComplexSymbol = RegExp('[' + rsZWJ + rsAstralRange + rsComboMarksRange + rsComboSymbolsRange + rsVarRange + ']'); + names: __webpack_require__(153), + phone: __webpack_require__(157), + address: __webpack_require__(148), + company: __webpack_require__(151), + internet: __webpack_require__(158) + }; - module.exports = reHasComplexSymbol; +/***/ }, +/* 153 */ +/***/ function(module, exports, __webpack_require__) { + "use strict"; -/***/ }, -/* 163 */ -/***/ function(module, exports) { + module.exports = { + firstNameM: __webpack_require__(154), - /** Used to compose unicode character classes. */ - var rsAstralRange = '\\ud800-\\udfff', - rsComboMarksRange = '\\u0300-\\u036f\\ufe20-\\ufe23', - rsComboSymbolsRange = '\\u20d0-\\u20f0', - rsVarRange = '\\ufe0e\\ufe0f'; + firstNameF: __webpack_require__(154), - /** Used to compose unicode capture groups. */ - var rsAstral = '[' + rsAstralRange + ']', - rsCombo = '[' + rsComboMarksRange + rsComboSymbolsRange + ']', - rsFitz = '\\ud83c[\\udffb-\\udfff]', - rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')', - rsNonAstral = '[^' + rsAstralRange + ']', - rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}', - rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]', - rsZWJ = '\\u200d'; + lastNameM: __webpack_require__(155), - /** Used to compose unicode regexes. */ - var reOptMod = rsModifier + '?', - rsOptVar = '[' + rsVarRange + ']?', - rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*', - rsSeq = rsOptVar + reOptMod + rsOptJoin, - rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')'; + lastNameF: __webpack_require__(155), - /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */ - var reComplexSymbol = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g'); + prefix: ["Hr.", "Fr.", "Dr.", "Prof. Dr."], - /** - * Converts `string` to an array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the converted array. - */ - function stringToArray(string) { - return string.match(reComplexSymbol); - } + nobilityTitlePrefix: __webpack_require__(156), - module.exports = stringToArray; + suffix: [], + name: ["#{names.prefix} #{names.firstName} #{names.lastName}", "#{names.firstName} #{names.nobilityTitlePrefix} #{names.lastName}", "#{names.firstName} #{names.lastName}", "#{names.firstName} #{names.lastName}", "#{names.firstName} #{names.lastName}", "#{names.firstName} #{names.lastName}"], -/***/ }, -/* 164 */ -/***/ function(module, exports, __webpack_require__) { + nameM: module.exports.name, + nameF: module.exports.name - var isObjectLike = __webpack_require__(65); + }; - /** `Object#toString` result references. */ - var numberTag = '[object Number]'; +/***/ }, +/* 154 */ +/***/ function(module, exports) { - /** Used for built-in method references. */ - var objectProto = Object.prototype; + "use strict"; - /** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) - * of values. - */ - var objectToString = objectProto.toString; + module.exports = ["Aaron", "Abdul", "Abdullah", "Adam", "Adrian", "Adriano", "Ahmad", "Ahmed", "Ahmet", "Alan", "Albert", "Alessandro", "Alessio", "Alex", "Alexander", "Alfred", "Ali", "Amar", "Amir", "Amon", "Andre", "Andreas", "Andrew", "Angelo", "Ansgar", "Anthony", "Anton", "Antonio", "Arda", "Arian", "Armin", "Arne", "Arno", "Arthur", "Artur", "Arved", "Arvid", "Ayman", "Baran", "Baris", "Bastian", "Batuhan", "Bela", "Ben", "Benedikt", "Benjamin", "Bennet", "Bennett", "Benno", "Bent", "Berat", "Berkay", "Bernd", "Bilal", "Bjarne", "Björn", "Bo", "Boris", "Brandon", "Brian", "Bruno", "Bryan", "Burak", "Calvin", "Can", "Carl", "Carlo", "Carlos", "Caspar", "Cedric", "Cedrik", "Cem", "Charlie", "Chris", "Christian", "Christiano", "Christoph", "Christopher", "Claas", "Clemens", "Colin", "Collin", "Conner", "Connor", "Constantin", "Corvin", "Curt", "Damian", "Damien", "Daniel", "Danilo", "Danny", "Darian", "Dario", "Darius", "Darren", "David", "Davide", "Davin", "Dean", "Deniz", "Dennis", "Denny", "Devin", "Diego", "Dion", "Domenic", "Domenik", "Dominic", "Dominik", "Dorian", "Dustin", "Dylan", "Ecrin", "Eddi", "Eddy", "Edgar", "Edwin", "Efe", "Ege", "Elia", "Eliah", "Elias", "Elijah", "Emanuel", "Emil", "Emilian", "Emilio", "Emir", "Emirhan", "Emre", "Enes", "Enno", "Enrico", "Eren", "Eric", "Erik", "Etienne", "Fabian", "Fabien", "Fabio", "Fabrice", "Falk", "Felix", "Ferdinand", "Fiete", "Filip", "Finlay", "Finley", "Finn", "Finnley", "Florian", "Francesco", "Franz", "Frederic", "Frederick", "Frederik", "Friedrich", "Fritz", "Furkan", "Fynn", "Gabriel", "Georg", "Gerrit", "Gian", "Gianluca", "Gino", "Giuliano", "Giuseppe", "Gregor", "Gustav", "Hagen", "Hamza", "Hannes", "Hanno", "Hans", "Hasan", "Hassan", "Hauke", "Hendrik", "Hennes", "Henning", "Henri", "Henrick", "Henrik", "Henry", "Hugo", "Hussein", "Ian", "Ibrahim", "Ilias", "Ilja", "Ilyas", "Immanuel", "Ismael", "Ismail", "Ivan", "Iven", "Jack", "Jacob", "Jaden", "Jakob", "Jamal", "James", "Jamie", "Jan", "Janek", "Janis", "Janne", "Jannek", "Jannes", "Jannik", "Jannis", "Jano", "Janosch", "Jared", "Jari", "Jarne", "Jarno", "Jaron", "Jason", "Jasper", "Jay", "Jayden", "Jayson", "Jean", "Jens", "Jeremias", "Jeremie", "Jeremy", "Jermaine", "Jerome", "Jesper", "Jesse", "Jim", "Jimmy", "Joe", "Joel", "Joey", "Johann", "Johannes", "John", "Johnny", "Jon", "Jona", "Jonah", "Jonas", "Jonathan", "Jonte", "Joost", "Jordan", "Joris", "Joscha", "Joschua", "Josef", "Joseph", "Josh", "Joshua", "Josua", "Juan", "Julian", "Julien", "Julius", "Juri", "Justin", "Justus", "Kaan", "Kai", "Kalle", "Karim", "Karl", "Karlo", "Kay", "Keanu", "Kenan", "Kenny", "Keno", "Kerem", "Kerim", "Kevin", "Kian", "Kilian", "Kim", "Kimi", "Kjell", "Klaas", "Klemens", "Konrad", "Konstantin", "Koray", "Korbinian", "Kurt", "Lars", "Lasse", "Laurence", "Laurens", "Laurenz", "Laurin", "Lean", "Leander", "Leandro", "Leif", "Len", "Lenn", "Lennard", "Lennart", "Lennert", "Lennie", "Lennox", "Lenny", "Leo", "Leon", "Leonard", "Leonardo", "Leonhard", "Leonidas", "Leopold", "Leroy", "Levent", "Levi", "Levin", "Lewin", "Lewis", "Liam", "Lian", "Lias", "Lino", "Linus", "Lio", "Lion", "Lionel", "Logan", "Lorenz", "Lorenzo", "Loris", "Louis", "Luan", "Luc", "Luca", "Lucas", "Lucian", "Lucien", "Ludwig", "Luis", "Luiz", "Luk", "Luka", "Lukas", "Luke", "Lutz", "Maddox", "Mads", "Magnus", "Maik", "Maksim", "Malik", "Malte", "Manuel", "Marc", "Marcel", "Marco", "Marcus", "Marek", "Marian", "Mario", "Marius", "Mark", "Marko", "Markus", "Marlo", "Marlon", "Marten", "Martin", "Marvin", "Marwin", "Mateo", "Mathis", "Matis", "Mats", "Matteo", "Mattes", "Matthias", "Matthis", "Matti", "Mattis", "Maurice", "Max", "Maxim", "Maximilian", "Mehmet", "Meik", "Melvin", "Merlin", "Mert", "Michael", "Michel", "Mick", "Miguel", "Mika", "Mikail", "Mike", "Milan", "Milo", "Mio", "Mirac", "Mirco", "Mirko", "Mohamed", "Mohammad", "Mohammed", "Moritz", "Morten", "Muhammed", "Murat", "Mustafa", "Nathan", "Nathanael", "Nelson", "Neo", "Nevio", "Nick", "Niclas", "Nico", "Nicolai", "Nicolas", "Niels", "Nikita", "Niklas", "Niko", "Nikolai", "Nikolas", "Nils", "Nino", "Noah", "Noel", "Norman", "Odin", "Oke", "Ole", "Oliver", "Omar", "Onur", "Oscar", "Oskar", "Pascal", "Patrice", "Patrick", "Paul", "Peer", "Pepe", "Peter", "Phil", "Philip", "Philipp", "Pierre", "Piet", "Pit", "Pius", "Quentin", "Quirin", "Rafael", "Raik", "Ramon", "Raphael", "Rasmus", "Raul", "Rayan", "René", "Ricardo", "Riccardo", "Richard", "Rick", "Rico", "Robert", "Robin", "Rocco", "Roman", "Romeo", "Ron", "Ruben", "Ryan", "Said", "Salih", "Sam", "Sami", "Sammy", "Samuel", "Sandro", "Santino", "Sascha", "Sean", "Sebastian", "Selim", "Semih", "Shawn", "Silas", "Simeon", "Simon", "Sinan", "Sky", "Stefan", "Steffen", "Stephan", "Steve", "Steven", "Sven", "Sönke", "Sören", "Taha", "Tamino", "Tammo", "Tarik", "Tayler", "Taylor", "Teo", "Theo", "Theodor", "Thies", "Thilo", "Thomas", "Thorben", "Thore", "Thorge", "Tiago", "Til", "Till", "Tillmann", "Tim", "Timm", "Timo", "Timon", "Timothy", "Tino", "Titus", "Tizian", "Tjark", "Tobias", "Tom", "Tommy", "Toni", "Tony", "Torben", "Tore", "Tristan", "Tyler", "Tyron", "Umut", "Valentin", "Valentino", "Veit", "Victor", "Viktor", "Vin", "Vincent", "Vito", "Vitus", "Wilhelm", "Willi", "William", "Willy", "Xaver", "Yannic", "Yannick", "Yannik", "Yannis", "Yasin", "Youssef", "Yunus", "Yusuf", "Yven", "Yves", "Ömer", "Aaliyah", "Abby", "Abigail", "Ada", "Adelina", "Adriana", "Aileen", "Aimee", "Alana", "Alea", "Alena", "Alessa", "Alessia", "Alexa", "Alexandra", "Alexia", "Alexis", "Aleyna", "Alia", "Alica", "Alice", "Alicia", "Alina", "Alisa", "Alisha", "Alissa", "Aliya", "Aliyah", "Allegra", "Alma", "Alyssa", "Amalia", "Amanda", "Amelia", "Amelie", "Amina", "Amira", "Amy", "Ana", "Anabel", "Anastasia", "Andrea", "Angela", "Angelina", "Angelique", "Anja", "Ann", "Anna", "Annabel", "Annabell", "Annabelle", "Annalena", "Anne", "Anneke", "Annelie", "Annemarie", "Anni", "Annie", "Annika", "Anny", "Anouk", "Antonia", "Arda", "Ariana", "Ariane", "Arwen", "Ashley", "Asya", "Aurelia", "Aurora", "Ava", "Ayleen", "Aylin", "Ayse", "Azra", "Betty", "Bianca", "Bianka", "Caitlin", "Cara", "Carina", "Carla", "Carlotta", "Carmen", "Carolin", "Carolina", "Caroline", "Cassandra", "Catharina", "Catrin", "Cecile", "Cecilia", "Celia", "Celina", "Celine", "Ceyda", "Ceylin", "Chantal", "Charleen", "Charlotta", "Charlotte", "Chayenne", "Cheyenne", "Chiara", "Christin", "Christina", "Cindy", "Claire", "Clara", "Clarissa", "Colleen", "Collien", "Cora", "Corinna", "Cosima", "Dana", "Daniela", "Daria", "Darleen", "Defne", "Delia", "Denise", "Diana", "Dilara", "Dina", "Dorothea", "Ecrin", "Eda", "Eileen", "Ela", "Elaine", "Elanur", "Elea", "Elena", "Eleni", "Eleonora", "Eliana", "Elif", "Elina", "Elisa", "Elisabeth", "Ella", "Ellen", "Elli", "Elly", "Elsa", "Emelie", "Emely", "Emilia", "Emilie", "Emily", "Emma", "Emmely", "Emmi", "Emmy", "Enie", "Enna", "Enya", "Esma", "Estelle", "Esther", "Eva", "Evelin", "Evelina", "Eveline", "Evelyn", "Fabienne", "Fatima", "Fatma", "Felicia", "Felicitas", "Felina", "Femke", "Fenja", "Fine", "Finia", "Finja", "Finnja", "Fiona", "Flora", "Florentine", "Francesca", "Franka", "Franziska", "Frederike", "Freya", "Frida", "Frieda", "Friederike", "Giada", "Gina", "Giulia", "Giuliana", "Greta", "Hailey", "Hana", "Hanna", "Hannah", "Heidi", "Helen", "Helena", "Helene", "Helin", "Henriette", "Henrike", "Hermine", "Ida", "Ilayda", "Imke", "Ina", "Ines", "Inga", "Inka", "Irem", "Isa", "Isabel", "Isabell", "Isabella", "Isabelle", "Ivonne", "Jacqueline", "Jamie", "Jamila", "Jana", "Jane", "Janin", "Janina", "Janine", "Janna", "Janne", "Jara", "Jasmin", "Jasmina", "Jasmine", "Jella", "Jenna", "Jennifer", "Jenny", "Jessica", "Jessy", "Jette", "Jil", "Jill", "Joana", "Joanna", "Joelina", "Joeline", "Joelle", "Johanna", "Joleen", "Jolie", "Jolien", "Jolin", "Jolina", "Joline", "Jona", "Jonah", "Jonna", "Josefin", "Josefine", "Josephin", "Josephine", "Josie", "Josy", "Joy", "Joyce", "Judith", "Judy", "Jule", "Julia", "Juliana", "Juliane", "Julie", "Julienne", "Julika", "Julina", "Juna", "Justine", "Kaja", "Karina", "Karla", "Karlotta", "Karolina", "Karoline", "Kassandra", "Katarina", "Katharina", "Kathrin", "Katja", "Katrin", "Kaya", "Kayra", "Kiana", "Kiara", "Kim", "Kimberley", "Kimberly", "Kira", "Klara", "Korinna", "Kristin", "Kyra", "Laila", "Lana", "Lara", "Larissa", "Laura", "Laureen", "Lavinia", "Lea", "Leah", "Leana", "Leandra", "Leann", "Lee", "Leila", "Lena", "Lene", "Leni", "Lenia", "Lenja", "Lenya", "Leona", "Leoni", "Leonie", "Leonora", "Leticia", "Letizia", "Levke", "Leyla", "Lia", "Liah", "Liana", "Lili", "Lilia", "Lilian", "Liliana", "Lilith", "Lilli", "Lillian", "Lilly", "Lily", "Lina", "Linda", "Lindsay", "Line", "Linn", "Linnea", "Lisa", "Lisann", "Lisanne", "Liv", "Livia", "Liz", "Lola", "Loreen", "Lorena", "Lotta", "Lotte", "Louisa", "Louise", "Luana", "Luca", "Lucia", "Lucie", "Lucienne", "Lucy", "Luisa", "Luise", "Luka", "Luna", "Luzie", "Lya", "Lydia", "Lyn", "Lynn", "Madeleine", "Madita", "Madleen", "Madlen", "Magdalena", "Maike", "Mailin", "Maira", "Maja", "Malena", "Malia", "Malin", "Malina", "Mandy", "Mara", "Marah", "Mareike", "Maren", "Maria", "Mariam", "Marie", "Marieke", "Mariella", "Marika", "Marina", "Marisa", "Marissa", "Marit", "Marla", "Marleen", "Marlen", "Marlena", "Marlene", "Marta", "Martha", "Mary", "Maryam", "Mathilda", "Mathilde", "Matilda", "Maxi", "Maxima", "Maxine", "Maya", "Mayra", "Medina", "Medine", "Meike", "Melanie", "Melek", "Melike", "Melina", "Melinda", "Melis", "Melisa", "Melissa", "Merle", "Merve", "Meryem", "Mette", "Mia", "Michaela", "Michelle", "Mieke", "Mila", "Milana", "Milena", "Milla", "Mina", "Mira", "Miray", "Miriam", "Mirja", "Mona", "Monique", "Nadine", "Nadja", "Naemi", "Nancy", "Naomi", "Natalia", "Natalie", "Nathalie", "Neele", "Nela", "Nele", "Nelli", "Nelly", "Nia", "Nicole", "Nika", "Nike", "Nikita", "Nila", "Nina", "Nisa", "Noemi", "Nora", "Olivia", "Patricia", "Patrizia", "Paula", "Paulina", "Pauline", "Penelope", "Philine", "Phoebe", "Pia", "Rahel", "Rania", "Rebecca", "Rebekka", "Riana", "Rieke", "Rike", "Romina", "Romy", "Ronja", "Rosa", "Rosalie", "Ruby", "Sabrina", "Sahra", "Sally", "Salome", "Samantha", "Samia", "Samira", "Sandra", "Sandy", "Sanja", "Saphira", "Sara", "Sarah", "Saskia", "Selin", "Selina", "Selma", "Sena", "Sidney", "Sienna", "Silja", "Sina", "Sinja", "Smilla", "Sofia", "Sofie", "Sonja", "Sophia", "Sophie", "Soraya", "Stefanie", "Stella", "Stephanie", "Stina", "Sude", "Summer", "Susanne", "Svea", "Svenja", "Sydney", "Tabea", "Talea", "Talia", "Tamara", "Tamia", "Tamina", "Tanja", "Tara", "Tarja", "Teresa", "Tessa", "Thalea", "Thalia", "Thea", "Theresa", "Tia", "Tina", "Tomke", "Tuana", "Valentina", "Valeria", "Valerie", "Vanessa", "Vera", "Veronika", "Victoria", "Viktoria", "Viola", "Vivian", "Vivien", "Vivienne", "Wibke", "Wiebke", "Xenia", "Yara", "Yaren", "Yasmin", "Ylvi", "Ylvie", "Yvonne", "Zara", "Zehra", "Zeynep", "Zoe", "Zoey", "Zoé"]; - /** - * 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 correctly classified, - * 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) && objectToString.call(value) == numberTag); - } +/***/ }, +/* 155 */ +/***/ function(module, exports) { - module.exports = isNumber; + "use strict"; + module.exports = ["Abel", "Abicht", "Abraham", "Abramovic", "Abt", "Achilles", "Achkinadze", "Ackermann", "Adam", "Adams", "Ade", "Agostini", "Ahlke", "Ahrenberg", "Ahrens", "Aigner", "Albert", "Albrecht", "Alexa", "Alexander", "Alizadeh", "Allgeyer", "Amann", "Amberg", "Anding", "Anggreny", "Apitz", "Arendt", "Arens", "Arndt", "Aryee", "Aschenbroich", "Assmus", "Astafei", "Auer", "Axmann", "Baarck", "Bachmann", "Badane", "Bader", "Baganz", "Bahl", "Bak", "Balcer", "Balck", "Balkow", "Balnuweit", "Balzer", "Banse", "Barr", "Bartels", "Barth", "Barylla", "Baseda", "Battke", "Bauer", "Bauermeister", "Baumann", "Baumeister", "Bauschinger", "Bauschke", "Bayer", "Beavogui", "Beck", "Beckel", "Becker", "Beckmann", "Bedewitz", "Beele", "Beer", "Beggerow", "Beh", "Behr", "Behrenbruch", "Belz", "Bender", "Benecke", "Benner", "Benninger", "Benzing", "Berends", "Berger", "Berner", "Berning", "Bertenbreiter", "Best", "Bethke", "Betz", "Beushausen", "Beutelspacher", "Beyer", "Biba", "Bichler", "Bickel", "Biedermann", "Bieler", "Bielert", "Bienasch", "Bienias", "Biesenbach", "Bigdeli", "Birkemeyer", "Bittner", "Blank", "Blaschek", "Blassneck", "Bloch", "Blochwitz", "Blockhaus", "Blum", "Blume", "Bock", "Bode", "Bogdashin", "Bogenrieder", "Bohge", "Bolm", "Borgschulze", "Bork", "Bormann", "Bornscheuer", "Borrmann", "Borsch", "Boruschewski", "Bos", "Bosler", "Bourrouag", "Bouschen", "Boxhammer", "Boyde", "Bozsik", "Brand", "Brandenburg", "Brandis", "Brandt", "Brauer", "Braun", "Brehmer", "Breitenstein", "Bremer", "Bremser", "Brenner", "Brettschneider", "Breu", "Breuer", "Briesenick", "Bringmann", "Brinkmann", "Brix", "Broening", "Brosch", "Bruckmann", "Bruder", "Bruhns", "Brunner", "Bruns", "Bräutigam", "Brömme", "Brüggmann", "Buchholz", "Buchrucker", "Buder", "Bultmann", "Bunjes", "Burger", "Burghagen", "Burkhard", "Burkhardt", "Burmeister", "Busch", "Buschbaum", "Busemann", "Buss", "Busse", "Bussmann", "Byrd", "Bäcker", "Böhm", "Bönisch", "Börgeling", "Börner", "Böttner", "Büchele", "Bühler", "Büker", "Büngener", "Bürger", "Bürklein", "Büscher", "Büttner", "Camara", "Carlowitz", "Carlsohn", "Caspari", "Caspers", "Chapron", "Christ", "Cierpinski", "Clarius", "Cleem", "Cleve", "Co", "Conrad", "Cordes", "Cornelsen", "Cors", "Cotthardt", "Crews", "Cronjäger", "Crosskofp", "Da", "Dahm", "Dahmen", "Daimer", "Damaske", "Danneberg", "Danner", "Daub", "Daubner", "Daudrich", "Dauer", "Daum", "Dauth", "Dautzenberg", "De", "Decker", "Deckert", "Deerberg", "Dehmel", "Deja", "Delonge", "Demut", "Dengler", "Denner", "Denzinger", "Derr", "Dertmann", "Dethloff", "Deuschle", "Dieckmann", "Diedrich", "Diekmann", "Dienel", "Dies", "Dietrich", "Dietz", "Dietzsch", "Diezel", "Dilla", "Dingelstedt", "Dippl", "Dittmann", "Dittmar", "Dittmer", "Dix", "Dobbrunz", "Dobler", "Dohring", "Dolch", "Dold", "Dombrowski", "Donie", "Doskoczynski", "Dragu", "Drechsler", "Drees", "Dreher", "Dreier", "Dreissigacker", "Dressler", "Drews", "Duma", "Dutkiewicz", "Dyett", "Dylus", "Dächert", "Döbel", "Döring", "Dörner", "Dörre", "Dück", "Eberhard", "Eberhardt", "Ecker", "Eckhardt", "Edorh", "Effler", "Eggenmueller", "Ehm", "Ehmann", "Ehrig", "Eich", "Eichmann", "Eifert", "Einert", "Eisenlauer", "Ekpo", "Elbe", "Eleyth", "Elss", "Emert", "Emmelmann", "Ender", "Engel", "Engelen", "Engelmann", "Eplinius", "Erdmann", "Erhardt", "Erlei", "Erm", "Ernst", "Ertl", "Erwes", "Esenwein", "Esser", "Evers", "Everts", "Ewald", "Fahner", "Faller", "Falter", "Farber", "Fassbender", "Faulhaber", "Fehrig", "Feld", "Felke", "Feller", "Fenner", "Fenske", "Feuerbach", "Fietz", "Figl", "Figura", "Filipowski", "Filsinger", "Fincke", "Fink", "Finke", "Fischer", "Fitschen", "Fleischer", "Fleischmann", "Floder", "Florczak", "Flore", "Flottmann", "Forkel", "Forst", "Frahmeke", "Frank", "Franke", "Franta", "Frantz", "Franz", "Franzis", "Franzmann", "Frauen", "Frauendorf", "Freigang", "Freimann", "Freimuth", "Freisen", "Frenzel", "Frey", "Fricke", "Fried", "Friedek", "Friedenberg", "Friedmann", "Friedrich", "Friess", "Frisch", "Frohn", "Frosch", "Fuchs", "Fuhlbrügge", "Fusenig", "Fust", "Förster", "Gaba", "Gabius", "Gabler", "Gadschiew", "Gakstädter", "Galander", "Gamlin", "Gamper", "Gangnus", "Ganzmann", "Garatva", "Gast", "Gastel", "Gatzka", "Gauder", "Gebhardt", "Geese", "Gehre", "Gehrig", "Gehring", "Gehrke", "Geiger", "Geisler", "Geissler", "Gelling", "Gens", "Gerbennow", "Gerdel", "Gerhardt", "Gerschler", "Gerson", "Gesell", "Geyer", "Ghirmai", "Ghosh", "Giehl", "Gierisch", "Giesa", "Giesche", "Gilde", "Glatting", "Goebel", "Goedicke", "Goldbeck", "Goldfuss", "Goldkamp", "Goldkühle", "Goller", "Golling", "Gollnow", "Golomski", "Gombert", "Gotthardt", "Gottschalk", "Gotz", "Goy", "Gradzki", "Graf", "Grams", "Grasse", "Gratzky", "Grau", "Greb", "Green", "Greger", "Greithanner", "Greschner", "Griem", "Griese", "Grimm", "Gromisch", "Gross", "Grosser", "Grossheim", "Grosskopf", "Grothaus", "Grothkopp", "Grotke", "Grube", "Gruber", "Grundmann", "Gruning", "Gruszecki", "Gröss", "Grötzinger", "Grün", "Grüner", "Gummelt", "Gunkel", "Gunther", "Gutjahr", "Gutowicz", "Gutschank", "Göbel", "Göckeritz", "Göhler", "Görlich", "Görmer", "Götz", "Götzelmann", "Güldemeister", "Günther", "Günz", "Gürbig", "Haack", "Haaf", "Habel", "Hache", "Hackbusch", "Hackelbusch", "Hadfield", "Hadwich", "Haferkamp", "Hahn", "Hajek", "Hallmann", "Hamann", "Hanenberger", "Hannecker", "Hanniske", "Hansen", "Hardy", "Hargasser", "Harms", "Harnapp", "Harter", "Harting", "Hartlieb", "Hartmann", "Hartwig", "Hartz", "Haschke", "Hasler", "Hasse", "Hassfeld", "Haug", "Hauke", "Haupt", "Haverney", "Heberstreit", "Hechler", "Hecht", "Heck", "Hedermann", "Hehl", "Heidelmann", "Heidler", "Heinemann", "Heinig", "Heinke", "Heinrich", "Heinze", "Heiser", "Heist", "Hellmann", "Helm", "Helmke", "Helpling", "Hengmith", "Henkel", "Hennes", "Henry", "Hense", "Hensel", "Hentel", "Hentschel", "Hentschke", "Hepperle", "Herberger", "Herbrand", "Hering", "Hermann", "Hermecke", "Herms", "Herold", "Herrmann", "Herschmann", "Hertel", "Herweg", "Herwig", "Herzenberg", "Hess", "Hesse", "Hessek", "Hessler", "Hetzler", "Heuck", "Heydemüller", "Hiebl", "Hildebrand", "Hildenbrand", "Hilgendorf", "Hillard", "Hiller", "Hingsen", "Hingst", "Hinrichs", "Hirsch", "Hirschberg", "Hirt", "Hodea", "Hoffman", "Hoffmann", "Hofmann", "Hohenberger", "Hohl", "Hohn", "Hohnheiser", "Hold", "Holdt", "Holinski", "Holl", "Holtfreter", "Holz", "Holzdeppe", "Holzner", "Hommel", "Honz", "Hooss", "Hoppe", "Horak", "Horn", "Horna", "Hornung", "Hort", "Howard", "Huber", "Huckestein", "Hudak", "Huebel", "Hugo", "Huhn", "Hujo", "Huke", "Huls", "Humbert", "Huneke", "Huth", "Häber", "Häfner", "Höcke", "Höft", "Höhne", "Hönig", "Hördt", "Hübenbecker", "Hübl", "Hübner", "Hügel", "Hüttcher", "Hütter", "Ibe", "Ihly", "Illing", "Isak", "Isekenmeier", "Itt", "Jacob", "Jacobs", "Jagusch", "Jahn", "Jahnke", "Jakobs", "Jakubczyk", "Jambor", "Jamrozy", "Jander", "Janich", "Janke", "Jansen", "Jarets", "Jaros", "Jasinski", "Jasper", "Jegorov", "Jellinghaus", "Jeorga", "Jerschabek", "Jess", "John", "Jonas", "Jossa", "Jucken", "Jung", "Jungbluth", "Jungton", "Just", "Jürgens", "Kaczmarek", "Kaesmacher", "Kahl", "Kahlert", "Kahles", "Kahlmeyer", "Kaiser", "Kalinowski", "Kallabis", "Kallensee", "Kampf", "Kampschulte", "Kappe", "Kappler", "Karhoff", "Karrass", "Karst", "Karsten", "Karus", "Kass", "Kasten", "Kastner", "Katzinski", "Kaufmann", "Kaul", "Kausemann", "Kawohl", "Kazmarek", "Kedzierski", "Keil", "Keiner", "Keller", "Kelm", "Kempe", "Kemper", "Kempter", "Kerl", "Kern", "Kesselring", "Kesselschläger", "Kette", "Kettenis", "Keutel", "Kick", "Kiessling", "Kinadeter", "Kinzel", "Kinzy", "Kirch", "Kirst", "Kisabaka", "Klaas", "Klabuhn", "Klapper", "Klauder", "Klaus", "Kleeberg", "Kleiber", "Klein", "Kleinert", "Kleininger", "Kleinmann", "Kleinsteuber", "Kleiss", "Klemme", "Klimczak", "Klinger", "Klink", "Klopsch", "Klose", "Kloss", "Kluge", "Kluwe", "Knabe", "Kneifel", "Knetsch", "Knies", "Knippel", "Knobel", "Knoblich", "Knoll", "Knorr", "Knorscheidt", "Knut", "Kobs", "Koch", "Kochan", "Kock", "Koczulla", "Koderisch", "Koehl", "Koehler", "Koenig", "Koester", "Kofferschlager", "Koha", "Kohle", "Kohlmann", "Kohnle", "Kohrt", "Koj", "Kolb", "Koleiski", "Kolokas", "Komoll", "Konieczny", "Konig", "Konow", "Konya", "Koob", "Kopf", "Kosenkow", "Koster", "Koszewski", "Koubaa", "Kovacs", "Kowalick", "Kowalinski", "Kozakiewicz", "Krabbe", "Kraft", "Kral", "Kramer", "Krauel", "Kraus", "Krause", "Krauspe", "Kreb", "Krebs", "Kreissig", "Kresse", "Kreutz", "Krieger", "Krippner", "Krodinger", "Krohn", "Krol", "Kron", "Krueger", "Krug", "Kruger", "Krull", "Kruschinski", "Krämer", "Kröckert", "Kröger", "Krüger", "Kubera", "Kufahl", "Kuhlee", "Kuhnen", "Kulimann", "Kulma", "Kumbernuss", "Kummle", "Kunz", "Kupfer", "Kupprion", "Kuprion", "Kurnicki", "Kurrat", "Kurschilgen", "Kuschewitz", "Kuschmann", "Kuske", "Kustermann", "Kutscherauer", "Kutzner", "Kwadwo", "Kähler", "Käther", "Köhler", "Köhrbrück", "Köhre", "Kölotzei", "König", "Köpernick", "Köseoglu", "Kúhn", "Kúhnert", "Kühn", "Kühnel", "Kühnemund", "Kühnert", "Kühnke", "Küsters", "Küter", "Laack", "Lack", "Ladewig", "Lakomy", "Lammert", "Lamos", "Landmann", "Lang", "Lange", "Langfeld", "Langhirt", "Lanig", "Lauckner", "Lauinger", "Laurén", "Lausecker", "Laux", "Laws", "Lax", "Leberer", "Lehmann", "Lehner", "Leibold", "Leide", "Leimbach", "Leipold", "Leist", "Leiter", "Leiteritz", "Leitheim", "Leiwesmeier", "Lenfers", "Lenk", "Lenz", "Lenzen", "Leo", "Lepthin", "Lesch", "Leschnik", "Letzelter", "Lewin", "Lewke", "Leyckes", "Lg", "Lichtenfeld", "Lichtenhagen", "Lichtl", "Liebach", "Liebe", "Liebich", "Liebold", "Lieder", "Lienshöft", "Linden", "Lindenberg", "Lindenmayer", "Lindner", "Linke", "Linnenbaum", "Lippe", "Lipske", "Lipus", "Lischka", "Lobinger", "Logsch", "Lohmann", "Lohre", "Lohse", "Lokar", "Loogen", "Lorenz", "Losch", "Loska", "Lott", "Loy", "Lubina", "Ludolf", "Lufft", "Lukoschek", "Lutje", "Lutz", "Löser", "Löwa", "Lübke", "Maak", "Maczey", "Madetzky", "Madubuko", "Mai", "Maier", "Maisch", "Malek", "Malkus", "Mallmann", "Malucha", "Manns", "Manz", "Marahrens", "Marchewski", "Margis", "Markowski", "Marl", "Marner", "Marquart", "Marschek", "Martel", "Marten", "Martin", "Marx", "Marxen", "Mathes", "Mathies", "Mathiszik", "Matschke", "Mattern", "Matthes", "Matula", "Mau", "Maurer", "Mauroff", "May", "Maybach", "Mayer", "Mebold", "Mehl", "Mehlhorn", "Mehlorn", "Meier", "Meisch", "Meissner", "Meloni", "Melzer", "Menga", "Menne", "Mensah", "Mensing", "Merkel", "Merseburg", "Mertens", "Mesloh", "Metzger", "Metzner", "Mewes", "Meyer", "Michallek", "Michel", "Mielke", "Mikitenko", "Milde", "Minah", "Mintzlaff", "Mockenhaupt", "Moede", "Moedl", "Moeller", "Moguenara", "Mohr", "Mohrhard", "Molitor", "Moll", "Moller", "Molzan", "Montag", "Moormann", "Mordhorst", "Morgenstern", "Morhelfer", "Moritz", "Moser", "Motchebon", "Motzenbbäcker", "Mrugalla", "Muckenthaler", "Mues", "Muller", "Mulrain", "Mächtig", "Mäder", "Möcks", "Mögenburg", "Möhsner", "Möldner", "Möllenbeck", "Möller", "Möllinger", "Mörsch", "Mühleis", "Müller", "Münch", "Nabein", "Nabow", "Nagel", "Nannen", "Nastvogel", "Nau", "Naubert", "Naumann", "Ne", "Neimke", "Nerius", "Neubauer", "Neubert", "Neuendorf", "Neumair", "Neumann", "Neupert", "Neurohr", "Neuschwander", "Newton", "Ney", "Nicolay", "Niedermeier", "Nieklauson", "Niklaus", "Nitzsche", "Noack", "Nodler", "Nolte", "Normann", "Norris", "Northoff", "Nowak", "Nussbeck", "Nwachukwu", "Nytra", "Nöh", "Oberem", "Obergföll", "Obermaier", "Ochs", "Oeser", "Olbrich", "Onnen", "Ophey", "Oppong", "Orth", "Orthmann", "Oschkenat", "Osei", "Osenberg", "Ostendarp", "Ostwald", "Otte", "Otto", "Paesler", "Pajonk", "Pallentin", "Panzig", "Paschke", "Patzwahl", "Paukner", "Peselman", "Peter", "Peters", "Petzold", "Pfeiffer", "Pfennig", "Pfersich", "Pfingsten", "Pflieger", "Pflügner", "Philipp", "Pichlmaier", "Piesker", "Pietsch", "Pingpank", "Pinnock", "Pippig", "Pitschugin", "Plank", "Plass", "Platzer", "Plauk", "Plautz", "Pletsch", "Plotzitzka", "Poehn", "Poeschl", "Pogorzelski", "Pohl", "Pohland", "Pohle", "Polifka", "Polizzi", "Pollmächer", "Pomp", "Ponitzsch", "Porsche", "Porth", "Poschmann", "Poser", "Pottel", "Prah", "Prange", "Prediger", "Pressler", "Preuk", "Preuss", "Prey", "Priemer", "Proske", "Pusch", "Pöche", "Pöge", "Raabe", "Rabenstein", "Rach", "Radtke", "Rahn", "Ranftl", "Rangen", "Ranz", "Rapp", "Rath", "Rau", "Raubuch", "Raukuc", "Rautenkranz", "Rehwagen", "Reiber", "Reichardt", "Reichel", "Reichling", "Reif", "Reifenrath", "Reimann", "Reinberg", "Reinelt", "Reinhardt", "Reinke", "Reitze", "Renk", "Rentz", "Renz", "Reppin", "Restle", "Restorff", "Retzke", "Reuber", "Reumann", "Reus", "Reuss", "Reusse", "Rheder", "Rhoden", "Richards", "Richter", "Riedel", "Riediger", "Rieger", "Riekmann", "Riepl", "Riermeier", "Riester", "Riethmüller", "Rietmüller", "Rietscher", "Ringel", "Ringer", "Rink", "Ripken", "Ritosek", "Ritschel", "Ritter", "Rittweg", "Ritz", "Roba", "Rockmeier", "Rodehau", "Rodowski", "Roecker", "Roggatz", "Rohländer", "Rohrer", "Rokossa", "Roleder", "Roloff", "Roos", "Rosbach", "Roschinsky", "Rose", "Rosenauer", "Rosenbauer", "Rosenthal", "Rosksch", "Rossberg", "Rossler", "Roth", "Rother", "Ruch", "Ruckdeschel", "Rumpf", "Rupprecht", "Ruth", "Ryjikh", "Ryzih", "Rädler", "Räntsch", "Rödiger", "Röse", "Röttger", "Rücker", "Rüdiger", "Rüter", "Sachse", "Sack", "Saflanis", "Sagafe", "Sagonas", "Sahner", "Saile", "Sailer", "Salow", "Salzer", "Salzmann", "Sammert", "Sander", "Sarvari", "Sattelmaier", "Sauer", "Sauerland", "Saumweber", "Savoia", "Scc", "Schacht", "Schaefer", "Schaffarzik", "Schahbasian", "Scharf", "Schedler", "Scheer", "Schelk", "Schellenbeck", "Schembera", "Schenk", "Scherbarth", "Scherer", "Schersing", "Scherz", "Scheurer", "Scheuring", "Scheytt", "Schielke", "Schieskow", "Schildhauer", "Schilling", "Schima", "Schimmer", "Schindzielorz", "Schirmer", "Schirrmeister", "Schlachter", "Schlangen", "Schlawitz", "Schlechtweg", "Schley", "Schlicht", "Schlitzer", "Schmalzle", "Schmid", "Schmidt", "Schmidtchen", "Schmitt", "Schmitz", "Schmuhl", "Schneider", "Schnelting", "Schnieder", "Schniedermeier", "Schnürer", "Schoberg", "Scholz", "Schonberg", "Schondelmaier", "Schorr", "Schott", "Schottmann", "Schouren", "Schrader", "Schramm", "Schreck", "Schreiber", "Schreiner", "Schreiter", "Schroder", "Schröder", "Schuermann", "Schuff", "Schuhaj", "Schuldt", "Schult", "Schulte", "Schultz", "Schultze", "Schulz", "Schulze", "Schumacher", "Schumann", "Schupp", "Schuri", "Schuster", "Schwab", "Schwalm", "Schwanbeck", "Schwandke", "Schwanitz", "Schwarthoff", "Schwartz", "Schwarz", "Schwarzer", "Schwarzkopf", "Schwarzmeier", "Schwatlo", "Schweisfurth", "Schwennen", "Schwerdtner", "Schwidde", "Schwirkschlies", "Schwuchow", "Schäfer", "Schäffel", "Schäffer", "Schäning", "Schöckel", "Schönball", "Schönbeck", "Schönberg", "Schönebeck", "Schönenberger", "Schönfeld", "Schönherr", "Schönlebe", "Schötz", "Schüler", "Schüppel", "Schütz", "Schütze", "Seeger", "Seelig", "Sehls", "Seibold", "Seidel", "Seiders", "Seigel", "Seiler", "Seitz", "Semisch", "Senkel", "Sewald", "Siebel", "Siebert", "Siegling", "Sielemann", "Siemon", "Siener", "Sievers", "Siewert", "Sihler", "Sillah", "Simon", "Sinnhuber", "Sischka", "Skibicki", "Sladek", "Slotta", "Smieja", "Soboll", "Sokolowski", "Soller", "Sollner", "Sommer", "Somssich", "Sonn", "Sonnabend", "Spahn", "Spank", "Spelmeyer", "Spiegelburg", "Spielvogel", "Spinner", "Spitzmüller", "Splinter", "Sporrer", "Sprenger", "Spöttel", "Stahl", "Stang", "Stanger", "Stauss", "Steding", "Steffen", "Steffny", "Steidl", "Steigauf", "Stein", "Steinecke", "Steinert", "Steinkamp", "Steinmetz", "Stelkens", "Stengel", "Stengl", "Stenzel", "Stepanov", "Stephan", "Stern", "Steuk", "Stief", "Stifel", "Stoll", "Stolle", "Stolz", "Storl", "Storp", "Stoutjesdijk", "Stratmann", "Straub", "Strausa", "Streck", "Streese", "Strege", "Streit", "Streller", "Strieder", "Striezel", "Strogies", "Strohschank", "Strunz", "Strutz", "Stube", "Stöckert", "Stöppler", "Stöwer", "Stürmer", "Suffa", "Sujew", "Sussmann", "Suthe", "Sutschet", "Swillims", "Szendrei", "Sören", "Sürth", "Tafelmeier", "Tang", "Tasche", "Taufratshofer", "Tegethof", "Teichmann", "Tepper", "Terheiden", "Terlecki", "Teufel", "Theele", "Thieke", "Thimm", "Thiomas", "Thomas", "Thriene", "Thränhardt", "Thust", "Thyssen", "Thöne", "Tidow", "Tiedtke", "Tietze", "Tilgner", "Tillack", "Timmermann", "Tischler", "Tischmann", "Tittman", "Tivontschik", "Tonat", "Tonn", "Trampeli", "Trauth", "Trautmann", "Travan", "Treff", "Tremmel", "Tress", "Tsamonikian", "Tschiers", "Tschirch", "Tuch", "Tucholke", "Tudow", "Tuschmo", "Tächl", "Többen", "Töpfer", "Uhlemann", "Uhlig", "Uhrig", "Uibel", "Uliczka", "Ullmann", "Ullrich", "Umbach", "Umlauft", "Umminger", "Unger", "Unterpaintner", "Urban", "Urbaniak", "Urbansky", "Urhig", "Vahlensieck", "Van", "Vangermain", "Vater", "Venghaus", "Verniest", "Verzi", "Vey", "Viellehner", "Vieweg", "Voelkel", "Vogel", "Vogelgsang", "Vogt", "Voigt", "Vokuhl", "Volk", "Volker", "Volkmann", "Von", "Vona", "Vontein", "Wachenbrunner", "Wachtel", "Wagner", "Waibel", "Wakan", "Waldmann", "Wallner", "Wallstab", "Walter", "Walther", "Walton", "Walz", "Wanner", "Wartenberg", "Waschbüsch", "Wassilew", "Wassiluk", "Weber", "Wehrsen", "Weidlich", "Weidner", "Weigel", "Weight", "Weiler", "Weimer", "Weis", "Weiss", "Weller", "Welsch", "Welz", "Welzel", "Weniger", "Wenk", "Werle", "Werner", "Werrmann", "Wessel", "Wessinghage", "Weyel", "Wezel", "Wichmann", "Wickert", "Wiebe", "Wiechmann", "Wiegelmann", "Wierig", "Wiese", "Wieser", "Wilhelm", "Wilky", "Will", "Willwacher", "Wilts", "Wimmer", "Winkelmann", "Winkler", "Winter", "Wischek", "Wischer", "Wissing", "Wittich", "Wittl", "Wolf", "Wolfarth", "Wolff", "Wollenberg", "Wollmann", "Woytkowska", "Wujak", "Wurm", "Wyludda", "Wölpert", "Wöschler", "Wühn", "Wünsche", "Zach", "Zaczkiewicz", "Zahn", "Zaituc", "Zandt", "Zanner", "Zapletal", "Zauber", "Zeidler", "Zekl", "Zender", "Zeuch", "Zeyen", "Zeyhle", "Ziegler", "Zimanyi", "Zimmer", "Zimmermann", "Zinser", "Zintl", "Zipp", "Zipse", "Zschunke", "Zuber", "Zwiener", "Zümsande", "Östringer", "Überacker"]; /***/ }, -/* 165 */ +/* 156 */ /***/ function(module, exports) { - 'use strict'; + "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 ? "symbol" : typeof obj; }; + module.exports = ["zu", "von", "vom", "von der"]; - function MersenneTwister19937() { - var N, M, MATRIX_A, UPPER_MASK, LOWER_MASK; +/***/ }, +/* 157 */ +/***/ function(module, exports) { - N = 624; - M = 397; - MATRIX_A = 0x9908b0df; - UPPER_MASK = 0x80000000; - LOWER_MASK = 0x7fffffff; - var mt = new Array(N); - var mti = N + 1; + "use strict"; - function unsigned32(n1) { - return n1 < 0 ? (n1 ^ UPPER_MASK) + UPPER_MASK : n1; - } + module.exports = { + number: ["(0###) #########", "(0####) #######", "+49-###-#######", "+49-####-########"] + }; - function subtraction32(n1, n2) { - return n1 < n2 ? unsigned32(0x100000000 - (n2 - n1) & 0xffffffff) : n1 - n2; - } +/***/ }, +/* 158 */ +/***/ function(module, exports) { - function addition32(n1, n2) { - return unsigned32(n1 + n2 & 0xffffffff); - } + "use strict"; - function multiplication32(n1, n2) { - var sum = 0; - for (var i = 0; i < 32; ++i) { - if (n1 >>> i & 0x1) { - sum = addition32(sum, unsigned32(n2 << i)); - } - } - return sum; - } + module.exports = { + tld: ["com", "info", "name", "net", "org", "de", "ch"], - this.init_genrand = function (s) { - mt[0] = unsigned32(s & 0xffffffff); - for (mti = 1; mti < N; mti++) { - mt[mti] = addition32(multiplication32(1812433253, unsigned32(mt[mti - 1] ^ mt[mti - 1] >>> 30)), mti); + emailDomain: ["gmail.com", "yahoo.com", "hotmail.com"] - mt[mti] = unsigned32(mt[mti] & 0xffffffff); - } - }; + }; - this.init_by_array = function (init_key, key_length) { - var i, j, k, dbg; +/***/ }, +/* 159 */ +/***/ function(module, exports, __webpack_require__) { - this.init_genrand(19650218); - i = 1;j = 0; - k = N > key_length ? N : key_length; - for (; k; k--) { - mt[i] = addition32(addition32(unsigned32(mt[i] ^ multiplication32(unsigned32(mt[i - 1] ^ mt[i - 1] >>> 30), 1664525)), init_key[j]), j); - mt[i] = unsigned32(mt[i] & 0xffffffff); - i++;j++; - if (i >= N) { - mt[0] = mt[N - 1];i = 1; - } - if (j >= key_length) j = 0; - } - for (k = N - 1; k; k--) { - mt[i] = subtraction32(unsigned32((dbg = mt[i]) ^ multiplication32(unsigned32(mt[i - 1] ^ mt[i - 1] >>> 30), 1566083941)), i); + "use strict"; - mt[i] = unsigned32(mt[i] & 0xffffffff); - i++; - if (i >= N) { - mt[0] = mt[N - 1];i = 1; - } - } - mt[0] = 0x80000000; - }; + var _countryWithCodes = __webpack_require__(160); - var mag01 = [0x0, MATRIX_A]; + var _countryWithCodes2 = _interopRequireDefault(_countryWithCodes); - this.genrand_int32 = function () { - var y; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + module.exports = { + countryAndCode: function countryAndCode() { + var country = this.random.objectElement(_countryWithCodes2.default); + return { + code: Object.keys(country)[0], + name: country[Object.keys(country)[0]] + }; + }, + country: function country() { + return this.address.countryAndCode().name; + }, + countryCode: function countryCode() { + return this.address.countryAndCode().code; + }, - if (mti >= N) { - var kk; - if (mti == N + 1) this.init_genrand(5489); + state: __webpack_require__(161), - for (kk = 0; kk < N - M; kk++) { - y = unsigned32(mt[kk] & UPPER_MASK | mt[kk + 1] & LOWER_MASK); - mt[kk] = unsigned32(mt[kk + M] ^ y >>> 1 ^ mag01[y & 0x1]); - } - for (; kk < N - 1; kk++) { - y = unsigned32(mt[kk] & UPPER_MASK | mt[kk + 1] & LOWER_MASK); - mt[kk] = unsigned32(mt[kk + (M - N)] ^ y >>> 1 ^ mag01[y & 0x1]); - } + stateAbbr: __webpack_require__(162), - y = unsigned32(mt[N - 1] & UPPER_MASK | mt[0] & LOWER_MASK); - mt[N - 1] = unsigned32(mt[M - 1] ^ y >>> 1 ^ mag01[y & 0x1]); - mti = 0; - } + city: ["#{address.cityPrefix} #{names.firstName}#{address.citySuffix}", "#{address.cityPrefix} #{names.firstName}", "#{names.firstName}#{address.citySuffix}", "#{names.lastName}#{address.citySuffix}"], - y = mt[mti++]; + cityPrefix: ["North", "East", "West", "South", "New", "Lake", "Port"], - y = unsigned32(y ^ y >>> 11); - y = unsigned32(y ^ y << 7 & 0x9d2c5680); - y = unsigned32(y ^ y << 15 & 0xefc60000); - y = unsigned32(y ^ y >>> 18); + citySuffix: ["town", "ton", "land", "ville", "berg", "burgh", "borough", "bury", "view", "port", "mouth", "stad", "furt", "chester", "mouth", "fort", "haven", "side", "shire"], - return y; - }; - - this.genrand_int31 = function () { - return this.genrand_int32() >>> 1; - }; - - this.genrand_real1 = function () { - return this.genrand_int32() * (1.0 / 4294967295.0); - }; - - this.genrand_real2 = function () { - return this.genrand_int32() * (1.0 / 4294967296.0); - }; - - this.genrand_real3 = function () { - return (this.genrand_int32() + 0.5) * (1.0 / 4294967296.0); - }; - - this.genrand_res53 = function () { - var a = this.genrand_int32() >>> 5, - b = this.genrand_int32() >>> 6; - return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0); - }; - } - - module.exports.MersenneTwister19937 = MersenneTwister19937; - - var gen = new MersenneTwister19937(); - gen.init_genrand(new Date().getTime() % 1000000000); - - module.exports.rand = function (max, min) { - if (max === undefined) { - min = 0; - max = 32768; - } - return Math.floor(gen.genrand_real2() * (max - min) + min); - }; - module.exports.seed = function (S) { - if (typeof S != 'number') throw new Error("seed(S) must take numeric argument; is " + (typeof S === 'undefined' ? 'undefined' : _typeof(S))); - - gen.init_genrand(S); - }; - module.exports.seed_array = function (A) { - if ((typeof A === 'undefined' ? 'undefined' : _typeof(A)) != 'object') throw new Error("seed_array(A) must take array of numbers; is " + (typeof A === 'undefined' ? 'undefined' : _typeof(A))); - - gen.init_by_array(A); - }; - -/***/ }, -/* 166 */ -/***/ function(module, exports, __webpack_require__) { - - var map = { - "./cs-CZ/address/index": 167, - "./cs-CZ/company/index": 171, - "./cs-CZ/index": 172, - "./cs-CZ/internet/index": 179, - "./cs-CZ/names/index": 173, - "./cs-CZ/phone/index": 178, - "./de-DE/address/index": 180, - "./de-DE/company/index": 183, - "./de-DE/index": 184, - "./de-DE/internet/index": 190, - "./de-DE/names/index": 185, - "./de-DE/phone/index": 189, - "./default/address/index": 191, - "./default/company/index": 197, - "./default/date/index": 198, - "./default/entity/index": 200, - "./default/index": 201, - "./default/internet/index": 207, - "./default/lorem/index": 234, - "./default/misc/index": 237, - "./default/names/index": 202, - "./default/phone/index": 206, - "./en-AU/address/index": 240, - "./en-AU/company/index": 242, - "./en-AU/index": 243, - "./en-AU/internet/index": 248, - "./en-AU/names/index": 244, - "./en-AU/phone/index": 247, - "./en-CA/address/index": 249, - "./en-CA/index": 250, - "./en-CA/internet/index": 251, - "./en-CA/phone/index": 252, - "./es-ES/address/index": 253, - "./es-ES/company/index": 257, - "./es-ES/index": 258, - "./es-ES/internet/index": 263, - "./es-ES/names/index": 259, - "./es-ES/phone/index": 262, - "./fr-FR/address/index": 264, - "./fr-FR/company/index": 269, - "./fr-FR/index": 270, - "./fr-FR/internet/index": 275, - "./fr-FR/names/index": 271, - "./fr-FR/phone/index": 274, - "./hu-HU/address/index": 276, - "./hu-HU/company/index": 278, - "./hu-HU/index": 279, - "./hu-HU/internet/index": 285, - "./hu-HU/names/index": 280, - "./hu-HU/phone/index": 284, - "./it-IT/address/index": 286, - "./it-IT/company/index": 291, - "./it-IT/index": 292, - "./it-IT/internet/index": 297, - "./it-IT/names/index": 293, - "./it-IT/phone/index": 296, - "./nb-NO/address/index": 298, - "./nb-NO/company/index": 302, - "./nb-NO/index": 303, - "./nb-NO/internet/index": 309, - "./nb-NO/names/index": 304, - "./nb-NO/phone/index": 308, - "./pl-PL/address/index": 310, - "./pl-PL/company/index": 313, - "./pl-PL/index": 314, - "./pl-PL/internet/index": 319, - "./pl-PL/names/index": 315, - "./pl-PL/phone/index": 318, - "./ru-RU/address/index": 320, - "./ru-RU/company/index": 324, - "./ru-RU/index": 325, - "./ru-RU/internet/index": 334, - "./ru-RU/names/index": 326, - "./ru-RU/phone/index": 333, - "./sk-SK/address/index": 335, - "./sk-SK/company/index": 339, - "./sk-SK/index": 340, - "./sk-SK/internet/index": 347, - "./sk-SK/names/index": 341, - "./sk-SK/phone/index": 346, - "./sv-SE/address/index": 348, - "./sv-SE/company/index": 350, - "./sv-SE/index": 351, - "./sv-SE/internet/index": 357, - "./sv-SE/names/index": 352, - "./sv-SE/phone/index": 356 - }; - function webpackContext(req) { - return __webpack_require__(webpackContextResolve(req)); - }; - function webpackContextResolve(req) { - return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }()); - }; - webpackContext.keys = function webpackContextKeys() { - return Object.keys(map); - }; - webpackContext.resolve = webpackContextResolve; - module.exports = webpackContext; - webpackContext.id = 166; - - -/***/ }, -/* 167 */ -/***/ function(module, exports, __webpack_require__) { + street: ["#{address.buildingNumber} #{address.streetName}", "#{address.buildingNumber} #{address.streetName}", "#{address.buildingNumber} #{address.streetName} Apt. ###", "#{address.buildingNumber} #{address.streetName} Suite ###"], - "use strict"; + streetName: ["#{names.firstName} #{address.streetSuffix}", "#{names.lastName} #{address.streetSuffix}"], - var _countryWithCodes = __webpack_require__(168); + streetSuffix: __webpack_require__(163), - var _countryWithCodes2 = _interopRequireDefault(_countryWithCodes); + buildingNumber: ["#####", "####", "###"], - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + postCode: ["#####", "#####-####"], - module.exports = { - countryAndCode: function countryAndCode() { - var country = this.random.objectElement(_countryWithCodes2.default); + geoLocation: function geoLocation() { return { - code: Object.keys(country)[0], - name: country[Object.keys(country)[0]] + latitude: this.random.number(180 * 10000) / 10000.0 - 90.0, + longitude: this.random.number(360 * 10000) / 10000.0 - 180.0 }; }, + altitude: function altitude() { + var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + return this.random.number(opts.min || 0, opts.max || 8848); + }, - state: [], - - stateAbbr: [], - - city: __webpack_require__(169), - - street: ["#{address.streetName} #{address.buildingNumber}"], - - streetName: __webpack_require__(170), - - buildingNumber: ["#", "##", "###"], - - postCode: ["#####", "### ##", "###-##"] + geoLocationNearBy: __webpack_require__(164) }; /***/ }, -/* 168 */ +/* 160 */ /***/ function(module, exports) { "use strict"; module.exports = { - "AF": "Afghánistán", - "AX": "Ålandy", - "AL": "Albánie", - "DZ": "Alžírsko", - "AS": "Americká Samoa", - "VI": "Americké Panenské ostrovy", + "AF": "Afghanistan", + "AX": "\xC5land Islands", + "AL": "Albania", + "DZ": "Algeria", + "AS": "American Samoa", "AD": "Andorra", "AO": "Angola", "AI": "Anguilla", - "AQ": "Antarktida", - "AG": "Antigua a Barbuda", + "AQ": "Antarctica", + "AG": "Antigua & Barbuda", "AR": "Argentina", - "AM": "Arménie", + "AM": "Armenia", "AW": "Aruba", - "AC": "Ascension", - "AU": "Austrálie", - "AZ": "Ázerbájdžán", - "BS": "Bahamy", - "BH": "Bahrajn", - "BD": "Bangladéš", + "AC": "Ascension Island", + "AU": "Australia", + "AT": "Austria", + "AZ": "Azerbaijan", + "BS": "Bahamas", + "BH": "Bahrain", + "BD": "Bangladesh", "BB": "Barbados", - "BE": "Belgie", + "BY": "Belarus", + "BE": "Belgium", "BZ": "Belize", - "BY": "Bělorusko", "BJ": "Benin", - "BM": "Bermudy", - "BT": "Bhútán", - "BO": "Bolívie", - "BA": "Bosna a Hercegovina", + "BM": "Bermuda", + "BT": "Bhutan", + "BO": "Bolivia", + "BA": "Bosnia & Herzegovina", "BW": "Botswana", - "BR": "Brazílie", - "IO": "Britské indickooceánské území", - "VG": "Britské Panenské ostrovy", - "BN": "Brunej", - "BG": "Bulharsko", + "BR": "Brazil", + "IO": "British Indian Ocean Territory", + "VG": "British Virgin Islands", + "BN": "Brunei", + "BG": "Bulgaria", "BF": "Burkina Faso", "BI": "Burundi", - "EA": "Ceuta a Melilla", - "CK": "Cookovy ostrovy", - "CW": "Curaçao", - "TD": "Čad", - "ME": "Černá Hora", - "CZ": "Česká republika", - "CN": "Čína", - "DK": "Dánsko", - "DG": "Diego García", - "DM": "Dominika", - "DO": "Dominikánská republika", - "DJ": "Džibutsko", + "KH": "Cambodia", + "CM": "Cameroon", + "CA": "Canada", + "IC": "Canary Islands", + "CV": "Cape Verde", + "BQ": "Caribbean Netherlands", + "KY": "Cayman Islands", + "CF": "Central African Republic", + "EA": "Ceuta & Melilla", + "TD": "Chad", + "CL": "Chile", + "CN": "China", + "CX": "Christmas Island", + "CC": "Cocos (Keeling) Islands", + "CO": "Colombia", + "KM": "Comoros", + "CG": "Congo - Brazzaville", + "CD": "Congo - Kinshasa", + "CK": "Cook Islands", + "CR": "Costa Rica", + "CI": "C\xF4te d\u2019Ivoire", + "HR": "Croatia", + "CU": "Cuba", + "CW": "Cura\xE7ao", + "CY": "Cyprus", + "CZ": "Czech Republic", + "DK": "Denmark", + "DG": "Diego Garcia", + "DJ": "Djibouti", + "DM": "Dominica", + "DO": "Dominican Republic", + "EC": "Ecuador", "EG": "Egypt", - "EC": "Ekvádor", + "SV": "El Salvador", + "GQ": "Equatorial Guinea", "ER": "Eritrea", - "EE": "Estonsko", - "ET": "Etiopie", - "FO": "Faerské ostrovy", - "FK": "Falklandské ostrovy", - "FJ": "Fidži", - "PH": "Filipíny", - "FI": "Finsko", - "FR": "Francie", - "GF": "Francouzská Guyana", - "TF": "Francouzská jižní území", - "PF": "Francouzská Polynésie", + "EE": "Estonia", + "ET": "Ethiopia", + "FK": "Falkland Islands", + "FO": "Faroe Islands", + "FJ": "Fiji", + "FI": "Finland", + "FR": "France", + "GF": "French Guiana", + "PF": "French Polynesia", + "TF": "French Southern Territories", "GA": "Gabon", - "GM": "Gambie", + "GM": "Gambia", + "GE": "Georgia", + "DE": "Germany", "GH": "Ghana", "GI": "Gibraltar", + "GR": "Greece", + "GL": "Greenland", "GD": "Grenada", - "GL": "Grónsko", - "GE": "Gruzie", "GP": "Guadeloupe", "GU": "Guam", "GT": "Guatemala", @@ -6355,4177 +5806,7328 @@ return /******/ (function(modules) { // webpackBootstrap "GY": "Guyana", "HT": "Haiti", "HN": "Honduras", - "HK": "Hongkong – ZAO Číny", - "CL": "Chile", - "HR": "Chorvatsko", - "IN": "Indie", - "ID": "Indonésie", - "IQ": "Irák", - "IR": "Írán", - "IE": "Irsko", - "IS": "Island", - "IT": "Itálie", - "IL": "Izrael", - "JM": "Jamajka", - "JP": "Japonsko", - "YE": "Jemen", + "HK": "Hong Kong SAR China", + "HU": "Hungary", + "IS": "Iceland", + "IN": "India", + "ID": "Indonesia", + "IR": "Iran", + "IQ": "Iraq", + "IE": "Ireland", + "IM": "Isle of Man", + "IL": "Israel", + "IT": "Italy", + "JM": "Jamaica", + "JP": "Japan", "JE": "Jersey", - "ZA": "Jihoafrická republika", - "GS": "Jižní Georgie a Jižní Sandwichovy ostrovy", - "KR": "Jižní Korea", - "SS": "Jižní Súdán", - "JO": "Jordánsko", - "KY": "Kajmanské ostrovy", - "KH": "Kambodža", - "CM": "Kamerun", - "CA": "Kanada", - "IC": "Kanárské ostrovy", - "CV": "Kapverdy", - "BQ": "Karibské Nizozemsko", - "QA": "Katar", - "KZ": "Kazachstán", - "KE": "Keňa", + "JO": "Jordan", + "KZ": "Kazakhstan", + "KE": "Kenya", "KI": "Kiribati", - "CC": "Kokosové ostrovy", - "CO": "Kolumbie", - "KM": "Komory", - "CG": "Kongo – Brazzaville", - "CD": "Kongo – Kinshasa", "XK": "Kosovo", - "CR": "Kostarika", - "CU": "Kuba", - "KW": "Kuvajt", - "CY": "Kypr", - "KG": "Kyrgyzstán", + "KW": "Kuwait", + "KG": "Kyrgyzstan", "LA": "Laos", + "LV": "Latvia", + "LB": "Lebanon", "LS": "Lesotho", - "LB": "Libanon", - "LR": "Libérie", - "LY": "Libye", - "LI": "Lichtenštejnsko", - "LT": "Litva", - "LV": "Lotyšsko", - "LU": "Lucembursko", - "MO": "Macao – ZAO Číny", - "MG": "Madagaskar", - "HU": "Maďarsko", - "MK": "Makedonie", - "MY": "Malajsie", + "LR": "Liberia", + "LY": "Libya", + "LI": "Liechtenstein", + "LT": "Lithuania", + "LU": "Luxembourg", + "MO": "Macau SAR China", + "MK": "Macedonia", + "MG": "Madagascar", "MW": "Malawi", - "MV": "Maledivy", + "MY": "Malaysia", + "MV": "Maldives", "ML": "Mali", "MT": "Malta", - "MA": "Maroko", - "MH": "Marshallovy ostrovy", - "MQ": "Martinik", - "MU": "Mauricius", - "MR": "Mauritánie", - "YT": "Mayotte", - "UM": "Menší odlehlé ostrovy USA", - "MX": "Mexiko", - "FM": "Mikronésie", - "MD": "Moldavsko", - "MC": "Monako", - "MN": "Mongolsko", + "MH": "Marshall Islands", + "MQ": "Martinique", + "MR": "Mauritania", + "MU": "Mauritius", + "YT": "Mayotte", + "MX": "Mexico", + "FM": "Micronesia", + "MD": "Moldova", + "MC": "Monaco", + "MN": "Mongolia", + "ME": "Montenegro", "MS": "Montserrat", - "MZ": "Mosambik", - "MM": "Myanmar (Barma)", - "NA": "Namibie", + "MA": "Morocco", + "MZ": "Mozambique", + "MM": "Myanmar (Burma)", + "NA": "Namibia", "NR": "Nauru", - "DE": "Německo", - "NP": "Nepál", + "NP": "Nepal", + "NL": "Netherlands", + "NC": "New Caledonia", + "NZ": "New Zealand", + "NI": "Nicaragua", "NE": "Niger", - "NG": "Nigérie", - "NI": "Nikaragua", + "NG": "Nigeria", "NU": "Niue", - "NL": "Nizozemsko", - "NF": "Norfolk", - "NO": "Norsko", - "NC": "Nová Kaledonie", - "NZ": "Nový Zéland", - "OM": "Omán", - "IM": "Ostrov Man", - "PK": "Pákistán", + "NF": "Norfolk Island", + "KP": "North Korea", + "MP": "Northern Mariana Islands", + "NO": "Norway", + "OM": "Oman", + "PK": "Pakistan", "PW": "Palau", - "PS": "Palestinská území", + "PS": "Palestinian Territories", "PA": "Panama", - "PG": "Papua-Nová Guinea", + "PG": "Papua New Guinea", "PY": "Paraguay", "PE": "Peru", - "PN": "Pitcairnovy ostrovy", - "CI": "Pobřeží slonoviny", - "PL": "Polsko", - "PR": "Portoriko", - "PT": "Portugalsko", - "AT": "Rakousko", - "RE": "Réunion", - "GQ": "Rovníková Guinea", - "RO": "Rumunsko", - "RU": "Rusko", + "PH": "Philippines", + "PN": "Pitcairn Islands", + "PL": "Poland", + "PT": "Portugal", + "PR": "Puerto Rico", + "QA": "Qatar", + "RE": "R\xE9union", + "RO": "Romania", + "RU": "Russia", "RW": "Rwanda", - "GR": "Řecko", - "PM": "Saint-Pierre a Miquelon", - "SV": "Salvador", "WS": "Samoa", "SM": "San Marino", - "SA": "Saúdská Arábie", + "ST": "S\xE3o Tom\xE9 & Pr\xEDncipe", + "SA": "Saudi Arabia", "SN": "Senegal", - "KP": "Severní Korea", - "MP": "Severní Mariany", - "SC": "Seychely", + "RS": "Serbia", + "SC": "Seychelles", "SL": "Sierra Leone", - "SG": "Singapur", - "SK": "Slovensko", - "SI": "Slovinsko", - "SO": "Somálsko", - "AE": "Spojené arabské emiráty", - "US": "Spojené státy", - "RS": "Srbsko", - "LK": "Srí Lanka", - "CF": "Středoafrická republika", - "SD": "Súdán", - "SR": "Surinam", - "SH": "Svatá Helena", - "LC": "Svatá Lucie", - "BL": "Svatý Bartoloměj", - "KN": "Svatý Kryštof a Nevis", - "MF": "Svatý Martin (Francie)", - "SX": "Svatý Martin (Nizozemsko)", - "ST": "Svatý Tomáš a Princův ostrov", - "VC": "Svatý Vincenc a Grenadiny", - "SZ": "Svazijsko", - "SY": "Sýrie", - "SB": "Šalamounovy ostrovy", - "ES": "Španělsko", - "SJ": "Špicberky a Jan Mayen", - "SE": "Švédsko", - "CH": "Švýcarsko", - "TJ": "Tádžikistán", - "TZ": "Tanzanie", - "TH": "Thajsko", - "TW": "Tchaj-wan", + "SG": "Singapore", + "SX": "Sint Maarten", + "SK": "Slovakia", + "SI": "Slovenia", + "SB": "Solomon Islands", + "SO": "Somalia", + "ZA": "South Africa", + "GS": "South Georgia & South Sandwich Islands", + "KR": "South Korea", + "SS": "South Sudan", + "ES": "Spain", + "LK": "Sri Lanka", + "BL": "St. Barth\xE9lemy", + "SH": "St. Helena", + "KN": "St. Kitts & Nevis", + "LC": "St. Lucia", + "MF": "St. Martin", + "PM": "St. Pierre & Miquelon", + "VC": "St. Vincent & Grenadines", + "SD": "Sudan", + "SR": "Suriname", + "SJ": "Svalbard & Jan Mayen", + "SZ": "Swaziland", + "SE": "Sweden", + "CH": "Switzerland", + "SY": "Syria", + "TW": "Taiwan", + "TJ": "Tajikistan", + "TZ": "Tanzania", + "TH": "Thailand", + "TL": "Timor-Leste", "TG": "Togo", "TK": "Tokelau", "TO": "Tonga", - "TT": "Trinidad a Tobago", + "TT": "Trinidad & Tobago", "TA": "Tristan da Cunha", - "TN": "Tunisko", - "TR": "Turecko", - "TM": "Turkmenistán", - "TC": "Turks a Caicos", + "TN": "Tunisia", + "TR": "Turkey", + "TM": "Turkmenistan", + "TC": "Turks & Caicos Islands", "TV": "Tuvalu", + "UM": "U.S. Outlying Islands", + "VI": "U.S. Virgin Islands", "UG": "Uganda", - "UA": "Ukrajina", + "UA": "Ukraine", + "AE": "United Arab Emirates", + "GB": "United Kingdom", + "US": "United States", "UY": "Uruguay", - "UZ": "Uzbekistán", - "CX": "Vánoční ostrov", + "UZ": "Uzbekistan", "VU": "Vanuatu", - "VA": "Vatikán", - "GB": "Velká Británie", + "VA": "Vatican City", "VE": "Venezuela", "VN": "Vietnam", - "TL": "Východní Timor", - "WF": "Wallis a Futuna", - "ZM": "Zambie", - "EH": "Západní Sahara", + "WF": "Wallis & Futuna", + "EH": "Western Sahara", + "YE": "Yemen", + "ZM": "Zambia", "ZW": "Zimbabwe" }; /***/ }, -/* 169 */ -/***/ function(module, exports) { - - "use strict"; - - module.exports = ["Abertamy", "Adamov", "Andělská Hora", "Aš", "Bakov nad Jizerou", "Bavorov", "Bechyně", "Bečov nad Teplou", "Bělá nad Radbuzou", "Bělá pod Bezdězem", "Benátky nad Jizerou", "Benešov", "Benešov nad Ploučnicí", "Beroun", "Bezdružice", "Bílina", "Bílovec", "Blansko", "Blatná", "Blovice", "Blšany", "Bochov", "Bohumín", "Bohušovice nad Ohří", "Bojkovice", "Bor", "Borohrádek", "Borovany", "Boskovice", "Boží Dar", "Brandýs nad Labem-Stará Boleslav", "Brandýs nad Orlicí", "Brno", "Broumov", "Brtnice", "Brumov-Bylnice", "Bruntál", "Brušperk", "Břeclav", "Březnice", "Březová", "Březová nad Svitavou", "Břidličná", "Bučovice", "Budišov nad Budišovkou", "Budyně nad Ohří", "Buštěhrad", "Bystré", "Bystřice", "Bystřice nad Pernštejnem", "Bystřice pod Hostýnem", "Bzenec", "Chabařovice", "Cheb", "Chlumec", "Chlumec nad Cidlinou", "Choceň", "Chodov", "Chomutov", "Chotěboř", "Chrast", "Chrastava", "Chropyně", "Chrudim", "Chřibská", "Chvaletice", "Chýnov", "Chyše", "Cvikov", "Čáslav", "Čelákovice", "Černošice", "Černošín", "Černovice", "Červená Řečice", "Červený Kostelec", "Česká Kamenice", "Česká Lípa", "Česká Skalice", "Česká Třebová", "České Budějovice", "České Velenice", "Český Brod", "Český Dub", "Český Krumlov", "Český Těšín", "Dačice", "Dašice", "Děčín", "Desná", "Deštná", "Dobrovice", "Dobruška", "Dobřany", "Dobřichovice", "Dobříš", "Doksy", "Dolní Benešov", "Dolní Bousov", "Dolní Kounice", "Dolní Poustevna", "Domažlice", "Dubá", "Dubí", "Dubňany", "Duchcov", "Dvůr Králové nad Labem", "Františkovy Lázně", "Frenštát pod Radhoštěm", "Frýdek-Místek", "Frýdlant", "Frýdlant nad Ostravicí", "Fryšták", "Fulnek", "Golčův Jeníkov", "Habartov", "Habry", "Hanušovice", "Harrachov", "Hartmanice", "Havířov", "Havlíčkův Brod", "Hejnice", "Heřmanův Městec", "Hlinsko", "Hluboká nad Vltavou", "Hlučín", "Hluk", "Hodkovice nad Mohelkou", "Hodonín", "Holešov", "Holice", "Holýšov", "Hora Svaté Kateřiny", "Horažďovice", "Horní Benešov", "Horní Blatná", "Horní Bříza", "Horní Cerekev", "Horní Jelení", "Horní Jiřetín", "Horní Planá", "Horní Slavkov", "Horšovský Týn", "Hořice", "Hořovice", "Hostinné", "Hostivice", "Hostomice", "Hostouň", "Hoštka", "Hradec Králové", "Hradec nad Moravicí", "Hrádek", "Hrádek nad Nisou", "Hranice (okres Cheb)", "Hranice (okres Přerov)", "Hrob", "Hrochův Týnec", "Hronov", "Hrotovice", "Hroznětín", "Hrušovany nad Jevišovkou", "Hulín", "Humpolec", "Husinec", "Hustopeče", "Ivančice", "Ivanovice na Hané", "Jablonec nad Jizerou", "Jablonec nad Nisou", "Jablonné nad Orlicí", "Jablonné v Podještědí", "Jablunkov", "Jáchymov", "Janov", "Janovice nad Úhlavou", "Janské Lázně", "Jaroměř", "Jaroměřice nad Rokytnou", "Javorník", "Jemnice", "Jesenice (okres Rakovník)", "Jeseník", "Jevíčko", "Jevišovice", "Jičín", "Jihlava", "Jilemnice", "Jílové", "Jílové u Prahy", "Jindřichův Hradec", "Jirkov", "Jiříkov", "Jistebnice", "Kadaň", "Kamenice nad Lipou", "Kamenický Šenov", "Kaplice", "Kardašova Řečice", "Karlovy Vary", "Karolinka", "Karviná", "Kasejovice", "Kašperské Hory", "Kaznějov", "Kdyně", "Kelč", "Kladno", "Kladruby", "Klášterec nad Ohří", "Klatovy", "Klecany", "Klimkovice", "Klobouky u Brna", "Kojetín", "Kolín", "Konice", "Kopidlno", "Kopřivnice", "Koryčany", "Kosmonosy", "Kostelec na Hané", "Kostelec nad Černými lesy", "Kostelec nad Labem", "Kostelec nad Orlicí", "Košťany", "Kouřim", "Kožlany", "Králíky", "Kralovice", "Kralupy nad Vltavou", "Králův Dvůr", "Kraslice", "Krásná Hora nad Vltavou", "Krásná Lípa", "Krásné Údolí", "Krásno", "Kravaře", "Krnov", "Kroměříž", "Krupka", "Kryry", "Kunovice", "Kunštát", "Kuřim", "Kutná Hora", "Kyjov", "Kynšperk nad Ohří", "Lanškroun", "Lanžhot", "Lázně Bělohrad", "Lázně Bohdaneč", "Lázně Kynžvart", "Ledeč nad Sázavou", "Ledvice", "Letohrad", "Letovice", "Libáň", "Libčice nad Vltavou", "Liběchov", "Liberec", "Libochovice", "Libušín", "Lipník nad Bečvou", "Lišov", "Litoměřice", "Litomyšl", "Litovel", "Litvínov", "Loket", "Lom", "Lomnice nad Lužnicí", "Lomnice nad Popelkou", "Loštice", "Loučná pod Klínovcem", "Louny", "Lovosice", "Luby", "Lučany nad Nisou", "Luhačovice", "Luže", "Lysá nad Labem", "Manětín", "Mariánské Lázně", "Mašťov", "Měčín", "Mělník", "Městec Králové", "Město Albrechtice", "Město Touškov", "Meziboří", "Meziměstí", "Mikulášovice", "Mikulov", "Miletín", "Milevsko", "Milovice", "Mimoň", "Miroslav", "Mirošov", "Mirotice", "Mirovice", "Mladá Boleslav", "Mladá Vožice", "Mnichovice", "Mnichovo Hradiště", "Mníšek pod Brdy", "Modřice", "Mohelnice", "Moravská Třebová", "Moravské Budějovice", "Moravský Beroun", "Moravský Krumlov", "Morkovice-Slížany", "Most", "Mšeno", "Mýto", "Náchod", "Nalžovské Hory", "Náměšť nad Oslavou", "Napajedla", "Nasavrky", "Nechanice", "Nejdek", "Němčice nad Hanou", "Nepomuk", "Neratovice", "Netolice", "Neveklov", "Nová Bystřice", "Nová Paka", "Nová Role", "Nová Včelnice", "Nové Hrady", "Nové Město na Moravě", "Nové Město nad Metují", "Nové Město pod Smrkem", "Nové Sedlo", "Nové Strašecí", "Nový Bor", "Nový Bydžov", "Nový Jičín", "Nový Knín", "Nymburk", "Nýrsko", "Nýřany", "Odolena Voda", "Odry", "Olešnice", "Olomouc", "Oloví", "Opava", "Opočno", "Orlová", "Osečná", "Osek", "Oslavany", "Ostrava", "Ostrov", "Otrokovice", "Pacov", "Pardubice", "Paskov", "Pec pod Sněžkou", "Pečky", "Pelhřimov", "Petřvald", "Pilníkov", "Písek", "Planá", "Planá nad Lužnicí", "Plánice", "Plasy", "Plesná", "Plumlov", "Plzeň", "Poběžovice", "Počátky", "Podbořany", "Poděbrady", "Podivín", "Pohořelice", "Police nad Metují", "Polička", "Polná", "Postoloprty", "Potštát", "Prachatice", "Praha", "Proseč", "Prostějov", "Protivín", "Přebuz", "Přelouč", "Přerov", "Přeštice", "Příbor", "Příbram", "Přibyslav", "Přimda", "Pyšely", "Rabí", "Radnice", "Rájec-Jestřebí", "Rajhrad", "Rakovník", "Ralsko", "Raspenava", "Rejštejn", "Rokycany", "Rokytnice nad Jizerou", "Rokytnice v Orlických horách", "Ronov nad Doubravou", "Rosice", "Rotava", "Roudnice nad Labem", "Rousínov", "Rovensko pod Troskami", "Roztoky", "Rožďalovice", "Rožmberk nad Vltavou", "Rožmitál pod Třemšínem", "Rožnov pod Radhoštěm", "Rtyně v Podkrkonoší", "Rudná", "Rudolfov", "Rumburk", "Rychnov nad Kněžnou", "Rychnov u Jablonce nad Nisou", "Rychvald", "Rýmařov", "Řevnice", "Říčany", "Sadská", "Sázava", "Seč", "Sedlčany", "Sedlec-Prčice", "Sedlice", "Semily", "Sezemice", "Sezimovo Ústí", "Skalná", "Skuteč", "Slaný", "Slatiňany", "Slavičín", "Slavkov u Brna", "Slavonice", "Slušovice", "Smečno", "Smiřice", "Smržovka", "Soběslav", "Sobotka", "Sokolov", "Solnice", "Spálené Poříčí", "Staňkov", "Staré Město (okres Šumperk)", "Staré Město (okres Uherské Hradiště)", "Stárkov", "Starý Plzenec", "Stochov", "Stod", "Strakonice", "Stráž nad Nežárkou", "Stráž pod Ralskem", "Strážnice", "Strážov", "Strmilov", "Stříbro", "Studénka", "Suchdol nad Lužnicí", "Sušice", "Světlá nad Sázavou", "Svitavy", "Svoboda nad Úpou", "Svratka", "Šenov", "Šlapanice", "Šluknov", "Špindlerův Mlýn", "Šternberk", "Štětí", "Štíty", "Štramberk", "Šumperk", "Švihov", "Tábor", "Tachov", "Tanvald", "Telč", "Teplá", "Teplice", "Teplice nad Metují", "Terezín", "Tišnov", "Toužim", "Tovačov", "Trhové Sviny", "Trhový Štěpánov", "Trmice", "Trutnov", "Třebechovice pod Orebem", "Třebenice", "Třebíč", "Třeboň", "Třemošná", "Třemošnice", "Třešť", "Třinec", "Turnov", "Týn nad Vltavou", "Týnec nad Labem", "Týnec nad Sázavou", "Týniště nad Orlicí", "Uherské Hradiště", "Uherský Brod", "Uherský Ostroh", "Uhlířské Janovice", "Újezd u Brna", "Unhošť", "Uničov", "Úpice", "Úsov", "Ústí nad Labem", "Ústí nad Orlicí", "Úštěk", "Úterý", "Úvaly", "Valašské Klobouky", "Valašské Meziříčí", "Valtice", "Vamberk", "Varnsdorf", "Vejprty", "Velešín", "Velká Bíteš", "Velká Bystřice", "Velké Bílovice", "Velké Hamry", "Velké Meziříčí", "Velké Opatovice", "Velké Pavlovice", "Velký Šenov", "Veltrusy", "Velvary", "Verneřice", "Veselí nad Lužnicí", "Veselí nad Moravou", "Vidnava", "Vimperk", "Vítkov", "Vizovice", "Vlachovo Březí", "Vlašim", "Vodňany", "Volary", "Volyně", "Votice", "Vracov", "Vratimov", "Vrbno pod Pradědem", "Vrchlabí", "Vroutek", "Vsetín", "Všeruby", "Výsluní", "Vysoké Mýto", "Vysoké nad Jizerou", "Vysoké Veselí", "Vyškov", "Vyšší Brod", "Zábřeh", "Zákupy", "Zásmuky", "Zbiroh", "Zbýšov", "Zdice", "Zlaté Hory", "Zlín", "Zliv", "Znojmo", "Zruč nad Sázavou", "Zubří", "Žacléř", "Žamberk", "Žandov", "Žatec", "Ždánice", "Žďár nad Sázavou", "Ždírec nad Doubravou", "Žebrák", "Železná Ruda", "Železnice", "Železný Brod", "Židlochovice", "Žirovnice", "Žlutice", "Žulová"]; - -/***/ }, -/* 170 */ +/* 161 */ /***/ function(module, exports, __webpack_require__) { - /* WEBPACK VAR INJECTION */(function(module) {"use strict";module["exports"]=["17. Listopadu","17. Listopadu","28. Pluku","28. Října","28. Října","5. Května","5. Května","5. Máje","7. Května","8. Listopadu","9. Května","Achátová","Adamova","Adamovská","Adélčina","Africká","Akademická","Aksamitova","Akátová","Alabastrová","Albertov","Albrechtická","Albánská","Albíny Hochové","Aldašínská","Alej Českých Exulantů","Aleny Santarové","Aloisovská","Aloisovská","Aloisovská","Altajská","Alšovo Nábř.","Alšovo Nábřeží","Alšovy Sady","Alžírská","Ambrožova","Americká","Ametystová","Amforová","Amortova","Ampérova","Amurská","Anastázova","Anderleho","Andersenova","Andrštova","Andělova","Anenská","Anenské Nám.","Anenské Náměstí","Anežky Malé","Anežská","Angelovova","Anglická","Angolská","Anhaltova","Ankarská","Anny Drabíkové","Anny Letenské","Anny Rybníčkové","Anny Čížkové","Anny Čížkové","Antala Staška","Antonína Hodného","Antonína Čermáka","Antonínská","Anýzová","Apolinářská","Arabská","Aranžérská","Arbesovo Nám.","Arbesovo Náměstí","Archangelská","Archeologická","Archimédova","Archivní","Argentinská","Aristotelova","Arkalycká","Armádní","Armádního Sboru","Armády","Arménská","Arnošta Valenty","Astlova","Athénská","Atletická","Aubrechtové","Augustinova","Augustova","Austova","Aviatická","Axmanova","Azalková","Azuritová","Ašská","Baarova","Babická","Babiččina","Babočková","Babská","Babylonská","Babákova","Bachmačské Nám.","Bachmačské Náměstí","Bachova","Bacháčkova","Badeniho","Badeniho","Bajgarova","Bajkalská","Bajkonurská","Bakalářská","Bakovská","Bakurinova","Balabánova","Balbínova","Banskobystrická","Baranova","Barchovická","Barešova","Barrandova","Barrandovská","Bartolomějská","Bartoňkova","Bartoňova","Bartoškova","Bartoškova","Bartoškova","Bartákova","Bartůňkova","Barunčina","Barvířská","Barákova","Basilejské Nám.","Basilejské Náměstí","Bassova","Batelovská","Batličkova","Bavorovská","Bavorská","Bazalková","Bazovského","Bačetínská","Baňská","Baškirská","Bašteckého","Baštýřská","Bažantní","Beaufortova","Bechlínská","Bechyňova","Bechyňská","Beckovská","Bedlová","Bednářská","Bedrnova","Bedřichovská","Beethovenova","Beldova","Belgická","Bellova","Bellušova","Bendlova","Bendova","Benecká","Benediktská","Benešovská","Benická","Benkova","Benákova","Benátská","Benáčanova","Beníškové","Beranových","Bergerova","Bergmanova","Berkovská","Berlínská","Bermanova","Bernartická","Bernolákova","Berounská","Bertrámová","Berylová","Besední","Beskydská","Betlémská","Betlémské Nám.","Betlémské Náměstí","Betáňská","Bezdrevská","Bezděkovská","Bezinková","Bezová","Bezprašná","Bečovská","Bečvářova","Bečvářská","Bečvářská","Beřkovická","Bešťákova","Bieblova","Binarova","Biskupcova","Biskupská","Biskupský Dvůr","Blachutova","Blahníkova","Blahoslavova","Blanická","Blatenská","Blatnická","Blatovská","Blatská","Blattného","Blažimská","Blažkova","Blažíčkova","Blešnovská","Blodkova","Bludovická","Blériotova","Blšanecká","Bobkova","Bochovská","Bodláková","Bohdalec","Bohdalec","Bohdalecká","Bohdalecká","Bohdanečská","Bohdašínská","Bohnická","Bohrova","Bohumínská","Bohuslava Martinů","Bohuslava Martinů","Bohuslava Ze Švamberka","Bohuslavická","Bohušovická","Bohušovická","Boháčova","Bohúňova","Bojanovická","Bojasova","Bojetická","Boješická","Bojkovická","Bojovská","Bojínková","Bojčenkova","Bolebořská","Boleratická","Boleslavova","Boleslavská","Boletická","Bolevecká","Bolinská","Boloňská","Bolzanova","Bolívarova","Borecká","Borečkova","Borodinská","Borotínská","Borovanská","Borovanského","Borovnická","Borovská","Borová","Borošova","Borská","Borského","Boršov","Boršovská","Borůvková","Boseňská","Botevova","Botičská","Botičská","Boudova","Bousovská","Boučkova","Bouřilova","Boušova","Bozděchova","Boční I","Boční Ii","Bořanovická","Bořetická","Bořetínská","Bořivojova","Bořivojova","Boříkova","Bošická","Bošilecká","Bošínská","Božanovská","Božecká","Božejovická","Boženy Hofmeisterové","Boženy Jandlové","Boženy Němcové","Boženy Němcové","Boženy Stárkové","Božetická","Božetěchova","Božkova","Božkovská","Božídarská","Brabcova","Bramboříková","Branaldova","Brandejsova","Brandejsovo Nám.","Brandejsovo Náměstí","Brandlova","Brandýská","Branická","Branická","Branické Nám.","Branické Náměstí","Branislavova","Branišovská","Branská","Bratislavská","Bratranců Veverkových","Bratří Dohalských","Bratří Venclíků","Bratří Čapků","Bratříkovská","Braunerova","Braunova","Braškovská","Brdecká","Brdičkova","Brdlíkova","Brechtova","Brechtova","Brehmova","Breitcetlova","Brichtova","Brigádnická","Brigádníků","Brixiho","Brodecká","Brodecká","Brodského","Bromova","Bronzová","Broskvoňová","Broumarská","Broumovská","Brozánská","Brožíkova","Brtecká","Brtnická","Brumovická","Brunclíkova","Brunelova","Brunnerova","Bruselská","Brusinková","Bruslařská","Bryksova","Brzická","Brzorádových","Brázdimská","Brňovská","Bubenečská","Bubenečská","Bubenská","Bubenské Nábř.","Bubenské Nábřeží","Bubeníčkova","Bublavská","Bublíkova","Bubnova","Bucharova","Buchlovská","Buchovcova","Budapešťská","Budečská","Budilova","Budilovská","Budovatelská","Budyňská","Budyšínská","Budínova","Budčická","Budějovická","Budějovická","Bukolská","Bukovecká","Bukovinská","Buková","Bulharská","Buližníková","Bulovka","Burdova","Burešova","Burianova","Butovická","Butovická","Buzulucká","Buštěhradská","Bydhošťská","Bydžovská","Bydžovského","Bylanská","Bystrá","Bystřická","Bystřičná","Byšická","Byškovická","Bzenecká","Bártlova","Bášťská","Bílenecké Nám.","Bílenecké Náměstí","Bílinská","Bílkova","Bílkova","Bílovská","Bílá","Bílčická","Bínova","Bítovská","Böhmova","Býšovská","Běchorská","Běchovická","Běhounkova","Bělehradská","Bělehradská","Bělehradská","Bělečská","Bělinského","Bělocerkevská","Bělocká","Bělohorská","Bělohorská","Bělomlýnská","Bělomlýnská","Běloveská","Běluňská","Bělušická","Bělásková","Bělčická","Bělčická","Běžecká","Běžná","Břeclavská","Břehová","Břehová","Břetislavova","Břevnovská","Březanova","Březecká","Březenská","Březinova","Březiněveská","Březnická","Březnová","Březovická","Březovského","Březová","Břečťanová","Břežanská","Břežánecká","Břidlicová","Břidličná","Břízova","Bříšťanská","Cafourkova","Cedrová","Celetná","Celniční","Celsiova","Cementářská","Ceplechova","Cerhenická","Cerhýnská","Cetyňská","Chabařovická","Chaberská","Chabeřická","Chabská","Chalabalova","Chaloupeckého","Chaloupky","Chaltická","Chalupkova","Chalupnická","Chaplinovo Nám.","Chaplinovo Náměstí","Charkovská","Charlese De Gaulla","Charvátova","Chatařská","Chatová","Chebská","Chelčického","Chemická","Chilská","Chittussiho","Chladírenská","Chlebovická","Chlumecká","Chlumecká","Chlumecká","Chlumova","Chlumínská","Chlumčanského","Chlupova","Chlupáčova","Chládkova","Chmelařská","Chmelická","Chmelová","Chmelířova","Choceradská","Choceňská","Chocholouškova","Chocholova","Chodecká","Chodovecké Nám.","Chodovecké Náměstí","Chodovická","Chodovská","Chodovská","Chodovská","Chodská","Cholupická","Chomutovická","Chomutovská","Chopinova","Choratická","Chorošová","Chorušická","Chorvatská","Chotečská","Chotkova","Chotouchovská","Chotouňská","Chotovická","Chotutická","Chotěbuzská","Chotěnovská","Chotětovská","Chotěšovská","Chovatelská","Chrastavská","Chrobolská","Chrpová","Chrudimská","Chráněná","Chrášťanská","Chuchelská","Chudenická","Chudoměřická","Churnajevova","Churáňovská","Chvaletická","Chvaletická","Chvalečská","Chvalkovická","Chvalova","Chvalská","Chvalská","Chvalšovická","Chvatěrubská","Chvojenecká","Chyjická","Chýnická","Chýnovská","Chýňská","Chřibská","Cibulka","Cidlinská","Cigánkova","Cihelná","Cihlářova","Cihlářská","Cimburkova","Ciolkovského","Cirkusová","Cisterciácká","Citolibská","Coriových","Ctiborova","Ctiněveská","Ctiradova","Ctěnická","Cukerní","Cukrovarnická","Cukrovarská","Cuřínova","Cvikovská","Cvičebná","Cvrčkova","Cvrčkova","Cvrčkova","Cyprichova","Cíglerova","Cílkova","Cínovecká","Církova","Církvická","Církvičná","Císařská Louka","Císařský Ostrov","Císařský Ostrov","Císařský Ostrov","Cítovská","Daimlerova","Dalejská","Dalejská","Dalešická","Daliborova","Dalimilova","Dalovická","Dandova","Danielova","Dany Medřické","Darwinova","Dasnická","Davelská","Davidovičova","Davídkova","Davídkova","Dačická","Dačického","Daňkova","Dašická","Daškova","Dehtínská","Dejvická","Dejvická","Demlova","Demoliční","Desenská","Destinnové","Destinové","Devonská","Deylova","Deštná","Dešťová","Diabasová","Diamantová","Diblíkova","Diblíkova","Dienzenhoferovy Sady","Dieselova","Diskařská","Diskařská","Dismanova","Dittrichova","Divadelní","Divadelní","Divecká","Diviznová","Divišova","Divišovská","Divoká Šárka","Divoká Šárka","Dlabačov","Dlabačov","Dlouhá","Dlážděná","Do Blatin","Do Borovin","Do Chuchle","Do Dolnic","Do Dubin","Do Dubče","Do Hlinek","Do Klukovic","Do Kopečka","Do Koutů","Do Koutů","Do Lipan","Do Lipin","Do Lipin","Do Luk","Do Panenek","Do Podkovy","Do Polí","Do Potoků","Do Píšovic","Do Roklí","Do Rybníčků","Do Svépravic","Do Vozovny","Do Vrchu","Do Vršku","Do Zahrádek I","Do Zahrádek I","Do Zahrádek I","Do Zahrádek Ii","Do Zahrádek Ii","Do Zátiší","Do Údolí","Do Újezda","Do Čertous","Do Čtvrti","Do Říčan","Dobevská","Dobnerova","Dobratická","Dobronická","Dobronická","Dobropolská","Dobrovická","Dobrovolného","Dobrovolského","Dobrovského","Dobrovízská","Dobročovická","Dobrošovská","Dobrušská","Dobřanská","Dobřejovická","Dobřenická","Dobřichovská","Dobšická","Dobšínská","Dohalická","Doksanská","Dolanská","Dolejškova","Doležalova","Dolina","Dolnobranská","Dolnobřežanská","Dolnocholupická","Dolnojirčanská","Dolnokrčská","Dolnokřeslická","Dolnomlýnská","Dolnoměcholupská","Dolnoměcholupská","Dolnopočernická","Dolnočernošická","Dolní","Dolní","Dolní Chaloupky","Dolomitová","Dolská","Dolákova","Dolínecká","Dolňanská","Domanovická","Domašínská","Domažlická","Dominova","Dominínská","Domkovská","Domkářská","Domousnická","Donatellova","Donovalská","Donská","Donátova","Donínská","Dopplerova","Dopravní","Dopraváků","Dopraváků","Dostihová","Dostojevského","Doubecká","Doubická","Doubravická","Doubravská","Doubravínova","Doubravčická","Doudlebská","Doudova","Doupovská","Dr. Marodyho","Dr. Zikmunda Wintra","Dr.Zikmunda Wintra","Dragounská","Drahanská","Drahanská","Drahelická","Drahelčická","Drahobejlova","Drahorádova","Drahotická","Drahotínská","Drahovská","Drahovská","Drahoňovského","Draženovská","Draženovská","Dražetická","Dražická","Dražického","Dražického Nám.","Dražického Náměstí","Dražkovská","Dreyerova","Drimlova","Drnovská","Drobná","Drtikolova","Drtinova","Druhanická","Druhého Odboje","Družicová","Družnosti","Družná","Družstevní","Družstevní Ochoz","Družstevní Ochoz","Drážní","Drůbežnická","Drůbežářská","Dubanská","Dubenecká","Dubečská","Dubečské Horky","Dubinská","Dubnická","Dubnova","Dubovická","Dubová","Dubrovnická","Dubská","Duchcovská","Duchoslávka","Dudkova","Dudínská","Duhová","Dukelská","Dukelských Hrdinů","Dunajevského","Dunajská","Dunická","Dunovského","Durychova","Durychova","Dusíkova","Duškova","Duškova","Dušní","Dušní","Dvorecká","Dvorecké Nám.","Dvorecké Náměstí","Dvorní","Dvorská","Dvoudílná","Dvouletky","Dvouramenná","Dvořeckého","Dvořišťská","Dvořákova","Dvořákovo Nábř.","Dvořákovo Nábřeží","Dygrýnova","Dyjská","Dykova","Dářská","Dürerova","Dýšinská","Děbolínská","Dědická","Dědinova","Dědinská","Děkanská","Děkanská Vinice I","Děkanská Vinice Ii","Dělená","Dělnická","Dělostřelecká","Dětenická","Dětská","Dětský Ostrov","Děvínská","Děčínská","Děčínská","Dřevařská","Dřevnická","Dřevná","Dřevčická","Dřínovská","Dřínová","Dřítenská","Eberlova","Ebrova","Edisonova","Edvardova","Egyptská","Eichlerova","Einsteinova","Ejpovická","Ekonomická","Eledrova","Elektrárenská","Eliášova","Eliášova","Elišky Junkové","Elišky Krásnohorské","Elišky Krásnohorské","Elišky Peškové","Elišky Přemyslovny","Ellnerové","Elsnicovo Náměstí","Emilie Hyblerové","Emlerova","Engelmüllerova","Engelova","Engelova","Englerova","Erbenova","Erbenova","Estonská","Etiopská","Euklidova","Evropská","Evropská","Evropská","Evropská","Evropská","Evy Olmerové","Exnárova","F.V.Veselého","Fabiánova","Fabiánská","Fadějevova","Fajmanové","Fajtlova","Falcká","Faltysova","Famfulíkova","Fantova","Faradayova","Farkašova","Farní","Farská","Farského","Fastrova","Federova","Fejfarova","Felberova","Fenyklová","Fetrovská","Feřtekova","Fialková","Fibichova","Fikerova","Filipova","Filipovského","Filipíny Welserové","Fillova","Filmařská","Filosofská","Fingerova","Finkovská","Finská","Firkušného","Fischlova","Fišerova","Flemingovo Nám.","Flemingovo Náměstí","Flájská","Flöglova","Foerstrova","Folmavská","Formanská","Formánkova","Fořtova","Fragnerova","Francouzská","Francouzská","Francouzská","Františka Diviše","Františka Jansy","Františka Kadlece","Františka Křížka","Františka Černého","Františka Červeného","Františka Šimáčka","Františkova","Franty Kocourka","Frančíkova","Freiwaldova","Freyova","Frimlova","Fričova","Froncova","Frostova","Froňkova","Frydrychova","Fryčovická","Fráni Šrámka","Frézařská","Frýdecká","Frýdlantská","Fuchsova","Fügnerovo Nám.","Fügnerovo Náměstí","Gabinova","Gabčíkova","Gagarinova","Galandova","Galileova","Gallašova","Galvaniho","Gaussova","Gdaňská","Generála Janouška","Generála Mejstříka","Generála Píky","Generála Šišky","Generála Šišky","Gensovská","Geologická","Gercenova","Gerstnerova","Ginzova","Glazunovova","Glinkova","Glowackého","Goetheho","Gogolova","Golfová","Gollova","Golčova","Gončarenkova","Gončarenkova","Gorazdova","Gotthardská","Goyova","Gočárova","Grafická","Grafitová","Grammova","Granátová","Gregorova","Grussova","Gruzínská","Gutfreundova","Gutova","Gymnasijní","Gymnastická","Habartická","Habartická","Habartovská","Haberfeldova","Habrovská","Habrová","Habřická","Habřická","Hackerova","Hadovitá","Hadravská","Hajní","Hakenova","Halasova","Halenkovská","Halštatská","Hamerská","Hamplova","Hamrová","Hamsíkova","Hankova","Hanouškova","Hanusova","Hanušova","Hanzelkova","Hanzlíkova","Harantova","Harcovská","Harlacherova","Harmonická","Harrachovská","Hartenberská","Hasičská","Hasičů","Hasova","Hastrmanská","Haunerova","Hauptova","Hausmannova","Havanská","Havelská","Havelská Ulička","Havlovického","Havlovického","Havlovská","Havlínova","Havlíčkova","Havlíčkovo Nám.","Havlíčkovo Náměstí","Havlíčkovy Sady","Havlůjové","Havlůjové","Havranická","Havraní","Havránkova","Havířovská","Havířská","Haškova","Hašlerova","Haštalská","Haštalské Nám.","Haštalské Náměstí","Heckelova","Heineho","Heinemannova","Hejnická","Hejnická","Hejplíkova","Hejtmanská","Hejtmánkova","Hekova","Hekrova","Heldova","Heleny Malířové","Hellichova","Helmova","Helsinská","Helénská","Hennerova","Heranova","Herbenova","Herdovská","Herlíkovická","Hermanická","Hermelínská","Hermíny Týrlové","Heroldovy Sady","Herrmannova","Herrova","Hertzova","Herálecká I","Herálecká Ii","Herálecká Iii","Herálecká Iv","Herčíkova","Hevlínská","Heydukova","Heyrovského Nám.","Heyrovského Nám.","Heyrovského Náměstí","Heyrovského Náměstí","Hečkova","Heřmanova","Heřmánková","Hildy Čihákové","Hillebrantova","Hilmarova","Hiršlova","Hlavatého","Hlavenecká","Hlavní","Hlavova","Hlaváčkova","Hlaváčova","Hlaďova","Hledíková","Hlinská","Hlivická","Hlohová","Hloubětínská","Hloubětínská","Hlubocká","Hluboká","Hlubočepská","Hlušičkova","Hládkov","Hládkov","Hlávkova","Hněvkovská","Hněvkovského","Hnězdenská","Hoblířská","Hodkovická","Hodkovská","Hodonínská","Hodčina","Hodějovská","Hodějovská","Hoděšovická","Hofbauerova","Hoffmannova","Hokejová","Hokešovo Nám.","Hokešovo Náměstí","Holandská","Holekova","Holenická","Holenská","Holečkova","Holečkova","Holešovické Nábřeží","Holešovický Přístav","Holická","Hollarovo Nám.","Hollarovo Náměstí","Holohlavská","Holotínská","Holoubkova","Holoubkovská","Holubická","Holubinková","Holubkova","Holubova","Holubí","Holušická","Holyňská","Holátova","Holínská","Holýšovská","Holčovická","Holšická","Homolová","Homérova","Honzíkova","Hornická","Hornocholupická","Hornocholupická","Hornofova","Hornokrčská","Hornokřeslická","Hornomlýnská","Hornoměcholupská","Hornoměcholupská","Hornopočernická","Horní","Horní Chaloupky","Horní Hrdlořezská","Horní Stromky","Horníčkova","Horolezecká","Horoměřická","Horoměřická","Horoušanská","Horoušanská","Horovo Nám.","Horovo Náměstí","Horská","Horusická","Horymírovo Nám.","Horymírovo Náměstí","Horákova","Horáčkova","Horčičkova","Horňátecká","Horšovská","Horšovská","Hospodářská","Hostavická","Hostavická","Hostinského","Hostivařská","Hostivařské Nám.","Hostivařské Náměstí","Hostivická","Hostivítova","Hostišovská","Hostouňská","Hostošova","Hostýnská","Hostýnská","Houbařská","Houdova","Hovorčovická","Hořanská","Hořejší Náb.","Hořejší Nábřeží","Hořejšího","Hořelická","Hořická","Hořovského","Hořínecká","Hoškova","Hoštická","Hošťálkova","Hrabačovská","Hrabákova","Hrachovská","Hrad I. Nádvoří","Hrad Ii. Nádvoří","Hrad Iii. Nádvoří","Hradební","Hradecká","Hradeckých","Hradečkova","Hradešínská","Hradčanské Nám.","Hradčanské Náměstí","Hraniční","Hrazanská","Hrazanská","Hrdinova","Hrdličkova","Hrdlořezská","Hrdoňovická","Hroncova","Hronovská","Hronětická","Hrozenkovská","Hroznová","Hrozného","Hrubého","Hrubínova","Hrudičkova","Hrusická","Hruškovská","Hruškovská","Hrušovanské Nám.","Hrušovanské Náměstí","Hrušovická","Hrušovská","Hrušínského","Hrušňová","Hrušňová","Hrádková","Hráského","Huberova","Hubičkova","Hubáčkova","Hudcova","Hudební","Hudečkova","Hudečkova","Hugo Haase","Hulanova","Hulická","Humenecká","Humpolecká","Huntířovská","Hurbanova","Husařská","Husinecká","Husitská","Husitská","Husníkova","Husova","Husovo Nám.","Husovo Náměstí","Hustopečská","Hutnická","Huťská","Hviezdoslavova","Hviezdoslavova","Hvozdecká","Hvozdnická","Hvozdíková","Hvožďanská","Hvězdonická","Hvězdova","Hvězdářská","Hyacintová","Hybernská","Hybešova","Hynaisova","Hypšmanova","Hábova","Hájecká","Hájenská","Hájkova","Hájovna U Podjezdu","Hájovna V Šárce","Hájová","Hájíčkova","Hájčí","Hákova","Hálkova","Hálova","Hálův Statek","Högerova","Hübnerové","Hřbitovní","Hřebenová","Hřebíkova","Hřenská","Hřibojedská","Hřibská","Hříbková","Hřídelecká","Hůlkova","Hůlkova","Hůrská","Ibsenova","Imrychova","Ingrišova","Internacionální","Irkutská","Irská","Irvingova","Italská","Italská","Italská","Ivančická","Izraelská","Izraelská","Jabkenická","Jablonecká","Jablonecká","Jablonského","Jabloňová","Jablunkovská","Jagellonská","Jagellonská","Jahodnická","Jahodová","Jakobiho","Jakubovská","Jakubská","Jakutská","Jalodvorská","Jalovcová","Jaltská","Jamborova","Jamská","Jana Bílka","Jana Jindřicha","Jana Karafiáta","Jana Kašpara","Jana Marka","Jana Masaryka","Jana Ouřady","Jana Přibíka","Jana Růžičky","Jana Srba","Jana Zajíce","Jana Čerstvého","Jana Želivského","Janderova","Jandova","Janečkova","Jankovcova","Jankovská","Janouchova","Janouškova","Janovická","Janovská","Janovského","Jansenova","Janského","Jansova","Jantarová","Janákova","Janáčkovo Nábř.","Janáčkovo Nábř.","Janáčkovo Nábřeží","Janáčkovo Nábřeží","Janýrova","Jančova","Jarešova","Jarkovská","Jarmily Novotné","Jarní","Jarníkova","Jaromíra Jindry","Jaromíra Vejvody","Jaromírova","Jaroměřská","Jaroslava Foglara","Jaroslava Švehly","Jaroslavická","Jasanová","Jaselská","Jaselská","Jasenická","Jasenná","Jasmínová","Jasná I","Jasná Ii","Jaspisová","Jateční","Jaurisova","Jaurisova","Javorenská","Javornická","Javorová","Javorská","Javořická","Jašíkova","Jažlovická","Jedlová","Jednostranná","Jednostranná","Jednotného Zemědělského Družstva","Jednořadá","Jelenovská","Jelení","Jelínkova","Jemenská","Jemnická","Jenerálka","Jenečská","Jenišovská","Jenská","Jeníkovická","Jenštejnská","Jeremenkova","Jeremenkova","Jeremenkova","Jeremiášova","Jeremiášova","Jerevanská","Jeronýmova","Jeruzalémská","Jesenická","Jeseniova","Jestřebická","Jetelová","Jetřichovická","Jevanská","Jezdecká","Jezdovická","Jezerní","Jezerská","Jezevčí","Ječná","Jeřabinová","Jeřabinová","Jeřická","Jeřábkova","Jeřábnická","Jeřábová","Ješetická","Ještědská","Ježdíkova","Ježkova","Ježovická","Ježovická","Ježovská","Jihlavská","Jihovýchodní I","Jihovýchodní Ii","Jihovýchodní Iii","Jihovýchodní Iv","Jihovýchodní Ix","Jihovýchodní V","Jihovýchodní Vi","Jihovýchodní Vii","Jihovýchodní Viii","Jihozápadní I","Jihozápadní Ii","Jihozápadní Iii","Jihozápadní Iv","Jihozápadní V","Jihozápadní Vi","Jihočeská","Jilemnická","Jilemnická","Jilemnického","Jilmová","Jilská","Jindrova","Jindřicha Jindřicha","Jindřicha Plachty","Jindřichova","Jindřišská","Jinolická","Jinonická","Jinonická","Jinočanská","Jirenská","Jirečkova","Jirkovská","Jirsákova","Jirsíkova","Jiránkova","Jiráskovo Nám.","Jiráskovo Náměstí","Jirčanská","Jiskrova","Jistebnická","Jitkovská","Jitravská","Jitravská","Jitrocelová","Jitřní","Jivenská","Jizerská","Jičínská","Jičínská","Jiřická","Jiřinková","Jiřiny Štěpničkové","Jiřská","Jiřího Jandy","Jiřího Mašína","Jiřího Ze Vtelna","Jiříčkova","Jiříčkové","Jižní I","Jižní Ii","Jižní Iii","Jižní Iv","Jižní Ix","Jižní Nám.","Jižní Náměstí","Jižní Spojka","Jižní Spojka","Jižní Spojka","Jižní Spojka","Jižní V","Jižní Vi","Jižní Vii","Jižní Viii","Jižní Xi","Jižní Xii","Jižní Xiii","Jižní Xiv","Jižní Xv","Jižní Xvi","Jižní Xvii","Johanitská","Jordana Jovkova","Jordánská","Josefa Bíbrdlíka","Josefa Houdka","Josefa Houdka","Josefa Kočího","Josefa Němce","Josefa Vašíčka","Josefa Šimůnka","Josefská","José Martího","Juarézova","Jugoslávská","Jugoslávských Partyzánů","Jugoslávských Partyzánů","Jungmannova","Jungmannova","Jungmannovo Náměstí","Junácká","Jupiterova","Jurkovičova","Juárezova","Jzd","Jáchymova","Jáchymova","Jáchymovská","Jánošíkova","Jánská","Jánský Vršek","Jíchova","Jílkova","Jílovická","Jílovišťská","Jílovská","Jílovská","Jílová","Jírova","Jírovcovo Nám.","Jírovcovo Náměstí","Jívanská","Jívová","K Austisu","K Avii","K Barrandovu","K Bateriím","K Bažantnici","K Belvederu","K Berance","K Beranovu","K Berounce","K Beránku","K Betonárně","K Betáni","K Blatovu","K Bohnicím","K Borovíčku","K Botiči","K Brance","K Brnkám","K Brusce","K Brusce","K Brůdku","K Bílému Vrchu","K Běchovicům","K Březince","K Březiněvsi","K Břečkám","K Celinám","K Cementárně","K Chabům","K Chabům","K Chaloupce","K Chaloupkám","K Chatám","K Chmelnici","K Chumberku","K Cihelně","K Cikánce","K Cíli","K Dalejím","K Dobré Vodě","K Dobré Vodě","K Dolům","K Drahani","K Drahani","K Drazdům","K Drsnici","K Dubinám","K Dubovému Mlýnu","K Dubu","K Dubči","K Dálnici","K Dálnici","K Dýmači","K Děrám","K Fantovu Mlýnu","K Farkám","K Fialce","K Fišpance","K Habrovce","K Habru","K Haltýři","K Havlínu","K Hluboké Cestě","K Hlásku","K Holyni","K Holému Vrchu","K Holému Vrchu","K Homolce","K Horkám","K Horkám","K Horkám","K Horním Počernicím","K Horoměřicům","K Hořavce","K Hradišti","K Hrnčířům","K Hrušovu","K Hrušovu","K Hrázi","K Hutím","K Hutím","K Hutím","K Hádku","K Háječku","K Háji","K Háji","K Hájku","K Hájovně","K Hájovně","K Hájovně","K Hájům","K Hárunce","K Interně","K Jalovce","K Jasánkám","K Jelenu","K Jelenám","K Jezeru","K Jezeru","K Jezu","K Jezírku","K Jihu","K Jihu","K Jinočanům","K Jinočanům","K Jižnímu Městu","K Juliáně","K Jízdárně","K Labeškám","K Ladům","K Lahovičkám","K Lahovské","K Lažance","K Lesoparku","K Lesu","K Lesu","K Lesíku","K Letišti","K Letňanům","K Libuši","K Lindě","K Lipanům","K Lipinám","K Lipám","K Lochkovu","K Lomu","K Louži","K Luhu","K Lukám","K Lučinám","K Lužinám","K Ládví","K Ládví","K Lánu","K Lávce","K Lázním","K Lípě","K Markétě","K Matěji","K Mejtu","K Metru","K Metru","K Milíčovu","K Mlíčníku","K Mlýnu","K Modřanskému Nádraží","K Mohyle","K Moravině","K Moravině","K Mostku","K Mostu","K Motelu","K Motolu","K Mírám","K Měcholupům","K Měchurce","K Nedvězí","K Netlukám","K Noskovně","K Nouzovu","K Nové Vsi","K Nové Vsi","K Nové Škole","K Novému Dvoru","K Novému Hradu","K Novému Sídlišti","K Novým Domkům","K Nádraží","K Nádrži","K Náhonu","K Náměstí","K Náplavce","K Náplavce","K Návrší","K Návrší","K Návsi","K Obci","K Obecním Hájovnám","K Oboře","K Obsinám","K Ochozu","K Ohradě","K Okrouhlíku","K Olympiku","K Opatřilce","K Opatřilce","K Oplocení","K Orionce","K Osmidomkům","K Otočce","K Ovčínu","K Ovčínu","K Padesátníku","K Palečku","K Panenkám","K Parku","K Pastvinám","K Pazderkám","K Pekárně","K Peluňku","K Petrově Komoře","K Pitkovicům","K Podchodu","K Podjezdu","K Podjezdu","K Polím","K Pomníku","K Popelce","K Popelce","K Potoku","K Poště","K Pramenu","K Prelátům","K Prádelně","K Průhonicům","K Průhonu","K Průmstavu","K Pyramidce","K Pérovně","K Pískovně","K Písnici","K Přehradám","K Přejezdu","K Přístavišti","K Přívozu","K Radhošti","K Radonicům","K Radotínu","K Radotínu","K Remízku","K Rokli","K Rokytce","K Rotundě","K Rovinám","K Rozkoši","K Rozmezí","K Roztokům","K Rozvodně","K Rukavičkárně","K Rybníku","K Rybníčku","K Rybníčkům","K Rybárně","K Ryšánce","K Ryšánce","K Sadu","K Safině","K Samoobsluze","K Samotě","K Sedlišti","K Sibřině","K Sokolovně","K Sopce","K Sopce","K Starému Bubenči","K Starému Lomu","K Stavebninám","K Sukovu","K Sádkám","K Sádkám","K Sídlišti","K Sídlišti","K Teplárně","K Topolům","K Topírně","K Transformátoru","K Trati","K Trninám","K Trnkám","K Trníčku","K Truhlářce","K Tržišti","K Tuchoměřicům","K Táboru","K Třebonicům","K Třešňovce","K Tůni","K Ubytovnám","K Uhříněvsi","K Uhříněvsi","K Učilišti","K Valu","K Vejvoďáku","K Velké Ohradě","K Velké Ohradě","K Velkému Dvoru","K Verneráku","K Viaduktu","K Vidouli","K Vilkám","K Vinici","K Vinicím","K Vinoři","K Vizerce","K Višňovce","K Višňovce","K Višňovému Sadu","K Vltavě","K Vlásence","K Vodici","K Vodojemu","K Vodárně","K Vodě","K Vrbičkám","K Vrbě","K Vrcholu","K Vrtilce","K Vršíčku","K Vyhlídce","K Vysoké Cestě","K Vystrkovu","K Václavce","K Vápence","K Váze","K Výboru","K Výtopně","K Výzkumným Ústavům","K Větrolamu","K Zabrkům","K Zadní Kopanině","K Zadní Kopanině","K Zahradnictví","K Zahradám","K Zahrádkám","K Zastávce","K Zatáčce","K Zelené Louce","K Zeleným Domkům","K Zelenči","K Zámku","K Zátiší","K Závodišti","K Závorám","K Závěrce","K Závětinám","K Údolí","K Údolí Hvězd","K Újezdu","K Ústavu","K Úvozu","K Černošicím","K Červenému Dvoru","K Červenému Dvoru","K Červenému Dvoru","K Červenému Vrchu","K Čestlicům","K Čihadlům","K Ďáblicům","K Řece","K Řeporyjím","K Řeporyjím","K Říčanům","K Šafránce","K Šafránce","K Šancím","K Šeberovu","K Šeberáku","K Šedivce","K Šubrtce","K Železnici","K Žižkovu","Kabeláčova","Kabešova","Kabátové","Kadaňská","Kadeřávkovská","Kafkova","Kahovská","Kaizlovy Sady","Kakosova","Kakostová","Kalabisova","Kalašova","Kalinová","Kališnická","Kališťská","Kalská","Kalvodova","Kamelova","Kamencová","Kamenická","Kamenická","Kamenitá","Kamenná","Kameníků","Kamerunská","Kampanova","Kamzíková","Kamýcká","Kamýcká","Kamýcká","Kanadská","Kandertova","Kanovnická","Kapitulská","Kaplanova","Kaplická","Kapraďová","Kaprova","Kaprova","Kapucínská","Karafiátová","Karasova","Karasovská","Kardausova","Kardašovská","Kardašovská","Karenova","Karfíkova","Karla Engliše","Karla Hlaváčka","Karla Kryla","Karla Křížka","Karla Michala","Karla Rachůnka","Karla Tomáše","Karla Zicha","Karla Černého","Karlická","Karlova","Karlovarská","Karlovarská","Karlovická","Karlovo Nám.","Karlovo Nám.","Karlovo Náměstí","Karlovo Náměstí","Karlínské Nám.","Karlínské Náměstí","Karlštejnská","Karmelitská","Karolinská","Karoliny Světlé","Karpatská","Kartounářů","Kartouzská","Kasalická","Kateřinská","Kateřinské Nám.","Kateřinské Náměstí","Katovická","Katusická","Kavkazská","Kazaňská","Kazašská","Kazimírova","Kaznějovská","Kazín","Kazínská","Kačerovská","Kačínská","Kaňkova","Kaňkovského","Kaňovská","Kašeho","Kaškova","Kašovická","Kašparovo Nám.","Kašparovo Náměstí","Kašperská","Kaštanová","Kbelská","Kbelská","Kbelská","Kbelská","Kdoulová","Ke Březině","Ke Břvům","Ke Cvičišti","Ke Dračkám","Ke Dráze","Ke Dvoru","Ke Džbánu","Ke Garážím","Ke Golfu","Ke Goniu","Ke Hlásce","Ke Hrádku","Ke Hrázi","Ke Hrázi","Ke Hřbitovu","Ke Hřišti","Ke Kablu","Ke Kablu","Ke Kalvárii","Ke Kaménce","Ke Kamínce","Ke Kamýku","Ke Kapličce","Ke Kapslovně","Ke Karlovu","Ke Kateřinkám","Ke Kazínu","Ke Kašně","Ke Kinu","Ke Kladivům","Ke Klimentce","Ke Klubovně","Ke Klínku","Ke Klínku","Ke Klíčovu","Ke Koh-I-Nooru","Ke Kolodějskému Zámku","Ke Kolodějům","Ke Kolonii","Ke Konstruktivě","Ke Kopečku","Ke Korunce","Ke Kostelu","Ke Kostelíčku","Ke Kotlářce","Ke Koulce","Ke Koupališti","Ke Kovárně","Ke Kozím Hřbetům","Ke Královicům","Ke Krči","Ke Krčské Stráni","Ke Kulišce","Ke Kulturnímu Domu","Ke Kurtům","Ke Kyjovu","Ke Kálku","Ke Křížku","Ke Křížkám","Ke Lhoteckému Lesu","Ke Mlýnku","Ke Mlýnu","Ke Mlýnu","Ke Schodům","Ke Skalce","Ke Skalkám","Ke Skladům","Ke Sklárně","Ke Skále","Ke Slatinám","Ke Slivenci","Ke Smrčině","Ke Smíchovu","Ke Smíchovu","Ke Splávku","Ke Spofě","Ke Spořilovu","Ke Spálence","Ke Srážku","Ke Stadionu","Ke Stanici","Ke Starému Hřišti","Ke Starým Rybníkům","Ke Stinkovskému Rybníku","Ke Strašnické","Ke Strouze","Ke Stráni","Ke Strži","Ke Studni","Ke Studni","Ke Studánce","Ke Stupicím","Ke Stáčírně","Ke Stírce","Ke Střelnici","Ke Střelnici","Ke Sv. Izidoru","Ke Třem Mostům","Ke Xaverovu","Ke Zbraslavi","Ke Zbrojnici","Ke Zbuzanům","Ke Zdibům","Ke Zdravotnímu Středisku","Ke Zděři","Ke Zlatému Kopci","Ke Zličínu","Ke Znaku","Ke Zvonici","Ke Zvoničce","Ke Školce","Ke Škole","Ke Šmejkalu","Ke Štvanici","Ke Štítu","Ke Štěpcům","Ke Štěrkovně","Ke Švestkovce","Kecova","Kejhova","Kejnická","Kellnerova","Keltská","Keltů","Kelvinova","Kemrova","Keplerova","Keplerova","Keramická","Kesnerka","Kestřanská","Keteňská","Kettnerova","Keřová","Khodlova","Kischova","Kišiněvská","Kladenská","Kladenská","Kladenská","Kladinovská","Kladrubská","Kladská","Klamovka","Klapkova","Klapálkova","Klatovská","Klausova","Klecandova","Klecanská","Klenečská","Klenovická","Klenovská","Klenová","Klečkova","Klečákova","Klešická","Klicperova","Klidná","Klihařská","Klikatá","Klikatá","Klimentská","Klivarova","Kloboukova","Kloboučnická","Kloknerova","Klokotská","Klostermannova","Klouzková","Kludských","Klukovická","Klánova","Klánova","Klánova","Klánovická","Klánovická","Klárov","Klášterecká","Klášterská","Klášterského","Klímova","Klímova","Klínecká","Klínovecká","Klínová","Klírova","Klíčanská","Klíčova","Klíčovská","Klíčovská","Kmochova","Knínická","Kněževeská","Kněžická","Koberkova","Kobrova","Kobyliská","Kobyliské Nám.","Kobyliské Náměstí","Kobylákova","Kochanova","Kocianova","Koclířova","Kocourova","Kodaňská","Kodicilova","Kodymova","Kohoutovská","Kohoutových","Kojetická","Kojická","Kokořínská","Kolbenova","Kolbenova","Kolbenova","Koldínova","Kolejní","Kolektivní","Kolešovská","Kollárova","Kolmistrova","Kolmá","Kolocova","Kolodějská","Kolonie U Obecní Cihelny","Kolonka","Kolovečská","Kolovratská","Kolová","Kolátorova","Koláčkova","Koláře Kaliny","Kolářova","Kolínova","Kolínská","Kolčavka","Komenského Nám.","Komenského Náměstí","Komornická","Komořanská","Komořanská","Komořanská","Komunardů","Komárkova","Komárovská","Koncová","Konecchlumského","Konečná","Kongresová","Konojedská","Konopišťská","Konopova","Konopáskova","Konstantinova","Konvalinková","Konviktská","Konzumní","Konzumní","Koníčkovo Nám.","Koníčkovo Náměstí","Konětopská","Koněvova","Konšelská","Konžská","Kopalova","Kopanina","Kopanská","Kopeckého","Koperníkova","Kopečná","Kopretinová","Kopřivnická","Korandova","Korandova","Korunní","Korunní","Korunní","Korunovační","Korunovační","Korybutova","Korycanská","Korytná","Kosatcová","Kosařova","Kosmická","Kosmonoská","Kosova","Kosořická","Kosořská","Kostelecká","Kostelecká","Kostelní","Kostelní Náměstí","Kostečná","Kostková","Kostlivého","Kostnické Nám.","Kostnické Náměstí","Kostomlatská","Kostrbova","Kostřínská","Kosárkovo Nábř.","Kosárkovo Nábřeží","Kosí","Koterovská","Koterovská","Kotevní","Kotlaska","Kotlářka","Kotorská","Kotovka","Kotrčová","Kotršálova","Kotíkova","Kotěrova","Koubkova","Koubkova","Koubova","Koukolová","Koulka","Koulova","Kounická","Kounovská","Koutská","Kouřimská","Kovanecká","Kovařovicova","Kovriginova","Kováků","Kovárenská","Kovářova","Kovářská","Kováříkova","Kozinova","Kozinovo Náměstí","Kozlova","Kozlovská","Kozmíkova","Kozomínská","Kozácká","Kozákovská","Kozáková","Kozí","Kočova","Kořenského","Košařova","Košická","Koštířova","Košátecká","Košíkářská","Košířské Nám.","Košířské Náměstí","Košťálkova","Koťátkova","Koželužská","Kožlanská","Kožná","Kožíškova","Kpt. Nálepky","Kpt. Stránského","Krabošická","Krahulčí","Krajanská","Krajní","Krajová","Krajánkova","Krakovská","Kralická","Kralupská","Krameriova","Kramlova","Kramolná","Kramolínská","Kramperova","Kraslická","Krasnická","Krasnojarská","Kratochvílova","Krausova","Krbická","Krchlebská","Krejnická","Krejčího","Kremličkova","Kremnická","Kremnická","Krhanická","Krhanická","Kristiánova","Kriváňská","Krkonošská","Krnovská","Krnská","Krocínova","Krocínovská","Kroftova","Krohova","Krokova","Krolmusova","Kropáčkova","Krosenská","Kroupova","Kroupova","Krouzova","Krovova","Krteňská","Kruhová","Krumlovská","Krupkovo Nám.","Krupkovo Náměstí","Krupná","Krupská","Krušovická","Kružberská","Krylovecká","Krylovecká","Krymská","Krynická","Krystalová","Kryšpínova","Kryštofova","Krále Václava Iv.","Králodvorská","Králova","Královická","Královny Žofie","Královská Obora","Královská Obora","Krásnolipská","Krásného","Krásova","Krátká","Krátká","Krátkého","Krátký Lán","Krčmářovská","Krčská","Krčínovo Nám.","Krčínovo Náměstí","Krčínská","Krňovická","Krškova","Kubatova","Kubaštova","Kubelíkova","Kubišova","Kubištova","Kubova","Kubánské Nám.","Kubánské Náměstí","Kubíkova","Kubínova","Kuchařská","Kudeříkové","Kudrnova","Kukelská","Kukelská","Kukulova","Kukulova","Kukučínova","Kulhavého","Kulhánkovská","Kuncova","Kundratka","Kunešova","Kunická","Kunratická","Kunratická Spojka","Kunratická Spojka","Kuní","Kuní","Kunínova","Kunčická","Kunětická","Kupeckého","Kupkova","Kurandové","Kurkova","Kurta Konráda","Kurzova","Kurčatovova","Kusá","Kusého","Kutilova","Kutnauerovo Náměstí","Kutnohorská","Kutnohorská","Kutrovická","Kuttelwascherova","Kutvirtova","Kučerova","Kučerové","Kuťatská","Kuželova","Kvapilova","Kvasinská","Kvestorská","Květinková","Květinářská","Květnická","Květnová","Květnového Povstání","Květnového Povstání","Květnového Vítězství","Květnového Vítězství","Květná","Květoslavova","Květová","Kyjevská","Kyjevská","Kyjovská","Kyjská","Kyjská","Kykalova","Kymrova","Kynická","Kyselova","Kyslíková","Kysucká","Kysúcká","Kytlická","Kytínská","Kácovská","Kádnerova","Kálikova","Kálmánova","Káranská","Křejpského","Křelovická","Křemelná","Křemencova","Křemenná","Křemenáčová","Křemílkova","Křenická","Křenova","Křepelčí","Křepelčí","Křesadlova","Křesanovská","Křeslická","Křesomyslova","Křešínská","Křimická","Křimovská","Křivatcová","Křivenická","Křivoklátská","Křivá","Křičkova","Křišťanova","Křišťálová","Křižovnická","Křižovnické Nám.","Křižovnické Náměstí","Křižíkova","Křižíkova","Křovinovo Nám.","Křovinovo Náměstí","Křtinská","Kříženeckého Nám.","Kříženeckého Náměstí","Křížkovského","Křížová","Křížová","Labská","Labětínská","Ladislava Coňka","Ladova","Laglerové","Lahovská","Lahovská","Lamačova","Langweilova","Lannova","Lanýžová","Lanžhotská","Lanžovská","Laténská","Laubova","Laudonova","Laudova","Laurinova","Lazarská","Lazarská","Lačnovská","Lažanská","Lažanská","Lažanského","Lebeděvova","Ledařská","Ledecká","Ledečská","Ledkovská","Lednická","Lednová","Ledvická","Ledvinova","Ledč","Ledčická","Legerova","Legerova","Legerova","Legerova","Legionářů","Lehárova","Leitzova","Leknínová","Leopoldova","Leskovecká","Lesnická","Lesného","Lesní","Lessnerova","Lesáků","Letců","Letecká","Letenská","Letenské Nám.","Letenské Nám.","Letenské Náměstí","Letenské Náměstí","Letenské Sady","Letní","Letohradská","Letovská","Letňanská","Letňanská","Levandulová","Levobřežní","Levského","Levá","Lexova","Lečkova","Lešanská","Lešenská","Lešetínská","Lešovská","Leštínská","Lhenická","Lhotecká","Lhotecká","Lhotská","Lhotákova","Liberecká","Liberijská","Libečkova","Libeňská","Libeňský Ostrov","Libeňský Ostrov","Libeřská","Libichovská","Libická","Libišanská","Libišská","Libkovská","Liblická","Liblická","Libochovická","Libocká","Liborova","Libotovská","Libovická","Libočanská","Liboňovská","Libošovická","Libuňská","Libušina","Libušská","Libušská","Libušská","Libušská","Libáňská","Libínská","Libčanská","Libčická","Liběchovská","Libědická","Liběšická","Libřická","Lichá","Lidečská","Lidická","Lidického","Lihovarská","Liliová","Lilková","Limuzská","Limuzská","Lindavská","Lindleyova","Lindnerova","Linhartova","Linhartská","Lipanská","Lipecká","Lipenecká","Lipenská","Lipenská","Lipenské Nám.","Lipenské Náměstí","Lipnická","Lipoltická","Lipovická","Lipovská","Lipová Alej","Lipové Náměstí","Lipského","Lipí","Lisabonská","Lisabonská","Listopadová","Lisztova","Litavská","Litevská","Litická","Litochlebská","Litoměřická","Litoměřická","Litovická","Litošická","Litošická","Litožnická","Litvínovská","Litvínovská","Livornská","Lišanská","Lišická","Liškova","Lišovická","Liščí","Liščí","Lnářská","Lobečská","Lochenická","Lochkovská","Lochotínská","Lodecká","Lodní Mlýny","Loděnická","Lodžská","Lodžská","Lohenická","Lohniského","Lojovická","Lojovická","Lojovická","Lolkova","Lomařská","Lomecká","Lomená","Lomnická","Lomnického","Lomová","Londýnská","Loosova","Lopatecká","Lopatecká","Lopuchová","Loretánská","Loretánské Nám.","Loretánské Náměstí","Losinská","Lotyšská","Loucká","Loudova","Lounská","Lounských","Loutkářská","Loučanská","Loučimská","Loučná","Louňovická","Lovecká","Lovosická","Lovosická","Lovosická","Lovčenská","Lovčická","Lozická","Lošetická","Lošáková","Lstibořská","Lubenecká","Lublaňská","Lublaňská","Lublinská","Lubnická","Lucemburská","Lucemburská","Lucinková","Ludmilina","Ludvíkova","Luhovská","Lukavecká","Lukavského","Lukešova","Lukešova","Lukovská","Lukášova","Lumiérů","Lumírova","Lumírova","Luníkovská","Lupenická","Lupáčova","Lutínská","Luční","Luštěnická","Lužanská","Lužecká","Lužická","Lužnická","Lužná","Lužní","Lužská","Lvovská","Lysinská","Lysolajská","Lysolajské Údolí","Lyčkovo Nám.","Lyčkovo Náměstí","Lyžařská","Ládevská","Lánovská","Lánská","Lásenická","Láskova","Lázeňská","Lékařská","Lékořicová","Líbalova","Líbeznická","Lípová","Lískovická","Lísková","Líšnická","Lýskova","M. J. Lermontova","Macešková","Macharovo Nám.","Macharovo Náměstí","Machatého","Machkova","Machnova","Machovcova","Machovická","Machovská","Machuldova","Macháčkova","Madarova","Madaťjanova","Madridská","Magd. Rettigové","Magdalény Rettigové","Magistrů","Magnitogorská","Mahenova","Mahlerovy Sady","Mahulenina","Maiselova","Maiselova","Majerové","Majerského","Makedonská","Makovská","Makovského","Maková","Malachitová","Malebná","Malenická","Malešická","Malešická","Malešická","Malešické Nám.","Malešické Náměstí","Malešovská","Malinová","Maličká","Malkovského","Malletova","Malletova","Malobřevnovská","Malostranské Nábř.","Malostranské Nábřeží","Malostranské Náměstí","Malotická","Malovická","Maltézské Nám.","Maltézské Náměstí","Malá","Malá Bylanská","Malá Houdova","Malá Klášterní","Malá Lada","Malá Michnovka","Malá Plynární","Malá Skloněná","Malá Smidarská","Malá Tyršovka","Malá Xaveriova","Malá Štupartská","Malá Štěpánská","Malátova","Malé Nám.","Malé Náměstí","Malého","Malínská","Malířská","Malý Dvůr","Malý Okrouhlík","Malšovická","Malšovské Nám.","Malšovské Náměstí","Mandloňová","Mandova","Mansfeldova","Manská Zahrada","Mantovská","Manželů Dostálových","Manželů Kotrbových","Manželů Lyčkových","Marciho","Marešova","Marie Cibulkové","Marie Podvalové","Mariánská","Mariánská","Mariánské Hradby","Mariánské Hradby","Mariánské Nám.","Mariánské Náměstí","Markova","Markupova","Markušova","Markvartická","Markyta","Markétská","Maroldova","Martinelliho","Martinická","Martinova","Martinovská","Martinská","Marty Krásové","Marvanova","Maršovská","Masarykovo Nábř.","Masarykovo Nábř.","Masarykovo Nábřeží","Masarykovo Nábřeží","Masná","Matek","Matenská","Maternova","Mateřská","Mateřídoušková","Matjuchinova","Matoušova","Mattioliho","Matúškova","Matěchova","Matějkova","Matějovského","Matějská","Maxovská","Mazancova","Mazovská","Mazurská","Maďarská","Maňákova","Mařatkova","Mařákova","Maříkova","Mašatova","Maškova","Mašovická","Maštěřovského","Mašínova","Mechovka","Mechová","Medinská","Medkova","Medlovská","Medová","Meduňková","Meinlinova","Mejstříkova","Melantrichova","Meliorační","Melodická","Melounová","Menclova","Mendelova","Mendíků","Menšíkova","Menšíkovská","Merhoutova","Merkurova","Meruňková","Meskářova","Meteorologická","Meteorologická","Metodějova","Metujská","Mexická","Mezi Chatami","Mezi Domky","Mezi Domy","Mezi Humny","Mezi Lysinami","Mezi Lány","Mezi Poli","Mezi Potoky","Mezi Rolemi","Mezi Rybníky","Mezi Sklady","Mezi Stráněmi","Mezi Vodami","Mezi Úvozy","Mezi Školami","Mezibranská","Mezihorská","Mezihoří","Mezilehlá","Mezilesní","Mezilesí","Meziluží","Mezipolí","Mezitraťová","Mezitraťová","Mezitraťová","Mezivrší","Meziškolská","Mečislavova","Mečovská","Mečíková","Michalovicova","Michalská","Michelangelova","Michelská","Michelská","Michnova","Michnovka","Mickiewiczova","Mikanova","Mikova","Mikovcova","Mikovická","Mikulandská","Mikuleckého","Mikulova","Mikulovická","Mikuláše Z Husi","Mikulášská","Mikulčická","Mikšovského","Milady Horákové","Milady Horákové","Milady Horákové","Milady Horákové","Milady Horákové","Milana Kadlece","Milenovská","Milerova","Miletická","Miletínská","Milevská","Milevská","Milešovská","Milotická","Milovická","Milovická","Milánská","Milínská","Milíčova","Milíčovská","Mimoňská","Minaříkova","Minerální","Minická","Minská","Miranova","Miroslava Hajna","Miroslava Hamra","Mirotická","Mirotická","Mirovická","Mirošovická","Mirošovská","Mistrovská","Mistřínská","Miřetická","Miškovická","Mladenovova","Mladoboleslavská","Mladoboleslavská","Mladoboleslavská","Mladoboleslavská","Mladoboleslavská","Mladotická","Mladotova","Mladých","Mladých Běchovic","Mladčina","Mladějovská","Mlynářská","Mládeže","Mládežnická","Mládkova","Mládí","Mlázovická","Mlékárenská","Mlýnská","Mlýnská","Mnichovická","Mochovská","Mochovská","Modenská","Modlanská","Modletická","Modletínská","Modravská","Modrá","Modrého","Modřanská","Modřanská","Modřanská","Modřanská","Modřínová","Mohelnická","Mohylová","Mojmírova","Mokrá","Mokřanská","Moldavská","Molitorovská","Molákova","Mongolská","Moravanská","Moravanů","Moravská","Morseova","Morstadtova","Morušová","Morušová","Morávkova","Moskevská","Mostecká","Motolská","Moulíkova","Moysesova","Mozambická","Mozartova","Mošnova","Možného","Mramorová","Mratínská","Mračnická","Mrkosova","Mrkvičkova","Mrákovská","Mrázkova","Mrázovka","Mráčkova","Mrštíkova","Mrštíkova","Muchomůrková","Muchova","Mukařovská","Mukařovského","Murgašova","Murmanská","Musilova","Musorgského","Musílkova","Mutěnínská","Muzejní","Muzikova","Muškova","Mydlářka","Myjavská","Mylnerovka","Myslbekova","Myslbekova","Myslivecká","Myslivečkova","Myslíkova","Myslíkova","Myšlínská","Máchova","Máchova","Mádrova","Májovková","Májová","Málkovská","Mánesova","Márova","Máslova","Máslovická","Mátová","Mílovská","Mílová","Mírová","Mírového Hnutí","Mírového Hnutí","Místecká","Míčova","Míšeňská","Míšovická","Münzbergerových","Mýtní","Měchenická","Měcholupská","Měděnecká","Mělická","Mělnická","Městská","Měsíčková","Měsíční","Měšická","Měšínská","Mšecká","Mšenská","N. A. Někrasova","Na Babách","Na Babě","Na Bahnech","Na Balkáně","Na Balkáně","Na Bambouzku","Na Baních","Na Barikádách","Na Bartoňce","Na Bateriích","Na Bateriích","Na Bačálkách","Na Baště Sv. Jiří","Na Baště Sv. Ludmily","Na Baště Sv. Tomáše","Na Bendovce","Na Benátkách","Na Beránce","Na Betonce","Na Bečvářce","Na Bitevní Pláni","Na Blanici","Na Blanseku","Na Blatech","Na Bluku","Na Bohdalci","Na Bojišti","Na Boleslavce","Na Borovém","Na Botiči","Na Botě","Na Božkovně","Na Brabenci","Na Brázdě","Na Bučance","Na Bělici","Na Bělidle","Na Bělohorské Pláni","Na Břehu","Na Břevnovské Pláni","Na Březince","Na Celné","Na Cestě","Na Chmelnici","Na Chobotě","Na Chodovci","Na Chvalce","Na Chvalské Tvrzi","Na Cihelně","Na Cihlářce","Na Cikorce","Na Cikánce","Na Cimbále","Na Cípu","Na Císařce","Na Dionysce","Na Dlouhé Mezi","Na Dlouhé Mezi","Na Dlouhé Mezi","Na Dlouhé Mezi","Na Dlouhém Lánu","Na Dlážděnce","Na Dlážděnce","Na Dlážděnce","Na Dlážděnce","Na Dobešce","Na Dobré Vodě","Na Dolinách","Na Dolinách","Na Dolnici","Na Dolíku","Na Domovině","Na Doubkové","Na Drahách","Na Dračkách","Na Dračkách","Na Dražkách","Na Dubině","Na Dvorcích","Na Dyrince","Na Dílcích","Na Dílech","Na Dědince","Na Dědinách","Na Děkance","Na Děkance","Na Dělostřílnách","Na Džbánu","Na Fabiánce","Na Farkách","Na Farkáně I","Na Farkáně Ii","Na Farkáně Iii","Na Farkáně Iv","Na Fialce I","Na Fialce Ii","Na Fidlovačce","Na Fišerce","Na Florenci","Na Florenci","Na Floře","Na Folimance","Na Formance","Na Františku","Na Groši","Na Habrovce","Na Habrové","Na Hanspaulce","Na Harfě","Na Havránce","Na Hlavní","Na Hlinách","Na Hloubětínské Vinici","Na Hlídce","Na Holém Vrchu","Na Homolce","Na Homoli","Na Horce","Na Horkách","Na Hradním Vodovodu","Na Hranicích","Na Hranicích","Na Hrobci","Na Hroudě","Na Hroudě","Na Hrádku","Na Hrázi","Na Hubálce","Na Humnech","Na Hupech","Na Hutmance","Na Hutích","Na Hutích","Na Hvížďalce","Na Hvězdárně","Na Hádku","Na Hájku","Na Hřebenech I","Na Hřebenech Ii","Na Hřebenech Ii","Na Hřebenkách","Na Hůrce","Na Jabloňce","Na Jabloňce","Na Jahodách","Na Jarově","Na Jelenách","Na Jelenách","Na Jetelce","Na Jetelce","Na Jezerce","Na Jezerách","Na Jitřence","Na Jivinách","Na Julisce","Na Jílech","Na Jílu","Na Kameni","Na Kampě","Na Kapličce","Na Karlovce","Na Kavčích Horách","Na Kazance","Na Kačence","Na Kačerově","Na Kindlovce","Na Klaudiánce","Na Klaudiánce","Na Kleovce","Na Klikovce","Na Klimentce","Na Klášterním","Na Klínech","Na Klínech","Na Klínku","Na Knížce","Na Kocourkách","Na Kocínce","Na Kodymce","Na Kolejním Statku","Na Komořsku","Na Komořsku","Na Konci","Na Konečné","Na Konvářce","Na Kopanině","Na Kopci","Na Kopečku","Na Kopytářce","Na Korunce","Na Korábě","Na Korálově","Na Kotlářce","Na Koupaliště","Na Kovárně","Na Kozačce","Na Kozinci","Na Košince","Na Košíku","Na Kraji","Na Krocínce","Na Krutci","Na Královce","Na Královně","Na Krčské Stráni","Na Kuthence","Na Kvintusce","Na Květnici","Na Kyjově","Na Křemínku","Na Křenkově","Na Křečku","Na Křivce","Na Křivce","Na Křivce","Na Křivině","Na Křtině","Na Křídle","Na Labuťce","Na Labuťce I","Na Labuťce Ii","Na Labuťce Iii","Na Labuťce Iv","Na Ladách","Na Lahovské","Na Laurové","Na Lepším","Na Lhotech","Na Lhotkách","Na Libušince","Na Losách","Na Louce","Na Loukoti","Na Louži","Na Loužku","Na Luka","Na Lukách","Na Luzích","Na Lučinách","Na Lužci","Na Lysinách","Na Lysině","Na Ládví","Na Lánech","Na Lávce","Na Lázeňce","Na Líše","Na Malovance","Na Malé Šárce","Na Malém Klínu","Na Maninách","Na Manoušce","Na Markvartce","Na Marně","Na Mezi","Na Mlejnku","Na Moklině","Na Mokřině","Na Moráni","Na Močále","Na Mrázovce","Na Musilech","Na Mírách","Na Míčánce","Na Míčánkách","Na Mýtě","Na Můstku","Na Neklance","Na Nežárce","Na Nivách","Na Novině","Na Nové Silnici","Na Náspu","Na Návrati","Na Návrší","Na Návsi","Na Obrátce","Na Obrátce","Na Odbočce","Na Ohradě","Na Okraji","Na Okraji","Na Okrouhlíku","Na Okruhu","Na Opyši","Na Opyši","Na Ostrohu","Na Ostrově","Na Ostrůvku","Na Ovesníku","Na Ovčinách","Na Ovčáckém","Na Ovčíně","Na Ořechovce","Na Padesátníku I","Na Padesátníku Ii","Na Padesátníku Iii","Na Padesátníku Iv","Na Padesátníku V","Na Padesátém","Na Pahorku","Na Pahoubce","Na Palouku","Na Paloučku","Na Pankráci","Na Panorámě","Na Parcelách","Na Parkáně","Na Parukářce","Na Pasece","Na Pasece","Na Pastvinách","Na Pavím Vrchu","Na Pazderce","Na Pecích","Na Pernikářce","Na Perštýně","Na Petynce","Na Petynce","Na Petřinách","Na Petřinách","Na Placích","Na Planině","Na Plužině","Na Plzeňce","Na Plácku","Na Pláni","Na Plískavě","Na Podkovce","Na Pokraji","Na Pokraji","Na Poli","Na Polníku","Na Pomezí","Na Pomezí","Na Popelce","Na Popelce","Na Potůčku","Na Poustkách","Na Pozorce","Na Poříčním Právu","Na Poříčí","Na Poříčí","Na Požáru","Na Požáru","Na Pramenech","Na Pramenech","Na Prosecké Vyhlídce","Na Proseku","Na Prostřední Cestě","Na Proutcích","Na Provaznici","Na Průhonu","Na Průseku","Na Pučálce","Na Pískovně","Na Písku","Na Pískách","Na Pěkné Vyhlídce","Na Pěšinách","Na Pěšinách","Na Pěšině","Na Předevsi","Na Přesypu","Na Přesypu","Na Přídole","Na Příkopě","Na Příkopě","Na Přívozích","Na Příčce","Na Příčné Mezi","Na Radosti","Na Radosti","Na Rampách","Na Rejdišti","Na Roháčku","Na Rokytce","Na Rolích","Na Rovinách","Na Rovině","Na Rovni","Na Rovnosti","Na Rovném","Na Rozcestí","Na Rozdílu","Na Rozdílu","Na Rozhledu","Na Rozhraní","Na Rozhraní","Na Rozvodí","Na Ročkově","Na Rybníčku","Na Rybářce","Na Rybářce","Na Rymáni","Na Rynku","Na Salabce","Na Samotě","Na Schodech","Na Schůdkách","Na Sedlišti","Na Sekyrce","Na Selském","Na Seníku","Na Skalce","Na Skalách","Na Sklonku","Na Skále","Na Slatince","Na Slatinách","Na Slatinách","Na Slatinách","Na Slavíkově","Na Slovance","Na Slupi","Na Slupi","Na Smetance","Na Souvrati","Na Souvrati","Na Spojce","Na Spádu","Na Spáleništi","Na Srpečku","Na Srázu","Na Srážku","Na Staré","Na Staré Cestě","Na Staré Návsi","Na Staré Silnici","Na Staré Vinici","Na Stezce","Na Stezce","Na Struze","Na Stráni","Na Stráňkách","Na Stráži","Na Stráži","Na Strži","Na Strži","Na Stupních","Na Stárce","Na Stírce","Na Střelnici","Na Svahu","Na Svěcence","Na Sychrově","Na Sychrově","Na Sypkém","Na Sypčině","Na Sádce","Na Terase","Na Topolce","Na Topolce","Na Truhlářce","Na Tržišti","Na Tykačce","Na Táboře","Na Třebešíně","Na Třebešíně","Na Universitním Statku","Na Usedlosti","Na Vackově","Na Valech","Na Valentince","Na Vartě","Na Vaňhově","Na Veselí","Na Vidouli","Na Viktorce","Na Vinici","Na Viničce","Na Viničkách","Na Viničních Horách","Na Vinobraní","Na Vinohradu","Na Višňovce","Na Vlasačce","Na Vlastní Půdě","Na Vlastním","Na Vlku","Na Vlčovce","Na Volánové","Na Vrchmezí","Na Vrchmezí","Na Vrchmezí","Na Vrcholu","Na Vrchu","Na Vrchu","Na Vrchách","Na Vrchách","Na Vrstevnici","Na Vrstvách","Na Vršku","Na Vrškách","Na Vrších","Na Vrších","Na Vydrholci","Na Vyhlídce","Na Vypichu","Na Vypichu","Na Vysoké I","Na Vysoké I","Na Vysoké Ii","Na Vysočanských Vinicích","Na Vysočině","Na Václavce","Na Vápence","Na Vápenném","Na Vítězné Pláni","Na Výběžku","Na Výhledech","Na Výhonku","Na Výrovně","Na Výsledku I","Na Výsledku Ii","Na Výsluní","Na Výspě","Na Výspě","Na Výstupu","Na Výtoni","Na Výši","Na Výšince","Na Výšinách","Na Výšině","Na Věnečku","Na Větrníku","Na Větrníku","Na Větrově","Na Větru","Na Zahrádkách","Na Zatlance","Na Zavadilce","Na Zbořenci","Na Zderaze","Na Zedníkové","Na Zelené Louce","Na Zemance","Na Zkratce","Na Zlatnici","Na Zlaté","Na Zlíchově","Na Zlíchově","Na Zmrzlíku","Na Znělci","Na Zvoničce","Na Zábradlí","Na Záhonech","Na Zájezdu","Na Zámecké","Na Zámkách","Na Zámyšli","Na Zástřelu","Na Zástřelu","Na Zátorce","Na Zátorách","Na Závěji","Na Úbočí","Na Úhoru","Na Úlehli","Na Úseku","Na Úspěchu","Na Černé Hoře","Na Černé Strouze","Na Černém Vrchu","Na Července","Na Čečeličce","Na Čihadle","Na Čisté","Na Říháku","Na Šabatce","Na Šachtě","Na Šafránce","Na Šancích","Na Šedivé","Na Šejdru","Na Šejdru","Na Šmukýřce","Na Špejcharu","Na Špitálce","Na Špitálsku","Na Štamberku","Na Štěpnici","Na Šubě","Na Šumavě","Na Šutce","Na Švihance","Na Šťáhlavce","Na Žertvách","Na Žvahově","Naardenská","Nad Akcízem","Nad Akáty","Nad Alejí","Nad Belvederem","Nad Belárií","Nad Berounkou","Nad Bertramkou","Nad Botičem","Nad Bořislavkou","Nad Bořislavkou","Nad Branickým Pivovarem","Nad Brůdkem","Nad Brůdkem","Nad Buďánkami I","Nad Buďánkami Ii","Nad Buďánkami Iii","Nad Cementárnou","Nad Chaloupkami","Nad Chuchlí","Nad Cihelnou","Nad Dalejským Údolím","Nad Doly","Nad Dolíky","Nad Drahou","Nad Dubovým Mlýnem","Nad Dvorem","Nad Dálnicí","Nad Elektrárnou","Nad Elektrárnou","Nad Flajšnerkou","Nad Habrovkou","Nad Havlem","Nad Helmrovkou","Nad Hercovkou","Nad Hercovkou","Nad Hliníkem","Nad Hliníkem","Nad Horizontem","Nad Hradním Potokem","Nad Hradním Vodojemem","Nad Husovými Sady","Nad Hutěmi","Nad Hutěmi","Nad Hájem","Nad Hřištěm","Nad Jenerálkou","Nad Jetelkou","Nad Jezem","Nad Jezerkou","Nad Jordánkem","Nad Kajetánkou","Nad Kamínkou","Nad Kaplankou","Nad Kapličkou","Nad Kavalírkou","Nad Kazankou","Nad Kazínem","Nad Kelerkou","Nad Kesnerkou","Nad Klamovkou","Nad Klikovkou","Nad Klíčovem","Nad Kolonií","Nad Kolčavkou","Nad Komornickou","Nad Konečnou","Nad Konvářkou","Nad Kostelem","Nad Kotlaskou I","Nad Kotlaskou Ii","Nad Kotlaskou Iii","Nad Kotlaskou Iv","Nad Kotlaskou V","Nad Koulkou","Nad Koupadly","Nad Koupalištěm","Nad Košinkou","Nad Košíkem","Nad Krocínkou","Nad Krocínkou","Nad Královskou Oborou","Nad Kuliškou","Nad Kundratkou","Nad Kundratkou","Nad Kundratkou","Nad Křížkem","Nad Laurovou","Nad Lesem","Nad Lesním Divadlem","Nad Lesíkem","Nad Libeňským Nádražím","Nad Libeřským Potokem","Nad Libušským Potokem","Nad Libří","Nad Lomem","Nad Lomy","Nad Lukami","Nad Lávkou","Nad Malým Mýtem","Nad Manovkou","Nad Markytou","Nad Mazankou","Nad Meandry","Nad Mlynářkou","Nad Mlýnem","Nad Mlýnským Potokem","Nad Mohylou","Nad Mokřinou","Nad Mostem","Nad Motolskou Nemocnicí","Nad Motolskou Nemocnicí","Nad Mrázovkou","Nad Mušlovkou","Nad Mušlovkou","Nad Novou Libní","Nad Nuslemi","Nad Nádražím","Nad Nádrží","Nad Náhonem","Nad Náměstím","Nad Návsí","Nad Obcí I","Nad Obcí Ii","Nad Octárnou","Nad Odbočkou","Nad Ohradou","Nad Okrouhlíkem","Nad Olšinami","Nad Olšinami","Nad Ondřejovem","Nad Opatovem","Nad Ostrovem","Nad Pahorkem","Nad Palatou","Nad Panenskou","Nad Parkem","Nad Parkánem","Nad Paťankou","Nad Pentlovkou","Nad Petruskou","Nad Petynkou","Nad Plynovodem","Nad Podbabskou Skálou","Nad Pomníkem","Nad Popelkou","Nad Popelářkou","Nad Potůčkem","Nad Prahou","Nad Pramenem","Nad Primaskou","Nad Primaskou","Nad Propustí","Nad Pruhy","Nad Pískovnou","Nad Přehradou","Nad Přívozem","Nad Radotínem","Nad Rohatci","Nad Roklí","Nad Rokoskou","Nad Rokytkou","Nad Rybníkem","Nad Rybníkem","Nad Rybníčky","Nad Ryšánkou","Nad Rážákem","Nad Sadem","Nad Sady","Nad Santoškou","Nad Schody","Nad Skálou","Nad Slávií","Nad Slávií","Nad Smetankou","Nad Sokolovnou","Nad Soutokem","Nad Soutokem","Nad Splavem","Nad Spádem","Nad Spáleným Mlýnem","Nad Stanicí","Nad Starou Pískovnou","Nad Statkem","Nad Strakovkou","Nad Strouhou","Nad Strání","Nad Strání","Nad Studánkou","Nad Svahem","Nad Sýpkou","Nad Tejnkou","Nad Teplárnou","Nad Topoly","Nad Tratí","Nad Trnkovem","Nad Trojou","Nad Turbovou","Nad Třebešínem I","Nad Třebešínem Ii","Nad Třebešínem Ii","Nad Třebešínem Iii","Nad Třebešínem Iii","Nad Vavrouškou","Nad Vernerákem","Nad Vinicí","Nad Vinným Potokem","Nad Vinným Potokem","Nad Vinným Potokem","Nad Vinohradem","Nad Višňovkou","Nad Vltavou","Nad Vodovodem","Nad Vodovodem","Nad Vojenským Hřbitovem","Nad Vokolky","Nad Volyňkou","Nad Vrbami","Nad Vrstvami","Nad Vršovskou Horou","Nad Vsí","Nad Vysočany","Nad Václavkou","Nad Výpustí","Nad Výšinkou","Nad Zahradnictvím","Nad Zatáčkou","Nad Zavážkou","Nad Zbraslaví","Nad Zbrojnicí","Nad Zemankou","Nad Zemankou","Nad Zlatnicí","Nad Zlíchovem","Nad Záložnou","Nad Zámečkem","Nad Zámečnicí","Nad Zátiším","Nad Závodištěm","Nad Závěrkou","Nad Údolím","Nad Údolím Hvězd","Nad Úpadem","Nad Úvozem","Nad Úžlabinou","Nad Úžlabinou","Nad Šafránkou","Nad Šancemi","Nad Šauerovými Sady","Nad Šeberákem","Nad Šejdrem","Nad Šestikopy","Nad Šetelkou","Nad Štolou","Nad Šutkou","Nad Šálkovnou","Nad Šárkou","Nad Želivkou","Nad Žlábkem","Nademlejnská","Nadějovská","Narcisová","Naskové","Natanaelka","Navarova","Navigátorů","Navrátilova","Načeradecká","Načešická","Neapolská","Nebeského","Nebovidská","Nebozízek-Sady","Nebušická","Nechanická","Nechanského","Nechvalická","Nechvílova","Nechybova","Nedašovská","Nedbalova","Nedokončená","Nedokončená","Nedošínské","Nedražická","Nedvědická","Nedvědovo Nám.","Nedvědovo Náměstí","Nedvězská","Neffova","Nefritová","Neherovská","Nehvizdská","Nehvizdská","Nejdkova","Neklanova","Nekvasilova","Nekázanka","Nemocniční","Nemošická","Nepasické Nám.","Nepasické Náměstí","Nepelova","Nepilova","Nepomucká","Nepomuckých","Nepovolená","Nepravidelná","Neprůjezdná","Nepálská","Neratovická","Nerudova","Nerudova","Nesměřická","Nespecká","Nesvadbova","Netlucká","Netluky","Netolická","Netušilská","Netínská","Netřebická","Netřebská","Neumannova","Neustupného","Neužilova","Nevanova","Neveklovská","Newtonova","Nezamyslova","Nezdova","Nezvalova","Nečova","Nešporova","Nežárská","Nickerleho","Niederleho","Nikodémova","Nikoly Tesly","Nikoly Vapcarova","Niská","Nitranská","Nitranská","Nivnická","Nobelova","Norbertov","Norská","Nosická","Nosticova","Notečská","Noutonická","Nouzov","Nouzovské Nám.","Nouzovské Náměstí","Nouzová","Novgorodská","Novobohdalecká","Novoborská","Novoborská","Novochuchelská","Novodvorská","Novodvorská","Novodvorská","Novodvorská","Novohradská","Novohrádecká","Novohrádecká","Novolhotská","Novolipanská","Novomeského","Novomeského","Novomlýnská","Novopacká","Novopetrovická","Novorossijská","Novosibřinská","Novostrašnická","Novosuchdolská","Novosvětská","Novotného Lávka","Novoveská","Novoveská","Novovysočanská","Novovysočanská","Novovysočanská","Novozámecká","Novozámecká","Novoškolská","Novoštěrboholská","Nová","Nová Cesta","Nová Kolonie","Nová Ves","Nová Ves","Nová Šárka","Novákovo Nám.","Novákovo Náměstí","Novákových","Nové Domy","Nové Dvory","Nové Mlýny","Nové Náměstí","Nového","Nový Lesík","Nový Svět","Nový Zlíchov","Nový Zlíchov","Nupacká","Nuselská","Nuselská","Nučická","Nušlova","Nymburská","Nábř. Edvarda Beneše","Nábř. Edvarda Beneše","Nábř. Edvarda Beneše","Nábř. Kapitána Jaroše","Nábř. Kapitána Jaroše","Nábřežní","Nábřeží Edvarda Beneše","Nábřeží Edvarda Beneše","Nábřeží Edvarda Beneše","Nábřeží Kapitána Jaroše","Nábřeží Ludvíka Svobody","Náchodská","Nádražní","Nádražní","Nádvorní","Náhorní","Nákupní","Nám. 14. Října","Nám. 25. Března","Nám. Antonína Pecáka","Nám. Barikád","Nám. Bořislavka","Nám. Bratří Synků","Nám. Chuchelských Bojovníků","Nám. Chuchleských Bojovníků","Nám. Curieových","Nám. Dr. V. Holého","Nám. Franze Kafky","Nám. Generála Kutlvašra","Nám. Hrdinů","Nám. I. P. Pavlova","Nám. Interbrigády","Nám. Jana Palacha","Nám. Jana Palacha","Nám. Jiřího Berana","Nám. Jiřího Z Lobkovic","Nám. Jiřího Z Poděbrad","Nám. Jiřího Z Poděbrad","Nám. Josefa Machka","Nám. Kinských","Nám. Kinských","Nám. Mezi Zahrádkami","Nám. Na Balabence","Nám. Na Farkáně","Nám. Na Lužinách","Nám. Na Santince","Nám. Na Stráži","Nám. Omladiny","Nám. Osvoboditelů","Nám. Padlých","Nám. Pod Kaštany","Nám. Pod Lípou","Nám. Prezidenta Masaryka","Nám. Před Bateriemi","Nám. Republiky","Nám. Smiřických","Nám. Svatopluka Čecha","Nám. Svobody","Nám. U Lva","Nám. U Lípy Svobody","Nám. U Svatého Jiří","Nám. Winstona Churchilla","Nám. Českého Povstání","Nám.Organizace Spojených Národ","Nám.Plukovníka Vlčka","Náměstí 14. Října","Náměstí 25. Března","Náměstí Antonína Pecáka","Náměstí Barikád","Náměstí Bořislavka","Náměstí Bořislavka","Náměstí Bratří Jandusů","Náměstí Bratří Synků","Náměstí Chuchelských Bojovníků","Náměstí Curieových","Náměstí Dr. Václava Holého","Náměstí Generála Kutlvašra","Náměstí Hrdinů","Náměstí I. P. Pavlova","Náměstí Interbrigády","Náměstí Jana Palacha","Náměstí Jana Palacha","Náměstí Jiřího Berana","Náměstí Jiřího Z Lobkovic","Náměstí Jiřího Z Poděbrad","Náměstí Jiřího Z Poděbrad","Náměstí Josefa Machka","Náměstí Junkových","Náměstí Kinských","Náměstí Kinských","Náměstí Kosmonautů","Náměstí Mezi Zahrádkami","Náměstí Míru","Náměstí Na Balabence","Náměstí Na Farkáně","Náměstí Na Lužinách","Náměstí Na Santince","Náměstí Na Stráži","Náměstí Omladiny","Náměstí Organizace Spojených Národů","Náměstí Osvoboditelů","Náměstí Padlých","Náměstí Plukovníka Vlčka","Náměstí Pod Emauzy","Náměstí Pod Kaštany","Náměstí Pod Lípou","Náměstí Prezidenta Masaryka","Náměstí Protifašistických Bojovníků","Náměstí Před Bateriemi","Náměstí Přátelství","Náměstí Republiky","Náměstí Republiky","Náměstí Smiřických","Náměstí Sv. Petra A Pavla","Náměstí Svatopluka Čecha","Náměstí Svobody","Náměstí U Lva","Náměstí U Lípy Svobody","Náměstí U Svatého Jiří","Náměstí Winstona Churchilla","Náměstí Zdenky Braunerové","Náměstí Českého Povstání","Náplavní","Náprstkova","Národní","Národní","Národní Obrany","Národních Hrdinů","Nárožní","Násirovo Nám.","Násirovo Náměstí","Nástrojářská","Návazná","Návršní","Návětrná","Návětrná","Názovská","Nýdecká","Nýrská","Nýřanská","Němčická","Něvská","Obchodní","Obchodní Nám.","Obchodní Náměstí","Obilní","Objízdná","Oblouková","Obora Hvězda","Oborská","Obrataňská","Obrovského","Obsiny","Obslužná","Obvodová","Obědovická","Obětí 6. Května","Obětí 6.Května","Ocelkova","Ocelářská","Ocelářská","Ocelíkova","Ochozská","Ochranovská","Od Rozcestí","Od Vysoké","Od Školy","Odboje","Odborů","Odbočná","Oddechová","Oddělená","Oderská","Odlehlá","Ohmova","Ohnivcova","Ohnišťanská","Ohradní","Ohradní","Ohradská","Ohradské Nám.","Ohradské Náměstí","Ohrobecká","Okenská","Okořská","Okrajní","Okrajová","Okrajová","Okrasná","Okrouhlická","Okrouhlíkova","Okrová","Okruhová","Okružní","Okružní","Okřínecká","Olbrachtova","Olbramovická","Oldřichova","Olešnická","Olešská","Olgy Havlové","Olivova","Olomoucká","Olympijská","Olšanská","Olšanské Nám.","Olšanské Náměstí","Olšovická","Olšová","Olštýnská","Omladinářů","Omská","Ondřejovská","Ondříčkova","Ondříčkova","Onšovecká","Opata Konráda","Opatovická","Opatovská","Opatovská","Opatřilka","Opatřilka","Opařanská","Oplanská","Opletalova","Opolská","Opočenská","Opočínská","Opravářská","Opuková","Opálkova","Opálová","Oravská","Ordovická","Orebitská","Orelská","Orlická","Ortenovo Náměstí","Osadní","Osamocená","Osecká","Osetá","Osická","Osiková","Osinalická","Osluněná","Osmého Listopadu","Osnická","Osnická","Osnická","Ostravická","Ostravská","Ostromečská","Ostrov Štvanice","Ostrovní","Ostrovského","Ostruženská","Ostružinová","Ostrá","Ostrčilovo Nám.","Ostrčilovo Náměstí","Ostředecká","Ostřicová","Osvobození","Osvětová","Otakara Vrby","Otakarova","Otavova","Otavova","Otavská","Otevřená","Otická","Otlíkovská","Otopašská","Otovická","Otradovická","Ottova","Otvovická","Oty Pavla","Otínská","Otěšínská","Ouholická","Ouhrabkova","Ovenecká","Ovenecká","Ovesná","Ovocná","Ovocnářská","Ovocný Trh","Ovsíková","Oválová","Ovčárská","Ovčí Hájek","Ořechová","Ořešská","Paběnická","Paběnická","Pacajevova","Paceřická","Pacholíkova","Pacovská","Paculova","Padovská","Pajerova","Pakoměřická","Palackého","Palackého Nám.","Palackého Náměstí","Palmetová","Palmovka","Paláskova","Pampelišková","Pancířova","Panelová","Panenky","Panenská","Pankrácké Náměstí","Panská","Panská Zahrada","Panský Dvůr","Panuškova","Paprsková","Papírenská","Papírníkova","Parašutistů","Pardubická","Park Přátelství","Parková","Parléřova","Parléřova","Parmská","Paroplavební","Partyzánská","Pasecká","Pasteurova","Pastevců","Patočkova","Patočkova","Patočkova","Pavelkova","Pavla Beneše","Pavla Švandy Ze Semčic","Pavlická","Pavlišovská","Pavlovická","Pavlovská","Pavlíkova","Pavrovského","Paříkova","Pařízkova","Pařížská","Pařížská","Paškova","Paťanka","Peceradská","Pecharova","Pechlátova","Pechlátova","Pecháčkova","Peckova","Pejevové","Pekařova","Pekařova","Pekařská","Pekárenská","Pekárkova","Pelclova","Pelechovská","Pelhřimovská","Pelikánova","Pelléova","Pelléova","Pelnářova","Pelušková","Pelyňková","Pelzova","Penízovková","Perlitová","Perlitová","Perlová","Pernerova","Pernerova","Peroutkova","Peroutkova","Peroutkova","Peroutkova","Perspektivní","Pertoldova","Perucká","Perunova","Perštejnská","Petra Bezruče","Petra Rezka","Petra Slezáka","Petrbokova","Petrklíčová","Petrohradská","Petrovická","Petrovská","Petrská","Petrské Nám.","Petrské Náměstí","Petráčkova","Petržílkova","Petržílova","Petýrkova","Petříkova","Petříkovská","Petřínská","Petřínská","Petřínské Sady","Petřínské Sady","Pevnostní","Pečárková","Pešinova","Peškova","Pešlova","Pešova","Peštukova","Pešákova","Picassova","Pickova","Pihelská","Pikovická","Pikrtova","Pilařská","Pilníkovská","Pilotů","Pilovská","Pilovská","Pilská","Pirinská","Pirnerova","Pitkovická","Pitterova","Pivcova","Pivovarnická","Pivovarská","Pivoňková","Pištěkova","Placina","Placina","Plajnerova","Plamínkové","Plaská","Platanová","Platnéřská","Platónova","Plavecká","Plavínová","Plačická","Plaňanská","Plevenská","Plečnikova","Plhovská","Plickova","Plkovská","Plojharova","Ploskovická","Ploučnická","Plovdivská","Plošná","Ploštilova","Plukovníka Mráze","Plumlovská","Plutova","Plynární","Plzeňská","Plzeňská","Plzeňská","Plzeňská","Plzeňská","Plánická","Pláničkova","Poberova","Pobočná","Pobořská","Poběžovická","Pobřežní","Pobřežní Cesta","Pod Akáty","Pod Altánem","Pod Altánem","Pod Andělkou","Pod Areálem","Pod Aritmou","Pod Ateliéry","Pod Bahnivkou","Pod Balkánem","Pod Barvířkou","Pod Bateriemi","Pod Baštami","Pod Belvederem","Pod Belárií","Pod Beránkem","Pod Beránkou","Pod Betání","Pod Bohdalcem I","Pod Bohdalcem I","Pod Bohdalcem Ii","Pod Brentovou","Pod Bruskou","Pod Buďánkou","Pod Bání","Pod Březinou","Pod Chaloupkami","Pod Chodovem","Pod Cihelnou","Pod Cihelnou","Pod Cukrákem","Pod Císařkou","Pod Dlážděnkou","Pod Domky","Pod Drinopolem","Pod Dráhou","Pod Duby","Pod Dvorem","Pod Dálnicí","Pod Děkankou","Pod Děkankou","Pod Děvínem","Pod Farou","Pod Fialkou","Pod Formankou","Pod Fořtem","Pod Garážemi","Pod Habrovkou","Pod Habrovou","Pod Haltýřem","Pod Harfou","Pod Havlínem","Pod Havránkou","Pod Havránkou","Pod Hliništěm","Pod Hloubětínskou Zastávkou","Pod Hláskem","Pod Homolkou","Pod Hotelem","Pod Hořavkou","Pod Hrachovkou","Pod Hradbami","Pod Hradem","Pod Hranicí","Pod Hrází","Pod Hvězdou","Pod Hvězdárnou","Pod Hvězdárnou","Pod Hybšmankou","Pod Hájem","Pod Hájkem","Pod Hájovnou","Pod Hřbitovem","Pod Hřištěm","Pod Jalovým Dvorem","Pod Jankovem","Pod Jarovem","Pod Javory","Pod Jiráskovou Čtvrtí","Pod Juliskou","Pod Kamínkou","Pod Kapličkou","Pod Kapličkou","Pod Karlovarskou Silnicí","Pod Karlovem","Pod Kavalírkou","Pod Kaštany","Pod Kaštany","Pod Kesnerkou","Pod Kladenskou Silnicí","Pod Klamovkou","Pod Klapicí","Pod Klaudiánkou","Pod Klikovkou","Pod Kopcem","Pod Kostelem","Pod Kotlaskou","Pod Kotlářkou","Pod Kotlářkou","Pod Kotlářkou","Pod Krejcárkem","Pod Krocínkou","Pod Královkou","Pod Krčským Lesem","Pod Kulturním Domem","Pod Kynclovkou","Pod Křížem","Pod Křížkem","Pod Labuťkou","Pod Lahovskou","Pod Lesem","Pod Lesíkem","Pod Letištěm","Pod Lečí","Pod Lipami","Pod Lipkami","Pod Lisem","Pod Lisem","Pod Lochkovem","Pod Lomem","Pod Lysinami","Pod Lázní","Pod Marjánkou","Pod Markétou","Pod Martinem","Pod Meliškou","Pod Mlýnkem","Pod Mohylou","Pod Mostem","Pod Napětím","Pod Nouzovem","Pod Novou Školou","Pod Novým Lesem","Pod Novým Lesem","Pod Nuselskými Schody","Pod Náměstím","Pod Náplavkou","Pod Náplavkou","Pod Náspem","Pod Návsí","Pod Oborou","Pod Ovčínem","Pod Ořechovkou","Pod Palatou","Pod Palírkou","Pod Parukářkou","Pod Paťankou","Pod Paťankou","Pod Pekařkou","Pod Pekárnami","Pod Petřinami","Pod Plynojemem","Pod Plynojemem","Pod Plynojemem","Pod Plískavou","Pod Poštou","Pod Pramenem","Pod Prodejnou","Pod Průsekem","Pod Písečnou","Pod Přehradou","Pod Přesypem","Pod Radnicí","Pod Rapidem","Pod Rapidem","Pod Rapidem","Pod Remízkem","Pod Rovinou","Pod Rozvodnou","Pod Rybníkem","Pod Rybníčkem","Pod Sady","Pod Salabkou","Pod Sirénou","Pod Skalkou","Pod Skalou","Pod Sklenářkou","Pod Slovany","Pod Smetankou","Pod Sokolovnou","Pod Soutratím","Pod Spalovnou","Pod Spiritkou","Pod Spravedlností","Pod Srázem","Pod Stadiony","Pod Stanicí","Pod Starou Školou","Pod Starákem","Pod Statky","Pod Strašnickou Vinicí","Pod Strojírnami","Pod Strání","Pod Studánkou","Pod Stupni","Pod Stárkou","Pod Stárkou","Pod Stírkou","Pod Svahem","Pod Sychrovem I","Pod Sychrovem I","Pod Sychrovem I","Pod Sychrovem Ii","Pod Sídlištěm","Pod Terasami","Pod Terebkou","Pod Topoly","Pod Tratí","Pod Turnovskou Tratí","Pod Turnovskou Tratí","Pod Táborem","Pod Táborem","Pod Třebešínem","Pod Třešněmi","Pod Třešňovkou","Pod Urnovým Hájem","Pod Valem","Pod Vartou","Pod Vavřincem","Pod Velkým Hájem","Pod Viaduktem","Pod Vidoulí","Pod Viktorkou","Pod Vilami","Pod Vinicemi","Pod Vinicí","Pod Vinohradem","Pod Višňovkou","Pod Vlachovkou","Pod Vlastním Krovem","Pod Vlkem","Pod Vodojemem","Pod Vodovodem","Pod Vodárenskou Věží","Pod Vrchem","Pod Vrcholem","Pod Vrstevnicí","Pod Vrškem","Pod Vrškem","Pod Vršovickou Vodárnou I","Pod Vršovickou Vodárnou Ii","Pod Vršovickou Vodárnou Iii","Pod Vsí","Pod Vyhlídkou","Pod Vysokou","Pod Vysokou Mezí","Pod Vysílačkou","Pod Vyšehradem","Pod Václavem","Pod Vítkovem","Pod Výtopnou","Pod Výšinkou","Pod Větrolamem","Pod Větrovem","Pod Věží","Pod Zahradami","Pod Zahrádkami","Pod Zastávkou","Pod Zatáčkou","Pod Zbuzany","Pod Zemankou","Pod Zličínem","Pod Zvonařkou","Pod Zvoničkou","Pod Zámečkem","Pod Závěrkou","Pod Útesy","Pod Čertovou Skalou","Pod Čihadlem","Pod Čimickým Hájem","Pod Šancemi","Pod Školou","Pod Šmukýřkou","Pod Špejcharem","Pod Špitálem","Pod Štěpem","Pod Žvahovem","Podbabská","Podbabská","Podbělohorská","Podbělová","Podchýšská","Podedvorská","Podhajská Pole","Podholí","Podhorská","Podhořská","Podivínská","Podjavorinské","Podjezd","Podkovářská","Podkrkonošská","Podkrkonošských Tkalců","Podle Kačerova","Podle Lomu","Podle Lomu","Podle Náhonu","Podle Náhonu","Podle Sadů","Podle Trati","Podlesek","Podleská","Podlesní","Podlešínská","Podlibská","Podlipného","Podlišovská","Podlužanská","Podléšková","Podnikatelská","Podnádražní","Podohradská","Podolanská","Podolská","Podolská","Podolské Nábř.","Podolské Nábřeží","Podolské Schody","Podpěrova","Podskalská","Podsychrovská","Podvinný Mlýn","Podvinný Mlýn","Podzámecká","Podéšťova","Poděbradova","Poděbradova","Poděbradská","Poděbradská","Poděbradská","Podůlší","Pohledná","Pohnertova","Pohořelec","Pohořelec","Pokojná","Pokorného","Pokřivená","Polabská","Polabská","Polaneckého","Polední","Polední","Polenská","Polepská","Poleradská","Polesná","Polešovická","Politických Vězňů","Poličanská","Poljanovova","Polní","Polovnická","Polská","Polygrafická","Polákova","Poláčkova","Políkenská","Polívkova","Pomezní","Pomněnková","Pomořanská","Ponrepova","Poplužní","Popovická","Popovova","Poslední","Pospíchalova","Pospíšilova","Postlova","Postranní","Postupická","Postřekovská","Postřižínská","Postřižínská","Potocká","Potoční","Pouchova","Poupětova","Poustka","Povltavská","Povltavská","Povltavská","Povodňová","Pozdeňská","Poznaňská","Počeradská","Počernická","Počernická","Počátecká","Počátecká","Poříčanská","Poříčanská","Poříčská","Pošepného Nám.","Pošepného Náměstí","Poštovská","Požárnická","Pplk. Nováčka","Pplk. Sochora","Prachatická","Prachnerova","Prachovická","Prachovská","Pramenná","Pramenná","Pravoúhlá","Pravská","Pravá","Prašná","Pražská","Pražského","Pražského Povstání","Pražský Okruh","Pražákovská","Prefátova","Preislerova","Preláta","Prelátská","Preslova","Primátorská","Probluzská","Proboštská","Procházkova","Prodloužená","Prokofjevova","Prokopka","Prokopova","Prokopovo Nám.","Prokopovo Náměstí","Prokopových","Prokopská","Prokopské Údolí","Prokopské Údolí","Prorektorská","Prosecká","Prosecká","Prosecká","Prosincová","Prosluněná","Prosná","Prostřední","Proti Proudu","Protilehlá","Protivínská","Proutěná","Prouzova","Provaznická","Provozní","Prunéřovská","Prusická","Prusíkova","Prušánecká","Prvního Pluku","Prvního Pluku","Prvomájová","Prácheňská","Práčská","Průběžná","Průchodní","Průchova","Průhledová","Průhonek","Průhonek","Průhonická","Průhonská","Průjezdná","Průmyslová","Průmyslová","Průmyslová","Průmyslová","Průtažní","Průčelní","Průškova","Psohlavců","Pstružná","Psárská","Ptáčnická","Puchmajerova","Puchmajerova","Pujmanové","Pujmanové","Pujmanové","Purkrabská","Purkyňova","Putimská","Pučova","Puškinovo Nám.","Puškinovo Náměstí","Pyšelská","Pálavská","Pálkařská","Pámelníková","Pánkova","Pátkova","Pávovské Náměstí","Písecká","Píseckého","Písečná","Pískařská","Pískovcová","Pískovna","Písková","Písnická","Písnická","Písnické Zahrady","Písčitá","Píškova","Píšovická","Pöslova","Púchovská","Púchovská","Pýchavková","Pýrová","Pěnkaví","Pěstitelská","Pětidomí","Pětipeského","Pěší","Přecechtělova","Přechodní","Před Cibulkami","Před Dráhou","Před Mosty","Před Nádražím","Před Oborou","Před Rybníkem","Před Skalkami I","Před Skalkami Ii","Před Skálou","Před Sokolovnou","Před Tratí","Před Ústavem","Předbořská","Předměřická","Přední","Předpolní","Předposlední","Předvoje","Předvoje","Předškolní","Přeletová","Přeloučská","Přemyslova","Přemyslovská","Přemyslovská","Přemyšlenská","Přerušená","Přesličková","Přespolní","Přetlucká","Přeučilova","Převoznická","Přezletická","Přeštická","Přeštínská","Přeťatá","Při Hranici","Při Hranici","Při Trati","Přibyslavská","Přibíkova","Přistoupimská","Přádova","Přátelství","Příborská","Příbramská","Příběnická","Příchovická","Přídolská","Příkrá","Přílepská","Přímské Nám.","Přímské Náměstí","Přímá","Přímětická","Přípotoční","Přípřežní","Přírodní","Přístavní","Přívorská","Přívozní","Příčka","Příčná","Pšeničná","Pšenčíkova","Pšovanská","Pštrossova","Půdova","Půlkruhová","Půlnoční","Půtova","R.A. Dvorského","Rabasova","Rabyňská","Rackova","Rackova Zahrada","Radbuzská","Radechovská","Radešovská","Radhošťská","Radhošťská","Radimova","Radimovická","Radimská","Radiová","Radiová","Radistů","Radkovská","Radlická","Radlická","Radlická","Radnické Schody","Radomská","Radonická","Radostavická","Radostná","Radotínská","Radotínská","Radouňova","Radouňova","Radouňova","Radova","Radovská","Radošovická","Radvanická","Radúzova","Radčina","Radějovská","Raffaelova","Raichlova","Raisova","Rajhradská","Rajmonova","Rajská","Rakousova","Rakovnická","Rakovského","Randova","Ranská","Ratajova","Ratajská","Ratbořská","Ratibořická","Ratibořská","Ratibořská","Ravennská","Račická","Račiněveská","Rašilovova","Rašova","Rašovická","Rašovská","Rašínovo Nábř.","Rašínovo Nábř.","Rašínovo Nábřeží","Rašínovo Nábřeží","Rašínská","Ražická","Reinerova","Rejchova","Rejskova","Rekreační","Rektorská","Rembrandtova","Remízková","Renoirova","Resslova","Revoluce","Revoluční","Revoluční","Rezedová","Rezlerova","Rečkova","Richtrova","Riegrova","Riegrovy Sady","Rilská","Ringhofferova","Ringhofferova","Rižská","Roblínská","Rochovská","Rochovská","Rodopská","Rodovská","Rodvinovská","Roentgenova","Rohanovská","Rohanské Nábřeží","Rohanský Ostrov","Rohatecká","Rohenická","Rohlovská","Rohová","Rohozecká","Rohožnická","Roháčova","Roithova","Rojická","Roklova","Rokycanova","Rokycanská","Rokytnická","Rokytná","Rolnická","Rolní","Romaina Rollanda","Romana Blahníka","Ronalda Reagana","Ronešova","Ronkova","Ronovská","Rooseveltova","Rorýsová","Rosečská","Rosická","Rostislavova","Rostoklatská","Rostovská","Rotavská","Rotenská","Roudnická","Rousovická","Rousínovská","Rovenská","Rovnoběžná","Rovná","Rozdělená","Rozdělovská","Rozhovická","Rozkošného","Rozkošská","Rozmarýnová","Rozrazilová","Roztocká","Roztylská","Roztylské Náměstí","Roztylské Sady","Rozvadovská","Rozvodova","Rozvojová","Rozárčina","Rozýnova","Rozšířená","Ročovská","Rošických","Roškotova","Rošovická","Rožmberská","Rožmitálská","Rožnovská","Rožďalovická","Rtyňská","Rubensova","Rubeška","Rubešova","Rubličova","Rubínová","Rudečská","Rudníkovská","Rudolfa Holeky","Rudoltická","Rudoltická","Rujanská","Rumburská","Rumunská","Rumunská","Ruprechtická","Ruská","Ruská","Ruzyňská","Ruzyňská","Ruzyňské Schody","Ružinovská","Rybalkova","Rybalkova","Rybalkova","Rybničná","Rybná","Rybova","Rybářská","Rybízová","Rychnovská","Rychtáře Petříka","Rychtáře Šimona","Rychtářská","Rypkova","Rytířova","Rytířská","Ryzcová","Ryzlinková","Ryšánkova","Rájecká","Rámová","Rápošovská","Rážova","Révová","Rýmařovská","Rýnská","Rýznerova","Růženínová","Růženínská","Růženínská","Růžová","S. K. Neumanna","Sabinova","Sadařská","Sadová","Sadská","Sadská","Sady Bratří Čapků","Safírová","Salabova","Salačova","Salmovská","Salvátorská","Samcova","Samohelova","Samota U Podleského Rybníka","Sarajevská","Saratovská","Sartoriova","Sasanková","Saská","Satalická","Saturnova","Saudkova","Sauerova","Saveljevova","Savojská","Sazečská","Sazečská","Sazovická","Sbíhavá I","Sbíhavá Ii","Schnirchova","Schodišťová","Schodová","Schoellerova","Schoellerova","Schulhoffova","Schwaigerova","Schwarzenberská","Schöfflerova","Sdružení","Sechterova","Sedlecká","Sedlovická","Sedloňovská","Sedlčanská","Sedmidomky","Sedmidomky","Sedmikrásková","Sedmnáctého Listopadu","Seidlova","Seifertova","Sekaninova","Sekeřická","Sekorova","Selmická","Selská","Selských Baterií","Semanského","Semická","Semilská","Semilská","Seminární","Seminářská","Seminářská Zahrada","Semonická","Semtínská","Semčická","Sendražická","Senegalská","Senohrabská","Senovážná","Senovážné Nám.","Senovážné Náměstí","Senožatská","Sestupná","Sestupná","Setbová","Sevastopolská","Severní I","Severní Ii","Severní Iii","Severní Iv","Severní Ix","Severní V","Severní Vi","Severní Vii","Severní Viii","Severní X","Severní Xi","Severovýchodní I","Severovýchodní Ii","Severovýchodní Iii","Severovýchodní Iv","Severovýchodní V","Severovýchodní Vi","Severozápadní I","Severozápadní Ii","Severozápadní Iii","Severozápadní Iv","Severozápadní V","Severozápadní Vi","Severýnova","Sevřená","Seydlerova","Sezemická","Sezemínská","Sezimova","Sečská","Sibeliova","Sibiřské Nám.","Sibiřské Náměstí","Sicherova","Sichrovského","Siemensova","Silurská","Sinkulova","Sinkulova","Sitteho","Siwiecova","Skalecká","Skalnatá","Skalnická","Skalní","Skalská","Skaláků","Skandinávská","Skandinávská","Skautská","Sklenská","Skloněná","Sklářská","Skokanská","Skorkovská","Skorkovská","Skotská","Skořepka","Skořicová","Skryjská","Skupova","Skuteckého","Skálova","Skřivanova","Skřivanská","Skřivánčí","Sladkovského Nám.","Sladkovského Náměstí","Sladovnická","Slancova","Slaná","Slapská","Slatinová","Slatinská","Slatiny","Slatiňanská","Slavatova","Slaviborské Nám.","Slaviborské Náměstí","Slavická","Slavičí","Slavičínská","Slavníkova","Slavojova","Slavonická","Slavíkova","Slavíkova","Slavíkova","Slavínského","Slavíčkova","Slavětínská","Slepá I","Slepá Ii","Slezanů","Slezská","Slezská","Sliačská","Sliačská","Slibná","Slinková","Slivenecká","Slovanský Ostrov","Slovačíkova","Slovenská","Slovenská","Slovinská","Slunečnicová","Slunečná","Sluneční","Sluneční Nám.","Sluneční Náměstí","Slunná","Sluštická","Služeb","Služeb","Služská","Sládkova","Sládkovičova","Slámova","Slánská","Slávy Horníka","Slévačská","Slévačská","Slévačská","Slídová","Slívová","Smaragdová","Smetanovo Nábř.","Smetanovo Nábřeží","Smetáčkova","Smidarská","Smikova","Smiřická","Smiřického","Smolenská","Smolkova","Smolíkova","Smotlachova","Smotlachova","Smrková","Smrčinská","Smržovská","Smržová","Smíchovská","Smíchovská","Smíchovská","Smírná","Snopkova","Sněmovní","Sněženková","Sněžná","Sobolákova","Soborská","Sobotecká","Sobínská","Soběslavova","Soběslavská","Sobětická","Sobětušská","Soběšínská","Sochařská","Socháňova","Sodomkova","Sofijské Nám.","Sofijské Náměstí","Sojkovská","Sojovická","Sojčí","Sojčí","Sokolovská","Sokolovská","Sokolovská","Sokolovská","Sokolská","Sokratova","Solidarity","Solnická","Solná","Sopotská","Sosnovecká","Souběžná I","Souběžná Ii","Souběžná Iii","Souběžná Iv","Soudní","Soukalova","Soukenická","Soumarská","Sousední","Sousední","Sousedská","Sousedíkova","Soustružnická","Soustružnická","Souvratní","Součkova","Sovenická","Sovova","Sovákova","Soví Vršek","Spinozova","Spiritka","Splavná","Spodní","Spojařů","Spojenců","Spojená","Spojná","Spojovací","Spojovací","Spojovací","Spojovací","Spojová","Společná","Spolská","Spolupráce","Sportovců","Sportovců","Sportovní","Spotřebitelská","Spořická","Spořilovská","Spytihněvova","Spádná","Spádová","Spálená","Spálená","Spálený Mlýn","Srbova","Srbská","Srbínská","Srnečkova","Srnčí","Srnčí","Srpnová","Srázná","Stachova","Stadická","Stadionová","Stadiónová","Stallichova","Stamicova","Staniční","Starobylá","Starochodovská","Starochuchelská","Starodejvická","Starodubečská","Starodvorská","Staroklánovická","Starokolínská","Starokošířská","Starolázeňská","Staromlýnská","Staromodřanská","Staroměstské Nám.","Staroměstské Náměstí","Staropacká","Staropramenná","Starostrašnická","Starostřešovická","Starosuchdolská","Staroújezdská","Staročeská","Stará Cesta","Stará Náves","Stará Obec","Stará Spojovací","Stará Stodůlecká","Staré Nám.","Staré Náměstí","Staré Zámecké Schody","Staré Zámecké Schody","Starého","Starý Lis","Statenická","Statková","Stavbařů","Stavební","Stavitelská","Stavovská","Staňkova","Staňkovka","Staňkovská","Stehlíkova","Steinerova","Stejskalova","Stiessova","Stinkovská","Stochovská","Stodůlecká","Stojická","Stoličkova","Stoliňská","Stoupající","Stoupající","Stradonická","Strahovská","Strahovské Nádvoří","Strakatého","Strakonická","Strakonická","Strakonická","Strakonická","Strakonická","Strakonická","Strakošová","Strančická","Stratovská","Strašnická","Strašnická","Strašovská","Strašínská","Strmá","Strmý Vrch","Strnadova","Strnady","Strojická","Strojnická","Strojírenská","Stromovka","Stromovka","Stropnická","Stropnická","Stropnická","Strossmayerovo Nám.","Strossmayerovo Náměstí","Strouhalova","Stroupežnického","Struhařovská","Strunkovská","Stružky","Stružná","Strážkovická","Strážnická","Strážní","Strážovská","Stržná","Studenecká","Studentská","Studená","Studnická","Studničkova","Studniční","Studánková","Stulíková","Stupická","Stupkova","Stupská","Stupňová","Stádlecká","Stárkova","Stýblova","Střední","Středohorská","Středová","Střekovská","Střelecký Ostrov","Střelečská","Střelničná","Střelničná","Střemchová","Střešovická","Střešovická","Střimelická","Stříbrná","Stříbrského","Stříbrského","Střížkovská","Střížkovská","Střížkovská","Suchardova","Suchdolská","Suchdolská","Suchdolská","Suchdolské Nám.","Suchdolské Náměstí","Suchý Vršek","Sudkova","Sudoměřská","Sudějovická","Sukova","Sulanského","Sulická","Sulická","Sulova","Sulovická","Sumova","Suppého","Suttnerové","Sušická","Sušilova","Svahová","Svatavina","Svatojánská","Svatoplukova","Svatoslavova","Svatovítská","Svatovítská","Svatoňovická","Svažitá","Svijanská","Svitavská","Svitákova","Svobodova","Svobodova","Svojetická","Svojsíkova","Svojšická","Svojšovická","Svornosti","Svratecká","Svárovská","Svátkova","Svážná","Svépomoci","Svépomocná","Svépravická","Svépravická","Svídnická","Svěceného","Světická","Světova","Světská","Sychrovská","Symfonická","Synkovická","Synkovská","Syrská","Sádky","Sádovská","Sámova","Sárská","Sárská","Sárská","Sázavská","Sáňkařská","Sídlištní","Sídlištní","Sídliště","Súdánská","Sýkorčí","Sýkovecká","Tachlovická","Tachovská","Tachovské Nám.","Tachovské Náměstí","Tadrova","Tajovského","Talafúsova","Talichova","Talmberská","Tanvaldská","Tasovská","Tatarkova","Tatranská","Tauerova","Tauferova","Taussigova","Tavolníková","Tařicová","Taškentská","Technická","Technologická","Tehovská","Tejnická","Tejnka","Telčská","Templová","Tenisová","Teplická","Teplárenská","Teplárenská","Terasovitá","Tererova","Terezínská","Terronská","Tesaříkova","Tetínská","Theinova","Thomayerova","Thunovská","Thurnova","Thákurova","Thámova","Tibetská","Tichnova","Tichnova","Tichonická","Tichá","Tichého","Tigridova","Tikovská","Tilleho Nám.","Tilleho Náměstí","Tilschové","Tiskařská","Tismická","Tišická","Tlumačovská","Tlustého","Tobrucká","Tolstého","Tomanova","Tomická","Tomkova","Tomsova","Tomáškova","Tomášská","Tomíčkova","Topasová","Topolová","Toruňská","Toulovská","Toušeňská","Toušická","Toužimská","Toužimská","Tovarova","Tovačovského","Tovární","Točenská","Točitá","Trabantská","Trachtova","Trampotova","Travnatá","Travná","Travná","Trenčínská","Trhanovské Náměstí","Trmická","Trnavská","Trnavská","Trnitá","Trnkovo Nám.","Trnkovo Náměstí","Trnková","Trnovanská","Trní","Trocnovská","Troilova","Trojanova","Trojanův Mlýn","Trojdílná","Trojická","Trojmezní","Trojmezní","Trojská","Trojská","Trojská","Trojská","Troskovická","Trousilova","Truhlářka","Truhlářova","Truhlářská","Trutnovská","Tryskovická","Tryskovická","Trytova","Trávnická","Trávníčkova","Tréglova","Tržiště","Tuchoměřická","Tuchorazská","Tuchotická","Tuháňská","Tuklatská","Tulešická","Tulipánová","Tulkova","Tulská","Tunelářů","Tuniská","Tupolevova","Turgeněvova","Turistická","Turkmenská","Turkovická","Turkovská","Turnovská","Turnovského","Turská","Turínská","Tusarova","Tuřická","Tušimická","Tužebníková","Tvrdonická","Tvrdého","Tychonova","Tylišovská","Tylovická","Tylovo Nám.","Tylovo Náměstí","Tymiánová","Tyrkysová","Tyršova","Táboritská","Táborská","Tádžická","Táhlá","Tálínská","Türkova","Týmlova","Týmlova","Týn","Týnecká","Týnská","Týnská Ulička","Týřovická","Tělovýchovná","Těšnov","Těšovická","Těšíkova","Těšínská","Třanovského","Třebanická","Třebechovická","Třebenická","Třebešovská","Třebihošťská","Třebohostická","Třebonická","Třeboradická","Třebotovská","Třeboňská","Třebízského","Třebějická","Třebětínská","Třešňová","Třešňová","Třešňová","Třinecká","Třtinová","Třídomá","Třístoličná","Tůmova","U Akademie","U Akátů","U Albrechtova Vrchu","U Andělky","U Arborky","U Bakaláře","U Balabenky","U Bazénu","U Bažantnice","U Berounky","U Beránky","U Besedy","U Blaženky","U Boroviček","U Botiče","U Botiče","U Božích Bojovníků","U Branek","U Bruských Kasáren","U Brusnice","U Brusnice","U Bubce","U Bulhara","U Bulhara","U Bílého Mlýnku","U Břehu","U Chaloupek","U Chmelnice","U Chodovského Hřbitova","U Cibulky","U Cihelny","U Cikánky","U Cukrovaru","U Císařské Cesty","U Dejvického Rybníčku","U Demartinky","U Divadla","U Divadla","U Dobešky","U Dobráků","U Dobráků","U Dobřenských","U Domu Služeb","U Drahaně","U Druhé Baterie","U Druhé Baterie","U Drupolu","U Družstev","U Družstva Ideál","U Družstva Klid","U Družstva Práce","U Družstva Práce","U Družstva Repo","U Družstva Tempo","U Družstva Život","U Dráhy","U Dráhy","U Drážky","U Drůbežárny","U Dubečské Tvrze","U Dubu","U Dvojdomů","U Dvora","U Dvou Srpů","U Dálnice","U Dívčích Hradů","U Dívčích Hradů","U Děkanky","U Dělnického Cvičiště","U Dětského Domova","U Dětského Hřiště","U Elektry","U Elektry","U Elektrárny","U Floriána","U Fořta","U Gabrielky","U Garáží","U Golfu","U Gymnázia","U Habeše","U Habrovky","U Hadovky","U Harfy","U Hasičské Zbrojnice","U Hasičské Zbrojnice","U Havlíčkových Sadů","U Hellady","U Hercovky","U Hliníku","U Hodin","U Homolky","U Hostavického Potoka","U Hostivařského Nádraží","U Hostivařského Nádraží","U Hotelu","U Hranic","U Hrnčířského Rybníka","U Hrocha","U Hrušky","U Hráze","U Hudební Školy","U Hvozdu","U Hvězdy","U Hvězdy","U Háje","U Hájku","U Hájovny","U Házů","U Hřbitovů","U Hřiště","U Invalidovny","U Jamské","U Jankovky","U Javoru","U Jedličkova Ústavu","U Jednoty","U Jeslí","U Jezera","U Jezerky","U Jezu","U Jezírka","U Jinonického Rybníčka","U Jirkovské","U Jizby","U Járku","U Jízdárny","U Kabelovny","U Kabelovny","U Kaménky","U Kamýku","U Kanálky","U Kapliček","U Kapličky","U Karlova Stánku","U Kasáren","U Kavalírky","U Kazína","U Kašny","U Kaštanu","U Kempinku","U Kina","U Klavírky","U Klikovky","U Klimentky","U Kloubových Domů","U Klubovny","U Klubu","U Kněžské Louky","U Kola","U Kolejí","U Kolejí","U Koloděj","U Kolonie","U Koloniálu","U Kombinátu","U Konečné","U Koní","U Kosinů","U Kostela","U Kostrounku","U Kotlářky","U Koupadel","U Košíku","U Krbu","U Krbu","U Krelovy Studánky","U Kruhovky","U Královské Louky","U Krčské Vodárny","U Krčského Nádraží","U Kublova","U Kunratického Lesa","U Křižovatky","U Kříže","U Kříže","U Křížku","U Laboratoře","U Ladronky","U Lanové Dráhy","U Ledáren","U Lesa","U Lesa","U Lesíka","U Letenského Sadu","U Letiště","U Letohrádku Královny Anny","U Libeňského Pivovaru","U Libeňského Zámku","U Libušiných Lázní","U Libušské Sokolovny","U Lidového Domu","U Lip","U Lipové Aleje","U Lisu","U Loděnice","U Lomu","U Loskotů","U Louky","U Lužického Semináře","U Lázeňky","U Lázní","U Lékárny","U Líhní","U Lípy","U Malvazinky","U Malé Řeky","U Markéty","U Mateřské Školy","U Matěje","U Maří Magdaleny","U Meteoru","U Mezníku","U Michelské Školy","U Michelského Lesa","U Michelského Lesa","U Michelského Mlýna","U Milosrdných","U Mlýna","U Mlýna","U Mlýnského Rybníka","U Modré Školy","U Modřanské Školy","U Močálu","U Mrázovky","U Mydlárny","U Myslivny","U Městských Domů","U Měšťanského Pivovaru","U Měšťanských Škol","U Nadýmače","U Nemocenské Pojišťovny","U Nemocnice","U Nesypky","U Nikolajky","U Nové Dálnice","U Nové Louky","U Nové Školy","U Nového Dvora","U Nového Suchdola","U Nového Suchdola","U Nových Domů I","U Nových Domů Ii","U Nových Domů Iii","U Nových Vil","U Nádražní Lávky","U Nádraží","U Nádrže","U Náhonu","U Náhonu","U Nákladového Nádraží","U Nákladového Nádraží","U Národní Galerie","U Nás","U Obce","U Obecního Domu","U Obecního Dvora","U Obory","U Okrouhlíku","U Olšiček","U Opatrovny","U Ovčína","U Palaty","U Paliárky","U Paloučku","U Památníku","U Panské Zahrady","U Papírny","U Parku","U Parkánu","U Parního Mlýna","U Pastoušky","U Pavilónu","U Pazderek","U Pejřárny","U Pekařky","U Pekáren","U Pentlovky","U Pergamenky","U Pernikářky","U Pernštejnských","U Petřin","U Pily","U Plovárny","U Plynárny","U Plynárny","U Plátenice","U Podchodu","U Podjezdu","U Podolského Hřbitova","U Podolského Sanatoria","U Pohádky","U Polikliniky","U Pomníku","U Potoka","U Poustek","U Poštovky","U Pošty","U Pramene","U Prašné Brány","U Prašného Mostu","U Prašného Mostu","U Pražských Lomů","U Prefy","U Prioru","U Prknovky","U Prodejny","U Propusti","U Prosecké Školy","U Proseckého Kostela","U První Baterie","U První Baterie","U Prádelny","U Průhonu","U Průseku","U Pumpy","U Párníků","U Páté Baterie","U Páté Baterie","U Písecké Brány","U Pískovny","U Přechodu","U Přehrady","U Přejezdu","U Půjčovny","U Radiály","U Radnice","U Rajské Zahrady","U Rakovky","U Roháčových Kasáren","U Rokytky","U Rokytky","U Rokytky","U Rozkoše","U Roztockého Háje","U Rybníka","U Rybníčka","U Rybářství","U Rychty","U Rychty","U Ryšánky","U Ryšánky","U Sadu","U Sanatoria","U Sanopzu","U Santošky","U Schodů","U Sedlecké Školy","U Seřadiště","U Sila","U Silnice","U Silnice","U Skalky","U Skladu","U Skládky","U Skopců","U Skály","U Sladovny","U Slavie","U Sloupu","U Slovanky","U Slovanské Pojišťovny","U Sluncové","U Slévárny","U Smaltovny","U Smetanky","U Smolnic","U Smíchovského Hřbitova","U Sokolovny","U Soutoku","U Sovových Mlýnů","U Sparty","U Splavu","U Spojky","U Spojů","U Společenské Zahrady","U Sportoviště","U Spořitelny","U Stanice","U Staré Cihelny","U Staré Plynárny","U Staré Pošty","U Staré Skládky","U Staré Sokolovny","U Staré Studánky","U Staré Tvrze","U Staré Školy","U Staré Školy","U Starého Hřbitova","U Starého Hřiště","U Starého Mlýna","U Starého Nádraží","U Starého Splavu","U Starého Stadionu","U Starého Stadiónu","U Starého Židovského Hřbitova","U Starého Židovského Hřbitova","U Statku","U Stavoservisu","U Stojanu","U Strouhy","U Strže","U Studny","U Studánky","U Studánky","U Stárovny","U Státní Dráhy","U Státní Dráhy","U Stírky","U Střediska","U Střešovických Hřišť","U Sušičky","U Svahu","U Svatého Ducha","U Svobodárny","U Svodnice","U Svornosti","U Svépomoci","U Světličky","U Synagogy","U Sádek","U Sídliště","U Tabulky","U Technoplynu","U Tenisu","U Teplárny","U Topíren","U Továren","U Transformační Stanice","U Transformátoru","U Trati","U Trativodu","U Trezorky","U Trojice","U Trojského Zámku","U Trpce","U Tržnice","U Tvrze","U Tyrše","U Tyršovky","U Tyršovy Školy","U Třetí Baterie","U Třešňovky","U Třešňového Sadu","U Tůně","U Uhříněveské Obory","U Uranie","U Učiliště","U Valu","U Velké Skály","U Vesny","U Viktorky","U Vinice","U Viniček","U Vinné Révy","U Vinných Sklepů","U Vinohradské Nemocnice","U Vinohradského Hřbitova","U Vinohradského Hřbitova","U Vizerky","U Višňovky","U Višňovky","U Vlachovky","U Vlasačky","U Vlečky","U Vlečky","U Vltavy","U Voborníků","U Vodice","U Vodojemu","U Vodojemu","U Vodotoku","U Vody","U Vodárny","U Vojanky","U Vojenské Nemocnice","U Vojtěšky","U Vokovické Školy","U Vorlíků","U Vozovny","U Vrbiček","U Vrby","U Vrtilky","U Vršovického Hřbitova","U Vršovického Hřbitova","U Vršovického Nádraží","U Vysočanského Cukrovaru","U Vysočanského Pivovaru","U Václava","U Váhy","U Vápenice","U Vápenky","U Vápenné Skály","U Výkupního Střediska","U Výstavby","U Výstaviště","U Výstaviště","U Výzkumu","U Včely","U Větrníku","U Větrolamu","U Větrolamu","U Věže","U Waltrovky","U Zahradnictví","U Zahradního Města","U Zahrady","U Zahrádek","U Zahrádkářské Kolonie","U Zastávky","U Zbrojnice","U Zdravotního Ústavu","U Zeleného Ptáka","U Zemníku","U Zeměpisného Ústavu","U Zlaté Studně","U Zličína","U Zličína","U Zličínského Hřiště","U Zvonařky","U Zvoničky","U Záběhlického Zámku","U Zájezdku","U Zákrutu","U Zámeckého Parku","U Zámečku","U Zámečnice","U Zásobní Zahrady","U Zátiší","U Závodiště","U Závor","U Úlů","U Čekárny","U Černé Rokle","U Červeného Mlýnku","U Červeného Mlýnku","U Českých Loděnic","U Čihadel","U Čističky","U Čokoládoven","U Čtvrté Baterie","U Čtyř Domů","U Řempa","U Říčanky","U Šalamounky","U Šalamounky","U Šesté Baterie","U Šesté Baterie","U Školičky","U Školky","U Školního Pole","U Školské Zahrady","U Školy","U Štěpu","U Šumavy","U Šumavěnky","U Šálkovny","U Šíchů","U Šípků","U Železnice","U Železničního Mostu","U Železné Lávky","U Želivky","U Židovského Hřbitova","U Žlábku","U Županských","Uhelný Trh","Uherská","Uhříněveská","Ukončená","Ukrajinská","Uljanovská","Ulrychova","Ulčova","Umělecká","Ungarova","Unhošťská","Univerzitní","Upolínová","Upravená","Uralská","Urbanická","Urbanova","Urbánkova","Urešova","Uruguayská","Urxova","Utěšilova","Uzavřená","Uzbecká","Uzoučká","Učitelská","Učňovská","Užocká","V Aleji","V Alejích","V Americe","V Babyku","V Bambouskách","V Bažinách","V Benátkách","V Bezpečí","V Bokách I","V Bokách Ii","V Bokách Iii","V Borovičkách","V Botanice","V Brance","V Brůdku","V Brůdku","V Bytovkách","V Bílce","V Březinkách","V Březině","V Březí","V Břízkách","V Celnici","V Cestičkách","V Cestkách","V Chaloupkách","V Chaloupkách","V Chatách","V Chotejně","V Cibulkách","V Cihelně","V Cípu","V Dolinách","V Dolině","V Dolině","V Dolích","V Domcích","V Domově","V Doubcích","V Dílcích","V Edenu","V Haltýři","V Hliništi","V Hluboké","V Hodkovičkách","V Holešovičkách","V Honu","V Horkách","V Horní Stromce","V Hrobech","V Humenci","V Humenci","V Humnech","V Háji","V Hájkách","V Hájích","V Hůrkách","V Jahodách","V Javorech","V Javoříčku","V Jehličině","V Jehličí","V Jezerách","V Jezevčinách","V Jezírkách","V Jirchářích","V Jámě","V Kališti","V Kališti","V Kapslovně","V Klukovicích","V Kole","V Kolkovně","V Korytech","V Korytech","V Kotcích","V Koutku","V Koutě","V Kratinách","V Kruhu","V Kuťatech","V Kálku","V Křepelkách","V Křovinách","V Křížkách","V Ladech","V Lesíčku","V Lipinách","V Lipinách","V Lipkách","V Lipách","V Listnáčích","V Lomech","V Louce","V Luhu","V Lukách","V Lučinách","V Lužích","V Lánech","V Lázních","V Lískách","V Malých Domech I","V Malých Domech Ii","V Malých Domech Iii","V Mezihoří","V Milíři","V Mokřinách","V Mydlinkách","V Nové Hostivaři","V Nové Vsi","V Nové Vsi","V Nové Čtvrti","V Novém Hloubětíně","V Novém Hloubětíně","V Nových Bohnicích","V Nových Domcích","V Nových Vokovicích","V Náklích","V Násypu","V Nížinách","V Oblouku","V Občanském Domově","V Obůrkách","V Ochozu","V Ohradě","V Ohybu","V Okruží","V Okálech","V Olšinách","V Olšinách","V Olšině","V Ondřejově","V Opatově","V Osikách","V Ostružiní","V Oudolku","V Ořeší","V Pachmance","V Padolině","V Parcelách","V Parku","V Parníku","V Pačátkách","V Pařezinách","V Pevnosti","V Pevnosti","V Pitkovičkách","V Planinách","V Platýzu","V Pláni","V Podbabě","V Podhoří","V Podhájí","V Podhájí","V Podluží","V Podskalí","V Podvrší","V Podzámčí","V Poli","V Polích","V Potokách","V Potočinách","V Potočkách","V Prutinách","V Průhledu","V Průčelí","V Pátém","V Pískovně","V Pěšinkách","V Předním Hloubětíně","V Předním Veleslavíně","V Předpolí","V Předpolí","V Přelomu","V Přístavu","V Remízku","V Rohožníku","V Rohu","V Roháčích","V Rokli","V Roklích","V Rovinách","V Rovinách","V Rybníkách","V Rybníčkách","V Ráji","V Ráji","V Rákosí","V Sadech","V Sedlci","V Sedlci","V Slavětíně","V Soudním","V Stráni","V Středu","V Sudech","V Sídlišti","V Tehovičkách","V Tišině","V Trninách","V Třešňovce","V Tůních","V Uličce","V Uličkách","V Zahradní Čtvrti","V Zahradách","V Zahrádkách","V Zatáčce","V Zeleni","V Zeleném Údolí","V Záhorském","V Záhybu","V Zákopech","V Zákoutí","V Zálesí","V Zálomu","V Zámcích","V Zápolí","V Zátiší","V Zátočce","V Závitu","V Závětří","V Zářezu","V Údolí","V Údolí Hvězd","V Úhlu","V Úhoru","V Úvalu","V Úvoze","V Úzké","V Úžlabině","V Úžlabině","V Čeňku","V Štíhlách","V Šáreckém Údolí","V Žabokřiku","V Žáčku","V. P. Čkalova","V. P. Čkalova","Vachkova","Vackova","Vacovská","Vacínova","Vacínovská","Vajdova","Vajgarská","Valcířská","Valdická","Valdovská","Valdštejnská","Valdštejnské Nám.","Valdštejnské Náměstí","Valentinská","Valentinská","Valentova","Valečovská","Valská","Valtická","Valtínovská","Valčíkova","Valšovská","Vamberská","Vanická","Vaníčkova","Vaníčkova","Varhulíkové","Varnsdorfská","Varšavská","Vavákova","Vavřenova","Vavřinecká","Vazovova","Vačkářova","Vaňkova","Vaňkova","Vašátkova","Ve Dvoře","Ve Lhotce","Ve Lhotce","Ve Skalkách","Ve Skalách","Ve Skále","Ve Slatinách","Ve Smečkách","Ve Smrčině","Ve Stromořadí","Ve Struhách","Ve Struhách","Ve Stráni","Ve Studeném","Ve Stínu","Ve Střešovičkách","Ve Střešovičkách","Ve Svahu","Ve Vilkách","Ve Vilách","Ve Višňovce","Ve Vratech","Ve Vrbách","Ve Vrchu","Ve Vrších","Ve Výhledu","Ve Výhledu","Ve Výrech","Ve Zliči","Ve Štěpnici","Ve Žlíbku","Vedlejší","Vehlovická","Vejražkova","Vejvanovského","Vejvodova","Velebného","Velehradská","Velemínská","Velemínská","Velenická","Velenovského","Veleslavínova","Veleslavínská","Veleslavínská","Veletovská","Veletržní","Veletržní","Veleňská","Velešínská","Velfloviců","Velflíkova","Velhartická","Velichovská","Velimská","Velkoborská","Velkoosecká","Velkopřevorské Nám.","Velkopřevorské Náměstí","Velká Lada","Velká Lada","Velká Skála","Velké Kunratické","Veltruská","Veltěžská","Velvarská","Velínská","Venušina","Verdiho","Verdunská","Verneřická","Verneřická","Vernéřovská","Veronské Nám.","Veselská","Veská","Veslařský Ostrov","Vestavěná","Vestecká","Veverkova","Večerní","Vidimova","Vidimská","Vidlicová","Vidlák","Vidonická","Vidoulská","Vidovická","Vietnamská","Viklefova","Vikova","Viktora Huga","Viktorinova","Viktorčina","Vikářská","Vilová","Vilímkova","Vilímovská","Vimperské Náměstí","Vinařického","Vinařská","Viničná","Vinohradská","Vinohradská","Vinohradská","Vinohradská","Vinohradská","Vinohradská","Vinohradská","Vinohrady","Vinopalnická","Vinořská","Vinořské Nám.","Vinořské Náměstí","Vinšova","Violková","Vitošská","Vitíkova","Vitějovská","Vizovická","Višňovka","Višňovka","Višňová","Vlachova","Vladimírova","Vladislava Vančury","Vladislavova","Vladivostocká","Vladycká","Vlastibořská","Vlastina","Vlastina","Vlastislavova","Vlasty Buriana","Vlasty Hilské","Vlasty Průchové","Vlasákova","Vlašimská","Vlašská","Vlašská","Vlaštovčí","Vlkanovská","Vlkova","Vlkovická","Vlnitá","Vltavanů","Vltavanů","Vltavanů","Vltavická","Vltavská","Vltavínová","Vlárská","Vlásenická","Vlčická","Vlčkova","Vlčnovská","Vnislavova","Vnitřní","Vnoučkova","Vnější","Voborského","Vobrubova","Vocelova","Voctářova","Voctářova","Vodická","Vodičkova","Vodičkova","Vodnická","Vodní","Vodochodská","Vodojemská","Vodácká","Vodárenská","Voděradská","Vodňanská","Vodňanského","Vojenova","Vojetická","Vojická","Vojkovická","Vojslavická","Vojtova","Vojtíškova","Vojtěšská","Vojáčkova","Vokovická","Vokovická","Vokrojova","Vokáčova","Vokřínská","Volarská","Volavkova","Voleníkova","Volkova","Volkovova","Voltova","Volutová","Volyňská","Volšovská","Volšovská","Vondroušova","Vorařská","Voroněžská","Voroněžská","Voráčovská","Voršilská","Voskova","Voskovcova","Vosmíkových","Vostrovská","Vostrého","Vosátkova","Votavova","Votická","Votočkova","Votrubova","Votuzská","Vozová","Vozová","Voňkova","Voříškova","Vošahlíkova","Vožická","Vrabčí","Vranická","Vranovská","Vranská","Vratimovská","Vratislavova","Vratislavská","Vratičová","Vraňanská","Vrbenského","Vrbická","Vrbková","Vrbova","Vrbčanská","Vrchlabská","Vrchlického","Vrchlického Sady","Vrchovinská","Vrátenská","Vrátkovská","Vrázova","Vrážská","Vrútecká","Vršní","Vršovická","Vršovické Nám.","Vršovické Náměstí","Vršovka","Vsetínská","Vstavačová","Vstupní","Vybíralova","Vycpálkova","Vyderská","Vydrova","Vyhlídkova","Vykoukových","Vykáňská","Vyskočilova","Vysokovská","Vysokoškolská","Vysoká Cesta","Vysočanská","Vysočanská","Vysočanská","Vysočanské Nám.","Vysočanské Náměstí","Vyvýšená","Vyšebrodská","Vyšehradská","Vyšší","Vyžlovská","Vzdušná","Vzdálená","Vzestupná","Vzpoury","Váchalova","Václava Balého","Václava Kovaříka","Václava Rady","Václava Trojana","Václava Špačka","Václavická","Václavkova","Václavská","Václavské Nám.","Václavské Náměstí","Vágnerova","Vánková","Vápencová","Vápenná","Vápeníkova","Vášova","Vážská","Vídeňská","Vídeňská","Vídeňská","Vírská","Víta Nejedlého","Vítkova","Vítkovická","Vítovcova","Vítovcova","Vítězná","Vítězná","Vítězné Nám.","Vítězné Nám.","Vítězné Náměstí","Vítězné Náměstí","Východní","Východní Nám.","Východní Náměstí","Výchozí","Výhledová","Výhledské Nám.","Výhledské Náměstí","Výjezdní","Výjezdová","Výletní","Výletní","Výmarova","Výmolova","Výpadová","Výpadová","Výravská","Výrobní","Výstaviště","Výstavní","Výstupní","Výtoňská","Výtvarnická","Výtvarná","Výzkumníků","Včelařská","Včelničná","Věkova","Věstonická","Větrná","Větrovcova","Větrová","Větrušická","Vězeňská","Vězeňská","Věštínská","Věšínova","Věžická","Vřesovická","Vřesová","Všehrdova","Všejanská","Všelipská","Všerubská","Všestarská","Všetatská","Všeňská","Wagnerova","Waldesova","Washingtonova","Wassermannova","Wattova","Weberova","Weberova","Weilova","Weissova","Wenzigova","Wenzigova","Werichova","Wichterlova","Wiedermannova","Wiesenthalova","Wilsonova","Wilsonova","Winklerova","Wolfova","Wolkerova","Wuchterlova","Xaveriova","Xaverovská","Za Archivem","Za Arielem","Za Avií","Za Bažantnicí","Za Botičem","Za Brankou","Za Brumlovkou","Za Brůdkem","Za Břízami","Za Chalupami","Za Cukrovarem","Za Císařským Mlýnem","Za Dolejšákem","Za Drahou","Za Dvorem","Za Dálnicí","Za Dálnicí","Za Elektrárnou","Za Elektrárnou","Za Farou","Za Fořtem","Za Hanspaulkou","Za Haštalem","Za Hládkovem","Za Horou","Za Horou","Za Hospodou","Za Hrází","Za Humny","Za Hájem","Za Hájem","Za Hájovnou","Za Hřbitovem","Za Invalidovnou","Za Jalovým Dvorem","Za Jednotou","Za Kajetánkou","Za Kapličkou","Za Karlínským Přístavem","Za Kačabkou","Za Klíčovem","Za Knotkem","Za Knotkem","Za Kostelem","Za Kovárnou","Za Kovářským Rybníkem","Za Křížem","Za Křížkem","Za Lesíkem","Za Lidovým Domem","Za Luhem","Za Lužinami","Za Lány","Za Lázeňkou","Za Mlýnem","Za Mosty","Za Mosty","Za Mototechnou","Za Můstkem","Za Nadýmačem","Za Novákovou Zahradou","Za Návsí","Za Obecním Úřadem","Za Oborou","Za Opravnou","Za Opusem","Za Ovčínem","Za Papírnou","Za Parkem","Za Pavilónem","Za Pekařkou","Za Pekárnou","Za Pivovarem","Za Ploty","Za Podjezdem","Za Pohořelcem","Za Pohádkou","Za Potokem","Za Poříčskou Branou","Za Poříčskou Bránou","Za Poštou","Za Poštovskou Zahradou","Za Poštovskou Zahradou","Za Prodejnou","Za Pruhy","Za Průsekem","Za Pískovnou","Za Radostí","Za Rokytkou","Za Rybníkem","Za Rybníčky","Za Rybářstvím","Za Rájem","Za Sadem","Za Sedmidomky","Za Skalkou","Za Skalkou","Za Slatinami","Za Slovankou","Za Sokolovnou","Za Stadionem","Za Statkem","Za Statky","Za Stodolami","Za Stodolou","Za Strahovem","Za Strašnickou Vozovnou","Za Strašnickou Vozovnou","Za Strojírnami","Za Studánkou","Za Střelnicí","Za Sídlištěm","Za Teplárnou","Za Tratí","Za Tratí","Za Třebešínem","Za Vackovem","Za Valem","Za Viaduktem","Za Vinicí","Za Vlasačkou","Za Vodárnou","Za Vokovickou Vozovnou","Za Vokovickou Vozovnou","Za Větrem","Za Zahradami","Za Zahradou","Za Zastávkou","Za Zelenou Liškou","Za Zámečkem","Za Černým Mostem","Za Černým Mostem","Za Černým Mostem","Za Školkou","Za Školou","Za Šmatlíkem","Za Železnicí","Za Ženskými Domovy","Za Žižkovskou Vozovnou","Zacharská","Zachova","Zadní","Zahrada Na Baště","Zahradnická","Zahradní","Zahradníčkova","Zahradníčkova","Zahrádecká","Zahrádecká","Zahrádkářská","Zahrádkářů","Zaječická","Zaječí","Zaječí","Zakouřilova","Zakrytá","Zakšínská","Zalešanská","Zalinská","Zamašská","Zamenhofova","Zapadlá","Zapomenutá","Zapova","Zapských","Zastavěná","Zastrčená","Zavadilova","Zavátá","Zaříčanská","Zbečenská","Zborovská","Zborovská","Zbraslavská","Zbraslavská","Zbraslavské Nám.","Zbraslavské Náměstí","Zbrojnická","Zbudovská","Zbuzanská","Zbuzkova","Zbynická","Zbyslavská","Zbytinská","Zbýšovská","Zdaru","Zdařilá","Zderazská","Zdeňky Nyplové","Zdibská","Zdická","Zdiměřická","Zdislavická","Zdobnická","Zdoňovská","Zdíkovská","Zelenečská","Zelenečská","Zelenkova","Zelenky-Hajského","Zelenohorská","Zelená","Zelená","Zelená Louka","Zelený Pruh","Zelený Pruh","Zelený Pruh","Zelinářská","Zemanka","Zemské Právo","Zemědělská","Zengrova","Zenklova","Zenklova","Zeyerova Alej","Zhořelecká","Zikova","Zimova","Zimákova","Zkrácená","Zlatnice","Zlatnická","Zlatokorunská","Zlatá","Zlatá Ulička U Daliborky","Zlenická","Zlešická","Zlivská","Zličínská","Zličínská","Zlonická","Zlonínská","Zlončická","Zlíchovská","Znojemská","Zoubkova","Zrzavého","Ztracená","Zubatého","Zubrnická","Zvolenská","Zvolská","Zvolská","Zvonařova","Zvonařovská","Zvonařská","Zvoncovitá","Zvonická","Zvonková","Zvoníčkova","Zvánovická","Zvíkovská","Záblatská","Záblatská","Zábranská","Zábrodí","Záběhlická","Zádražanská","Záhornická","Záhorského","Záhořanská","Záhořanského","Záhřebská","Zájezdní","Zákolanská","Zákostelní","Zákupská","Zálesí","Zálesí","Zálesí","Záluské","Zálužanského","Zálužická","Zálužská","Zálužská","Zámecká","Zámecké Schody","Zámezí","Zámišova","Zámělská","Západní","Zápasnická","Zápolská","Zápotoční","Zápská","Zárubova","Zárybnická","Zárybničná","Zárybská","Zásadská","Zásmucká","Zátišská","Zátiší","Zátopkova","Zátoňská","Závadova","Záveská","Závist","Závišova","Závišova","Závodní","Závrchy","Závěrka","Zázvorkova","Zářijová","Zítkova","Zívrova","Zúžená","Údlická","Údolní","Údolní","Údolí Hvězd","Úhlavská","Úhlová","Újezd","Újezd","Újezdská","Úlibická","Únorová","Únětická","Únětická","Úpická","Úprkova","Úpská","Úslavská","Ústavní","Ústecká","Ústecká","Ústřední","Útulná","Útulná","Úvalská","Úvoz","Úvoz","Úvozová","Úzká","Čajkovského","Čakovická","Čakovická","Čankovská","Čapkova","Častavina","Častonická","Čechova","Čechtická","Čechurova","Čedičová","Čejetická","Čejkovická","Čekanková","Čekanková","Čekanovská","Čelakovského Sady","Čelakovského Sady","Čeljabinská","Čelkovická","Čelná","Čelákovická","Čenkovská","Čenovická","Čentická","Čenětická","Čeperská","Čeradická","Čerchovská","Čermákova","Černická","Černilovská","Černičná","Černochova","Černockého","Černohorského","Černokostelecká","Černokostelecká","Černokostelecká","Černomořská","Černotínská","Černovická","Černošická","Černá","Černého","Černínova","Černínská","Čerpadlová","Čertouská","Čertouská","Čertův Vršek","Červencová","Červenkova","Červená","Červená Báň","Červený Mlýn","Červeňanského","Červnová","Čerčanská","Českobratrská","Českobrodská","Českobrodská","Českobrodská","Českobrodská","Českobrodská","Českobrodská","Českobrodská","Českobrodská","Českodubská","Českolipská","Českolipská","Českomalínská","Českomoravská","Českomoravská","Československého Exilu","Československého Exilu","Česká","České Družiny","Českého Červeného Kříže","Čestlická","Čestmírova","Česákova","Čečelická","Čeňkova","Češovská","Čibuzská","Čihákova","Čiklova","Čiklova","Čimelická","Čimická","Čimická","Čimická","Čimická","Čirůvková","Čistovická","Čmelická","Čs. Armády","Čs. Tankistů","Čtyřdílná","Čtyřkolská","Čumpelíkova","Čuprova","Čábelecká","Čápova","Čáslavská","Čílova","Čílova","Čínská","Čínská","Čížovská","Ďáblická","Ďáblická","Ďáblická","Řadová","Řehořova","Řepečská","Řepná","Řeporyjská","Řeporyjská","Řeporyjská","Řeporyjské Náměstí","Řepová","Řepská","Řepíková","Řepínská","Řepčická","Řepčická","Řetězokovářů","Řetězová","Řevnická","Řevnická","Řeznická","Řezáčovo Nám.","Řezáčovo Náměstí","Řečického","Řešetovská","Řešovská","Řipská","Řipská","Řásnovka","Říjnová","Římovská","Římovská","Římská","Říčanova","Říčanská","Říční","Šachovská","Šafaříkova","Šafránecká","Šafránkova","Šafránová","Šafářova","Šakvická","Šaldova","Šalounova","Šalvějová","Šanovská","Šantrochova","Šatrova","Šatrova","Šebelova","Šeberovská","Šebestiánská","Šebkova","Šedivého","Šedova","Šejbalové","Šemberova","Šenovská","Šermířská","Šermířská","Šestajovická","Šestajovická","Šestidomí","Šetelíkova","Ševce Matouše","Ševčenkova","Ševčíkova","Šeříková","Šeříková","Šibřinská","Šikmá","Šimanovská","Šimkova","Šimonova","Šimáčkova","Šimůnkova","Šircova","Široká","Široká","Šiškova","Školní","Školská","Škroupovo Nám.","Škroupovo Náměstí","Škrétova","Škvorecká","Škábova","Šlechtitelská","Šlejnická","Šlikova","Šlitrova","Šluknovská","Šmeralova","Šmilovského","Šmolíkova","Šolínova","Šostakovičovo Nám.","Šostakovičovo Náměstí","Španielova","Španělská","Špačkova","Špeciánova","Šperlova","Špirkova","Špitálská","Šplechnerova","Šporkova","Špotzova","Špálova","Šrobárova","Šrobárova","Šromova","Štamberk","Štefkova","Štefánikova","Štemberova","Šternberkova","Šternova","Šternovská","Štichova","Štiplova","Štičkova","Štiřínská","Štochlova","Štolbova","Štolcova","Štolmířská","Štolmířská","Štorchova","Štorkánova","Štramberská","Štulcova","Štupartská","Štursova","Štverákova","Štychova","Štychova","Štíbrova","Štíhlická","Štítného","Štítová","Štúrova","Štúrova","Štěchovická","Štěpanická","Štěpařská","Štěpničná","Štěpánkova","Štěpánovská","Štěpánská","Štěpánská","Štěrboholská","Štěrková","Štětkova","Štětínská","Šubertova","Šulcova","Šultysova","Šumavská","Šumavského","Šumberova","Šumenská","Šumická","Šumperská","Šustova","Švabinského","Švecova","Švehlova","Švehlova","Švejcarovo Náměstí","Švestková","Švestková","Švestková","Švihovská","Švábky","Švábova","Švédská","Šárecká","Šárovo Kolo","Šárčina","Šátalská","Šífařská","Šímova","Šípková","Šítkova","Šťastného","Šůrova","Žabovřeská","Žacléřská","Žalanského","Žalmanova","Žalovská","Žamberská","Žampašská","Žampiónová","Žandovská","Žatecká","Žatecká","Žateckých","Ždírnická","Žehuňská","Žehušická","Želetavská","Železniční","Železničářů","Železnobrodská","Železná","Želivecká","Želivka","Želivská","Želkovická","Želnavská","Ženíškova","Žeretická","Žermanická","Žernosecká","Žernovská","Žerotínova","Žherská","Žichlínská","Židlického","Žilinská","Žilovská","Žinkovská","Žirovnická","Žitavská","Žitavského","Žitná","Žitná","Žitomírská","Živanická","Živcová","Živcových","Živonínská","Žiželická","Žižkova","Žižkovo Nám.","Žižkovo Náměstí","Žlebská","Žluťásková","Žofie Podlipské","Žufanova","Žukovského","Žukovského","Žulová","Županovická","Žvahovská","Žábova","Žákovská","Žárovická","Žíšovská","Žďárská"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) - -/***/ }, -/* 171 */ -/***/ function(module, exports) { - - "use strict"; - - module.exports = { - name: ["#{names.lastName} #{company.suffix}", "#{names.lastName} #{company.suffix}", "#{names.lastName} a #{names.lastName} #{company.suffix}"], + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; - suffix: ["s.r.o.", "a.s.", "v.o.s."] - }; + module["exports"] = ["Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Washington", "West Virginia", "Wisconsin", "Wyoming"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) /***/ }, -/* 172 */ +/* 162 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - - module.exports = { - _meta: { - id: "cs-CZ", - fallback: null, - language: "Czech", - country: "Česká republika", - countryCode: "CZ" - }, + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; - names: __webpack_require__(173), - phone: __webpack_require__(178), - address: __webpack_require__(167), - company: __webpack_require__(171), - internet: __webpack_require__(179) - }; + module["exports"] = ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) /***/ }, -/* 173 */ +/* 163 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - - module.exports = { - firstNameM: __webpack_require__(174), - - firstNameF: __webpack_require__(175), - - lastNameM: __webpack_require__(176), - - lastNameF: __webpack_require__(177), - - prefix: ["Ing.", "Mgr.", "JUDr.", "MUDr."], - - suffix: ["Phd."], - - nameM: ["#{names.prefix} #{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM} #{names.suffix}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}"], - - nameF: ["#{names.prefix} #{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF} #{names.suffix}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}"] + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; - }; + module["exports"] = ["Alley", "Avenue", "Branch", "Bridge", "Brook", "Brooks", "Burg", "Burgs", "Bypass", "Camp", "Canyon", "Cape", "Causeway", "Center", "Centers", "Circle", "Circles", "Cliff", "Cliffs", "Club", "Common", "Corner", "Corners", "Course", "Court", "Courts", "Cove", "Coves", "Creek", "Crescent", "Crest", "Crossing", "Crossroad", "Curve", "Dale", "Dam", "Divide", "Drive", "Drive", "Drives", "Estate", "Estates", "Expressway", "Extension", "Extensions", "Fall", "Falls", "Ferry", "Field", "Fields", "Flat", "Flats", "Ford", "Fords", "Forest", "Forge", "Forges", "Fork", "Forks", "Fort", "Freeway", "Garden", "Gardens", "Gateway", "Glen", "Glens", "Green", "Greens", "Grove", "Groves", "Harbor", "Harbors", "Haven", "Heights", "Highway", "Hill", "Hills", "Hollow", "Inlet", "Inlet", "Island", "Island", "Islands", "Islands", "Isle", "Isle", "Junction", "Junctions", "Key", "Keys", "Knoll", "Knolls", "Lake", "Lakes", "Land", "Landing", "Lane", "Light", "Lights", "Loaf", "Lock", "Locks", "Locks", "Lodge", "Lodge", "Loop", "Mall", "Manor", "Manors", "Meadow", "Meadows", "Mews", "Mill", "Mills", "Mission", "Mission", "Motorway", "Mount", "Mountain", "Mountain", "Mountains", "Mountains", "Neck", "Orchard", "Oval", "Overpass", "Park", "Parks", "Parkway", "Parkways", "Pass", "Passage", "Path", "Pike", "Pine", "Pines", "Place", "Plain", "Plains", "Plains", "Plaza", "Plaza", "Point", "Points", "Port", "Port", "Ports", "Ports", "Prairie", "Prairie", "Radial", "Ramp", "Ranch", "Rapid", "Rapids", "Rest", "Ridge", "Ridges", "River", "Road", "Road", "Roads", "Roads", "Route", "Row", "Rue", "Run", "Shoal", "Shoals", "Shore", "Shores", "Skyway", "Spring", "Springs", "Springs", "Spur", "Spurs", "Square", "Square", "Squares", "Squares", "Station", "Station", "Stravenue", "Stravenue", "Stream", "Stream", "Street", "Street", "Streets", "Summit", "Summit", "Terrace", "Throughway", "Trace", "Track", "Trafficway", "Trail", "Trail", "Tunnel", "Tunnel", "Turnpike", "Turnpike", "Underpass", "Union", "Unions", "Valley", "Valleys", "Via", "Viaduct", "View", "Views", "Village", "Village", "Villages", "Ville", "Vista", "Vista", "Walk", "Walks", "Wall", "Way", "Ways", "Well", "Wells"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) /***/ }, -/* 174 */ +/* 164 */ /***/ function(module, exports) { "use strict"; - module.exports = ["Abadon", "Abdon", "Ábel", "Abelard", "Abraham", "Abrahám", "Absolon", "Absolón", "Adalbert", "Adam", "Adin", "Adolf", "Adrian", "Adrián", "Agaton", "Achil", "Achiles", "Alan", "Alban", "Albert", "Albín", "Albrecht", "Aldo", "Alen", "Aleš", "Alexandr", "Alexej", "Alfons", "Alfréd", "Alois", "Alojz", "Alva", "Alvar", "Alvin", "Amadeus", "Amand", "Amát", "Ambrož", "Amos", "Ámos", "Anastáz", "Anatol", "Anděl", "Andělín", "Andrej", "Anselm", "Antal", "Antonín", "Aram", "Ariel", "Aristid", "Arkád", "Armand", "Armin", "Arne", "Arnold", "Arnošt", "Áron", "Árón", "Arpád", "Arsen", "Artur", "Artuš", "Arzen", "Atanas", "Atanáš", "Atila", "August", "Augustin", "Augustýn", "Aurel", "Aurelián", "Axel", "Baltazar", "Barnabáš", "Bartoloměj", "Basil", "Bazil", "Beatus", "Bedřich", "Benedikt", "Benjamin", "Benjamín", "Bernard", "Bertold", "Bertram", "Bivoj", "Blahomil", "Blahomír", "Blahoslav", "Blažej", "Bohdan", "Bohuchval", "Bohumil", "Bohumír", "Bohun", "Bohuslav", "Bohuš", "Bojan", "Bolemír", "Boleslav", "Bonifác", "Borek", "Boris", "Borislav", "Bořek", "Bořislav", "Bořivoj", "Božetěch", "Božidar", "Božislav", "Branimír", "Branislav", "Bratislav", "Bret", "Brian", "Brit", "Bronislav", "Bruno", "Břetislav", "Budimír", "Budislav", "Budivoj", "Cecil", "Cedrik", "Celestin", "Celestýn", "César", "Cézar", "Ctibor", "Ctirad", "Ctislav", "Cyprián", "Cyril", "Čeněk", "Čestmír", "Čistoslav", "Dag", "Dalibor", "Dalimil", "Dalimír", "Damián", "Dan", "Daniel", "Darek", "Darius", "David", "Denis", "Děpold", "Dětmar", "Dětřich", "Dezider", "Dimitrij", "Dino", "Dionýz", "Dionýzos", "Diviš", "Dluhoš", "Dobromil", "Dobromír", "Dobroslav", "Dominik", "Donald", "Donát", "Dorian", "Dorián", "Drahomil", "Drahomír", "Drahoň", "Drahoslav", "Drahoš", "Drahotín", "Drahutin", "Dušan", "Edgar", "Edmond", "Edmund", "Eduard", "Edvard", "Edvin", "Edvín", "Egmont", "Egon", "Eliáš", "Elizej", "Elizeus", "Elmar", "Elvis", "Emanuel", "Emanuel", "Emerich", "Emil", "Emilián", "Engelbert", "Erazim", "Erazmus", "Erhard", "Erich", "Erik", "Ernest", "Ernst", "Ervín", "Eugen", "Eusebius", "Evald", "Evan", "Evarist", "Evžen", "Ezechiel", "Ezra", "Fabián", "Faust", "Faustin", "Faustýn", "Fedor", "Felicián", "Felix", "Ferdinand", "Fidel", "Fidelius", "Filemon", "Filibert", "Filip", "Filomen", "Flavián", "Flavius", "Florentin", "Florentýn", "Florián", "Fortunát", "Fráňa", "Franc", "František", "Fridolín", "Gabin", "Gabriel", "Gál", "Garik", "Gaston", "Gedeon", "Gejza", "Genadij", "Gerald", "Gerard", "Gerazim", "Gerhard", "Géza", "Gilbert", "Gleb", "Glen", "Gorazd", "Gordon", "Gothard", "Gracián", "Grant", "Gunter", "Gűnter", "Gustav", "Hanuš", "Harald", "Harold", "Haštal", "Havel", "Helmut", "Herbert", "Herman", "Heřman", "Hilar", "Hilarius", "Hjalmar", "Homér", "Honor", "Honorius", "Horác", "Horst", "Horymír", "Hostimil", "Hostimír", "Hostislav", "Hostivít", "Hovard", "Hubert", "Hugo", "Hvězdoslav", "Hyacint", "Hynek", "Hypolit", "Chrabroš", "Chraniboj", "Chranibor", "Chranislav", "Chrudoš", "Chval", "Ignác", "Ignát", "Igor", "Ilja", "Inocenc", "Irenej", "Ireneus", "Irvin", "Isidor", "Ivan", "Ivar", "Ivo", "Ivor", "Izaiáš", "Izák", "Izidor", "Izmael", "Jacek", "Jáchym", "Jakub", "Jan", "Jarmil", "Jarolím", "Jaromil", "Jaromír", "Jaroslav", "Jason", "Jasoň", "Jeremiáš", "Jeroným", "Jiljí", "Jimram", "Jindřich", "Jiří", "Job", "Joel", "Jonáš", "Jonatan", "Jonathan", "Jordan", "Josef", "Jošt", "Jozef", "Jozue", "Juda", "Julián", "Julius", "Justin", "Justýn", "Kajetán", "Kamil", "Karel", "Kasián", "Kastor", "Kašpar", "Kazimír", "Kilián", "Kim", "Klaudián", "Klaudius", "Klement", "Kliment", "Knut", "Koloman", "Kolombín", "Kolumbán", "Kolumbín", "Konrád", "Konstantin", "Konstantýn", "Kornel", "Kornelius", "Kosma", "Kosmas", "Krasomil", "Krasoslav", "Kristián", "Kryšpín", "Kryštof", "Křesomysl", "Křišťan", "Kurt", "Květoň", "Květoslav", "Květoš", "Kvido", "Ladislav", "Lambert", "Lars", "Laurenc", "Lazar", "Leander", "Leandr", "Leo", "Leodegar", "Leon", "Leonard", "Leonid", "Leontýn", "Leopold", "Leoš", "Lešek", "Lev", "Libor", "Liboslav", "Lionel", "Livius", "Lorenc", "Lotar", "Lothar", "Lubomír", "Lubor", "Luboslav", "Luboš", "Lucián", "Lucius", "Luděk", "Ludivoj", "Ludomír", "Ludoslav", "Ludvík", "Lukáš", "Lukrecius", "Lumír", "Lutibor", "Lutobor", "Magnus", "Makar", "Manfred", "Manfréd", "Mansvet", "Manuel", "Marcel", "Marek", "Marian", "Marián", "Marin", "Mario", "Marius", "Martin", "Matěj", "Matouš", "Matyáš", "Max", "Maxim", "Maximilián", "Maxmilián", "Mečislav", "Medard", "Melichar", "Merlin", "Mervin", "Metod", "Metoděj", "Michael", "Michal", "Mikoláš", "Mikuláš", "Milan", "Milíč", "Milík", "Milivoj", "Miloň", "Milorad", "Miloslav", "Miloš", "Milota", "Milouš", "Milovan", "Milovín", "Milutín", "Mirek", "Mirko", "Miromil", "Miron", "Miroslav", "Mirtil", "Mlad", "Mladen", "Mnata", "Mnislav", "Modest", "Mojmír", "Mojžíš", "Morgan", "Moric", "Moris", "Mořic", "Mstislav", "Myron", "Myrtil", "Napoleon", "Narcis", "Natan", "Natanael", "Nathan", "Nathanael", "Něhoslav", "Neklan", "Nepomuk", "Nezamysl", "Nikita", "Nikodém", "Nikola", "Nikolas", "Norbert", "Norman", "Odolen", "Odon", "Oktavián", "Oktavius", "Olaf", "Olbram", "Oldřich", "Oleg", "Oliver", "Omar", "Ondřej", "Orest", "Oskar", "Osvald", "Ota", "Otakar", "Otmar", "Oto", "Otokar", "Otomar", "Ovidius", "Palmiro", "Pankrác", "Pantaleon", "Paris", "Parsival", "Paskal", "Patrik", "Pavel", "Pavlín", "Pelhřim", "Perikles", "Petr", "Petronius", "Pius", "Platon", "Platón", "Polykarp", "Pravdomil", "Pravomil", "Prokop", "Prosper", "Přemysl", "Přibyslav", "Radan", "Radegast", "Radek", "Radhost", "Radim", "Radimír", "Radislav", "Radivoj", "Radko", "Radmil", "Radomil", "Radomír", "Radoslav", "Radoš", "Radovan", "Radúz", "Radvan", "Rafael", "Raimund", "Rainald", "Rainer", "Rainhard", "Rainold", "Rajko", "Ralf", "Ramon", "Randolf", "Ranek", "Ranko", "Rastislav", "Ratibor", "Ratmír", "Redmond", "Reginald", "Remig", "Remus", "Renát", "René", "Richard", "Robert", "Robin", "Robinson", "Rodan", "Roderik", "Rodrigo", "Roger", "Roch", "Roland", "Rolf", "Roman", "Romeo", "Romuald", "Romul", "Romulus", "Ronald", "Rostislav", "Ruben", "Rudolf", "Rufus", "Rupert", "Ruprecht", "Ruslan", "Řehoř", "Sába", "Sámo", "Samson", "Samuel", "Saturnin", "Saul", "Sáva", "Sebastian", "Sebastián", "Sebestian", "Sedrik", "Serafín", "Serenus", "Sergej", "Servác", "Severín", "Sidon", "Sigfríd", "Silvan", "Silván", "Silvestr", "Silvius", "Simeon", "Simon", "Sinkler", "Sixt", "Sixtus", "Slávek", "Slaviboj", "Slavibor", "Slavoboj", "Slavoj", "Slavomil", "Slavomír", "Smil", "Soběslav", "Sokrat", "Soter", "Spytihněv", "Stanimír", "Stanislav", "Stojan", "Stojmír", "Svatoboj", "Svatobor", "Svatomír", "Svatopluk", "Svatoslav", "Sven", "Svetozar", "Šalamoun", "Šalomoun", "Šavel", "Šebastián", "Šimon", "Šťasta", "Štefan", "Štěpán", "Tadeáš", "Tankred", "Taras", "Teobald", "Teodor", "Teodorik", "Teodoz", "Teofan", "Teofil", "Terenc", "Terencius", "Theobald", "Theodor", "Theodorik", "Theofan", "Theofil", "Tiber", "Tiberius", "Tibor", "Tiburcius", "Tichomil", "Tichomír", "Tichon", "Timon", "Timotej", "Timoteus", "Timur", "Titus", "Tobiáš", "Tomáš", "Tomislav", "Tor", "Torkvát", "Torsten", "Tristan", "Udo", "Ulrich", "Upton", "Urban", "Uve", "Václav", "Vadim", "Valdemar", "Valentin", "Valentýn", "Valerián", "Valter", "Valtr", "Vasil", "Vavřinec", "Veleslav", "Velimír", "Velislav", "Věnceslav", "Vendelín", "Věnek", "Verner", "Věroslav", "Vidor", "Viktor", "Viktorin", "Viktorín", "Vilém", "Vilibald", "Vilmar", "Vincenc", "Virgil", "Virgin", "Vít", "Vítězslav", "Vitold", "Vítoslav", "Vivian", "Vladan", "Vladimír", "Vladislav", "Vladivoj", "Vlastimil", "Vlastimír", "Vlastislav", "Vlk", "Vojen", "Vojmil", "Vojmír", "Vojslav", "Vojtěch", "Vok", "Volfgang", "Vratislav", "Vsevolod", "Všeboj", "Všebor", "Všerad", "Všeslav", "Xaver", "Xaverius", "Záboj", "Zachar", "Zachariáš", "Záviš", "Zbislav", "Zbyhněv", "Zbyněk", "Zbyslav", "Zbyšek", "Zdeněk", "Zderad", "Zdeslav", "Zdík", "Zdirad", "Zdislav", "Zeno", "Zenon", "Zikmund", "Zlatan", "Zlatko", "Zlatomír", "Zoltán", "Zoran", "Zoroslav", "Zosim", "Zvonimír", "Žarko", "Ždan", "Želibor", "Želimír", "Želislav", "Želmír", "Žitomír", "Žitoslav", "Živan"]; + module.exports = function (coordinate) { + var radius = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10.0; + var isMetric = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; -/***/ }, -/* 175 */ -/***/ function(module, exports) { - "use strict"; + function degreesToRadians(degrees) { + return degrees * (Math.PI / 180.0); + } - module.exports = ["Abigail", "Ada", "Adalberta", "Adéla", "Adelaida", "Adina", "Adolfa", "Adolfína", "Adriana", "Adriána", "Adriena", "Afra", "Agáta", "Aglaja", "Aida", "Alana", "Albena", "Alberta", "Albertina", "Albertýna", "Albína", "Alena", "Aleška", "Alexandra", "Alfréda", "Alice", "Alida", "Alina", "Alma", "Aloisie", "Alojzije", "Alžběta", "Amálie", "Amanda", "Amáta", "Amélie", "Anabela", "Anastázie", "Anatázie", "Anatolie", "Anatólie", "Anděla", "Andělína", "Andrea", "Aneta", "Anežka", "Angela", "Angelika", "Anita", "Anna", "Anselma", "Antonie", "Apolena", "Arabela", "Aranka", "Areta", "Ariadna", "Ariana", "Ariela", "Arleta", "Armida", "Arna", "Arnolda", "Arnoštka", "Astrid", "Astrida", "Atanázie", "Augusta", "Augustina", "Augustýna", "Aura", "Aurélie", "Aurora", "Babeta", "Barbara", "Barbora", "Beáta", "Beatrice", "Bedřiška", "Bela", "Běla", "Belinda", "Benedikta", "Berenika", "Berit", "Bernarda", "Berta", "Bertolda", "Bianka", "Bibiana", "Birgit", "Birgita", "Blahomila", "Blahomíra", "Blahoslava", "Blanka", "Blažena", "Bohdana", "Bohumila", "Bohumíra", "Bohuna", "Bohuslava", "Bohuše", "Bojana", "Bojislava", "Boleslava", "Borislava", "Bořislava", "Božena", "Božetěcha", "Božidara", "Branimíra", "Branislava", "Bratislava", "Brenda", "Brigita", "Brita", "Bronislava", "Bruna", "Brunhilda", "Břetislava", "Cecilie", "Cecílie", "Celestina", "Celestýna", "Celie", "Celina", "Ctibora", "Ctirada", "Ctislava", "Cyntie", "Cyrila", "Čeňka", "Čestmíra", "Čistoslava", "Dagmar", "Dagmara", "Dalibora", "Dalida", "Dalie", "Dalila", "Dalimila", "Dalimíra", "Damaris", "Damiana", "Damiána", "Dana", "Danica", "Daniela", "Danuše", "Danuta", "Daria", "Darie", "Darina", "Darja", "Davida", "Debora", "Delie", "Denisa", "Diana", "Dina", "Dita", "Diviška", "Dobrava", "Dobromila", "Dobromíra", "Dobroslava", "Dominika", "Donalda", "Donáta", "Dora", "Doris", "Dorota", "Doubrava", "Doubravka", "Drahomila", "Drahomíra", "Drahoslava", "Drahotína", "Drahuše", "Dulcinea", "Dušana", "Edita", "Eduarda", "Edvarda", "Egona", "Ela", "Elektra", "Elena", "Eleonora", "Elfrída", "Eliška", "Elsa", "Elvíra", "Elza", "Ema", "Emanuela", "Emilie", "Emílie", "Erika", "Erna", "Ervína", "Estela", "Ester", "Estera", "Etela", "Eufrozina", "Eufrozína", "Eugenie", "Eulálie", "Eunika", "Eusebie", "Eva", "Evelina", "Evelína", "Evženie", "Fabiána", "Fabie", "Fatima", "Faustina", "Faustýna", "Féba", "Fedora", "Felicie", "Felície", "Felicita", "Ferdinanda", "Fidelie", "Filipa", "Filoména", "Flavie", "Flora", "Flóra", "Florentina", "Florentýna", "Františka", "Frída", "Gabriela", "Gaja", "Gajana", "Galina", "Garika", "Gema", "Geralda", "Geraldina", "Gerarda", "Gerardina", "Gerda", "Gerharda", "Gertruda", "Gilberta", "Gina", "Gisela", "Gita", "Gizela", "Glorie", "Gordana", "Graciána", "Gracie", "Grácie", "Gražina", "Gréta", "Griselda", "Grizelda", "Gudrun", "Gustava", "Gvendolina", "Gvendolína", "Halina", "Hana", "Háta", "Havla", "Heda", "Hedvika", "Heidrun", "Helena", "Helga", "Herberta", "Hermína", "Herta", "Hilda", "Hortensie", "Hortenzie", "Horymíra", "Hostimila", "Hostimíra", "Hostislava", "Hvězdoslava", "Hyacinta", "Chranislava", "Iboja", "Ida", "Ignácie", "Ignáta", "Ildika", "Iljana", "Ilona", "Ilsa", "Ilza", "Ines", "Inesa", "Inéz", "Ingeborg", "Ingeborga", "Ingrid", "Ingrida", "Inka", "Irena", "Iris", "Irma", "Isabela", "Isidora", "Isolda", "Iva", "Ivana", "Iveta", "Ivona", "Izabela", "Izidora", "Izolda", "Jadrana", "Jadranka", "Jakuba", "Jakubka", "Jana", "Jarmila", "Jarolíma", "Jaromíra", "Jaroslava", "Jasmína", "Jasna", "Jasněna", "Jelena", "Jenovéfa", "Jesika", "Jindra", "Jindřiška", "Jiřina", "Jitka", "Johana", "Jolana", "Jolanta", "Jordana", "Jorga", "Josefa", "Josefína", "Jovana", "Jozefa", "Jozefína", "Judita", "Juliana", "Juliána", "Julie", "Justina", "Justýna", "Juta", "Kamila", "Karin", "Karina", "Karla", "Karmela", "Karmen", "Karolina", "Karolína", "Kateřina", "Katrin", "Katrina", "Kazi", "Kazimíra", "Kira", "Klára", "Klaudie", "Klementina", "Klementýna", "Kleopatra", "Klotylda", "Koleta", "Kolombína", "Kolumbína", "Konstance", "Konstancie", "Konsuela", "Konzuela", "Kora", "Kordula", "Korina", "Kornélie", "Krasava", "Krasomila", "Kristina", "Kristýna", "Kunhuta", "Květa", "Květoslava", "Květuše", "Lada", "Ladislava", "Larisa", "Laura", "Laurencie", "Lea", "Léda", "Leila", "Lejla", "Lena", "Lenka", "Leokádie", "Leona", "Leonora", "Leontina", "Leontýna", "Leopolda", "Leopoldina", "Leopoldýna", "Leticie", "Lia", "Liana", "Liběna", "Libora", "Liboslava", "Libuše", "Lidmila", "Liliana", "Lina", "Linda", "Livie", "Ljuba", "Lola", "Loreta", "Lorna", "Lota", "Lubomíra", "Luboslava", "Luciána", "Lucie", "Ludiše", "Luďka", "Ludmila", "Ludomíra", "Ludoslava", "Ludvika", "Ludvíka", "Luisa", "Lujza", "Lukrécie", "Lumíra", "Lydie", "Lýdie", "Mabel", "Mabela", "Magda", "Magdalena", "Magdaléna", "Mahulena", "Maja", "Mája", "Malvína", "Manon", "Manona", "Manuela", "Marcela", "Marcelína", "Margit", "Margita", "Mariana", "Marie", "Marieta", "Marika", "Marilyn", "Marina", "Mariola", "Marion", "Marisa", "Marita", "Markéta", "Marlena", "Marta", "Martina", "Matylda", "Maud", "Maxima", "Mečislava", "Medea", "Médea", "Melánie", "Melinda", "Melisa", "Melita", "Mercedes", "Michaela", "Michala", "Milada", "Milana", "Milena", "Miloslava", "Milred", "Miluše", "Mína", "Mira", "Mirabela", "Miranda", "Mirela", "Miriam", "Mirjam", "Mirka", "Miromila", "Miroslava", "Mnislava", "Mona", "Monika", "Muriel", "Muriela", "Myrna", "Naďa", "Naděžda", "Naneta", "Narcisa", "Natalie", "Natálie", "Nataša", "Neda", "Nela", "Nevena", "Nika", "Niké", "Nikodéma", "Nikol", "Nikola", "Nila", "Nina", "Noema", "Noemi", "Nona", "Nora", "Norberta", "Norma", "Odeta", "Ofélie", "Oktavie", "Oktávie", "Oldřiška", "Olga", "Oliva", "Olivie", "Olympie", "Ondřejka", "Otakara", "Otilie", "Otýlie", "Oxana", "Palmira", "Pamela", "Paskala", "Patricie", "Pavla", "Pavlína", "Pelagie", "Penelopa", "Perla", "Persida", "Perzida", "Petra", "Petrana", "Petronela", "Petronila", "Petruše", "Petula", "Pilar", "Polyxena", "Pravdomila", "Pravomila", "Pravoslav", "Pravoslava", "Priscila", "Priska", "Prokopa", "Přibyslava", "Radana", "Radimíra", "Radislava", "Radka", "Radmila", "Radomila", "Radomíra", "Radoslava", "Radovana", "Radslava", "Rafaela", "Ráchel", "Raisa", "Rajsa", "Ramona", "Rastislava", "Rebeka", "Regina", "Regína", "Renata", "Renáta", "René", "Ria", "Riana", "Richarda", "Rina", "Rita", "Roberta", "Robina", "Romana", "Rosa", "Rosalinda", "Rosamunda", "Rosana", "Rostislava", "Rovena", "Roxana", "Róza", "Rozálie", "Rozalinda", "Rozamunda", "Rozana", "Rozina", "Rozita", "Rozvita", "Rudolfa", "Rudolfina", "Rudolfína", "Rut", "Rút", "Růžena", "Řehořka", "Sabina", "Sabrina", "Salomea", "Salomena", "Samuela", "Sandra", "Sára", "Saskia", "Saskie", "Saxona", "Selena", "Selma", "Senta", "Serafína", "Serena", "Scholastika", "Sibyla", "Sidonie", "Silvána", "Silvie", "Simeona", "Simona", "Skarlet", "Skarleta", "Slavěna", "Slávka", "Slavomila", "Slavomíra", "Soběslava", "Sofie", "Sofronie", "Solveig", "Solveiga", "Soňa", "Sotira", "Stanislava", "Stáza", "Stela", "Svatava", "Svatoslava", "Světla", "Světlana", "Světluše", "Sylva", "Sylvie", "Sylvie", "Šárka", "Šarlota", "Šimona", "Štěpána", "Štěpánka", "Tamara", "Táňa", "Taťána", "Tea", "Tekla", "Teodora", "Teodozie", "Teofila", "Tereza", "Terezie", "Thea", "Theodora", "Theodosie", "Theofila", "Tomáška", "Toska", "Ulrika", "Una", "Uršula", "Václava", "Valburga", "Valdemara", "Valentina", "Valentýna", "Valerie", "Valérie", "Vanda", "Vanesa", "Věduna", "Veleslava", "Velislava", "Věnceslava", "Vendelína", "Vendula", "Vendulka", "Věnka", "Venuše", "Věra", "Verona", "Veronika", "Věroslava", "Věslava", "Vesna", "Viktorie", "Viléma", "Vilemína", "Vilma", "Vincencie", "Viola", "Violeta", "Virginie", "Virgínie", "Víta", "Vítězslava", "Viviana", "Vladana", "Vladěna", "Vladimíra", "Vladislava", "Vlasta", "Vlastimila", "Vlastimíra", "Vlastislava", "Vojmíra", "Vojslava", "Vojtěška", "Voršila", "Vratislava", "Xaverie", "Xenie", "Zaida", "Zaira", "Zbyhněva", "Zbyňka", "Zbyslava", "Zbyška", "Zdena", "Zdenka", "Zdeňka", "Zdeslava", "Zdislava", "Zenobie", "Zina", "Zinaida", "Zita", "Zlata", "Zlatomíra", "Zlatuše", "Zoe", "Zoja", "Zora", "Zoroslava", "Zuzana", "Zvonimíra", "Žakelina", "Žakelína", "Žaneta", "Ždana", "Želimíra", "Želislava", "Želmíra", "Žitomíra", "Žitoslava", "Živa", "Živana", "Žofie"]; + function radiansToDegrees(radians) { + return radians * (180.0 / Math.PI); + } -/***/ }, -/* 176 */ -/***/ function(module, exports) { + function milesToKm(miles) { + return miles * 0.621371; + } - "use strict"; + function coordinateWithOffset(coordinate, bearing, distance, isMetric) { + var R = 6378.137; + var d = isMetric ? distance : milesToKm(distance); - module.exports = ["Adam", "Adamec", "Adámek", "Albrecht", "Ambrož", "Anděl", "Andrle", "Antoš", "Bajer", "Baláž", "Balcar", "Balog", "Baloun", "Barák", "Baran", "Bareš", "Bárta", "Barták", "Bartoň", "Bartoš", "Bartošek", "Bartůněk", "Bašta", "Bauer", "Bayer", "Bažant", "Bečka", "Bečvář", "Bednář", "Bednařík", "Bělohlávek", "Benda", "Beneš", "Beran", "Beránek", "Berger", "Berka", "Berky", "Bernard", "Bezděk", "Bílek", "Bílý", "Bína", "Bittner", "Blaha", "Bláha", "Blažek", "Blecha", "Bobek", "Boček", "Boháč", "Boháček", "Böhm", "Borovička", "Bouček", "Bouda", "Bouška", "Brabec", "Brabenec", "Brada", "Bradáč", "Braun", "Brázda", "Brázdil", "Brejcha", "Březina", "Bříza", "Brož", "Brožek", "Brychta", "Bubeník", "Buček", "Buchta", "Burda", "Bureš", "Burian", "Buriánek", "Byrtus", "čada", "Caha", "čáp", "čapek", "čech", "čejka", "čermák", "černík", "černoch", "černohorský", "černý", "červeňák", "červenka", "červený", "červinka", "Chaloupka", "Chalupa", "Charvát", "Chládek", "Chlup", "Chmelař", "Chmelík", "Chovanec", "Chromý", "Chudoba", "Chvátal", "Chvojka", "Chytil", "Cibulka", "čihák", "Cihlář", "Císař", "čížek", "čonka", "Coufal", "čurda", "Daněk", "Daniel", "Daniš", "David", "Dědek", "Demeter", "Dittrich", "Diviš", "Dlouhý", "Dobeš", "Dobiáš", "Dobrovolný", "Dočekal", "Dočkal", "Dohnal", "Dokoupil", "Doleček", "Dolejš", "Dolejší", "Doležal", "Doležel", "Doskočil", "Dostál", "Doubek", "Doubrava", "Douša", "Drábek", "Drozd", "Dubský", "Duchoň", "Duda", "Dudek", "Dufek", "Dunka", "Dušek", "Dvořáček", "Dvořák", "Dvorský", "Eliáš", "Erben", "Fabián", "Fanta", "Farkaš", "Fejfar", "Fencl", "Ferenc", "Ferko", "Fiala", "Fiedler", "Filip", "Fischer", "Fišer", "Florián", "Fojtík", "Foltýn", "Forman", "Formánek", "Fořt", "Fousek", "Franc", "Franěk", "Frank", "Fridrich", "Frydrych", "Fuchs", "Fučík", "Fuksa", "Gábor", "Gabriel", "Gajdoš", "Gaži", "Gottwald", "Gregor", "Gruber", "Grundza", "Grygar", "Hájek", "Hajný", "Hála", "Hampl", "Hána", "Hanáček", "Hanák", "Hanousek", "Hanus", "Hanuš", "Hanzal", "Hanzl", "Hanzlík", "Hartman", "Hašek", "Havel", "Havelka", "Havlíček", "Havlík", "Havránek", "Heczko", "Heger", "Hejda", "Hejduk", "Hejl", "Hejna", "Hendrych", "Herman", "Heřman", "Heřmánek", "Hladík", "Hladký", "Hlaváč", "Hlaváček", "Hlavatý", "Hlávka", "Hloušek", "Hoffmann", "Hofman", "Holan", "Holas", "Holec", "Holeček", "Holík", "Holoubek", "Holub", "Holý", "Homola", "Homolka", "Hora", "Horáček", "Horák", "Hořejší", "Horký", "Horňák", "Horníček", "Horník", "Horský", "Horvát", "Horváth", "Hošek", "Houdek", "Houška", "Hovorka", "Hrabal", "Hrabovský", "Hradecký", "Hradil", "Hrbáček", "Hrbek", "Hrdina", "Hrdlička", "Hrdý", "Hrnčíř", "Hroch", "Hromádka", "Hron", "Hrubeš", "Hrubý", "Hruška", "Hrůza", "Hubáček", "Hudec", "Hudeček", "Hůlka", "Huml", "Husák", "Hušek", "Hýbl", "Hynek", "Jahoda", "Jakeš", "Jakl", "Jakoubek", "Jakubec", "Janáček", "Janák", "Janata", "Janča", "Jančík", "Janda", "Janeček", "Janečka", "Janíček", "Janík", "Janků", "Janota", "Janoušek", "Janovský", "Jansa", "Jánský", "Janů", "Jareš", "Jaroš", "Jašek", "Javůrek", "Jech", "Jedlička", "Jelen", "Jelínek", "Jeníček", "Jeřábek", "Jež", "Ježek", "Jílek", "Jindra", "Jíra", "Jirák", "Jiránek", "Jirásek", "Jiřík", "Jirka", "Jirků", "Jiroušek", "Jirsa", "John", "Jonáš", "Junek", "Jurčík", "Jurečka", "Juřica", "Juřík", "Kabát", "Kačírek", "Kadeřábek", "Kadlec", "Kafka", "Kaiser", "Kala", "Kaláb", "Kalaš", "Kalina", "Kalivoda", "Kalous", "Kalousek", "Kameník", "Kaňa", "Káňa", "Kaňka", "Kantor", "Kaplan", "Karas", "Karásek", "Karban", "Karel", "Karlík", "Kasal", "Kašík", "Kašpar", "Kašpárek", "Kavka", "Kazda", "Kindl", "Klečka", "Klein", "Klement", "Klíma", "Kliment", "Klimeš", "Klouček", "Klouda", "Knap", "Knotek", "Koch", "Kočí", "Kocián", "Kocman", "Kocourek", "Kohout", "Kohoutek", "Koláček", "Kolář", "Kolařík", "Kolek", "Kolman", "Komárek", "Komínek", "Konečný", "Koníček", "Kopal", "Kopeček", "Kopecký", "Kopečný", "Kopřiva", "Korbel", "Kořínek", "Kos", "Kosík", "Kosina", "Košťál", "Kostka", "Kotas", "Kotek", "Kotlár", "Kotrba", "Kouba", "Koubek", "Koudela", "Koudelka", "Koukal", "Kouřil", "Koutný", "Kováč", "Kovář", "Kovařík", "Kovářík", "Kozák", "Kozel", "Krajíček", "Král", "Králíček", "Králík", "Krátký", "Kratochvíl", "Kraus", "Krčmář", "Křeček", "Krejčí", "Krejčík", "Krejčíř", "Křenek", "Krištof", "Křivánek", "Kříž", "Křížek", "Kropáček", "Kroupa", "Krupa", "Krupička", "Krupka", "Kuba", "Kubánek", "Kubát", "Kubec", "Kubelka", "Kubeš", "Kubica", "Kubíček", "Kubík", "Kubín", "Kubiš", "Kuča", "Kučera", "Kuchař", "Kuchta", "Kudláček", "Kudrna", "Kukla", "Kulhánek", "Kulhavý", "Kunc", "Kuneš", "Kupec", "Kupka", "Kurka", "Kužel", "Kvapil", "Kvasnička", "Kyncl", "Kysela", "Lacina", "Lacko", "Lakatoš", "Landa", "Lang", "Langer", "Langr", "Látal", "Lavička", "Le", "Lebeda", "Levý", "Líbal", "Linhart", "Liška", "Lorenc", "Louda", "Ludvík", "Lukáč", "Lukáš", "Lukášek", "Lukeš", "Macák", "Macek", "Mach", "Mácha", "Machač", "Macháč", "Macháček", "Machala", "Machálek", "Macura", "Majer", "Maleček", "Málek", "Malík", "Malina", "Malý", "Maňák", "Mareček", "Marek", "Mareš", "Mařík", "Maršálek", "Maršík", "Martinec", "Martinek", "Martínek", "Mašek", "Masopust", "Matějíček", "Matějka", "Matouš", "Matoušek", "Matula", "Matuška", "Matyáš", "Matys", "Maxa", "Mayer", "Mazánek", "Medek", "Melichar", "Mencl", "Menšík", "Merta", "Michal", "Michalec", "Michálek", "Michalík", "Michna", "Mička", "Mika", "Míka", "Mikeš", "Miko", "Mikula", "Mikulášek", "Minář", "Minařík", "Mirga", "Mládek", "Mlčoch", "Mlejnek", "Mojžíš", "Mokrý", "Molnár", "Moravec", "Morávek", "Motl", "Motyčka", "Moučka", "Moudrý", "Mráček", "Mráz", "Mrázek", "Mrkvička", "Mucha", "Müller", "Műller", "Musil", "Mužík", "Myška", "Nagy", "Najman", "Navrátil", "Nečas", "Nedbal", "Nedoma", "Nedvěd", "Nejedlý", "Němec", "Němeček", "Nešpor", "Nesvadba", "Neubauer", "Neuman", "Neumann", "Nguyen", "Nguyen van", "Nosek", "Nováček", "Novák", "Novosad", "Novotný", "Nový", "Odehnal", "Oláh", "Oliva", "Ondra", "Ondráček", "Orság", "Otáhal", "Paleček", "Pánek", "Papež", "Pařízek", "Pašek", "Pátek", "Patočka", "Paul", "Pavel", "Pavelek", "Pavelka", "Pavlas", "Pavlica", "Pavlíček", "Pavlík", "Pavlů", "Pazdera", "Pech", "Pecha", "Pecháček", "Pecka", "Pekař", "Pekárek", "Pelc", "Pelikán", "Peřina", "Pernica", "Peroutka", "Pešek", "Peška", "Pešta", "Peterka", "Petr", "Petrák", "Petráš", "Petříček", "Petřík", "Petrů", "Pham", "Pícha", "Pilař", "Pilát", "Píša", "Pivoňka", "Plaček", "Plachý", "Plšek", "Pluhař", "Podzimek", "Pohl", "Pokorný", "Poláček", "Polách", "Polák", "Polanský", "Polášek", "Polívka", "Popelka", "Pospíchal", "Pospíšil", "Potůček", "Pour", "Prachař", "Prášek", "Pražák", "Prchal", "Přibyl", "Příhoda", "Přikryl", "Procházka", "Prokeš", "Prokop", "Prošek", "Provazník", "Průcha", "Průša", "Pšenička", "Ptáček", "Rác", "Rada", "Rak", "Rambousek", "Raška", "Rataj", "řeháček", "řehák", "řehoř", "Remeš", "řezáč", "Rezek", "řezníček", "Richter", "Richtr", "říha", "Roubal", "Rous", "Rozsypal", "Rudolf", "Růžek", "Růžička", "Ryba", "Rybář", "Rýdl", "Ryšavý", "Sadílek", "šafář", "šafařík", "šafránek", "šálek", "Samek", "šanda", "šašek", "Schejbal", "Schmidt", "Schneider", "Schwarz", "šebek", "šebela", "šebesta", "šeda", "šedivý", "Sedláček", "Sedlák", "Sedlář", "Sehnal", "Seidl", "Seifert", "Sekanina", "Semerád", "šenk", "šesták", "ševčík", "Severa", "Sikora", "šilhavý", "šíma", "šimáček", "šimák", "šimánek", "šimčík", "šimeček", "šimek", "šimon", "šimůnek", "šindelář", "šindler", "šíp", "šípek", "šír", "široký", "šiška", "Sivák", "Skácel", "Skala", "Skála", "Skalický", "Sklenář", "škoda", "Skopal", "Skořepa", "škrabal", "Skřivánek", "Slabý", "Sládek", "Sladký", "Sláma", "Slanina", "Slavíček", "Slavík", "šlechta", "Slezák", "Slováček", "Slovák", "Sluka", "Smejkal", "šmejkal", "Smékal", "šmerda", "Smetana", "šmíd", "Smola", "Smolík", "Smolka", "Smrčka", "Smrž", "Smutný", "šnajdr", "Sobek", "Sobotka", "Sochor", "Sojka", "Sokol", "šolc", "Sommer", "Souček", "Soukup", "Sova", "špaček", "Spáčil", "špička", "šplíchal", "Spurný", "šrámek", "Srb", "Staněk", "Stárek", "Starý", "šťastný", "štefan", "štefek", "štefl", "Stehlík", "Steiner", "Stejskal", "štěpán", "štěpánek", "štěrba", "Stibor", "Stoklasa", "Straka", "Stránský", "Strejček", "Strnad", "Strouhal", "Stuchlík", "Studený", "Studnička", "Stupka", "šubrt", "Suchánek", "Suchomel", "Suchý", "Suk", "šulc", "šustr", "šváb", "Svačina", "švanda", "švarc", "Svatoň", "Svatoš", "švec", "švehla", "švejda", "švestka", "Světlík", "Sviták", "Svoboda", "Svozil", "Sýkora", "Synek", "Syrový", "Táborský", "Tancoš", "Teplý", "Tesař", "Tichý", "Toman", "Tománek", "Tomáš", "Tomášek", "Tomeček", "Tomek", "Tomeš", "Tóth", "Tran", "Trávníček", "Trčka", "Tříska", "Trnka", "Trojan", "Truhlář", "Tuček", "Tůma", "Tureček", "Turek", "Tvrdík", "Tvrdý", "Uher", "Uhlíř", "Ulrich", "Urban", "Urbanec", "Urbánek", "Vacek", "Vácha", "Václavek", "Václavík", "Vaculík", "Vágner", "Vala", "Valášek", "Válek", "Valenta", "Valeš", "Váňa", "Vančura", "Vaněček", "Vaněk", "Vaníček", "Varga", "Vašák", "Vašek", "Vašíček", "Vávra", "Vavřík", "Večeřa", "Vejvoda", "Verner", "Veselý", "Veverka", "Vícha", "Vilímek", "Vinš", "Víšek", "Vít", "Vitásek", "Vítek", "Vlach", "Vlasák", "Vlček", "Vlk", "Vobořil", "Vodák", "Vodička", "Vodrážka", "Vojáček", "Vojta", "Vojtěch", "Vojtek", "Vojtíšek", "Vokoun", "Volek", "Volf", "Volný", "Vondra", "Vondráček", "Vondrák", "Voráček", "Vorel", "Voříšek", "Vorlíček", "Votava", "Votruba", "Vrabec", "Vrána", "Vrba", "Vrzal", "Vybíral", "Vydra", "Vymazal", "Vyskočil", "Vysloužil", "Wagner", "Walter", "Weber", "Weiss", "Winkler", "Wolf", "Zábranský", "žáček", "Zach", "Zahrádka", "Zahradník", "Zajíc", "Zajíček", "žák", "Zálešák", "Zámečník", "Zapletal", "Záruba", "Zatloukal", "Zavadil", "Zavřel", "Zbořil", "žďárský", "Zdražil", "Zedník", "Zelenka", "Zelený", "Zelinka", "Zeman", "Zemánek", "žemlička", "Zezula", "žídek", "žiga", "Zíka", "Zikmund", "Zima", "žižka", "Zlámal", "Zoubek", "Zouhar", "žůrek", "Zvěřina"]; + var lat1 = degreesToRadians(coordinate.latitude); + var lon1 = degreesToRadians(coordinate.longitude); -/***/ }, -/* 177 */ -/***/ function(module, exports) { + var lat2 = Math.asin(Math.sin(lat1) * Math.cos(d / R) + Math.cos(lat1) * Math.sin(d / R) * Math.cos(bearing)); - "use strict"; + var lon2 = lon1 + Math.atan2(Math.sin(bearing) * Math.sin(d / R) * Math.cos(lat1), Math.cos(d / R) - Math.sin(lat1) * Math.sin(lat2)); - module.exports = ["Adamová", "Adamcová", "Adámková", "Albrechtová", "Ambrožová", "Andělová", "Andrleová", "Antošová", "Bajrová", "Balážová", "Balcarová", "Balogová", "Balounová", "Baráková", "Baranová", "Barešová", "Bártová", "Bartáková", "Bartoňová", "Bartošová", "Bartošková", "Bartůněková", "Baštová", "Baurová", "Bayrová", "Bažantová", "Bečková", "Bečvářová", "Bednářová", "Bednaříková", "Bělohlávková", "Bendová", "Benešová", "Beranová", "Beránková", "Bergrová", "Berková", "Berkyová", "Bernardová", "Bezděková", "Bílková", "Bílýová", "Bínová", "Bittnrová", "Blahová", "Bláhová", "Blažková", "Blechová", "Bobková", "Bočková", "Boháčová", "Boháčková", "Böhmová", "Borovičková", "Boučková", "Boudová", "Boušková", "Brabcová", "Brabencová", "Bradová", "Bradáčová", "Braunová", "Brázdová", "Brázdilová", "Brejchová", "Březinová", "Břízová", "Brožová", "Brožková", "Brychtová", "Bubeníková", "Bučková", "Buchtová", "Burdová", "Burešová", "Burianová", "Buriánková", "Byrtusová", "čadová", "Cahová", "čápová", "čapková", "čechová", "čejková", "čermáková", "černíková", "černochová", "černohorskýová", "černýová", "červeňáková", "červenková", "červenýová", "červinková", "Chaloupková", "Chalupová", "Charvátová", "Chládková", "Chlupová", "Chmelařová", "Chmelíková", "Chovancová", "Chromýová", "Chudobová", "Chvátalová", "Chvojková", "Chytilová", "Cibulková", "čiháková", "Cihlářová", "Císařová", "čížková", "čonková", "Coufalová", "čurdová", "Daněková", "Danilová", "Danišová", "Davidová", "Dědková", "Demetrová", "Dittrichová", "Divišová", "Dlouhýová", "Dobešová", "Dobiášová", "Dobrovolnýová", "Dočekalová", "Dočkalová", "Dohnalová", "Dokoupilová", "Dolečková", "Dolejšová", "Dolejšíová", "Doležalová", "Doležlová", "Doskočilová", "Dostálová", "Doubková", "Doubravová", "Doušová", "Drábková", "Drozdová", "Dubskýová", "Duchoňová", "Dudová", "Dudková", "Dufková", "Dunková", "Dušková", "Dvořáčková", "Dvořáková", "Dvorskýová", "Eliášová", "Erbnová", "Fabiánová", "Fantová", "Farkašová", "Fejfarová", "Fenclová", "Ferencová", "Ferkoová", "Fialová", "Fiedlrová", "Filipová", "Fischrová", "Fišrová", "Floriánová", "Fojtíková", "Foltýnová", "Formanová", "Formánková", "Fořtová", "Fousková", "Francová", "Franěková", "Franková", "Fridrichová", "Frydrychová", "Fuchsová", "Fučíková", "Fuksová", "Gáborová", "Gabrilová", "Gajdošová", "Gažiová", "Gottwaldová", "Gregorová", "Grubrová", "Grundzová", "Grygarová", "Hájková", "Hajnýová", "Hálová", "Hamplová", "Hánová", "Hanáčková", "Hanáková", "Hanousková", "Hanusová", "Hanušová", "Hanzalová", "Hanzlová", "Hanzlíková", "Hartmanová", "Hašková", "Havlová", "Havelková", "Havlíčková", "Havlíková", "Havránková", "Heczkoová", "Hegrová", "Hejdová", "Hejduková", "Hejlová", "Hejnová", "Hendrychová", "Hermanová", "Heřmanová", "Heřmánková", "Hladíková", "Hladkýová", "Hlaváčová", "Hlaváčková", "Hlavatýová", "Hlávková", "Hloušková", "Hoffmannová", "Hofmanová", "Holanová", "Holasová", "Holcová", "Holečková", "Holíková", "Holoubková", "Holubová", "Holýová", "Homolová", "Homolková", "Horová", "Horáčková", "Horáková", "Hořejšíová", "Horkýová", "Horňáková", "Horníčková", "Horníková", "Horskýová", "Horvátová", "Horváthová", "Hošková", "Houdková", "Houšková", "Hovorková", "Hrabalová", "Hrabovskýová", "Hradeckýová", "Hradilová", "Hrbáčková", "Hrbková", "Hrdinová", "Hrdličková", "Hrdýová", "Hrnčířová", "Hrochová", "Hromádková", "Hronová", "Hrubešová", "Hrubýová", "Hrušková", "Hrůzová", "Hubáčková", "Hudcová", "Hudečková", "Hůlková", "Humlová", "Husáková", "Hušková", "Hýblová", "Hynková", "Jahodová", "Jakešová", "Jaklová", "Jakoubková", "Jakubcová", "Janáčková", "Janáková", "Janatová", "Jančová", "Jančíková", "Jandová", "Janečková", "Janečková", "Janíčková", "Janíková", "Jankůová", "Janotová", "Janoušková", "Janovskýová", "Jansová", "Jánskýová", "Janůová", "Jarešová", "Jarošová", "Jašková", "Javůrková", "Jechová", "Jedličková", "Jelnová", "Jelínková", "Jeníčková", "Jeřábková", "Ježová", "Ježková", "Jílková", "Jindrová", "Jírová", "Jiráková", "Jiránková", "Jirásková", "Jiříková", "Jirková", "Jirkůová", "Jiroušková", "Jirsová", "Johnová", "Jonášová", "Junková", "Jurčíková", "Jurečková", "Juřicová", "Juříková", "Kabátová", "Kačírková", "Kadeřábková", "Kadlcová", "Kafková", "Kaisrová", "Kalová", "Kalábová", "Kalašová", "Kalinová", "Kalivodová", "Kalousová", "Kalousková", "Kameníková", "Kaňová", "Káňová", "Kaňková", "Kantorová", "Kaplanová", "Karasová", "Karásková", "Karbanová", "Karlová", "Karlíková", "Kasalová", "Kašíková", "Kašparová", "Kašpárková", "Kavková", "Kazdová", "Kindlová", "Klečková", "Kleinová", "Klementová", "Klímová", "Klimentová", "Klimešová", "Kloučková", "Kloudová", "Knapová", "Knotková", "Kochová", "Kočíová", "Kociánová", "Kocmanová", "Kocourková", "Kohoutová", "Kohoutková", "Koláčková", "Kolářová", "Kolaříková", "Kolková", "Kolmanová", "Komárková", "Komínková", "Konečnýová", "Koníčková", "Kopalová", "Kopečková", "Kopeckýová", "Kopečnýová", "Kopřivová", "Korblová", "Kořínková", "Kosová", "Kosíková", "Kosinová", "Košťálová", "Kostková", "Kotasová", "Kotková", "Kotlárová", "Kotrbová", "Koubová", "Koubková", "Koudelová", "Koudelková", "Koukalová", "Kouřilová", "Koutnýová", "Kováčová", "Kovářová", "Kovaříková", "Kováříková", "Kozáková", "Kozlová", "Krajíčková", "Králová", "Králíčková", "Králíková", "Krátkýová", "Kratochvílová", "Krausová", "Krčmářová", "Křečková", "Krejčíová", "Krejčíková", "Krejčířová", "Křenková", "Krištofová", "Křivánková", "Křížová", "Křížková", "Kropáčková", "Kroupová", "Krupová", "Krupičková", "Krupková", "Kubová", "Kubánková", "Kubátová", "Kubcová", "Kubelková", "Kubešová", "Kubicová", "Kubíčková", "Kubíková", "Kubínová", "Kubišová", "Kučová", "Kučerová", "Kuchařová", "Kuchtová", "Kudláčková", "Kudrnová", "Kuklová", "Kulhánková", "Kulhavýová", "Kuncová", "Kunešová", "Kupcová", "Kupková", "Kurková", "Kužlová", "Kvapilová", "Kvasničková", "Kynclová", "Kyselová", "Lacinová", "Lackoová", "Lakatošová", "Landová", "Langová", "Langrová", "Langrová", "Látalová", "Lavičková", "Leová", "Lebedová", "Levýová", "Líbalová", "Linhartová", "Lišková", "Lorencová", "Loudová", "Ludvíková", "Lukáčová", "Lukášová", "Lukášková", "Lukešová", "Macáková", "Macková", "Machová", "Máchová", "Machačová", "Macháčová", "Macháčková", "Machalová", "Machálková", "Macurová", "Majrová", "Malečková", "Málková", "Malíková", "Malinová", "Malýová", "Maňáková", "Marečková", "Marková", "Marešová", "Maříková", "Maršálková", "Maršíková", "Martincová", "Martinková", "Martínková", "Mašková", "Masopustová", "Matějíčková", "Matějková", "Matoušová", "Matoušková", "Matulová", "Matušková", "Matyášová", "Matysová", "Maxová", "Mayrová", "Mazánková", "Medková", "Melicharová", "Menclová", "Menšíková", "Mertová", "Michalová", "Michalcová", "Michálková", "Michalíková", "Michnová", "Mičková", "Miková", "Míková", "Mikešová", "Mikoová", "Mikulová", "Mikulášková", "Minářová", "Minaříková", "Mirgová", "Mládková", "Mlčochová", "Mlejnková", "Mojžíšová", "Mokrýová", "Molnárová", "Moravcová", "Morávková", "Motlová", "Motyčková", "Moučková", "Moudrýová", "Mráčková", "Mrázová", "Mrázková", "Mrkvičková", "Muchová", "Müllrová", "Műllrová", "Musilová", "Mužíková", "Myšková", "Nagyová", "Najmanová", "Navrátilová", "Nečasová", "Nedbalová", "Nedomová", "Nedvědová", "Nejedlýová", "Němcová", "Němečková", "Nešporová", "Nesvadbová", "Neubaurová", "Neumanová", "Neumannová", "Nguynová", "Nguyen vanová", "Nosková", "Nováčková", "Nováková", "Novosadová", "Novotnýová", "Novýová", "Odehnalová", "Oláhová", "Olivová", "Ondrová", "Ondráčková", "Orságová", "Otáhalová", "Palečková", "Pánková", "Papežová", "Pařízková", "Pašková", "Pátková", "Patočková", "Paulová", "Pavlová", "Pavelková", "Pavelková", "Pavlasová", "Pavlicová", "Pavlíčková", "Pavlíková", "Pavlůová", "Pazderová", "Pechová", "Pechová", "Pecháčková", "Pecková", "Pekařová", "Pekárková", "Pelcová", "Pelikánová", "Peřinová", "Pernicová", "Peroutková", "Pešková", "Pešková", "Peštová", "Peterková", "Petrová", "Petráková", "Petrášová", "Petříčková", "Petříková", "Petrůová", "Phamová", "Píchová", "Pilařová", "Pilátová", "Píšová", "Pivoňková", "Plačková", "Plachýová", "Plšková", "Pluhařová", "Podzimková", "Pohlová", "Pokornýová", "Poláčková", "Poláchová", "Poláková", "Polanskýová", "Polášková", "Polívková", "Popelková", "Pospíchalová", "Pospíšilová", "Potůčková", "Pourová", "Prachařová", "Prášková", "Pražáková", "Prchalová", "Přibylová", "Příhodová", "Přikrylová", "Procházková", "Prokešová", "Prokopová", "Prošková", "Provazníková", "Průchová", "Průšová", "Pšeničková", "Ptáčková", "Rácová", "Radová", "Raková", "Rambousková", "Rašková", "Ratajová", "řeháčková", "řeháková", "řehořová", "Remešová", "řezáčová", "Rezková", "řezníčková", "Richtrová", "Richtrová", "říhová", "Roubalová", "Rousová", "Rozsypalová", "Rudolfová", "Růžková", "Růžičková", "Rybová", "Rybářová", "Rýdlová", "Ryšavýová", "Sadílková", "šafářová", "šafaříková", "šafránková", "šálková", "Samková", "šandová", "šašková", "Schejbalová", "Schmidtová", "Schneidrová", "Schwarzová", "šebková", "šebelová", "šebestová", "šedová", "šedivýová", "Sedláčková", "Sedláková", "Sedlářová", "Sehnalová", "Seidlová", "Seifertová", "Sekaninová", "Semerádová", "šenková", "šestáková", "ševčíková", "Severová", "Sikorová", "šilhavýová", "šímová", "šimáčková", "šimáková", "šimánková", "šimčíková", "šimečková", "šimková", "šimonová", "šimůnková", "šindelářová", "šindlrová", "šípová", "šípková", "šírová", "širokýová", "šišková", "Siváková", "Skáclová", "Skalová", "Skálová", "Skalickýová", "Sklenářová", "škodová", "Skopalová", "Skořepová", "škrabalová", "Skřivánková", "Slabýová", "Sládková", "Sladkýová", "Slámová", "Slaninová", "Slavíčková", "Slavíková", "šlechtová", "Slezáková", "Slováčková", "Slováková", "Sluková", "Smejkalová", "šmejkalová", "Smékalová", "šmerdová", "Smetanová", "šmídová", "Smolová", "Smolíková", "Smolková", "Smrčková", "Smržová", "Smutnýová", "šnajdrová", "Sobková", "Sobotková", "Sochorová", "Sojková", "Sokolová", "šolcová", "Sommrová", "Součková", "Soukupová", "Sovová", "špačková", "Spáčilová", "špičková", "šplíchalová", "Spurnýová", "šrámková", "Srbová", "Staněková", "Stárková", "Starýová", "šťastnýová", "štefanová", "štefková", "šteflová", "Stehlíková", "Steinrová", "Stejskalová", "štěpánová", "štěpánková", "štěrbová", "Stiborová", "Stoklasová", "Straková", "Stránskýová", "Strejčková", "Strnadová", "Strouhalová", "Stuchlíková", "Studenýová", "Studničková", "Stupková", "šubrtová", "Suchánková", "Suchomlová", "Suchýová", "Suková", "šulcová", "šustrová", "švábová", "Svačinová", "švandová", "švarcová", "Svatoňová", "Svatošová", "švcová", "švehlová", "švejdová", "švestková", "Světlíková", "Svitáková", "Svobodová", "Svozilová", "Sýkorová", "Synková", "Syrovýová", "Táborskýová", "Tancošová", "Teplýová", "Tesařová", "Tichýová", "Tomanová", "Tománková", "Tomášová", "Tomášková", "Tomečková", "Tomková", "Tomešová", "Tóthová", "Tranová", "Trávníčková", "Trčková", "Třísková", "Trnková", "Trojanová", "Truhlářová", "Tučková", "Tůmová", "Turečková", "Turková", "Tvrdíková", "Tvrdýová", "Uhrová", "Uhlířová", "Ulrichová", "Urbanová", "Urbancová", "Urbánková", "Vacková", "Váchová", "Václavková", "Václavíková", "Vaculíková", "Vágnrová", "Valová", "Valášková", "Válková", "Valentová", "Valešová", "Váňová", "Vančurová", "Vaněčková", "Vaněková", "Vaníčková", "Vargová", "Vašáková", "Vašková", "Vašíčková", "Vávrová", "Vavříková", "Večeřová", "Vejvodová", "Vernrová", "Veselýová", "Veverková", "Víchová", "Vilímková", "Vinšová", "Víšková", "Vítová", "Vitásková", "Vítková", "Vlachová", "Vlasáková", "Vlčková", "Vlková", "Vobořilová", "Vodáková", "Vodičková", "Vodrážková", "Vojáčková", "Vojtová", "Vojtěchová", "Vojtková", "Vojtíšková", "Vokounová", "Volková", "Volfová", "Volnýová", "Vondrová", "Vondráčková", "Vondráková", "Voráčková", "Vorlová", "Voříšková", "Vorlíčková", "Votavová", "Votrubová", "Vrabcová", "Vránová", "Vrbová", "Vrzalová", "Vybíralová", "Vydrová", "Vymazalová", "Vyskočilová", "Vysloužilová", "Wagnrová", "Waltrová", "Webrová", "Weissová", "Winklrová", "Wolfová", "Zábranskýová", "žáčková", "Zachová", "Zahrádková", "Zahradníková", "Zajícová", "Zajíčková", "žáková", "Zálešáková", "Zámečníková", "Zapletalová", "Zárubová", "Zatloukalová", "Zavadilová", "Zavřlová", "Zbořilová", "žďárskýová", "Zdražilová", "Zedníková", "Zelenková", "Zelenýová", "Zelinková", "Zemanová", "Zemánková", "žemličková", "Zezulová", "žídková", "žigová", "Zíková", "Zikmundová", "Zimová", "žižková", "Zlámalová", "Zoubková", "Zouharová", "žůrková", "Zvěřinová"]; + if (lon2 > degreesToRadians(180)) { + lon2 = lon2 - degreesToRadians(360); + } else if (lon2 < degreesToRadians(-180)) { + lon2 = lon2 + degreesToRadians(360); + } -/***/ }, -/* 178 */ -/***/ function(module, exports) { + return [radiansToDegrees(lat2), radiansToDegrees(lon2)]; + } - "use strict"; + if (coordinate === undefined) { + return this.address.geoLocation(); + } - module.exports = { - number: ["601 ### ###", "737 ### ###", "736 ### ###", "### ### ###", "+420 ### ### ###", "00420 ### ### ###"] + var randomCoord = coordinateWithOffset(coordinate, degreesToRadians(this.random.number(360)), radius, isMetric); + + return { + latitude: randomCoord[0], + longitude: randomCoord[1] + }; }; /***/ }, -/* 179 */ +/* 165 */ /***/ function(module, exports) { "use strict"; module.exports = { - tld: ["cz", "com", "net", "eu", "org"], - - emailDomain: ["gmail.com", "seznam.cz", "centrum.cz", "volny.cz", "atlas.cz"] + name: ["#{names.lastName} #{company.suffix}", "#{names.lastName}-#{names.lastName} #{company.suffix}", "#{names.lastName}, #{names.lastName} and #{names.lastName} #{company.suffix}"], + suffix: ["Ltd.", "Inc.", "Corp.", "LLC", "Group"] }; /***/ }, -/* 180 */ +/* 166 */ /***/ function(module, exports, __webpack_require__) { "use strict"; - var _countryWithCodes = __webpack_require__(181); + module.exports = { + month: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], - var _countryWithCodes2 = _interopRequireDefault(_countryWithCodes); + weekday: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + weekdayShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], - module.exports = { - countryAndCode: function countryAndCode() { - var country = this.random.objectElement(_countryWithCodes2.default); - return { - code: Object.keys(country)[0], - name: country[Object.keys(country)[0]] + weekdayMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], + + timezone: __webpack_require__(167), + + past: function past() { + var years = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var refDate = arguments[1]; + + var date = refDate ? new Date(Date.parse(refDate)) : new Date(); + var min = 1000; + var max = years * 365 * 24 * 3600 * 1000; + + var past = date.getTime(); + past -= this.random.number(min, max); + date.setTime(past); + + return date; + }, + future: function future() { + var years = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var refDate = arguments[1]; + + var date = refDate ? new Date(Date.parse(refDate)) : new Date(); + var min = 1000; + var max = years * 365 * 24 * 3600 * 1000; + + var future = date.getTime(); + future += this.random.number(min, max); + date.setTime(future); + + return date; + }, + between: function between(from, to) { + var fromMilli = Date.parse(from); + var dateOffset = this.random.number(Date.parse(to) - fromMilli); + + var newDate = new Date(fromMilli + dateOffset); + + return newDate; + }, + recent: function recent() { + var days = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + + var date = new Date(); + var min = 1000; + var max = days * 24 * 3600 * 1000; + + var past = date.getTime(); + past -= this.random.number(min, max); + date.setTime(past); + + return date; + }, + age: function age() { + var min = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 18; + var max = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 80; + + return this.random.number(min, max); + } + }; + +/***/ }, +/* 167 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + + module["exports"] = ["Pacific/Midway", "Pacific/Pago_Pago", "Pacific/Honolulu", "America/Juneau", "America/Los_Angeles", "America/Tijuana", "America/Denver", "America/Phoenix", "America/Chihuahua", "America/Mazatlan", "America/Chicago", "America/Regina", "America/Mexico_City", "America/Mexico_City", "America/Monterrey", "America/Guatemala", "America/New_York", "America/Indiana/Indianapolis", "America/Bogota", "America/Lima", "America/Lima", "America/Halifax", "America/Caracas", "America/La_Paz", "America/Santiago", "America/St_Johns", "America/Sao_Paulo", "America/Argentina/Buenos_Aires", "America/Guyana", "America/Godthab", "Atlantic/South_Georgia", "Atlantic/Azores", "Atlantic/Cape_Verde", "Europe/Dublin", "Europe/London", "Europe/Lisbon", "Europe/London", "Africa/Casablanca", "Africa/Monrovia", "Etc/UTC", "Europe/Belgrade", "Europe/Bratislava", "Europe/Budapest", "Europe/Ljubljana", "Europe/Prague", "Europe/Sarajevo", "Europe/Skopje", "Europe/Warsaw", "Europe/Zagreb", "Europe/Brussels", "Europe/Copenhagen", "Europe/Madrid", "Europe/Paris", "Europe/Amsterdam", "Europe/Berlin", "Europe/Berlin", "Europe/Rome", "Europe/Stockholm", "Europe/Vienna", "Africa/Algiers", "Europe/Bucharest", "Africa/Cairo", "Europe/Helsinki", "Europe/Kiev", "Europe/Riga", "Europe/Sofia", "Europe/Tallinn", "Europe/Vilnius", "Europe/Athens", "Europe/Istanbul", "Europe/Minsk", "Asia/Jerusalem", "Africa/Harare", "Africa/Johannesburg", "Europe/Moscow", "Europe/Moscow", "Europe/Moscow", "Asia/Kuwait", "Asia/Riyadh", "Africa/Nairobi", "Asia/Baghdad", "Asia/Tehran", "Asia/Muscat", "Asia/Muscat", "Asia/Baku", "Asia/Tbilisi", "Asia/Yerevan", "Asia/Kabul", "Asia/Yekaterinburg", "Asia/Karachi", "Asia/Karachi", "Asia/Tashkent", "Asia/Kolkata", "Asia/Kolkata", "Asia/Kolkata", "Asia/Kolkata", "Asia/Kathmandu", "Asia/Dhaka", "Asia/Dhaka", "Asia/Colombo", "Asia/Almaty", "Asia/Novosibirsk", "Asia/Rangoon", "Asia/Bangkok", "Asia/Bangkok", "Asia/Jakarta", "Asia/Krasnoyarsk", "Asia/Shanghai", "Asia/Chongqing", "Asia/Hong_Kong", "Asia/Urumqi", "Asia/Kuala_Lumpur", "Asia/Singapore", "Asia/Taipei", "Australia/Perth", "Asia/Irkutsk", "Asia/Ulaanbaatar", "Asia/Seoul", "Asia/Tokyo", "Asia/Tokyo", "Asia/Tokyo", "Asia/Yakutsk", "Australia/Darwin", "Australia/Adelaide", "Australia/Melbourne", "Australia/Melbourne", "Australia/Sydney", "Australia/Brisbane", "Australia/Hobart", "Asia/Vladivostok", "Pacific/Guam", "Pacific/Port_Moresby", "Asia/Magadan", "Asia/Magadan", "Pacific/Noumea", "Pacific/Fiji", "Asia/Kamchatka", "Pacific/Majuro", "Pacific/Auckland", "Pacific/Auckland", "Pacific/Tongatapu", "Pacific/Fakaofo", "Pacific/Apia"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) + +/***/ }, +/* 168 */ +/***/ function(module, exports) { + + "use strict"; + + module.exports = { + address: function address() { + var def = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var country = this.address.countryAndCode(); + return { + country: def.country || country.name, + countryCode: def.countryCode || country.code, + state: def.state || this.address.state(), + city: def.city || this.address.city(), + street: def.street || this.address.street(), + zip: def.zip || this.address.postCode(), + geo: def.geo || this.address.geoLocation() }; }, + user: function user(gender) { + var firstName = this.populate("#{names.firstName" + (gender ? gender.toUpperCase() : "") + "}"); + var lastName = this.populate("#{names.lastName" + (gender ? gender.toUpperCase() : "") + "}"); - state: ["Baden-Württemberg", "Bayern", "Berlin", "Brandenburg", "Bremen", "Hamburg", "Hessen", "Mecklenburg-Vorpommern", "Niedersachsen", "Nordrhein-Westfalen", "Rheinland-Pfalz", "Saarland", "Sachsen", "Sachsen-Anhalt", "Schleswig-Holstein", "Thüringen"], - stateAbbr: ["BW", "BY", "BE", "BB", "HB", "HH", "HE", "MV", "NI", "NW", "RP", "SL", "SN", "ST", "SH", "TH"], + return { + firstName: firstName, + lastName: lastName, + gender: gender, + userName: this.internet.userName(firstName, lastName), + password: this.internet.password(), + email: this.internet.email(firstName, lastName), + phone: this.phone.number(), + dob: this.date.past(80), + website: this.internet.url(), + ip: this.internet.ip(), + avatar: this.internet.avatar(), + gravatar: this.internet.gravatar(), + address: this.entity.address(), + status: this.random.boolean() + }; + }, + company: function company(name) { + name = name || this.company.name(); - city: ["#{address.cityPrefix} #{names.firstName}#{address.citySuffix}", "#{address.cityPrefix} #{names.firstName}", "#{names.firstName}#{address.citySuffix}", "#{names.lastName}#{address.citySuffix}"], + return { + name: name, + email: this.internet.email(name), + phone: this.phone.number(), + website: this.internet.url(), + ip: this.internet.ip(), + address: this.entity.address() + }; + }, + post: function post() { + var paragraphs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3; - cityPrefix: ["Nord", "Ost", "West", "Süd", "Neu", "Alt", "Bad"], + return { + title: this.lorem.sentence(), + keywords: this.utimes(this.lorem.word, 3), + created: this.date.recent(7), + content: this.times(this.lorem.paragraph, paragraphs).join("\r\n") + }; + } + }; - citySuffix: ["stadt", "dorf", "land", "scheid", "burg"], +/***/ }, +/* 169 */ +/***/ function(module, exports, __webpack_require__) { - street: ["#{address.streetName} #{address.buildingNumber}"], + "use strict"; - streetName: __webpack_require__(182), + module.exports = { + _meta: { + id: "default", + fallback: null, + mask: "\#\{([A-Za-z0-9_\.]+)\}", + language: "English", + country: "United Kingdom", + countryCode: "UK" + }, - streetSuffix: [], + names: __webpack_require__(170), + phone: __webpack_require__(174), + address: __webpack_require__(159), + company: __webpack_require__(165), + internet: __webpack_require__(175), + lorem: __webpack_require__(238), + date: __webpack_require__(166), + misc: __webpack_require__(241), + entity: __webpack_require__(168) + }; - buildingNumber: ["###", "##", "#", "##a", "##b", "##c"], +/***/ }, +/* 170 */ +/***/ function(module, exports, __webpack_require__) { - postCode: ["#####"] + "use strict"; + + module.exports = { + firstNameM: __webpack_require__(171), + + firstNameF: __webpack_require__(172), + + firstName: ["#{names.firstNameM}", "#{names.firstNameF}"], + + lastNameM: __webpack_require__(173), + + lastNameF: __webpack_require__(173), + + lastName: ["#{names.lastNameM}", "#{names.lastNameF}"], + + prefix: ["Mr.", "Mrs.", "Ms.", "Miss", "Dr."], + suffix: ["Jr.", "Sr.", "I", "II", "III", "IV", "V", "MD", "DDS", "PhD", "DVM"], + + nameM: ["#{names.prefix} #{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM} #{names.suffix}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}"], + + nameF: ["#{names.prefix} #{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF} #{names.suffix}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}"], + + name: ["#{names.nameM}", "#{names.nameF}"] }; /***/ }, -/* 181 */ +/* 171 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + + module["exports"] = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Charles", "Joseph", "Thomas", "Christopher", "Daniel", "Paul", "Mark", "Donald", "George", "Kenneth", "Steven", "Edward", "Brian", "Ronald", "Anthony", "Kevin", "Jason", "Matthew", "Gary", "Timothy", "Jose", "Larry", "Jeffrey", "Frank", "Scott", "Eric", "Stephen", "Andrew", "Raymond", "Gregory", "Joshua", "Jerry", "Dennis", "Walter", "Patrick", "Peter", "Harold", "Douglas", "Henry", "Carl", "Arthur", "Ryan", "Roger", "Joe", "Juan", "Jack", "Albert", "Jonathan", "Justin", "Terry", "Gerald", "Keith", "Samuel", "Willie", "Ralph", "Lawrence", "Nicholas", "Roy", "Benjamin", "Bruce", "Brandon", "Adam", "Harry", "Fred", "Wayne", "Billy", "Steve", "Louis", "Jeremy", "Aaron", "Randy", "Howard", "Eugene", "Carlos", "Russell", "Bobby", "Victor", "Martin", "Ernest", "Phillip", "Todd", "Jesse", "Craig", "Alan", "Shawn", "Clarence", "Sean", "Philip", "Chris", "Johnny", "Earl", "Jimmy", "Antonio", "Danny", "Bryan", "Tony", "Luis", "Mike", "Stanley", "Leonard", "Nathan", "Dale", "Manuel", "Rodney", "Curtis", "Norman", "Allen", "Marvin", "Vincent", "Glenn", "Jeffery", "Travis", "Jeff", "Chad", "Jacob", "Lee", "Melvin", "Alfred", "Kyle", "Francis", "Bradley", "Jesus", "Herbert", "Frederick", "Ray", "Joel", "Edwin", "Don", "Eddie", "Ricky", "Troy", "Randall", "Barry", "Alexander", "Bernard", "Mario", "Leroy", "Francisco", "Marcus", "Micheal", "Theodore", "Clifford", "Miguel", "Oscar", "Jay", "Jim", "Tom", "Calvin", "Alex", "Jon", "Ronnie", "Bill", "Lloyd", "Tommy", "Leon", "Derek", "Warren", "Darrell", "Jerome", "Floyd", "Leo", "Alvin", "Tim", "Wesley", "Gordon", "Dean", "Greg", "Jorge", "Dustin", "Pedro", "Derrick", "Dan", "Lewis", "Zachary", "Corey", "Herman", "Maurice", "Vernon", "Roberto", "Clyde", "Glen", "Hector", "Shane", "Ricardo", "Sam", "Rick", "Lester", "Brent", "Ramon", "Charlie", "Tyler", "Gilbert", "Gene", "Marc", "Reginald", "Ruben", "Brett", "Angel", "Nathaniel", "Rafael", "Leslie", "Edgar", "Milton", "Raul", "Ben", "Chester", "Cecil", "Duane", "Franklin", "Andre", "Elmer", "Brad", "Gabriel", "Ron", "Mitchell", "Roland", "Arnold", "Harvey", "Jared", "Adrian", "Karl", "Cory", "Claude", "Erik", "Darryl", "Jamie", "Neil", "Jessie", "Christian", "Javier", "Fernando", "Clinton", "Ted", "Mathew", "Tyrone", "Darren", "Lonnie", "Lance", "Cody", "Julio", "Kelly", "Kurt", "Allan", "Nelson", "Guy", "Clayton", "Hugh", "Max", "Dwayne", "Dwight", "Armando", "Felix", "Jimmie", "Everett", "Jordan", "Ian", "Wallace", "Ken", "Bob", "Jaime", "Casey", "Alfredo", "Alberto", "Dave", "Ivan", "Johnnie", "Sidney", "Byron", "Julian", "Isaac", "Morris", "Clifton", "Willard", "Daryl", "Ross", "Virgil", "Andy", "Marshall", "Salvador", "Perry", "Kirk", "Sergio", "Marion", "Tracy", "Seth", "Kent", "Terrance", "Rene", "Eduardo", "Terrence", "Enrique", "Freddie", "Wade", "Austin", "Stuart", "Fredrick", "Arturo", "Alejandro", "Jackie", "Joey", "Nick", "Luther", "Wendell", "Jeremiah", "Evan", "Julius", "Dana", "Donnie", "Otis", "Shannon", "Trevor", "Oliver", "Luke", "Homer", "Gerard", "Doug", "Kenny", "Hubert", "Angelo", "Shaun", "Lyle", "Matt", "Lynn", "Alfonso", "Orlando", "Rex", "Carlton", "Ernesto", "Cameron", "Neal", "Pablo", "Lorenzo", "Omar", "Wilbur", "Blake", "Grant", "Horace", "Roderick", "Kerry", "Abraham", "Willis", "Rickey", "Jean", "Ira", "Andres", "Cesar", "Johnathan", "Malcolm", "Rudolph", "Damon", "Kelvin", "Rudy", "Preston", "Alton", "Archie", "Marco", "Wm", "Pete", "Randolph", "Garry", "Geoffrey", "Jonathon", "Felipe", "Bennie", "Gerardo", "Ed", "Dominic", "Robin", "Loren", "Delbert", "Colin", "Guillermo", "Earnest", "Lucas", "Benny", "Noel", "Spencer", "Rodolfo", "Myron", "Edmund", "Garrett", "Salvatore", "Cedric", "Lowell", "Gregg", "Sherman", "Wilson", "Devin", "Sylvester", "Kim", "Roosevelt", "Israel", "Jermaine", "Forrest", "Wilbert", "Leland", "Simon", "Guadalupe", "Clark", "Irving", "Carroll", "Bryant", "Owen", "Rufus", "Woodrow", "Sammy", "Kristopher", "Mack", "Levi", "Marcos", "Gustavo", "Jake", "Lionel", "Marty", "Taylor", "Ellis", "Dallas", "Gilberto", "Clint", "Nicolas", "Laurence", "Ismael", "Orville", "Drew", "Jody", "Ervin", "Dewey", "Al", "Wilfred", "Josh", "Hugo", "Ignacio", "Caleb", "Tomas", "Sheldon", "Erick", "Frankie", "Stewart", "Doyle", "Darrel", "Rogelio", "Terence", "Santiago", "Alonzo", "Elias", "Bert", "Elbert", "Ramiro", "Conrad", "Pat", "Noah", "Grady", "Phil", "Cornelius", "Lamar", "Rolando", "Clay", "Percy", "Dexter", "Bradford", "Merle", "Darin", "Amos", "Terrell", "Moses", "Irvin", "Saul", "Roman", "Darnell", "Randal", "Tommie", "Timmy", "Darrin", "Winston", "Brendan", "Toby", "Van", "Abel", "Dominick", "Boyd", "Courtney", "Jan", "Emilio", "Elijah", "Cary", "Domingo", "Santos", "Aubrey", "Emmett", "Marlon", "Emanuel", "Jerald", "Edmond"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) + +/***/ }, +/* 172 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + + module["exports"] = ["Mary", "Patricia", "Linda", "Barbara", "Elizabeth", "Jennifer", "Maria", "Susan", "Margaret", "Dorothy", "Lisa", "Nancy", "Karen", "Betty", "Helen", "Sandra", "Donna", "Carol", "Ruth", "Sharon", "Michelle", "Laura", "Sarah", "Kimberly", "Deborah", "Jessica", "Shirley", "Cynthia", "Angela", "Melissa", "Brenda", "Amy", "Anna", "Rebecca", "Virginia", "Kathleen", "Pamela", "Martha", "Debra", "Amanda", "Stephanie", "Carolyn", "Christine", "Marie", "Janet", "Catherine", "Frances", "Ann", "Joyce", "Diane", "Alice", "Julie", "Heather", "Teresa", "Doris", "Gloria", "Evelyn", "Jean", "Cheryl", "Mildred", "Katherine", "Joan", "Ashley", "Judith", "Rose", "Janice", "Kelly", "Nicole", "Judy", "Christina", "Kathy", "Theresa", "Beverly", "Denise", "Tammy", "Irene", "Jane", "Lori", "Rachel", "Marilyn", "Andrea", "Kathryn", "Louise", "Sara", "Anne", "Jacqueline", "Wanda", "Bonnie", "Julia", "Ruby", "Lois", "Tina", "Phyllis", "Norma", "Paula", "Diana", "Annie", "Lillian", "Emily", "Robin", "Peggy", "Crystal", "Gladys", "Rita", "Dawn", "Connie", "Florence", "Tracy", "Edna", "Tiffany", "Carmen", "Rosa", "Cindy", "Grace", "Wendy", "Victoria", "Edith", "Kim", "Sherry", "Sylvia", "Josephine", "Thelma", "Shannon", "Sheila", "Ethel", "Ellen", "Elaine", "Marjorie", "Carrie", "Charlotte", "Monica", "Esther", "Pauline", "Emma", "Juanita", "Anita", "Rhonda", "Hazel", "Amber", "Eva", "Debbie", "April", "Leslie", "Clara", "Lucille", "Jamie", "Joanne", "Eleanor", "Valerie", "Danielle", "Megan", "Alicia", "Suzanne", "Michele", "Gail", "Bertha", "Darlene", "Veronica", "Jill", "Erin", "Geraldine", "Lauren", "Cathy", "Joann", "Lorraine", "Lynn", "Sally", "Regina", "Erica", "Beatrice", "Dolores", "Bernice", "Audrey", "Yvonne", "Annette", "June", "Samantha", "Marion", "Dana", "Stacy", "Ana", "Renee", "Ida", "Vivian", "Roberta", "Holly", "Brittany", "Melanie", "Loretta", "Yolanda", "Jeanette", "Laurie", "Katie", "Kristen", "Vanessa", "Alma", "Sue", "Elsie", "Beth", "Jeanne", "Vicki", "Carla", "Tara", "Rosemary", "Eileen", "Terri", "Gertrude", "Lucy", "Tonya", "Ella", "Stacey", "Wilma", "Gina", "Kristin", "Jessie", "Natalie", "Agnes", "Vera", "Willie", "Charlene", "Bessie", "Delores", "Melinda", "Pearl", "Arlene", "Maureen", "Colleen", "Allison", "Tamara", "Joy", "Georgia", "Constance", "Lillie", "Claudia", "Jackie", "Marcia", "Tanya", "Nellie", "Minnie", "Marlene", "Heidi", "Glenda", "Lydia", "Viola", "Courtney", "Marian", "Stella", "Caroline", "Dora", "Jo", "Vickie", "Mattie", "Terry", "Maxine", "Irma", "Mabel", "Marsha", "Myrtle", "Lena", "Christy", "Deanna", "Patsy", "Hilda", "Gwendolyn", "Jennie", "Nora", "Margie", "Nina", "Cassandra", "Leah", "Penny", "Kay", "Priscilla", "Naomi", "Carole", "Brandy", "Olga", "Billie", "Dianne", "Tracey", "Leona", "Jenny", "Felicia", "Sonia", "Miriam", "Velma", "Becky", "Bobbie", "Violet", "Kristina", "Toni", "Misty", "Mae", "Shelly", "Daisy", "Ramona", "Sherri", "Erika", "Katrina", "Claire", "Lindsey", "Lindsay", "Geneva", "Guadalupe", "Belinda", "Margarita", "Sheryl", "Cora", "Faye", "Ada", "Natasha", "Sabrina", "Isabel", "Marguerite", "Hattie", "Harriet", "Molly", "Cecilia", "Kristi", "Brandi", "Blanche", "Sandy", "Rosie", "Joanna", "Iris", "Eunice", "Angie", "Inez", "Lynda", "Madeline", "Amelia", "Alberta", "Genevieve", "Monique", "Jodi", "Janie", "Maggie", "Kayla", "Sonya", "Jan", "Lee", "Kristine", "Candace", "Fannie", "Maryann", "Opal", "Alison", "Yvette", "Melody", "Luz", "Susie", "Olivia", "Flora", "Shelley", "Kristy", "Mamie", "Lula", "Lola", "Verna", "Beulah", "Antoinette", "Candice", "Juana", "Jeannette", "Pam", "Kelli", "Hannah", "Whitney", "Bridget", "Karla", "Celia", "Latoya", "Patty", "Shelia", "Gayle", "Della", "Vicky", "Lynne", "Sheri", "Marianne", "Kara", "Jacquelyn", "Erma", "Blanca", "Myra", "Leticia", "Pat", "Krista", "Roxanne", "Angelica", "Johnnie", "Robyn", "Francis", "Adrienne", "Rosalie", "Alexandra", "Brooke", "Bethany", "Sadie", "Bernadette", "Traci", "Jody", "Kendra", "Jasmine", "Nichole", "Rachael", "Chelsea", "Mable", "Ernestine", "Muriel", "Marcella", "Elena", "Krystal", "Angelina", "Nadine", "Kari", "Estelle", "Dianna", "Paulette", "Lora", "Mona", "Doreen", "Rosemarie", "Angel", "Desiree", "Antonia", "Hope", "Ginger", "Janis", "Betsy", "Christie", "Freda", "Mercedes", "Meredith", "Lynette", "Teri", "Cristina", "Eula", "Leigh", "Meghan", "Sophia", "Eloise", "Rochelle", "Gretchen", "Cecelia", "Raquel", "Henrietta", "Alyssa", "Jana", "Kelley", "Gwen", "Kerry", "Jenna", "Tricia", "Laverne", "Olive", "Alexis", "Tasha", "Silvia", "Elvira", "Casey", "Delia", "Sophie", "Kate", "Patti", "Lorena", "Kellie", "Sonja", "Lila", "Lana", "Darla", "May", "Mindy", "Essie", "Mandy", "Lorene", "Elsa", "Josefina", "Jeannie", "Miranda", "Dixie", "Lucia", "Marta", "Faith", "Lela", "Johanna", "Shari", "Camille", "Tami", "Shawna", "Elisa", "Ebony", "Melba", "Ora", "Nettie", "Tabitha", "Ollie", "Jaime", "Winifred", "Kristie"]; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(56)(module))) + +/***/ }, +/* 173 */ +/***/ function(module, exports) { + + "use strict"; + + module.exports = ["Abbott", "Abernathy", "Abshire", "Adams", "Altenwerth", "Anderson", "Ankunding", "Armstrong", "Auer", "Aufderhar", "Bahringer", "Bailey", "Balistreri", "Barrows", "Bartell", "Bartoletti", "Barton", "Bashirian", "Batz", "Bauch", "Baumbach", "Bayer", "Beahan", "Beatty", "Bechtelar", "Becker", "Bednar", "Beer", "Beier", "Berge", "Bergnaum", "Bergstrom", "Bernhard", "Bernier", "Bins", "Blanda", "Blick", "Block", "Bode", "Boehm", "Bogan", "Bogisich", "Borer", "Bosco", "Botsford", "Boyer", "Boyle", "Bradtke", "Brakus", "Braun", "Breitenberg", "Brekke", "Brown", "Bruen", "Buckridge", "Carroll", "Carter", "Cartwright", "Casper", "Cassin", "Champlin", "Christiansen", "Cole", "Collier", "Collins", "Conn", "Connelly", "Conroy", "Considine", "Corkery", "Cormier", "Corwin", "Cremin", "Crist", "Crona", "Cronin", "Crooks", "Cruickshank", "Cummerata", "Cummings", "Dach", "D'Amore", "Daniel", "Dare", "Daugherty", "Davis", "Deckow", "Denesik", "Dibbert", "Dickens", "Dicki", "Dickinson", "Dietrich", "Donnelly", "Dooley", "Douglas", "Doyle", "DuBuque", "Durgan", "Ebert", "Effertz", "Eichmann", "Emard", "Emmerich", "Erdman", "Ernser", "Fadel", "Fahey", "Farrell", "Fay", "Feeney", "Feest", "Feil", "Ferry", "Fisher", "Flatley", "Frami", "Franecki", "Friesen", "Fritsch", "Funk", "Gaylord", "Gerhold", "Gerlach", "Gibson", "Gislason", "Gleason", "Gleichner", "Glover", "Goldner", "Goodwin", "Gorczany", "Gottlieb", "Goyette", "Grady", "Graham", "Grant", "Green", "Greenfelder", "Greenholt", "Grimes", "Gulgowski", "Gusikowski", "Gutkowski", "Gutmann", "Haag", "Hackett", "Hagenes", "Hahn", "Haley", "Halvorson", "Hamill", "Hammes", "Hand", "Hane", "Hansen", "Harber", "Harris", "Hartmann", "Harvey", "Hauck", "Hayes", "Heaney", "Heathcote", "Hegmann", "Heidenreich", "Heller", "Herman", "Hermann", "Hermiston", "Herzog", "Hessel", "Hettinger", "Hickle", "Hilll", "Hills", "Hilpert", "Hintz", "Hirthe", "Hodkiewicz", "Hoeger", "Homenick", "Hoppe", "Howe", "Howell", "Hudson", "Huel", "Huels", "Hyatt", "Jacobi", "Jacobs", "Jacobson", "Jakubowski", "Jaskolski", "Jast", "Jenkins", "Jerde", "Johns", "Johnson", "Johnston", "Jones", "Kassulke", "Kautzer", "Keebler", "Keeling", "Kemmer", "Kerluke", "Kertzmann", "Kessler", "Kiehn", "Kihn", "Kilback", "King", "Kirlin", "Klein", "Kling", "Klocko", "Koch", "Koelpin", "Koepp", "Kohler", "Konopelski", "Koss", "Kovacek", "Kozey", "Krajcik", "Kreiger", "Kris", "Kshlerin", "Kub", "Kuhic", "Kuhlman", "Kuhn", "Kulas", "Kunde", "Kunze", "Kuphal", "Kutch", "Kuvalis", "Labadie", "Lakin", "Lang", "Langosh", "Langworth", "Larkin", "Larson", "Leannon", "Lebsack", "Ledner", "Leffler", "Legros", "Lehner", "Lemke", "Lesch", "Leuschke", "Lind", "Lindgren", "Littel", "Little", "Lockman", "Lowe", "Lubowitz", "Lueilwitz", "Luettgen", "Lynch", "Macejkovic", "MacGyver", "Maggio", "Mann", "Mante", "Marks", "Marquardt", "Marvin", "Mayer", "Mayert", "McClure", "McCullough", "McDermott", "McGlynn", "McKenzie", "McLaughlin", "Medhurst", "Mertz", "Metz", "Miller", "Mills", "Mitchell", "Moen", "Mohr", "Monahan", "Moore", "Morar", "Morissette", "Mosciski", "Mraz", "Mueller", "Muller", "Murazik", "Murphy", "Murray", "Nader", "Nicolas", "Nienow", "Nikolaus", "Nitzsche", "Nolan", "Oberbrunner", "O'Connell", "O'Conner", "O'Hara", "O'Keefe", "O'Kon", "Okuneva", "Olson", "Ondricka", "O'Reilly", "Orn", "Ortiz", "Osinski", "Pacocha", "Padberg", "Pagac", "Parisian", "Parker", "Paucek", "Pfannerstill", "Pfeffer", "Pollich", "Pouros", "Powlowski", "Predovic", "Price", "Prohaska", "Prosacco", "Purdy", "Quigley", "Quitzon", "Rath", "Ratke", "Rau", "Raynor", "Reichel", "Reichert", "Reilly", "Reinger", "Rempel", "Renner", "Reynolds", "Rice", "Rippin", "Ritchie", "Robel", "Roberts", "Rodriguez", "Rogahn", "Rohan", "Rolfson", "Romaguera", "Roob", "Rosenbaum", "Rowe", "Ruecker", "Runolfsdottir", "Runolfsson", "Runte", "Russel", "Rutherford", "Ryan", "Sanford", "Satterfield", "Sauer", "Sawayn", "Schaden", "Schaefer", "Schamberger", "Schiller", "Schimmel", "Schinner", "Schmeler", "Schmidt", "Schmitt", "Schneider", "Schoen", "Schowalter", "Schroeder", "Schulist", "Schultz", "Schumm", "Schuppe", "Schuster", "Senger", "Shanahan", "Shields", "Simonis", "Sipes", "Skiles", "Smith", "Smitham", "Spencer", "Spinka", "Sporer", "Stamm", "Stanton", "Stark", "Stehr", "Steuber", "Stiedemann", "Stokes", "Stoltenberg", "Stracke", "Streich", "Stroman", "Strosin", "Swaniawski", "Swift", "Terry", "Thiel", "Thompson", "Tillman", "Torp", "Torphy", "Towne", "Toy", "Trantow", "Tremblay", "Treutel", "Tromp", "Turcotte", "Turner", "Ullrich", "Upton", "Vandervort", "Veum", "Volkman", "Von", "VonRueden", "Waelchi", "Walker", "Walsh", "Walter", "Ward", "Waters", "Watsica", "Weber", "Wehner", "Weimann", "Weissnat", "Welch", "West", "White", "Wiegand", "Wilderman", "Wilkinson", "Will", "Williamson", "Willms", "Windler", "Wintheiser", "Wisoky", "Wisozk", "Witting", "Wiza", "Wolf", "Wolff", "Wuckert", "Wunsch", "Wyman", "Yost", "Yundt", "Zboncak", "Zemlak", "Ziemann", "Zieme", "Zulauf"]; + +/***/ }, +/* 174 */ /***/ function(module, exports) { "use strict"; module.exports = { - "AF": "Afghanistan", - "EG": "Ägypten", - "AX": "Åland-Inseln", - "AL": "Albanien", - "DZ": "Algerien", - "UM": "Amerikanisch-Ozeanien", - "AS": "Amerikanisch-Samoa", - "VI": "Amerikanische Jungferninseln", - "AD": "Andorra", - "AO": "Angola", - "AI": "Anguilla", - "AQ": "Antarktis", - "AG": "Antigua und Barbuda", - "GQ": "Äquatorialguinea", - "AR": "Argentinien", - "AM": "Armenien", - "AW": "Aruba", - "AC": "Ascension", - "AZ": "Aserbaidschan", - "ET": "Äthiopien", - "AU": "Australien", - "BS": "Bahamas", - "BH": "Bahrain", - "BD": "Bangladesch", - "BB": "Barbados", - "BY": "Belarus", - "BE": "Belgien", - "BZ": "Belize", - "BJ": "Benin", - "BM": "Bermuda", - "BT": "Bhutan", - "BO": "Bolivien", - "BA": "Bosnien und Herzegowina", - "BW": "Botsuana", - "BR": "Brasilien", - "VG": "Britische Jungferninseln", - "IO": "Britisches Territorium im Indischen Ozean", - "BN": "Brunei Darussalam", - "BG": "Bulgarien", - "BF": "Burkina Faso", - "BI": "Burundi", - "EA": "Ceuta und Melilla", - "CL": "Chile", - "CN": "China", - "CK": "Cookinseln", - "CR": "Costa Rica", - "CI": "Côte d’Ivoire", - "CW": "Curaçao", - "DK": "Dänemark", - "KP": "Demokratische Volksrepublik Korea", - "DE": "Deutschland", - "DG": "Diego Garcia", - "DM": "Dominica", - "DO": "Dominikanische Republik", - "DJ": "Dschibuti", - "EC": "Ecuador", - "SV": "El Salvador", - "ER": "Eritrea", - "EE": "Estland", - "FK": "Falklandinseln", - "FO": "Färöer", - "FJ": "Fidschi", - "FI": "Finnland", - "FR": "Frankreich", - "GF": "Französisch-Guayana", - "PF": "Französisch-Polynesien", - "TF": "Französische Süd- und Antarktisgebiete", - "GA": "Gabun", - "GM": "Gambia", - "GE": "Georgien", - "GH": "Ghana", - "GI": "Gibraltar", - "GD": "Grenada", - "GR": "Griechenland", - "GL": "Grönland", - "GP": "Guadeloupe", - "GU": "Guam", - "GT": "Guatemala", - "GG": "Guernsey", - "GN": "Guinea", - "GW": "Guinea-Bissau", - "GY": "Guyana", - "HT": "Haiti", - "HN": "Honduras", - "IN": "Indien", - "ID": "Indonesien", - "IQ": "Irak", - "IR": "Iran", - "IE": "Irland", - "IS": "Island", - "IM": "Isle of Man", - "IL": "Israel", - "IT": "Italien", - "JM": "Jamaika", - "JP": "Japan", - "YE": "Jemen", - "JE": "Jersey", - "JO": "Jordanien", - "KY": "Kaimaninseln", - "KH": "Kambodscha", - "CM": "Kamerun", - "CA": "Kanada", - "IC": "Kanarische Inseln", - "CV": "Kap Verde", - "BQ": "Karibische Niederlande", - "KZ": "Kasachstan", - "QA": "Katar", - "KE": "Kenia", - "KG": "Kirgisistan", - "KI": "Kiribati", - "CC": "Kokosinseln", - "CO": "Kolumbien", - "KM": "Komoren", - "CG": "Kongo-Brazzaville", - "CD": "Kongo-Kinshasa", - "XK": "Kosovo", - "HR": "Kroatien", - "CU": "Kuba", - "KW": "Kuwait", - "LA": "Laos", - "LS": "Lesotho", - "LV": "Lettland", - "LB": "Libanon", - "LR": "Liberia", - "LY": "Libyen", - "LI": "Liechtenstein", - "LT": "Litauen", - "LU": "Luxemburg", - "MG": "Madagaskar", - "MW": "Malawi", - "MY": "Malaysia", - "MV": "Malediven", - "ML": "Mali", - "MT": "Malta", - "MA": "Marokko", - "MH": "Marshallinseln", - "MQ": "Martinique", - "MR": "Mauretanien", - "MU": "Mauritius", - "YT": "Mayotte", - "MK": "Mazedonien", - "MX": "Mexiko", - "FM": "Mikronesien", - "MC": "Monaco", - "MN": "Mongolei", - "ME": "Montenegro", - "MS": "Montserrat", - "MZ": "Mosambik", - "MM": "Myanmar", - "NA": "Namibia", - "NR": "Nauru", - "NP": "Nepal", - "NC": "Neukaledonien", - "NZ": "Neuseeland", - "NI": "Nicaragua", - "NL": "Niederlande", - "NE": "Niger", - "NG": "Nigeria", - "NU": "Niue", - "MP": "Nördliche Marianen", - "NF": "Norfolkinsel", - "NO": "Norwegen", - "OM": "Oman", - "AT": "Österreich", - "PK": "Pakistan", - "PS": "Palästinensische Autonomiegebiete", - "PW": "Palau", - "PA": "Panama", - "PG": "Papua-Neuguinea", - "PY": "Paraguay", - "PE": "Peru", - "PH": "Philippinen", - "PN": "Pitcairninseln", - "PL": "Polen", - "PT": "Portugal", - "PR": "Puerto Rico", - "KR": "Republik Korea", - "MD": "Republik Moldau", - "RE": "Réunion", - "RW": "Ruanda", - "RO": "Rumänien", - "RU": "Russische Föderation", - "SB": "Salomonen", - "ZM": "Sambia", - "WS": "Samoa", - "SM": "San Marino", - "ST": "São Tomé und Príncipe", - "SA": "Saudi-Arabien", - "SE": "Schweden", - "CH": "Schweiz", - "SN": "Senegal", - "RS": "Serbien", - "SC": "Seychellen", - "SL": "Sierra Leone", - "ZW": "Simbabwe", - "SG": "Singapur", - "SX": "Sint Maarten", - "SK": "Slowakei", - "SI": "Slowenien", - "SO": "Somalia", - "MO": "Sonderverwaltungsregion Macau", - "HK": "Sonderverwaltungszone Hongkong", - "ES": "Spanien", - "LK": "Sri Lanka", - "BL": "St. Barthélemy", - "SH": "St. Helena", - "KN": "St. Kitts und Nevis", - "LC": "St. Lucia", - "MF": "St. Martin", - "PM": "St. Pierre und Miquelon", - "VC": "St. Vincent und die Grenadinen", - "ZA": "Südafrika", - "SD": "Sudan", - "GS": "Südgeorgien und die Südlichen Sandwichinseln", - "SS": "Südsudan", - "SR": "Suriname", - "SJ": "Svalbard und Jan Mayen", - "SZ": "Swasiland", - "SY": "Syrien", - "TJ": "Tadschikistan", - "TW": "Taiwan", - "TZ": "Tansania", - "TH": "Thailand", - "TL": "Timor-Leste", - "TG": "Togo", - "TK": "Tokelau", - "TO": "Tonga", - "TT": "Trinidad und Tobago", - "TA": "Tristan da Cunha", - "TD": "Tschad", - "CZ": "Tschechische Republik", - "TN": "Tunesien", - "TR": "Türkei", - "TM": "Turkmenistan", - "TC": "Turks- und Caicosinseln", - "TV": "Tuvalu", - "UG": "Uganda", - "UA": "Ukraine", - "HU": "Ungarn", - "UY": "Uruguay", - "UZ": "Usbekistan", - "VU": "Vanuatu", - "VA": "Vatikanstadt", - "VE": "Venezuela", - "AE": "Vereinigte Arabische Emirate", - "US": "Vereinigte Staaten", - "GB": "Vereinigtes Königreich", - "VN": "Vietnam", - "WF": "Wallis und Futuna", - "CX": "Weihnachtsinsel", - "EH": "Westsahara", - "CF": "Zentralafrikanische Republik", - "CY": "Zypern" + number: ["###-###-####", "(###) ###-####", "1-###-###-####", "###.###.####", "###-###-####", "(###) ###-####", "1-###-###-####", "###.###.####", "###-###-#### x###", "(###) ###-#### x###", "1-###-###-#### x###", "###.###.#### x###", "###-###-#### x####", "(###) ###-#### x####", "1-###-###-#### x####", "###.###.#### x####", "###-###-#### x#####", "(###) ###-#### x#####", "1-###-###-#### x#####", "###.###.#### x#####"] }; /***/ }, -/* 182 */ -/***/ function(module, exports) { +/* 175 */ +/***/ function(module, exports, __webpack_require__) { "use strict"; - module.exports = ["Ackerweg", "Adalbert-Stifter-Str.", "Adalbertstr.", "Adolf-Baeyer-Str.", "Adolf-Kaschny-Str.", "Adolf-Reichwein-Str.", "Adolfsstr.", "Ahornweg", "Ahrstr.", "Akazienweg", "Albert-Einstein-Str.", "Albert-Schweitzer-Str.", "Albertus-Magnus-Str.", "Albert-Zarthe-Weg", "Albin-Edelmann-Str.", "Albrecht-Haushofer-Str.", "Aldegundisstr.", "Alexanderstr.", "Alfred-Delp-Str.", "Alfred-Kubin-Str.", "Alfred-Stock-Str.", "Alkenrather Str.", "Allensteiner Str.", "Alsenstr.", "Alt Steinbücheler Weg", "Alte Garten", "Alte Heide", "Alte Landstr.", "Alte Ziegelei", "Altenberger Str.", "Altenhof", "Alter Grenzweg", "Altstadtstr.", "Am Alten Gaswerk", "Am Alten Schafstall", "Am Arenzberg", "Am Benthal", "Am Birkenberg", "Am Blauen Berg", "Am Borsberg", "Am Brungen", "Am Büchelter Hof", "Am Buttermarkt", "Am Ehrenfriedhof", "Am Eselsdamm", "Am Falkenberg", "Am Frankenberg", "Am Gesundheitspark", "Am Gierlichshof", "Am Graben", "Am Hagelkreuz", "Am Hang", "Am Heidkamp", "Am Hemmelrather Hof", "Am Hofacker", "Am Hohen Ufer", "Am Höllers Eck", "Am Hühnerberg", "Am Jägerhof", "Am Junkernkamp", "Am Kemperstiegel", "Am Kettnersbusch", "Am Kiesberg", "Am Klösterchen", "Am Knechtsgraben", "Am Köllerweg", "Am Köttersbach", "Am Kreispark", "Am Kronefeld", "Am Küchenhof", "Am Kühnsbusch", "Am Lindenfeld", "Am Märchen", "Am Mittelberg", "Am Mönchshof", "Am Mühlenbach", "Am Neuenhof", "Am Nonnenbruch", "Am Plattenbusch", "Am Quettinger Feld", "Am Rosenhügel", "Am Sandberg", "Am Scherfenbrand", "Am Schokker", "Am Silbersee", "Am Sonnenhang", "Am Sportplatz", "Am Stadtpark", "Am Steinberg", "Am Telegraf", "Am Thelenhof", "Am Vogelkreuz", "Am Vogelsang", "Am Vogelsfeldchen", "Am Wambacher Hof", "Am Wasserturm", "Am Weidenbusch", "Am Weiher", "Am Weingarten", "Am Werth", "Amselweg", "An den Irlen", "An den Rheinauen", "An der Bergerweide", "An der Dingbank", "An der Evangelischen Kirche", "An der Evgl. Kirche", "An der Feldgasse", "An der Fettehenne", "An der Kante", "An der Laach", "An der Lehmkuhle", "An der Lichtenburg", "An der Luisenburg", "An der Robertsburg", "An der Schmitten", "An der Schusterinsel", "An der Steinrütsch", "An St. Andreas", "An St. Remigius", "Andreasstr.", "Ankerweg", "Annette-Kolb-Str.", "Apenrader Str.", "Arnold-Ohletz-Str.", "Atzlenbacher Str.", "Auerweg", "Auestr.", "Auf dem Acker", "Auf dem Blahnenhof", "Auf dem Bohnbüchel", "Auf dem Bruch", "Auf dem End", "Auf dem Forst", "Auf dem Herberg", "Auf dem Lehn", "Auf dem Stein", "Auf dem Weierberg", "Auf dem Weiherhahn", "Auf den Reien", "Auf der Donnen", "Auf der Grieße", "Auf der Ohmer", "Auf der Weide", "Auf'm Berg", "Auf'm Kamp", "Augustastr.", "August-Kekulé-Str.", "A.-W.-v.-Hofmann-Str.", "Bahnallee", "Bahnhofstr.", "Baltrumstr.", "Bamberger Str.", "Baumberger Str.", "Bebelstr.", "Beckers Kämpchen", "Beerenstr.", "Beethovenstr.", "Behringstr.", "Bendenweg", "Bensberger Str.", "Benzstr.", "Bergische Landstr.", "Bergstr.", "Berliner Platz", "Berliner Str.", "Bernhard-Letterhaus-Str.", "Bernhard-Lichtenberg-Str.", "Bernhard-Ridder-Str.", "Bernsteinstr.", "Bertha-Middelhauve-Str.", "Bertha-von-Suttner-Str.", "Bertolt-Brecht-Str.", "Berzeliusstr.", "Bielertstr.", "Biesenbach", "Billrothstr.", "Birkenbergstr.", "Birkengartenstr.", "Birkenweg", "Bismarckstr.", "Bitterfelder Str.", "Blankenburg", "Blaukehlchenweg", "Blütenstr.", "Boberstr.", "Böcklerstr.", "Bodelschwinghstr.", "Bodestr.", "Bogenstr.", "Bohnenkampsweg", "Bohofsweg", "Bonifatiusstr.", "Bonner Str.", "Borkumstr.", "Bornheimer Str.", "Borsigstr.", "Borussiastr.", "Bracknellstr.", "Brahmsweg", "Brandenburger Str.", "Breidenbachstr.", "Breslauer Str.", "Bruchhauser Str.", "Brückenstr.", "Brucknerstr.", "Brüder-Bonhoeffer-Str.", "Buchenweg", "Bürgerbuschweg", "Burgloch", "Burgplatz", "Burgstr.", "Burgweg", "Bürriger Weg", "Burscheider Str.", "Buschkämpchen", "Butterheider Str.", "Carl-Duisberg-Platz", "Carl-Duisberg-Str.", "Carl-Leverkus-Str.", "Carl-Maria-von-Weber-Platz", "Carl-Maria-von-Weber-Str.", "Carlo-Mierendorff-Str.", "Carl-Rumpff-Str.", "Carl-von-Ossietzky-Str.", "Charlottenburger Str.", "Christian-Heß-Str.", "Claasbruch", "Clemens-Winkler-Str.", "Concordiastr.", "Cranachstr.", "Dahlemer Str.", "Daimlerstr.", "Damaschkestr.", "Danziger Str.", "Debengasse", "Dechant-Fein-Str.", "Dechant-Krey-Str.", "Deichtorstr.", "Dhünnberg", "Dhünnstr.", "Dianastr.", "Diedenhofener Str.", "Diepental", "Diepenthaler Str.", "Dieselstr.", "Dillinger Str.", "Distelkamp", "Dohrgasse", "Domblick", "Dönhoffstr.", "Dornierstr.", "Drachenfelsstr.", "Dr.-August-Blank-Str.", "Dresdener Str.", "Driescher Hecke", "Drosselweg", "Dudweilerstr.", "Dünenweg", "Dünfelder Str.", "Dünnwalder Grenzweg", "Düppeler Str.", "Dürerstr.", "Dürscheider Weg", "Düsseldorfer Str.", "Edelrather Weg", "Edmund-Husserl-Str.", "Eduard-Spranger-Str.", "Ehrlichstr.", "Eichenkamp", "Eichenweg", "Eidechsenweg", "Eifelstr.", "Eifgenstr.", "Eintrachtstr.", "Elbestr.", "Elisabeth-Langgässer-Str.", "Elisabethstr.", "Elisabeth-von-Thadden-Str.", "Elisenstr.", "Elsa-Brändström-Str.", "Elsbachstr.", "Else-Lasker-Schüler-Str.", "Elsterstr.", "Emil-Fischer-Str.", "Emil-Nolde-Str.", "Engelbertstr.", "Engstenberger Weg", "Entenpfuhl", "Erbelegasse", "Erftstr.", "Erfurter Str.", "Erich-Heckel-Str.", "Erich-Klausener-Str.", "Erich-Ollenhauer-Str.", "Erlenweg", "Ernst-Bloch-Str.", "Ernst-Ludwig-Kirchner-Str.", "Erzbergerstr.", "Eschenallee", "Eschenweg", "Esmarchstr.", "Espenweg", "Euckenstr.", "Eulengasse", "Eulenkamp", "Ewald-Flamme-Str.", "Ewald-Röll-Str.", "Fährstr.", "Farnweg", "Fasanenweg", "Faßbacher Hof", "Felderstr.", "Feldkampstr.", "Feldsiefer Weg", "Feldsiefer Wiesen", "Feldstr.", "Feldtorstr.", "Felix-von-Roll-Str.", "Ferdinand-Lassalle-Str.", "Fester Weg", "Feuerbachstr.", "Feuerdornweg", "Fichtenweg", "Fichtestr.", "Finkelsteinstr.", "Finkenweg", "Fixheider Str.", "Flabbenhäuschen", "Flensburger Str.", "Fliederweg", "Florastr.", "Florianweg", "Flotowstr.", "Flurstr.", "Föhrenweg", "Fontanestr.", "Forellental", "Fortunastr.", "Franz-Esser-Str.", "Franz-Hitze-Str.", "Franz-Kail-Str.", "Franz-Marc-Str.", "Freiburger Str.", "Freiheitstr.", "Freiherr-vom-Stein-Str.", "Freudenthal", "Freudenthaler Weg", "Fridtjof-Nansen-Str.", "Friedenberger Str.", "Friedensstr.", "Friedhofstr.", "Friedlandstr.", "Friedlieb-Ferdinand-Runge-Str.", "Friedrich-Bayer-Str.", "Friedrich-Bergius-Platz", "Friedrich-Ebert-Platz", "Friedrich-Ebert-Str.", "Friedrich-Engels-Str.", "Friedrich-List-Str.", "Friedrich-Naumann-Str.", "Friedrich-Sertürner-Str.", "Friedrichstr.", "Friedrich-Weskott-Str.", "Friesenweg", "Frischenberg", "Fritz-Erler-Str.", "Fritz-Henseler-Str.", "Fröbelstr.", "Fürstenbergplatz", "Fürstenbergstr.", "Gabriele-Münter-Str.", "Gartenstr.", "Gebhardstr.", "Geibelstr.", "Gellertstr.", "Georg-von-Vollmar-Str.", "Gerhard-Domagk-Str.", "Gerhart-Hauptmann-Str.", "Gerichtsstr.", "Geschwister-Scholl-Str.", "Gezelinallee", "Gierener Weg", "Ginsterweg", "Gisbert-Cremer-Str.", "Glücksburger Str.", "Gluckstr.", "Gneisenaustr.", "Goetheplatz", "Goethestr.", "Golo-Mann-Str.", "Görlitzer Str.", "Görresstr.", "Graebestr.", "Graf-Galen-Platz", "Gregor-Mendel-Str.", "Greifswalder Str.", "Grillenweg", "Gronenborner Weg", "Große Kirchstr.", "Grunder Wiesen", "Grundermühle", "Grundermühlenhof", "Grundermühlenweg", "Grüner Weg", "Grunewaldstr.", "Grünstr.", "Günther-Weisenborn-Str.", "Gustav-Freytag-Str.", "Gustav-Heinemann-Str.", "Gustav-Radbruch-Str.", "Gut Reuschenberg", "Gutenbergstr.", "Haberstr.", "Habichtgasse", "Hafenstr.", "Hagenauer Str.", "Hahnenblecher", "Halenseestr.", "Halfenleimbach", "Hallesche Str.", "Halligstr.", "Hamberger Str.", "Hammerweg", "Händelstr.", "Hannah-Höch-Str.", "Hans-Arp-Str.", "Hans-Gerhard-Str.", "Hans-Sachs-Str.", "Hans-Schlehahn-Str.", "Hans-von-Dohnanyi-Str.", "Hardenbergstr.", "Haselweg", "Hauptstr.", "Haus-Vorster-Str.", "Hauweg", "Havelstr.", "Havensteinstr.", "Haydnstr.", "Hebbelstr.", "Heckenweg", "Heerweg", "Hegelstr.", "Heidberg", "Heidehöhe", "Heidestr.", "Heimstättenweg", "Heinrich-Böll-Str.", "Heinrich-Brüning-Str.", "Heinrich-Claes-Str.", "Heinrich-Heine-Str.", "Heinrich-Hörlein-Str.", "Heinrich-Lübke-Str.", "Heinrich-Lützenkirchen-Weg", "Heinrichstr.", "Heinrich-Strerath-Str.", "Heinrich-von-Kleist-Str.", "Heinrich-von-Stephan-Str.", "Heisterbachstr.", "Helenenstr.", "Helmestr.", "Hemmelrather Weg", "Henry-T.-v.-Böttinger-Str.", "Herderstr.", "Heribertstr.", "Hermann-Ehlers-Str.", "Hermann-Hesse-Str.", "Hermann-König-Str.", "Hermann-Löns-Str.", "Hermann-Milde-Str.", "Hermann-Nörrenberg-Str.", "Hermann-von-Helmholtz-Str.", "Hermann-Waibel-Str.", "Herzogstr.", "Heymannstr.", "Hindenburgstr.", "Hirzenberg", "Hitdorfer Kirchweg", "Hitdorfer Str.", "Höfer Mühle", "Höfer Weg", "Hohe Str.", "Höhenstr.", "Höltgestal", "Holunderweg", "Holzer Weg", "Holzer Wiesen", "Hornpottweg", "Hubertusweg", "Hufelandstr.", "Hufer Weg", "Humboldtstr.", "Hummelsheim", "Hummelweg", "Humperdinckstr.", "Hüscheider Gärten", "Hüscheider Str.", "Hütte", "Ilmstr.", "Im Bergischen Heim", "Im Bruch", "Im Buchenhain", "Im Bühl", "Im Burgfeld", "Im Dorf", "Im Eisholz", "Im Friedenstal", "Im Frohental", "Im Grunde", "Im Hederichsfeld", "Im Jücherfeld", "Im Kalkfeld", "Im Kirberg", "Im Kirchfeld", "Im Kreuzbruch", "Im Mühlenfeld", "Im Nesselrader Kamp", "Im Oberdorf", "Im Oberfeld", "Im Rosengarten", "Im Rottland", "Im Scheffengarten", "Im Staderfeld", "Im Steinfeld", "Im Weidenblech", "Im Winkel", "Im Ziegelfeld", "Imbach", "Imbacher Weg", "Immenweg", "In den Blechenhöfen", "In den Dehlen", "In der Birkenau", "In der Dasladen", "In der Felderhütten", "In der Hartmannswiese", "In der Höhle", "In der Schaafsdellen", "In der Wasserkuhl", "In der Wüste", "In Holzhausen", "Insterstr.", "Jacob-Fröhlen-Str.", "Jägerstr.", "Jahnstr.", "Jakob-Eulenberg-Weg", "Jakobistr.", "Jakob-Kaiser-Str.", "Jenaer Str.", "Johannes-Baptist-Str.", "Johannes-Dott-Str.", "Johannes-Popitz-Str.", "Johannes-Wislicenus-Str.", "Johannisburger Str.", "Johann-Janssen-Str.", "Johann-Wirtz-Weg", "Josefstr.", "Jüch", "Julius-Doms-Str.", "Julius-Leber-Str.", "Kaiserplatz", "Kaiserstr.", "Kaiser-Wilhelm-Allee", "Kalkstr.", "Kämpchenstr.", "Kämpenwiese", "Kämper Weg", "Kamptalweg", "Kanalstr.", "Kandinskystr.", "Kantstr.", "Kapellenstr.", "Karl-Arnold-Str.", "Karl-Bosch-Str.", "Karl-Bückart-Str.", "Karl-Carstens-Ring", "Karl-Friedrich-Goerdeler-Str.", "Karl-Jaspers-Str.", "Karl-König-Str.", "Karl-Krekeler-Str.", "Karl-Marx-Str.", "Karlstr.", "Karl-Ulitzka-Str.", "Karl-Wichmann-Str.", "Karl-Wingchen-Str.", "Käsenbrod", "Käthe-Kollwitz-Str.", "Katzbachstr.", "Kerschensteinerstr.", "Kiefernweg", "Kieler Str.", "Kieselstr.", "Kiesweg", "Kinderhausen", "Kleiberweg", "Kleine Kirchstr.", "Kleingansweg", "Kleinheider Weg", "Klief", "Kneippstr.", "Knochenbergsweg", "Kochergarten", "Kocherstr.", "Kockelsberg", "Kolberger Str.", "Kolmarer Str.", "Kölner Gasse", "Kölner Str.", "Kolpingstr.", "Königsberger Platz", "Konrad-Adenauer-Platz", "Köpenicker Str.", "Kopernikusstr.", "Körnerstr.", "Köschenberg", "Köttershof", "Kreuzbroicher Str.", "Kreuzkamp", "Krummer Weg", "Kruppstr.", "Kuhlmannweg", "Kump", "Kumper Weg", "Kunstfeldstr.", "Küppersteger Str.", "Kursiefen", "Kursiefer Weg", "Kurtekottenweg", "Kurt-Schumacher-Ring", "Kyllstr.", "Langenfelder Str.", "Längsleimbach", "Lärchenweg", "Legienstr.", "Lehner Mühle", "Leichlinger Str.", "Leimbacher Hof", "Leinestr.", "Leineweberstr.", "Leipziger Str.", "Lerchengasse", "Lessingstr.", "Libellenweg", "Lichstr.", "Liebigstr.", "Lindenstr.", "Lingenfeld", "Linienstr.", "Lippe", "Löchergraben", "Löfflerstr.", "Loheweg", "Lohrbergstr.", "Lohrstr.", "Löhstr.", "Lortzingstr.", "Lötzener Str.", "Löwenburgstr.", "Lucasstr.", "Ludwig-Erhard-Platz", "Ludwig-Girtler-Str.", "Ludwig-Knorr-Str.", "Luisenstr.", "Lupinenweg", "Lurchenweg", "Lützenkirchener Str.", "Lycker Str.", "Maashofstr.", "Manforter Str.", "Marc-Chagall-Str.", "Maria-Dresen-Str.", "Maria-Terwiel-Str.", "Marie-Curie-Str.", "Marienburger Str.", "Mariendorfer Str.", "Marienwerderstr.", "Marie-Schlei-Str.", "Marktplatz", "Markusweg", "Martin-Buber-Str.", "Martin-Heidegger-Str.", "Martin-Luther-Str.", "Masurenstr.", "Mathildenweg", "Maurinusstr.", "Mauspfad", "Max-Beckmann-Str.", "Max-Delbrück-Str.", "Max-Ernst-Str.", "Max-Holthausen-Platz", "Max-Horkheimer-Str.", "Max-Liebermann-Str.", "Max-Pechstein-Str.", "Max-Planck-Str.", "Max-Scheler-Str.", "Max-Schönenberg-Str.", "Maybachstr.", "Meckhofer Feld", "Meisenweg", "Memelstr.", "Menchendahler Str.", "Mendelssohnstr.", "Merziger Str.", "Mettlacher Str.", "Metzer Str.", "Michaelsweg", "Miselohestr.", "Mittelstr.", "Mohlenstr.", "Moltkestr.", "Monheimer Str.", "Montanusstr.", "Montessoriweg", "Moosweg", "Morsbroicher Str.", "Moselstr.", "Moskauer Str.", "Mozartstr.", "Mühlenweg", "Muhrgasse", "Muldestr.", "Mülhausener Str.", "Mülheimer Str.", "Münsters Gäßchen", "Münzstr.", "Müritzstr.", "Myliusstr.", "Nachtigallenweg", "Nauener Str.", "Neißestr.", "Nelly-Sachs-Str.", "Netzestr.", "Neuendriesch", "Neuenhausgasse", "Neuenkamp", "Neujudenhof", "Neukronenberger Str.", "Neustadtstr.", "Nicolai-Hartmann-Str.", "Niederblecher", "Niederfeldstr.", "Nietzschestr.", "Nikolaus-Groß-Str.", "Nobelstr.", "Norderneystr.", "Nordstr.", "Ober dem Hof", "Obere Lindenstr.", "Obere Str.", "Oberölbach", "Odenthaler Str.", "Oderstr.", "Okerstr.", "Olof-Palme-Str.", "Ophovener Str.", "Opladener Platz", "Opladener Str.", "Ortelsburger Str.", "Oskar-Moll-Str.", "Oskar-Schlemmer-Str.", "Oststr.", "Oswald-Spengler-Str.", "Otto-Dix-Str.", "Otto-Grimm-Str.", "Otto-Hahn-Str.", "Otto-Müller-Str.", "Otto-Stange-Str.", "Ottostr.", "Otto-Varnhagen-Str.", "Otto-Wels-Str.", "Ottweilerstr.", "Oulustr.", "Overfeldweg", "Pappelweg", "Paracelsusstr.", "Parkstr.", "Pastor-Louis-Str.", "Pastor-Scheibler-Str.", "Pastorskamp", "Paul-Klee-Str.", "Paul-Löbe-Str.", "Paulstr.", "Peenestr.", "Pescher Busch", "Peschstr.", "Pestalozzistr.", "Peter-Grieß-Str.", "Peter-Joseph-Lenné-Str.", "Peter-Neuenheuser-Str.", "Petersbergstr.", "Peterstr.", "Pfarrer-Jekel-Str.", "Pfarrer-Klein-Str.", "Pfarrer-Röhr-Str.", "Pfeilshofstr.", "Philipp-Ott-Str.", "Piet-Mondrian-Str.", "Platanenweg", "Pommernstr.", "Porschestr.", "Poststr.", "Potsdamer Str.", "Pregelstr.", "Prießnitzstr.", "Pützdelle", "Quarzstr.", "Quettinger Str.", "Rat-Deycks-Str.", "Rathenaustr.", "Ratherkämp", "Ratiborer Str.", "Raushofstr.", "Regensburger Str.", "Reinickendorfer Str.", "Renkgasse", "Rennbaumplatz", "Rennbaumstr.", "Reuschenberger Str.", "Reusrather Str.", "Reuterstr.", "Rheinallee", "Rheindorfer Str.", "Rheinstr.", "Rhein-Wupper-Platz", "Richard-Wagner-Str.", "Rilkestr.", "Ringstr.", "Robert-Blum-Str.", "Robert-Koch-Str.", "Robert-Medenwald-Str.", "Rolandstr.", "Romberg", "Röntgenstr.", "Roonstr.", "Ropenstall", "Ropenstaller Weg", "Rosenthal", "Rostocker Str.", "Rotdornweg", "Röttgerweg", "Rückertstr.", "Rudolf-Breitscheid-Str.", "Rudolf-Mann-Platz", "Rudolf-Stracke-Str.", "Ruhlachplatz", "Ruhlachstr.", "Rüttersweg", "Saalestr.", "Saarbrücker Str.", "Saarlauterner Str.", "Saarstr.", "Salamanderweg", "Samlandstr.", "Sanddornstr.", "Sandstr.", "Sauerbruchstr.", "Schäfershütte", "Scharnhorststr.", "Scheffershof", "Scheidemannstr.", "Schellingstr.", "Schenkendorfstr.", "Schießbergstr.", "Schillerstr.", "Schlangenhecke", "Schlebuscher Heide", "Schlebuscher Str.", "Schlebuschrath", "Schlehdornstr.", "Schleiermacherstr.", "Schloßstr.", "Schmalenbruch", "Schnepfenflucht", "Schöffenweg", "Schöllerstr.", "Schöne Aussicht", "Schöneberger Str.", "Schopenhauerstr.", "Schubertplatz", "Schubertstr.", "Schulberg", "Schulstr.", "Schumannstr.", "Schwalbenweg", "Schwarzastr.", "Sebastianusweg", "Semmelweisstr.", "Siebelplatz", "Siemensstr.", "Solinger Str.", "Sonderburger Str.", "Spandauer Str.", "Speestr.", "Sperberweg", "Sperlingsweg", "Spitzwegstr.", "Sporrenberger Mühle", "Spreestr.", "St. Ingberter Str.", "Starenweg", "Stauffenbergstr.", "Stefan-Zweig-Str.", "Stegerwaldstr.", "Steglitzer Str.", "Steinbücheler Feld", "Steinbücheler Str.", "Steinstr.", "Steinweg", "Stephan-Lochner-Str.", "Stephanusstr.", "Stettiner Str.", "Stixchesstr.", "Stöckenstr.", "Stralsunder Str.", "Straßburger Str.", "Stresemannplatz", "Strombergstr.", "Stromstr.", "Stüttekofener Str.", "Sudestr.", "Sürderstr.", "Syltstr.", "Talstr.", "Tannenbergstr.", "Tannenweg", "Taubenweg", "Teitscheider Weg", "Telegrafenstr.", "Teltower Str.", "Tempelhofer Str.", "Theodor-Adorno-Str.", "Theodor-Fliedner-Str.", "Theodor-Gierath-Str.", "Theodor-Haubach-Str.", "Theodor-Heuss-Ring", "Theodor-Storm-Str.", "Theodorstr.", "Thomas-Dehler-Str.", "Thomas-Morus-Str.", "Thomas-von-Aquin-Str.", "Tönges Feld", "Torstr.", "Treptower Str.", "Treuburger Str.", "Uhlandstr.", "Ulmenweg", "Ulmer Str.", "Ulrichstr.", "Ulrich-von-Hassell-Str.", "Umlag", "Unstrutstr.", "Unter dem Schildchen", "Unterölbach", "Unterstr.", "Uppersberg", "Van\\'t-Hoff-Str.", "Veit-Stoß-Str.", "Vereinsstr.", "Viktor-Meyer-Str.", "Vincent-van-Gogh-Str.", "Virchowstr.", "Voigtslach", "Volhardstr.", "Völklinger Str.", "Von-Brentano-Str.", "Von-Diergardt-Str.", "Von-Eichendorff-Str.", "Von-Ketteler-Str.", "Von-Knoeringen-Str.", "Von-Pettenkofer-Str.", "Von-Siebold-Str.", "Wacholderweg", "Waldstr.", "Walter-Flex-Str.", "Walter-Hempel-Str.", "Walter-Hochapfel-Str.", "Walter-Nernst-Str.", "Wannseestr.", "Warnowstr.", "Warthestr.", "Weddigenstr.", "Weichselstr.", "Weidenstr.", "Weidfeldstr.", "Weiherfeld", "Weiherstr.", "Weinhäuser Str.", "Weißdornweg", "Weißenseestr.", "Weizkamp", "Werftstr.", "Werkstättenstr.", "Werner-Heisenberg-Str.", "Werrastr.", "Weyerweg", "Widdauener Str.", "Wiebertshof", "Wiehbachtal", "Wiembachallee", "Wiesdorfer Platz", "Wiesenstr.", "Wilhelm-Busch-Str.", "Wilhelm-Hastrich-Str.", "Wilhelm-Leuschner-Str.", "Wilhelm-Liebknecht-Str.", "Wilhelmsgasse", "Wilhelmstr.", "Willi-Baumeister-Str.", "Willy-Brandt-Ring", "Winand-Rossi-Str.", "Windthorststr.", "Winkelweg", "Winterberg", "Wittenbergstr.", "Wolf-Vostell-Str.", "Wolkenburgstr.", "Wupperstr.", "Wuppertalstr.", "Wüstenhof", "Yitzhak-Rabin-Str.", "Zauberkuhle", "Zedernweg", "Zehlendorfer Str.", "Zehntenweg", "Zeisigweg", "Zeppelinstr.", "Zschopaustr.", "Zum Claashäuschen", "Zündhütchenweg", "Zur Alten Brauerei", "Zur alten Fabrik"]; + var _passwordGenerator = __webpack_require__(176); -/***/ }, -/* 183 */ -/***/ function(module, exports) { + var _passwordGenerator2 = _interopRequireDefault(_passwordGenerator); - "use strict"; + var _crypto = __webpack_require__(177); - module.exports = { - name: ["#{names.lastName} #{company.suffix}", "#{names.lastName}-#{names.lastName}", "#{names.lastName}, #{names.lastName} und #{names.lastName}"], + var _crypto2 = _interopRequireDefault(_crypto); - suffix: ["GmbH", "AG", "Gruppe", "KG", "GmbH & Co. KG", "UG", "OHG"] - }; + var _uifaces = __webpack_require__(236); -/***/ }, -/* 184 */ -/***/ function(module, exports, __webpack_require__) { + var _uifaces2 = _interopRequireDefault(_uifaces); - "use strict"; + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } module.exports = { - _meta: { - id: "de-DE", - fallback: null, - language: "German", - country: "Germany", - countryCode: "DE" - }, - - names: __webpack_require__(185), - phone: __webpack_require__(189), - address: __webpack_require__(180), - company: __webpack_require__(183), - internet: __webpack_require__(190) - }; - -/***/ }, -/* 185 */ -/***/ function(module, exports, __webpack_require__) { + tld: __webpack_require__(237), - "use strict"; + userName: function userName(firstName, lastName) { + firstName = this.slugify(firstName ? firstName : this.populate("#{names.firstName}")).toLowerCase(); + lastName = this.slugify(lastName ? lastName : this.populate("#{names.lastName}")).toLowerCase(); - module.exports = { - firstNameM: __webpack_require__(186), + return this.populate(this.random.arrayElement([firstName + "." + lastName, firstName + "." + lastName + "##", firstName + "." + lastName + "####", firstName + "_" + lastName, firstName + "_" + lastName + "##", "" + firstName + lastName + "##", firstName + "##"])); + }, + password: function password(length, memorable, pattern, prefix) { + return (0, _passwordGenerator2.default)(length, memorable, pattern, prefix); + }, + domain: function domain() { + return this.slugify(this.populate(this.random.arrayElement(["#{names.firstName}", "#{names.firstName}#{names.lastName}", "#{names.firstName}-#{names.lastName}"]))).toLowerCase() + "." + this.random.arrayElement(module.exports.tld); + }, + url: function url(https://github.com/isHttps,%20hasWWW) { + if (isHttps == null) isHttps = this.random.boolean(); - firstNameF: __webpack_require__(186), + if (hasWWW == null) hasWWW = !this.random.boolean(); - lastNameM: __webpack_require__(187), + var prefix = isHttps ? "https://" : "http://"; + if (hasWWW) prefix += "www."; - lastNameF: __webpack_require__(187), + return prefix + this.internet.domain(); + }, - prefix: ["Hr.", "Fr.", "Dr.", "Prof. Dr."], - nobilityTitlePrefix: __webpack_require__(188), + emailDomain: ["gmail.com", "yahoo.com", "hotmail.com"], - suffix: [], + email: function email(firstName, lastName, domain) { + firstName = this.slugify(firstName ? firstName : this.populate("#{names.firstName}")).toLowerCase(); + lastName = this.slugify(lastName ? lastName : this.populate("#{names.lastName}")).toLowerCase(); + domain = domain ? domain : this.populate("#{internet.emailDomain}"); - name: ["#{names.prefix} #{names.firstName} #{names.lastName}", "#{names.firstName} #{names.nobilityTitlePrefix} #{names.lastName}", "#{names.firstName} #{names.lastName}", "#{names.firstName} #{names.lastName}", "#{names.firstName} #{names.lastName}", "#{names.firstName} #{names.lastName}"], + return [firstName + "." + lastName + "@" + domain, firstName + "." + lastName + "##@" + domain, "" + firstName + lastName + "##@" + domain, firstName + "##@" + domain]; + }, - nameM: module.exports.name, - nameF: module.exports.name - }; + imageCategories: ["abstract", "animals", "business", "cats", "city", "food", "nightlife", "fashion", "people", "nature", "sports", "technics", "transport"], -/***/ }, -/* 186 */ -/***/ function(module, exports) { + image: function image() { + var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 640; + var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 480; + var category = arguments[2]; - "use strict"; + var url = "http://lorempixel.com/" + width + "/" + height; + if (category) url += "/" + category; - module.exports = ["Aaron", "Abdul", "Abdullah", "Adam", "Adrian", "Adriano", "Ahmad", "Ahmed", "Ahmet", "Alan", "Albert", "Alessandro", "Alessio", "Alex", "Alexander", "Alfred", "Ali", "Amar", "Amir", "Amon", "Andre", "Andreas", "Andrew", "Angelo", "Ansgar", "Anthony", "Anton", "Antonio", "Arda", "Arian", "Armin", "Arne", "Arno", "Arthur", "Artur", "Arved", "Arvid", "Ayman", "Baran", "Baris", "Bastian", "Batuhan", "Bela", "Ben", "Benedikt", "Benjamin", "Bennet", "Bennett", "Benno", "Bent", "Berat", "Berkay", "Bernd", "Bilal", "Bjarne", "Björn", "Bo", "Boris", "Brandon", "Brian", "Bruno", "Bryan", "Burak", "Calvin", "Can", "Carl", "Carlo", "Carlos", "Caspar", "Cedric", "Cedrik", "Cem", "Charlie", "Chris", "Christian", "Christiano", "Christoph", "Christopher", "Claas", "Clemens", "Colin", "Collin", "Conner", "Connor", "Constantin", "Corvin", "Curt", "Damian", "Damien", "Daniel", "Danilo", "Danny", "Darian", "Dario", "Darius", "Darren", "David", "Davide", "Davin", "Dean", "Deniz", "Dennis", "Denny", "Devin", "Diego", "Dion", "Domenic", "Domenik", "Dominic", "Dominik", "Dorian", "Dustin", "Dylan", "Ecrin", "Eddi", "Eddy", "Edgar", "Edwin", "Efe", "Ege", "Elia", "Eliah", "Elias", "Elijah", "Emanuel", "Emil", "Emilian", "Emilio", "Emir", "Emirhan", "Emre", "Enes", "Enno", "Enrico", "Eren", "Eric", "Erik", "Etienne", "Fabian", "Fabien", "Fabio", "Fabrice", "Falk", "Felix", "Ferdinand", "Fiete", "Filip", "Finlay", "Finley", "Finn", "Finnley", "Florian", "Francesco", "Franz", "Frederic", "Frederick", "Frederik", "Friedrich", "Fritz", "Furkan", "Fynn", "Gabriel", "Georg", "Gerrit", "Gian", "Gianluca", "Gino", "Giuliano", "Giuseppe", "Gregor", "Gustav", "Hagen", "Hamza", "Hannes", "Hanno", "Hans", "Hasan", "Hassan", "Hauke", "Hendrik", "Hennes", "Henning", "Henri", "Henrick", "Henrik", "Henry", "Hugo", "Hussein", "Ian", "Ibrahim", "Ilias", "Ilja", "Ilyas", "Immanuel", "Ismael", "Ismail", "Ivan", "Iven", "Jack", "Jacob", "Jaden", "Jakob", "Jamal", "James", "Jamie", "Jan", "Janek", "Janis", "Janne", "Jannek", "Jannes", "Jannik", "Jannis", "Jano", "Janosch", "Jared", "Jari", "Jarne", "Jarno", "Jaron", "Jason", "Jasper", "Jay", "Jayden", "Jayson", "Jean", "Jens", "Jeremias", "Jeremie", "Jeremy", "Jermaine", "Jerome", "Jesper", "Jesse", "Jim", "Jimmy", "Joe", "Joel", "Joey", "Johann", "Johannes", "John", "Johnny", "Jon", "Jona", "Jonah", "Jonas", "Jonathan", "Jonte", "Joost", "Jordan", "Joris", "Joscha", "Joschua", "Josef", "Joseph", "Josh", "Joshua", "Josua", "Juan", "Julian", "Julien", "Julius", "Juri", "Justin", "Justus", "Kaan", "Kai", "Kalle", "Karim", "Karl", "Karlo", "Kay", "Keanu", "Kenan", "Kenny", "Keno", "Kerem", "Kerim", "Kevin", "Kian", "Kilian", "Kim", "Kimi", "Kjell", "Klaas", "Klemens", "Konrad", "Konstantin", "Koray", "Korbinian", "Kurt", "Lars", "Lasse", "Laurence", "Laurens", "Laurenz", "Laurin", "Lean", "Leander", "Leandro", "Leif", "Len", "Lenn", "Lennard", "Lennart", "Lennert", "Lennie", "Lennox", "Lenny", "Leo", "Leon", "Leonard", "Leonardo", "Leonhard", "Leonidas", "Leopold", "Leroy", "Levent", "Levi", "Levin", "Lewin", "Lewis", "Liam", "Lian", "Lias", "Lino", "Linus", "Lio", "Lion", "Lionel", "Logan", "Lorenz", "Lorenzo", "Loris", "Louis", "Luan", "Luc", "Luca", "Lucas", "Lucian", "Lucien", "Ludwig", "Luis", "Luiz", "Luk", "Luka", "Lukas", "Luke", "Lutz", "Maddox", "Mads", "Magnus", "Maik", "Maksim", "Malik", "Malte", "Manuel", "Marc", "Marcel", "Marco", "Marcus", "Marek", "Marian", "Mario", "Marius", "Mark", "Marko", "Markus", "Marlo", "Marlon", "Marten", "Martin", "Marvin", "Marwin", "Mateo", "Mathis", "Matis", "Mats", "Matteo", "Mattes", "Matthias", "Matthis", "Matti", "Mattis", "Maurice", "Max", "Maxim", "Maximilian", "Mehmet", "Meik", "Melvin", "Merlin", "Mert", "Michael", "Michel", "Mick", "Miguel", "Mika", "Mikail", "Mike", "Milan", "Milo", "Mio", "Mirac", "Mirco", "Mirko", "Mohamed", "Mohammad", "Mohammed", "Moritz", "Morten", "Muhammed", "Murat", "Mustafa", "Nathan", "Nathanael", "Nelson", "Neo", "Nevio", "Nick", "Niclas", "Nico", "Nicolai", "Nicolas", "Niels", "Nikita", "Niklas", "Niko", "Nikolai", "Nikolas", "Nils", "Nino", "Noah", "Noel", "Norman", "Odin", "Oke", "Ole", "Oliver", "Omar", "Onur", "Oscar", "Oskar", "Pascal", "Patrice", "Patrick", "Paul", "Peer", "Pepe", "Peter", "Phil", "Philip", "Philipp", "Pierre", "Piet", "Pit", "Pius", "Quentin", "Quirin", "Rafael", "Raik", "Ramon", "Raphael", "Rasmus", "Raul", "Rayan", "René", "Ricardo", "Riccardo", "Richard", "Rick", "Rico", "Robert", "Robin", "Rocco", "Roman", "Romeo", "Ron", "Ruben", "Ryan", "Said", "Salih", "Sam", "Sami", "Sammy", "Samuel", "Sandro", "Santino", "Sascha", "Sean", "Sebastian", "Selim", "Semih", "Shawn", "Silas", "Simeon", "Simon", "Sinan", "Sky", "Stefan", "Steffen", "Stephan", "Steve", "Steven", "Sven", "Sönke", "Sören", "Taha", "Tamino", "Tammo", "Tarik", "Tayler", "Taylor", "Teo", "Theo", "Theodor", "Thies", "Thilo", "Thomas", "Thorben", "Thore", "Thorge", "Tiago", "Til", "Till", "Tillmann", "Tim", "Timm", "Timo", "Timon", "Timothy", "Tino", "Titus", "Tizian", "Tjark", "Tobias", "Tom", "Tommy", "Toni", "Tony", "Torben", "Tore", "Tristan", "Tyler", "Tyron", "Umut", "Valentin", "Valentino", "Veit", "Victor", "Viktor", "Vin", "Vincent", "Vito", "Vitus", "Wilhelm", "Willi", "William", "Willy", "Xaver", "Yannic", "Yannick", "Yannik", "Yannis", "Yasin", "Youssef", "Yunus", "Yusuf", "Yven", "Yves", "Ömer", "Aaliyah", "Abby", "Abigail", "Ada", "Adelina", "Adriana", "Aileen", "Aimee", "Alana", "Alea", "Alena", "Alessa", "Alessia", "Alexa", "Alexandra", "Alexia", "Alexis", "Aleyna", "Alia", "Alica", "Alice", "Alicia", "Alina", "Alisa", "Alisha", "Alissa", "Aliya", "Aliyah", "Allegra", "Alma", "Alyssa", "Amalia", "Amanda", "Amelia", "Amelie", "Amina", "Amira", "Amy", "Ana", "Anabel", "Anastasia", "Andrea", "Angela", "Angelina", "Angelique", "Anja", "Ann", "Anna", "Annabel", "Annabell", "Annabelle", "Annalena", "Anne", "Anneke", "Annelie", "Annemarie", "Anni", "Annie", "Annika", "Anny", "Anouk", "Antonia", "Arda", "Ariana", "Ariane", "Arwen", "Ashley", "Asya", "Aurelia", "Aurora", "Ava", "Ayleen", "Aylin", "Ayse", "Azra", "Betty", "Bianca", "Bianka", "Caitlin", "Cara", "Carina", "Carla", "Carlotta", "Carmen", "Carolin", "Carolina", "Caroline", "Cassandra", "Catharina", "Catrin", "Cecile", "Cecilia", "Celia", "Celina", "Celine", "Ceyda", "Ceylin", "Chantal", "Charleen", "Charlotta", "Charlotte", "Chayenne", "Cheyenne", "Chiara", "Christin", "Christina", "Cindy", "Claire", "Clara", "Clarissa", "Colleen", "Collien", "Cora", "Corinna", "Cosima", "Dana", "Daniela", "Daria", "Darleen", "Defne", "Delia", "Denise", "Diana", "Dilara", "Dina", "Dorothea", "Ecrin", "Eda", "Eileen", "Ela", "Elaine", "Elanur", "Elea", "Elena", "Eleni", "Eleonora", "Eliana", "Elif", "Elina", "Elisa", "Elisabeth", "Ella", "Ellen", "Elli", "Elly", "Elsa", "Emelie", "Emely", "Emilia", "Emilie", "Emily", "Emma", "Emmely", "Emmi", "Emmy", "Enie", "Enna", "Enya", "Esma", "Estelle", "Esther", "Eva", "Evelin", "Evelina", "Eveline", "Evelyn", "Fabienne", "Fatima", "Fatma", "Felicia", "Felicitas", "Felina", "Femke", "Fenja", "Fine", "Finia", "Finja", "Finnja", "Fiona", "Flora", "Florentine", "Francesca", "Franka", "Franziska", "Frederike", "Freya", "Frida", "Frieda", "Friederike", "Giada", "Gina", "Giulia", "Giuliana", "Greta", "Hailey", "Hana", "Hanna", "Hannah", "Heidi", "Helen", "Helena", "Helene", "Helin", "Henriette", "Henrike", "Hermine", "Ida", "Ilayda", "Imke", "Ina", "Ines", "Inga", "Inka", "Irem", "Isa", "Isabel", "Isabell", "Isabella", "Isabelle", "Ivonne", "Jacqueline", "Jamie", "Jamila", "Jana", "Jane", "Janin", "Janina", "Janine", "Janna", "Janne", "Jara", "Jasmin", "Jasmina", "Jasmine", "Jella", "Jenna", "Jennifer", "Jenny", "Jessica", "Jessy", "Jette", "Jil", "Jill", "Joana", "Joanna", "Joelina", "Joeline", "Joelle", "Johanna", "Joleen", "Jolie", "Jolien", "Jolin", "Jolina", "Joline", "Jona", "Jonah", "Jonna", "Josefin", "Josefine", "Josephin", "Josephine", "Josie", "Josy", "Joy", "Joyce", "Judith", "Judy", "Jule", "Julia", "Juliana", "Juliane", "Julie", "Julienne", "Julika", "Julina", "Juna", "Justine", "Kaja", "Karina", "Karla", "Karlotta", "Karolina", "Karoline", "Kassandra", "Katarina", "Katharina", "Kathrin", "Katja", "Katrin", "Kaya", "Kayra", "Kiana", "Kiara", "Kim", "Kimberley", "Kimberly", "Kira", "Klara", "Korinna", "Kristin", "Kyra", "Laila", "Lana", "Lara", "Larissa", "Laura", "Laureen", "Lavinia", "Lea", "Leah", "Leana", "Leandra", "Leann", "Lee", "Leila", "Lena", "Lene", "Leni", "Lenia", "Lenja", "Lenya", "Leona", "Leoni", "Leonie", "Leonora", "Leticia", "Letizia", "Levke", "Leyla", "Lia", "Liah", "Liana", "Lili", "Lilia", "Lilian", "Liliana", "Lilith", "Lilli", "Lillian", "Lilly", "Lily", "Lina", "Linda", "Lindsay", "Line", "Linn", "Linnea", "Lisa", "Lisann", "Lisanne", "Liv", "Livia", "Liz", "Lola", "Loreen", "Lorena", "Lotta", "Lotte", "Louisa", "Louise", "Luana", "Luca", "Lucia", "Lucie", "Lucienne", "Lucy", "Luisa", "Luise", "Luka", "Luna", "Luzie", "Lya", "Lydia", "Lyn", "Lynn", "Madeleine", "Madita", "Madleen", "Madlen", "Magdalena", "Maike", "Mailin", "Maira", "Maja", "Malena", "Malia", "Malin", "Malina", "Mandy", "Mara", "Marah", "Mareike", "Maren", "Maria", "Mariam", "Marie", "Marieke", "Mariella", "Marika", "Marina", "Marisa", "Marissa", "Marit", "Marla", "Marleen", "Marlen", "Marlena", "Marlene", "Marta", "Martha", "Mary", "Maryam", "Mathilda", "Mathilde", "Matilda", "Maxi", "Maxima", "Maxine", "Maya", "Mayra", "Medina", "Medine", "Meike", "Melanie", "Melek", "Melike", "Melina", "Melinda", "Melis", "Melisa", "Melissa", "Merle", "Merve", "Meryem", "Mette", "Mia", "Michaela", "Michelle", "Mieke", "Mila", "Milana", "Milena", "Milla", "Mina", "Mira", "Miray", "Miriam", "Mirja", "Mona", "Monique", "Nadine", "Nadja", "Naemi", "Nancy", "Naomi", "Natalia", "Natalie", "Nathalie", "Neele", "Nela", "Nele", "Nelli", "Nelly", "Nia", "Nicole", "Nika", "Nike", "Nikita", "Nila", "Nina", "Nisa", "Noemi", "Nora", "Olivia", "Patricia", "Patrizia", "Paula", "Paulina", "Pauline", "Penelope", "Philine", "Phoebe", "Pia", "Rahel", "Rania", "Rebecca", "Rebekka", "Riana", "Rieke", "Rike", "Romina", "Romy", "Ronja", "Rosa", "Rosalie", "Ruby", "Sabrina", "Sahra", "Sally", "Salome", "Samantha", "Samia", "Samira", "Sandra", "Sandy", "Sanja", "Saphira", "Sara", "Sarah", "Saskia", "Selin", "Selina", "Selma", "Sena", "Sidney", "Sienna", "Silja", "Sina", "Sinja", "Smilla", "Sofia", "Sofie", "Sonja", "Sophia", "Sophie", "Soraya", "Stefanie", "Stella", "Stephanie", "Stina", "Sude", "Summer", "Susanne", "Svea", "Svenja", "Sydney", "Tabea", "Talea", "Talia", "Tamara", "Tamia", "Tamina", "Tanja", "Tara", "Tarja", "Teresa", "Tessa", "Thalea", "Thalia", "Thea", "Theresa", "Tia", "Tina", "Tomke", "Tuana", "Valentina", "Valeria", "Valerie", "Vanessa", "Vera", "Veronika", "Victoria", "Viktoria", "Viola", "Vivian", "Vivien", "Vivienne", "Wibke", "Wiebke", "Xenia", "Yara", "Yaren", "Yasmin", "Ylvi", "Ylvie", "Yvonne", "Zara", "Zehra", "Zeynep", "Zoe", "Zoey", "Zoé"]; + return url; + }, + mac: function mac() { + return this.times(this.random.hex, 6, 2).join(":"); + }, + ip: function ip() { + return this.times(this.random.number, 4, 1, 254).join("."); + }, + ipv6: function ipv6() { + return this.times(this.random.hex, 8, 4).join(":"); + }, + color: function color() { + var baseRed255 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + var baseGreen255 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var baseBlue255 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + + var red = Math.floor((this.random.number(256) + baseRed255) / 2); + var green = Math.floor((this.random.number(256) + baseGreen255) / 2); + var blue = Math.floor((this.random.number(256) + baseBlue255) / 2); + var redStr = red.toString(16); + var greenStr = green.toString(16); + var blueStr = blue.toString(16); + return (redStr.length === 1 ? "0" : "") + redStr + (greenStr.length === 1 ? "0" : "") + greenStr + (blueStr.length === 1 ? "0" : "") + blueStr; + }, + avatar: function avatar() { + return "https://s3.amazonaws.com/uifaces/faces/twitter/" + this.random.arrayElement(_uifaces2.default) + "/128.jpg"; + }, + gravatar: function gravatar(email) { + if (email == null) { + email = this.internet.email(); + } + + return "https://www.gravatar.com/avatar/" + _crypto2.default.createHash("md5").update(email).digest("hex"); + } + }; /***/ }, -/* 187 */ -/***/ function(module, exports) { +/* 176 */ +/***/ function(module, exports, __webpack_require__) { "use strict"; - module.exports = ["Abel", "Abicht", "Abraham", "Abramovic", "Abt", "Achilles", "Achkinadze", "Ackermann", "Adam", "Adams", "Ade", "Agostini", "Ahlke", "Ahrenberg", "Ahrens", "Aigner", "Albert", "Albrecht", "Alexa", "Alexander", "Alizadeh", "Allgeyer", "Amann", "Amberg", "Anding", "Anggreny", "Apitz", "Arendt", "Arens", "Arndt", "Aryee", "Aschenbroich", "Assmus", "Astafei", "Auer", "Axmann", "Baarck", "Bachmann", "Badane", "Bader", "Baganz", "Bahl", "Bak", "Balcer", "Balck", "Balkow", "Balnuweit", "Balzer", "Banse", "Barr", "Bartels", "Barth", "Barylla", "Baseda", "Battke", "Bauer", "Bauermeister", "Baumann", "Baumeister", "Bauschinger", "Bauschke", "Bayer", "Beavogui", "Beck", "Beckel", "Becker", "Beckmann", "Bedewitz", "Beele", "Beer", "Beggerow", "Beh", "Behr", "Behrenbruch", "Belz", "Bender", "Benecke", "Benner", "Benninger", "Benzing", "Berends", "Berger", "Berner", "Berning", "Bertenbreiter", "Best", "Bethke", "Betz", "Beushausen", "Beutelspacher", "Beyer", "Biba", "Bichler", "Bickel", "Biedermann", "Bieler", "Bielert", "Bienasch", "Bienias", "Biesenbach", "Bigdeli", "Birkemeyer", "Bittner", "Blank", "Blaschek", "Blassneck", "Bloch", "Blochwitz", "Blockhaus", "Blum", "Blume", "Bock", "Bode", "Bogdashin", "Bogenrieder", "Bohge", "Bolm", "Borgschulze", "Bork", "Bormann", "Bornscheuer", "Borrmann", "Borsch", "Boruschewski", "Bos", "Bosler", "Bourrouag", "Bouschen", "Boxhammer", "Boyde", "Bozsik", "Brand", "Brandenburg", "Brandis", "Brandt", "Brauer", "Braun", "Brehmer", "Breitenstein", "Bremer", "Bremser", "Brenner", "Brettschneider", "Breu", "Breuer", "Briesenick", "Bringmann", "Brinkmann", "Brix", "Broening", "Brosch", "Bruckmann", "Bruder", "Bruhns", "Brunner", "Bruns", "Bräutigam", "Brömme", "Brüggmann", "Buchholz", "Buchrucker", "Buder", "Bultmann", "Bunjes", "Burger", "Burghagen", "Burkhard", "Burkhardt", "Burmeister", "Busch", "Buschbaum", "Busemann", "Buss", "Busse", "Bussmann", "Byrd", "Bäcker", "Böhm", "Bönisch", "Börgeling", "Börner", "Böttner", "Büchele", "Bühler", "Büker", "Büngener", "Bürger", "Bürklein", "Büscher", "Büttner", "Camara", "Carlowitz", "Carlsohn", "Caspari", "Caspers", "Chapron", "Christ", "Cierpinski", "Clarius", "Cleem", "Cleve", "Co", "Conrad", "Cordes", "Cornelsen", "Cors", "Cotthardt", "Crews", "Cronjäger", "Crosskofp", "Da", "Dahm", "Dahmen", "Daimer", "Damaske", "Danneberg", "Danner", "Daub", "Daubner", "Daudrich", "Dauer", "Daum", "Dauth", "Dautzenberg", "De", "Decker", "Deckert", "Deerberg", "Dehmel", "Deja", "Delonge", "Demut", "Dengler", "Denner", "Denzinger", "Derr", "Dertmann", "Dethloff", "Deuschle", "Dieckmann", "Diedrich", "Diekmann", "Dienel", "Dies", "Dietrich", "Dietz", "Dietzsch", "Diezel", "Dilla", "Dingelstedt", "Dippl", "Dittmann", "Dittmar", "Dittmer", "Dix", "Dobbrunz", "Dobler", "Dohring", "Dolch", "Dold", "Dombrowski", "Donie", "Doskoczynski", "Dragu", "Drechsler", "Drees", "Dreher", "Dreier", "Dreissigacker", "Dressler", "Drews", "Duma", "Dutkiewicz", "Dyett", "Dylus", "Dächert", "Döbel", "Döring", "Dörner", "Dörre", "Dück", "Eberhard", "Eberhardt", "Ecker", "Eckhardt", "Edorh", "Effler", "Eggenmueller", "Ehm", "Ehmann", "Ehrig", "Eich", "Eichmann", "Eifert", "Einert", "Eisenlauer", "Ekpo", "Elbe", "Eleyth", "Elss", "Emert", "Emmelmann", "Ender", "Engel", "Engelen", "Engelmann", "Eplinius", "Erdmann", "Erhardt", "Erlei", "Erm", "Ernst", "Ertl", "Erwes", "Esenwein", "Esser", "Evers", "Everts", "Ewald", "Fahner", "Faller", "Falter", "Farber", "Fassbender", "Faulhaber", "Fehrig", "Feld", "Felke", "Feller", "Fenner", "Fenske", "Feuerbach", "Fietz", "Figl", "Figura", "Filipowski", "Filsinger", "Fincke", "Fink", "Finke", "Fischer", "Fitschen", "Fleischer", "Fleischmann", "Floder", "Florczak", "Flore", "Flottmann", "Forkel", "Forst", "Frahmeke", "Frank", "Franke", "Franta", "Frantz", "Franz", "Franzis", "Franzmann", "Frauen", "Frauendorf", "Freigang", "Freimann", "Freimuth", "Freisen", "Frenzel", "Frey", "Fricke", "Fried", "Friedek", "Friedenberg", "Friedmann", "Friedrich", "Friess", "Frisch", "Frohn", "Frosch", "Fuchs", "Fuhlbrügge", "Fusenig", "Fust", "Förster", "Gaba", "Gabius", "Gabler", "Gadschiew", "Gakstädter", "Galander", "Gamlin", "Gamper", "Gangnus", "Ganzmann", "Garatva", "Gast", "Gastel", "Gatzka", "Gauder", "Gebhardt", "Geese", "Gehre", "Gehrig", "Gehring", "Gehrke", "Geiger", "Geisler", "Geissler", "Gelling", "Gens", "Gerbennow", "Gerdel", "Gerhardt", "Gerschler", "Gerson", "Gesell", "Geyer", "Ghirmai", "Ghosh", "Giehl", "Gierisch", "Giesa", "Giesche", "Gilde", "Glatting", "Goebel", "Goedicke", "Goldbeck", "Goldfuss", "Goldkamp", "Goldkühle", "Goller", "Golling", "Gollnow", "Golomski", "Gombert", "Gotthardt", "Gottschalk", "Gotz", "Goy", "Gradzki", "Graf", "Grams", "Grasse", "Gratzky", "Grau", "Greb", "Green", "Greger", "Greithanner", "Greschner", "Griem", "Griese", "Grimm", "Gromisch", "Gross", "Grosser", "Grossheim", "Grosskopf", "Grothaus", "Grothkopp", "Grotke", "Grube", "Gruber", "Grundmann", "Gruning", "Gruszecki", "Gröss", "Grötzinger", "Grün", "Grüner", "Gummelt", "Gunkel", "Gunther", "Gutjahr", "Gutowicz", "Gutschank", "Göbel", "Göckeritz", "Göhler", "Görlich", "Görmer", "Götz", "Götzelmann", "Güldemeister", "Günther", "Günz", "Gürbig", "Haack", "Haaf", "Habel", "Hache", "Hackbusch", "Hackelbusch", "Hadfield", "Hadwich", "Haferkamp", "Hahn", "Hajek", "Hallmann", "Hamann", "Hanenberger", "Hannecker", "Hanniske", "Hansen", "Hardy", "Hargasser", "Harms", "Harnapp", "Harter", "Harting", "Hartlieb", "Hartmann", "Hartwig", "Hartz", "Haschke", "Hasler", "Hasse", "Hassfeld", "Haug", "Hauke", "Haupt", "Haverney", "Heberstreit", "Hechler", "Hecht", "Heck", "Hedermann", "Hehl", "Heidelmann", "Heidler", "Heinemann", "Heinig", "Heinke", "Heinrich", "Heinze", "Heiser", "Heist", "Hellmann", "Helm", "Helmke", "Helpling", "Hengmith", "Henkel", "Hennes", "Henry", "Hense", "Hensel", "Hentel", "Hentschel", "Hentschke", "Hepperle", "Herberger", "Herbrand", "Hering", "Hermann", "Hermecke", "Herms", "Herold", "Herrmann", "Herschmann", "Hertel", "Herweg", "Herwig", "Herzenberg", "Hess", "Hesse", "Hessek", "Hessler", "Hetzler", "Heuck", "Heydemüller", "Hiebl", "Hildebrand", "Hildenbrand", "Hilgendorf", "Hillard", "Hiller", "Hingsen", "Hingst", "Hinrichs", "Hirsch", "Hirschberg", "Hirt", "Hodea", "Hoffman", "Hoffmann", "Hofmann", "Hohenberger", "Hohl", "Hohn", "Hohnheiser", "Hold", "Holdt", "Holinski", "Holl", "Holtfreter", "Holz", "Holzdeppe", "Holzner", "Hommel", "Honz", "Hooss", "Hoppe", "Horak", "Horn", "Horna", "Hornung", "Hort", "Howard", "Huber", "Huckestein", "Hudak", "Huebel", "Hugo", "Huhn", "Hujo", "Huke", "Huls", "Humbert", "Huneke", "Huth", "Häber", "Häfner", "Höcke", "Höft", "Höhne", "Hönig", "Hördt", "Hübenbecker", "Hübl", "Hübner", "Hügel", "Hüttcher", "Hütter", "Ibe", "Ihly", "Illing", "Isak", "Isekenmeier", "Itt", "Jacob", "Jacobs", "Jagusch", "Jahn", "Jahnke", "Jakobs", "Jakubczyk", "Jambor", "Jamrozy", "Jander", "Janich", "Janke", "Jansen", "Jarets", "Jaros", "Jasinski", "Jasper", "Jegorov", "Jellinghaus", "Jeorga", "Jerschabek", "Jess", "John", "Jonas", "Jossa", "Jucken", "Jung", "Jungbluth", "Jungton", "Just", "Jürgens", "Kaczmarek", "Kaesmacher", "Kahl", "Kahlert", "Kahles", "Kahlmeyer", "Kaiser", "Kalinowski", "Kallabis", "Kallensee", "Kampf", "Kampschulte", "Kappe", "Kappler", "Karhoff", "Karrass", "Karst", "Karsten", "Karus", "Kass", "Kasten", "Kastner", "Katzinski", "Kaufmann", "Kaul", "Kausemann", "Kawohl", "Kazmarek", "Kedzierski", "Keil", "Keiner", "Keller", "Kelm", "Kempe", "Kemper", "Kempter", "Kerl", "Kern", "Kesselring", "Kesselschläger", "Kette", "Kettenis", "Keutel", "Kick", "Kiessling", "Kinadeter", "Kinzel", "Kinzy", "Kirch", "Kirst", "Kisabaka", "Klaas", "Klabuhn", "Klapper", "Klauder", "Klaus", "Kleeberg", "Kleiber", "Klein", "Kleinert", "Kleininger", "Kleinmann", "Kleinsteuber", "Kleiss", "Klemme", "Klimczak", "Klinger", "Klink", "Klopsch", "Klose", "Kloss", "Kluge", "Kluwe", "Knabe", "Kneifel", "Knetsch", "Knies", "Knippel", "Knobel", "Knoblich", "Knoll", "Knorr", "Knorscheidt", "Knut", "Kobs", "Koch", "Kochan", "Kock", "Koczulla", "Koderisch", "Koehl", "Koehler", "Koenig", "Koester", "Kofferschlager", "Koha", "Kohle", "Kohlmann", "Kohnle", "Kohrt", "Koj", "Kolb", "Koleiski", "Kolokas", "Komoll", "Konieczny", "Konig", "Konow", "Konya", "Koob", "Kopf", "Kosenkow", "Koster", "Koszewski", "Koubaa", "Kovacs", "Kowalick", "Kowalinski", "Kozakiewicz", "Krabbe", "Kraft", "Kral", "Kramer", "Krauel", "Kraus", "Krause", "Krauspe", "Kreb", "Krebs", "Kreissig", "Kresse", "Kreutz", "Krieger", "Krippner", "Krodinger", "Krohn", "Krol", "Kron", "Krueger", "Krug", "Kruger", "Krull", "Kruschinski", "Krämer", "Kröckert", "Kröger", "Krüger", "Kubera", "Kufahl", "Kuhlee", "Kuhnen", "Kulimann", "Kulma", "Kumbernuss", "Kummle", "Kunz", "Kupfer", "Kupprion", "Kuprion", "Kurnicki", "Kurrat", "Kurschilgen", "Kuschewitz", "Kuschmann", "Kuske", "Kustermann", "Kutscherauer", "Kutzner", "Kwadwo", "Kähler", "Käther", "Köhler", "Köhrbrück", "Köhre", "Kölotzei", "König", "Köpernick", "Köseoglu", "Kúhn", "Kúhnert", "Kühn", "Kühnel", "Kühnemund", "Kühnert", "Kühnke", "Küsters", "Küter", "Laack", "Lack", "Ladewig", "Lakomy", "Lammert", "Lamos", "Landmann", "Lang", "Lange", "Langfeld", "Langhirt", "Lanig", "Lauckner", "Lauinger", "Laurén", "Lausecker", "Laux", "Laws", "Lax", "Leberer", "Lehmann", "Lehner", "Leibold", "Leide", "Leimbach", "Leipold", "Leist", "Leiter", "Leiteritz", "Leitheim", "Leiwesmeier", "Lenfers", "Lenk", "Lenz", "Lenzen", "Leo", "Lepthin", "Lesch", "Leschnik", "Letzelter", "Lewin", "Lewke", "Leyckes", "Lg", "Lichtenfeld", "Lichtenhagen", "Lichtl", "Liebach", "Liebe", "Liebich", "Liebold", "Lieder", "Lienshöft", "Linden", "Lindenberg", "Lindenmayer", "Lindner", "Linke", "Linnenbaum", "Lippe", "Lipske", "Lipus", "Lischka", "Lobinger", "Logsch", "Lohmann", "Lohre", "Lohse", "Lokar", "Loogen", "Lorenz", "Losch", "Loska", "Lott", "Loy", "Lubina", "Ludolf", "Lufft", "Lukoschek", "Lutje", "Lutz", "Löser", "Löwa", "Lübke", "Maak", "Maczey", "Madetzky", "Madubuko", "Mai", "Maier", "Maisch", "Malek", "Malkus", "Mallmann", "Malucha", "Manns", "Manz", "Marahrens", "Marchewski", "Margis", "Markowski", "Marl", "Marner", "Marquart", "Marschek", "Martel", "Marten", "Martin", "Marx", "Marxen", "Mathes", "Mathies", "Mathiszik", "Matschke", "Mattern", "Matthes", "Matula", "Mau", "Maurer", "Mauroff", "May", "Maybach", "Mayer", "Mebold", "Mehl", "Mehlhorn", "Mehlorn", "Meier", "Meisch", "Meissner", "Meloni", "Melzer", "Menga", "Menne", "Mensah", "Mensing", "Merkel", "Merseburg", "Mertens", "Mesloh", "Metzger", "Metzner", "Mewes", "Meyer", "Michallek", "Michel", "Mielke", "Mikitenko", "Milde", "Minah", "Mintzlaff", "Mockenhaupt", "Moede", "Moedl", "Moeller", "Moguenara", "Mohr", "Mohrhard", "Molitor", "Moll", "Moller", "Molzan", "Montag", "Moormann", "Mordhorst", "Morgenstern", "Morhelfer", "Moritz", "Moser", "Motchebon", "Motzenbbäcker", "Mrugalla", "Muckenthaler", "Mues", "Muller", "Mulrain", "Mächtig", "Mäder", "Möcks", "Mögenburg", "Möhsner", "Möldner", "Möllenbeck", "Möller", "Möllinger", "Mörsch", "Mühleis", "Müller", "Münch", "Nabein", "Nabow", "Nagel", "Nannen", "Nastvogel", "Nau", "Naubert", "Naumann", "Ne", "Neimke", "Nerius", "Neubauer", "Neubert", "Neuendorf", "Neumair", "Neumann", "Neupert", "Neurohr", "Neuschwander", "Newton", "Ney", "Nicolay", "Niedermeier", "Nieklauson", "Niklaus", "Nitzsche", "Noack", "Nodler", "Nolte", "Normann", "Norris", "Northoff", "Nowak", "Nussbeck", "Nwachukwu", "Nytra", "Nöh", "Oberem", "Obergföll", "Obermaier", "Ochs", "Oeser", "Olbrich", "Onnen", "Ophey", "Oppong", "Orth", "Orthmann", "Oschkenat", "Osei", "Osenberg", "Ostendarp", "Ostwald", "Otte", "Otto", "Paesler", "Pajonk", "Pallentin", "Panzig", "Paschke", "Patzwahl", "Paukner", "Peselman", "Peter", "Peters", "Petzold", "Pfeiffer", "Pfennig", "Pfersich", "Pfingsten", "Pflieger", "Pflügner", "Philipp", "Pichlmaier", "Piesker", "Pietsch", "Pingpank", "Pinnock", "Pippig", "Pitschugin", "Plank", "Plass", "Platzer", "Plauk", "Plautz", "Pletsch", "Plotzitzka", "Poehn", "Poeschl", "Pogorzelski", "Pohl", "Pohland", "Pohle", "Polifka", "Polizzi", "Pollmächer", "Pomp", "Ponitzsch", "Porsche", "Porth", "Poschmann", "Poser", "Pottel", "Prah", "Prange", "Prediger", "Pressler", "Preuk", "Preuss", "Prey", "Priemer", "Proske", "Pusch", "Pöche", "Pöge", "Raabe", "Rabenstein", "Rach", "Radtke", "Rahn", "Ranftl", "Rangen", "Ranz", "Rapp", "Rath", "Rau", "Raubuch", "Raukuc", "Rautenkranz", "Rehwagen", "Reiber", "Reichardt", "Reichel", "Reichling", "Reif", "Reifenrath", "Reimann", "Reinberg", "Reinelt", "Reinhardt", "Reinke", "Reitze", "Renk", "Rentz", "Renz", "Reppin", "Restle", "Restorff", "Retzke", "Reuber", "Reumann", "Reus", "Reuss", "Reusse", "Rheder", "Rhoden", "Richards", "Richter", "Riedel", "Riediger", "Rieger", "Riekmann", "Riepl", "Riermeier", "Riester", "Riethmüller", "Rietmüller", "Rietscher", "Ringel", "Ringer", "Rink", "Ripken", "Ritosek", "Ritschel", "Ritter", "Rittweg", "Ritz", "Roba", "Rockmeier", "Rodehau", "Rodowski", "Roecker", "Roggatz", "Rohländer", "Rohrer", "Rokossa", "Roleder", "Roloff", "Roos", "Rosbach", "Roschinsky", "Rose", "Rosenauer", "Rosenbauer", "Rosenthal", "Rosksch", "Rossberg", "Rossler", "Roth", "Rother", "Ruch", "Ruckdeschel", "Rumpf", "Rupprecht", "Ruth", "Ryjikh", "Ryzih", "Rädler", "Räntsch", "Rödiger", "Röse", "Röttger", "Rücker", "Rüdiger", "Rüter", "Sachse", "Sack", "Saflanis", "Sagafe", "Sagonas", "Sahner", "Saile", "Sailer", "Salow", "Salzer", "Salzmann", "Sammert", "Sander", "Sarvari", "Sattelmaier", "Sauer", "Sauerland", "Saumweber", "Savoia", "Scc", "Schacht", "Schaefer", "Schaffarzik", "Schahbasian", "Scharf", "Schedler", "Scheer", "Schelk", "Schellenbeck", "Schembera", "Schenk", "Scherbarth", "Scherer", "Schersing", "Scherz", "Scheurer", "Scheuring", "Scheytt", "Schielke", "Schieskow", "Schildhauer", "Schilling", "Schima", "Schimmer", "Schindzielorz", "Schirmer", "Schirrmeister", "Schlachter", "Schlangen", "Schlawitz", "Schlechtweg", "Schley", "Schlicht", "Schlitzer", "Schmalzle", "Schmid", "Schmidt", "Schmidtchen", "Schmitt", "Schmitz", "Schmuhl", "Schneider", "Schnelting", "Schnieder", "Schniedermeier", "Schnürer", "Schoberg", "Scholz", "Schonberg", "Schondelmaier", "Schorr", "Schott", "Schottmann", "Schouren", "Schrader", "Schramm", "Schreck", "Schreiber", "Schreiner", "Schreiter", "Schroder", "Schröder", "Schuermann", "Schuff", "Schuhaj", "Schuldt", "Schult", "Schulte", "Schultz", "Schultze", "Schulz", "Schulze", "Schumacher", "Schumann", "Schupp", "Schuri", "Schuster", "Schwab", "Schwalm", "Schwanbeck", "Schwandke", "Schwanitz", "Schwarthoff", "Schwartz", "Schwarz", "Schwarzer", "Schwarzkopf", "Schwarzmeier", "Schwatlo", "Schweisfurth", "Schwennen", "Schwerdtner", "Schwidde", "Schwirkschlies", "Schwuchow", "Schäfer", "Schäffel", "Schäffer", "Schäning", "Schöckel", "Schönball", "Schönbeck", "Schönberg", "Schönebeck", "Schönenberger", "Schönfeld", "Schönherr", "Schönlebe", "Schötz", "Schüler", "Schüppel", "Schütz", "Schütze", "Seeger", "Seelig", "Sehls", "Seibold", "Seidel", "Seiders", "Seigel", "Seiler", "Seitz", "Semisch", "Senkel", "Sewald", "Siebel", "Siebert", "Siegling", "Sielemann", "Siemon", "Siener", "Sievers", "Siewert", "Sihler", "Sillah", "Simon", "Sinnhuber", "Sischka", "Skibicki", "Sladek", "Slotta", "Smieja", "Soboll", "Sokolowski", "Soller", "Sollner", "Sommer", "Somssich", "Sonn", "Sonnabend", "Spahn", "Spank", "Spelmeyer", "Spiegelburg", "Spielvogel", "Spinner", "Spitzmüller", "Splinter", "Sporrer", "Sprenger", "Spöttel", "Stahl", "Stang", "Stanger", "Stauss", "Steding", "Steffen", "Steffny", "Steidl", "Steigauf", "Stein", "Steinecke", "Steinert", "Steinkamp", "Steinmetz", "Stelkens", "Stengel", "Stengl", "Stenzel", "Stepanov", "Stephan", "Stern", "Steuk", "Stief", "Stifel", "Stoll", "Stolle", "Stolz", "Storl", "Storp", "Stoutjesdijk", "Stratmann", "Straub", "Strausa", "Streck", "Streese", "Strege", "Streit", "Streller", "Strieder", "Striezel", "Strogies", "Strohschank", "Strunz", "Strutz", "Stube", "Stöckert", "Stöppler", "Stöwer", "Stürmer", "Suffa", "Sujew", "Sussmann", "Suthe", "Sutschet", "Swillims", "Szendrei", "Sören", "Sürth", "Tafelmeier", "Tang", "Tasche", "Taufratshofer", "Tegethof", "Teichmann", "Tepper", "Terheiden", "Terlecki", "Teufel", "Theele", "Thieke", "Thimm", "Thiomas", "Thomas", "Thriene", "Thränhardt", "Thust", "Thyssen", "Thöne", "Tidow", "Tiedtke", "Tietze", "Tilgner", "Tillack", "Timmermann", "Tischler", "Tischmann", "Tittman", "Tivontschik", "Tonat", "Tonn", "Trampeli", "Trauth", "Trautmann", "Travan", "Treff", "Tremmel", "Tress", "Tsamonikian", "Tschiers", "Tschirch", "Tuch", "Tucholke", "Tudow", "Tuschmo", "Tächl", "Többen", "Töpfer", "Uhlemann", "Uhlig", "Uhrig", "Uibel", "Uliczka", "Ullmann", "Ullrich", "Umbach", "Umlauft", "Umminger", "Unger", "Unterpaintner", "Urban", "Urbaniak", "Urbansky", "Urhig", "Vahlensieck", "Van", "Vangermain", "Vater", "Venghaus", "Verniest", "Verzi", "Vey", "Viellehner", "Vieweg", "Voelkel", "Vogel", "Vogelgsang", "Vogt", "Voigt", "Vokuhl", "Volk", "Volker", "Volkmann", "Von", "Vona", "Vontein", "Wachenbrunner", "Wachtel", "Wagner", "Waibel", "Wakan", "Waldmann", "Wallner", "Wallstab", "Walter", "Walther", "Walton", "Walz", "Wanner", "Wartenberg", "Waschbüsch", "Wassilew", "Wassiluk", "Weber", "Wehrsen", "Weidlich", "Weidner", "Weigel", "Weight", "Weiler", "Weimer", "Weis", "Weiss", "Weller", "Welsch", "Welz", "Welzel", "Weniger", "Wenk", "Werle", "Werner", "Werrmann", "Wessel", "Wessinghage", "Weyel", "Wezel", "Wichmann", "Wickert", "Wiebe", "Wiechmann", "Wiegelmann", "Wierig", "Wiese", "Wieser", "Wilhelm", "Wilky", "Will", "Willwacher", "Wilts", "Wimmer", "Winkelmann", "Winkler", "Winter", "Wischek", "Wischer", "Wissing", "Wittich", "Wittl", "Wolf", "Wolfarth", "Wolff", "Wollenberg", "Wollmann", "Woytkowska", "Wujak", "Wurm", "Wyludda", "Wölpert", "Wöschler", "Wühn", "Wünsche", "Zach", "Zaczkiewicz", "Zahn", "Zaituc", "Zandt", "Zanner", "Zapletal", "Zauber", "Zeidler", "Zekl", "Zender", "Zeuch", "Zeyen", "Zeyhle", "Ziegler", "Zimanyi", "Zimmer", "Zimmermann", "Zinser", "Zintl", "Zipp", "Zipse", "Zschunke", "Zuber", "Zwiener", "Zümsande", "Östringer", "Überacker"]; + (function (root) { -/***/ }, -/* 188 */ -/***/ function(module, exports) { + var localName, consonant, letter, _password, vowel; + letter = /[a-zA-Z]$/; + vowel = /[aeiouAEIOU]$/; + consonant = /[bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ]$/; - "use strict"; + localName = "generatePassword", _password = function password(length, memorable, pattern, prefix) { + var char, n; + if (length == null) { + length = 10; + } + if (memorable == null) { + memorable = true; + } + if (pattern == null) { + pattern = /\w/; + } + if (prefix == null) { + prefix = ''; + } + if (prefix.length >= length) { + return prefix; + } + if (memorable) { + if (prefix.match(consonant)) { + pattern = vowel; + } else { + pattern = consonant; + } + } + n = Math.floor(Math.random() * 94) + 33; + char = String.fromCharCode(n); + if (memorable) { + char = char.toLowerCase(); + } + if (!char.match(pattern)) { + return _password(length, memorable, pattern, prefix); + } + return _password(length, memorable, pattern, "" + prefix + char); + }; - module.exports = ["zu", "von", "vom", "von der"]; + ( true ? exports : root)[localName] = _password; + if (true) { + if (typeof module !== 'undefined' && module.exports) { + module.exports = _password; + } + } + })(undefined); /***/ }, -/* 189 */ -/***/ function(module, exports) { +/* 177 */ +/***/ function(module, exports, __webpack_require__) { - "use strict"; + /* WEBPACK VAR INJECTION */(function(Buffer) {var rng = __webpack_require__(182) - module.exports = { - number: ["(0###) #########", "(0####) #######", "+49-###-#######", "+49-####-########"] - }; + function error () { + var m = [].slice.call(arguments).join(' ') + throw new Error([ + m, + 'we accept pull requests', + 'http://github.com/dominictarr/crypto-browserify' + ].join('\n')) + } -/***/ }, -/* 190 */ -/***/ function(module, exports) { + exports.createHash = __webpack_require__(184) - "use strict"; + exports.createHmac = __webpack_require__(200) - module.exports = { - tld: ["com", "info", "name", "net", "org", "de", "ch"], + exports.randomBytes = function(size, callback) { + if (callback && callback.call) { + try { + callback.call(this, undefined, new Buffer(rng(size))) + } catch (err) { callback(err) } + } else { + return new Buffer(rng(size)) + } + } - emailDomain: ["gmail.com", "yahoo.com", "hotmail.com"] + function each(a, f) { + for(var i in a) + f(a[i], i) + } - }; + exports.getHashes = function () { + return ['sha1', 'sha256', 'sha512', 'md5', 'rmd160'] + } + + var p = __webpack_require__(201)(exports) + exports.pbkdf2 = p.pbkdf2 + exports.pbkdf2Sync = p.pbkdf2Sync + __webpack_require__(203)(exports, module.exports); + + // the least I can do is make error messages for the rest of the node.js/crypto api. + each(['createCredentials' + , 'createSign' + , 'createVerify' + , 'createDiffieHellman' + ], function (name) { + exports[name] = function () { + error('sorry,', name, 'is not implemented yet') + } + }) + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) /***/ }, -/* 191 */ +/* 178 */ /***/ function(module, exports, __webpack_require__) { - "use strict"; - - var _countryWithCodes = __webpack_require__(192); + /* WEBPACK VAR INJECTION */(function(global) {/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + /* eslint-disable no-proto */ - var _countryWithCodes2 = _interopRequireDefault(_countryWithCodes); + 'use strict' - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + var base64 = __webpack_require__(179) + var ieee754 = __webpack_require__(180) + var isArray = __webpack_require__(181) - module.exports = { - countryAndCode: function countryAndCode() { - var country = this.random.objectElement(_countryWithCodes2.default); - return { - code: Object.keys(country)[0], - name: country[Object.keys(country)[0]] - }; - }, - country: function country() { - return this.address.countryAndCode().name; - }, - countryCode: function countryCode() { - return this.address.countryAndCode().code; - }, + exports.Buffer = Buffer + exports.SlowBuffer = SlowBuffer + exports.INSPECT_MAX_BYTES = 50 + /** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use Object implementation (most compatible, even IE6) + * + * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, + * Opera 11.6+, iOS 4.2+. + * + * Due to various browser bugs, sometimes the Object implementation will be used even + * when the browser supports typed arrays. + * + * Note: + * + * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. - state: __webpack_require__(193), + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they + * get the Object implementation, which is slower but behaves correctly. + */ + Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined + ? global.TYPED_ARRAY_SUPPORT + : typedArraySupport() - stateAbbr: __webpack_require__(194), + /* + * Export kMaxLength after typed array support is determined. + */ + exports.kMaxLength = kMaxLength() - city: ["#{address.cityPrefix} #{names.firstName}#{address.citySuffix}", "#{address.cityPrefix} #{names.firstName}", "#{names.firstName}#{address.citySuffix}", "#{names.lastName}#{address.citySuffix}"], + function typedArraySupport () { + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 && // typed array instances can be augmented + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } + } - cityPrefix: ["North", "East", "West", "South", "New", "Lake", "Port"], + function kMaxLength () { + return Buffer.TYPED_ARRAY_SUPPORT + ? 0x7fffffff + : 0x3fffffff + } - citySuffix: ["town", "ton", "land", "ville", "berg", "burgh", "borough", "bury", "view", "port", "mouth", "stad", "furt", "chester", "mouth", "fort", "haven", "side", "shire"], + function createBuffer (that, length) { + if (kMaxLength() < length) { + throw new RangeError('Invalid typed array length') + } + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = new Uint8Array(length) + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + if (that === null) { + that = new Buffer(length) + } + that.length = length + } - street: ["#{address.buildingNumber} #{address.streetName}", "#{address.buildingNumber} #{address.streetName}", "#{address.buildingNumber} #{address.streetName} Apt. ###", "#{address.buildingNumber} #{address.streetName} Suite ###"], + return that + } - streetName: ["#{names.firstName} #{address.streetSuffix}", "#{names.lastName} #{address.streetSuffix}"], + /** + * The Buffer constructor returns instances of `Uint8Array` that have their + * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of + * `Uint8Array`, so the returned instances will have all the node `Buffer` methods + * and the `Uint8Array` methods. Square bracket notation works as expected -- it + * returns a single octet. + * + * The `Uint8Array` prototype remains unmodified. + */ - streetSuffix: __webpack_require__(195), + function Buffer (arg, encodingOrOffset, length) { + if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { + return new Buffer(arg, encodingOrOffset, length) + } - buildingNumber: ["#####", "####", "###"], + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new Error( + 'If encoding is specified then the first argument must be a string' + ) + } + return allocUnsafe(this, arg) + } + return from(this, arg, encodingOrOffset, length) + } - postCode: ["#####", "#####-####"], + Buffer.poolSize = 8192 // not used by this implementation - geoLocation: function geoLocation() { - return { - latitude: this.random.number(180 * 10000) / 10000.0 - 90.0, - longitude: this.random.number(360 * 10000) / 10000.0 - 180.0 - }; - }, - altitude: function altitude() { - var opts = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; + // TODO: Legacy, not needed anymore. Remove in next major version. + Buffer._augment = function (arr) { + arr.__proto__ = Buffer.prototype + return arr + } - return this.random.number(opts.min || 0, opts.max || 8848); - }, + function from (that, value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('"value" argument must not be a number') + } + if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { + return fromArrayBuffer(that, value, encodingOrOffset, length) + } - geoLocationNearBy: __webpack_require__(196) - }; + if (typeof value === 'string') { + return fromString(that, value, encodingOrOffset) + } -/***/ }, -/* 192 */ -/***/ function(module, exports) { + return fromObject(that, value) + } - "use strict"; + /** + * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError + * if value is a number. + * Buffer.from(str[, encoding]) + * Buffer.from(array) + * Buffer.from(buffer) + * Buffer.from(arrayBuffer[, byteOffset[, length]]) + **/ + Buffer.from = function (value, encodingOrOffset, length) { + return from(null, value, encodingOrOffset, length) + } - module.exports = { - "AF": "Afghanistan", - "AX": "Åland Islands", - "AL": "Albania", - "DZ": "Algeria", - "AS": "American Samoa", - "AD": "Andorra", - "AO": "Angola", - "AI": "Anguilla", - "AQ": "Antarctica", - "AG": "Antigua & Barbuda", - "AR": "Argentina", - "AM": "Armenia", - "AW": "Aruba", - "AC": "Ascension Island", - "AU": "Australia", - "AT": "Austria", - "AZ": "Azerbaijan", - "BS": "Bahamas", - "BH": "Bahrain", - "BD": "Bangladesh", - "BB": "Barbados", - "BY": "Belarus", - "BE": "Belgium", - "BZ": "Belize", - "BJ": "Benin", - "BM": "Bermuda", - "BT": "Bhutan", - "BO": "Bolivia", - "BA": "Bosnia & Herzegovina", - "BW": "Botswana", - "BR": "Brazil", - "IO": "British Indian Ocean Territory", - "VG": "British Virgin Islands", - "BN": "Brunei", - "BG": "Bulgaria", - "BF": "Burkina Faso", - "BI": "Burundi", - "KH": "Cambodia", - "CM": "Cameroon", - "CA": "Canada", - "IC": "Canary Islands", - "CV": "Cape Verde", - "BQ": "Caribbean Netherlands", - "KY": "Cayman Islands", - "CF": "Central African Republic", - "EA": "Ceuta & Melilla", - "TD": "Chad", - "CL": "Chile", - "CN": "China", - "CX": "Christmas Island", - "CC": "Cocos (Keeling) Islands", - "CO": "Colombia", - "KM": "Comoros", - "CG": "Congo - Brazzaville", - "CD": "Congo - Kinshasa", - "CK": "Cook Islands", - "CR": "Costa Rica", - "CI": "Côte d’Ivoire", - "HR": "Croatia", - "CU": "Cuba", - "CW": "Curaçao", - "CY": "Cyprus", - "CZ": "Czech Republic", - "DK": "Denmark", - "DG": "Diego Garcia", - "DJ": "Djibouti", - "DM": "Dominica", - "DO": "Dominican Republic", - "EC": "Ecuador", - "EG": "Egypt", - "SV": "El Salvador", - "GQ": "Equatorial Guinea", - "ER": "Eritrea", - "EE": "Estonia", - "ET": "Ethiopia", - "FK": "Falkland Islands", - "FO": "Faroe Islands", - "FJ": "Fiji", - "FI": "Finland", - "FR": "France", - "GF": "French Guiana", - "PF": "French Polynesia", - "TF": "French Southern Territories", - "GA": "Gabon", - "GM": "Gambia", - "GE": "Georgia", - "DE": "Germany", - "GH": "Ghana", - "GI": "Gibraltar", - "GR": "Greece", - "GL": "Greenland", - "GD": "Grenada", - "GP": "Guadeloupe", - "GU": "Guam", - "GT": "Guatemala", - "GG": "Guernsey", - "GN": "Guinea", - "GW": "Guinea-Bissau", - "GY": "Guyana", - "HT": "Haiti", - "HN": "Honduras", - "HK": "Hong Kong SAR China", - "HU": "Hungary", - "IS": "Iceland", - "IN": "India", - "ID": "Indonesia", - "IR": "Iran", - "IQ": "Iraq", - "IE": "Ireland", - "IM": "Isle of Man", - "IL": "Israel", - "IT": "Italy", - "JM": "Jamaica", - "JP": "Japan", - "JE": "Jersey", - "JO": "Jordan", - "KZ": "Kazakhstan", - "KE": "Kenya", - "KI": "Kiribati", - "XK": "Kosovo", - "KW": "Kuwait", - "KG": "Kyrgyzstan", - "LA": "Laos", - "LV": "Latvia", - "LB": "Lebanon", - "LS": "Lesotho", - "LR": "Liberia", - "LY": "Libya", - "LI": "Liechtenstein", - "LT": "Lithuania", - "LU": "Luxembourg", - "MO": "Macau SAR China", - "MK": "Macedonia", - "MG": "Madagascar", - "MW": "Malawi", - "MY": "Malaysia", - "MV": "Maldives", - "ML": "Mali", - "MT": "Malta", - "MH": "Marshall Islands", - "MQ": "Martinique", - "MR": "Mauritania", - "MU": "Mauritius", - "YT": "Mayotte", - "MX": "Mexico", - "FM": "Micronesia", - "MD": "Moldova", - "MC": "Monaco", - "MN": "Mongolia", - "ME": "Montenegro", - "MS": "Montserrat", - "MA": "Morocco", - "MZ": "Mozambique", - "MM": "Myanmar (Burma)", - "NA": "Namibia", - "NR": "Nauru", - "NP": "Nepal", - "NL": "Netherlands", - "NC": "New Caledonia", - "NZ": "New Zealand", - "NI": "Nicaragua", - "NE": "Niger", - "NG": "Nigeria", - "NU": "Niue", - "NF": "Norfolk Island", - "KP": "North Korea", - "MP": "Northern Mariana Islands", - "NO": "Norway", - "OM": "Oman", - "PK": "Pakistan", - "PW": "Palau", - "PS": "Palestinian Territories", - "PA": "Panama", - "PG": "Papua New Guinea", - "PY": "Paraguay", - "PE": "Peru", - "PH": "Philippines", - "PN": "Pitcairn Islands", - "PL": "Poland", - "PT": "Portugal", - "PR": "Puerto Rico", - "QA": "Qatar", - "RE": "Réunion", - "RO": "Romania", - "RU": "Russia", - "RW": "Rwanda", - "WS": "Samoa", - "SM": "San Marino", - "ST": "São Tomé & Príncipe", - "SA": "Saudi Arabia", - "SN": "Senegal", - "RS": "Serbia", - "SC": "Seychelles", - "SL": "Sierra Leone", - "SG": "Singapore", - "SX": "Sint Maarten", - "SK": "Slovakia", - "SI": "Slovenia", - "SB": "Solomon Islands", - "SO": "Somalia", - "ZA": "South Africa", - "GS": "South Georgia & South Sandwich Islands", - "KR": "South Korea", - "SS": "South Sudan", - "ES": "Spain", - "LK": "Sri Lanka", - "BL": "St. Barthélemy", - "SH": "St. Helena", - "KN": "St. Kitts & Nevis", - "LC": "St. Lucia", - "MF": "St. Martin", - "PM": "St. Pierre & Miquelon", - "VC": "St. Vincent & Grenadines", - "SD": "Sudan", - "SR": "Suriname", - "SJ": "Svalbard & Jan Mayen", - "SZ": "Swaziland", - "SE": "Sweden", - "CH": "Switzerland", - "SY": "Syria", - "TW": "Taiwan", - "TJ": "Tajikistan", - "TZ": "Tanzania", - "TH": "Thailand", - "TL": "Timor-Leste", - "TG": "Togo", - "TK": "Tokelau", - "TO": "Tonga", - "TT": "Trinidad & Tobago", - "TA": "Tristan da Cunha", - "TN": "Tunisia", - "TR": "Turkey", - "TM": "Turkmenistan", - "TC": "Turks & Caicos Islands", - "TV": "Tuvalu", - "UM": "U.S. Outlying Islands", - "VI": "U.S. Virgin Islands", - "UG": "Uganda", - "UA": "Ukraine", - "AE": "United Arab Emirates", - "GB": "United Kingdom", - "US": "United States", - "UY": "Uruguay", - "UZ": "Uzbekistan", - "VU": "Vanuatu", - "VA": "Vatican City", - "VE": "Venezuela", - "VN": "Vietnam", - "WF": "Wallis & Futuna", - "EH": "Western Sahara", - "YE": "Yemen", - "ZM": "Zambia", - "ZW": "Zimbabwe" + if (Buffer.TYPED_ARRAY_SUPPORT) { + Buffer.prototype.__proto__ = Uint8Array.prototype + Buffer.__proto__ = Uint8Array + if (typeof Symbol !== 'undefined' && Symbol.species && + Buffer[Symbol.species] === Buffer) { + // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true + }) + } + } + + function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be a number') + } else if (size < 0) { + throw new RangeError('"size" argument must not be negative') + } + } + + function alloc (that, size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(that, size) + } + if (fill !== undefined) { + // Only pay attention to encoding if it's a string. This + // prevents accidentally sending in a number that would + // be interpretted as a start offset. + return typeof encoding === 'string' + ? createBuffer(that, size).fill(fill, encoding) + : createBuffer(that, size).fill(fill) + } + return createBuffer(that, size) + } + + /** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ + Buffer.alloc = function (size, fill, encoding) { + return alloc(null, size, fill, encoding) + } + + function allocUnsafe (that, size) { + assertSize(size) + that = createBuffer(that, size < 0 ? 0 : checked(size) | 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < size; ++i) { + that[i] = 0 + } + } + return that + } + + /** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ + Buffer.allocUnsafe = function (size) { + return allocUnsafe(null, size) + } + /** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ + Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(null, size) + } + + function fromString (that, string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('"encoding" must be a valid string encoding') + } + + var length = byteLength(string, encoding) | 0 + that = createBuffer(that, length) + + var actual = that.write(string, encoding) + + if (actual !== length) { + // Writing a hex string, for example, that contains invalid characters will + // cause everything after the first invalid character to be ignored. (e.g. + // 'abxxcd' will be treated as 'ab') + that = that.slice(0, actual) + } + + return that + } + + function fromArrayLike (that, array) { + var length = array.length < 0 ? 0 : checked(array.length) | 0 + that = createBuffer(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that + } + + function fromArrayBuffer (that, array, byteOffset, length) { + array.byteLength // this throws if `array` is not a valid ArrayBuffer + + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('\'offset\' is out of bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('\'length\' is out of bounds') + } + + if (byteOffset === undefined && length === undefined) { + array = new Uint8Array(array) + } else if (length === undefined) { + array = new Uint8Array(array, byteOffset) + } else { + array = new Uint8Array(array, byteOffset, length) + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = array + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + that = fromArrayLike(that, array) + } + return that + } + + function fromObject (that, obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0 + that = createBuffer(that, len) + + if (that.length === 0) { + return that + } + + obj.copy(that, 0, 0, len) + return that + } + + if (obj) { + if ((typeof ArrayBuffer !== 'undefined' && + obj.buffer instanceof ArrayBuffer) || 'length' in obj) { + if (typeof obj.length !== 'number' || isnan(obj.length)) { + return createBuffer(that, 0) + } + return fromArrayLike(that, obj) + } + + if (obj.type === 'Buffer' && isArray(obj.data)) { + return fromArrayLike(that, obj.data) + } + } + + throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') + } + + function checked (length) { + // Note: cannot use `length < kMaxLength()` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength()) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength().toString(16) + ' bytes') + } + return length | 0 + } + + function SlowBuffer (length) { + if (+length != length) { // eslint-disable-line eqeqeq + length = 0 + } + return Buffer.alloc(+length) + } + + Buffer.isBuffer = function isBuffer (b) { + return !!(b != null && b._isBuffer) + } + + Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + if (a === b) return 0 + + var x = a.length + var y = b.length + + for (var i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i] + y = b[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 + } + + Buffer.isEncoding = function isEncoding (encoding) { + switch (String(encoding).toLowerCase()) { + case 'hex': + case 'utf8': + case 'utf-8': + case 'ascii': + case 'latin1': + case 'binary': + case 'base64': + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return true + default: + return false + } + } + + Buffer.concat = function concat (list, length) { + if (!isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + + if (list.length === 0) { + return Buffer.alloc(0) + } + + var i + if (length === undefined) { + length = 0 + for (i = 0; i < list.length; ++i) { + length += list[i].length + } + } + + var buffer = Buffer.allocUnsafe(length) + var pos = 0 + for (i = 0; i < list.length; ++i) { + var buf = list[i] + if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers') + } + buf.copy(buffer, pos) + pos += buf.length + } + return buffer + } + + function byteLength (string, encoding) { + if (Buffer.isBuffer(string)) { + return string.length + } + if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && + (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { + return string.byteLength + } + if (typeof string !== 'string') { + string = '' + string + } + + var len = string.length + if (len === 0) return 0 + + // Use a for loop to avoid recursion + var loweredCase = false + for (;;) { + switch (encoding) { + case 'ascii': + case 'latin1': + case 'binary': + return len + case 'utf8': + case 'utf-8': + case undefined: + return utf8ToBytes(string).length + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return len * 2 + case 'hex': + return len >>> 1 + case 'base64': + return base64ToBytes(string).length + default: + if (loweredCase) return utf8ToBytes(string).length // assume utf8 + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } + } + Buffer.byteLength = byteLength + + function slowToString (encoding, start, end) { + var loweredCase = false + + // No need to verify that "this.length <= MAX_UINT32" since it's a read-only + // property of a typed array. + + // This behaves neither like String nor Uint8Array in that we set start/end + // to their upper/lower bounds if the value passed is out of range. + // undefined is handled specially as per ECMA-262 6th Edition, + // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization. + if (start === undefined || start < 0) { + start = 0 + } + // Return early if start > this.length. Done here to prevent potential uint32 + // coercion fail below. + if (start > this.length) { + return '' + } + + if (end === undefined || end > this.length) { + end = this.length + } + + if (end <= 0) { + return '' + } + + // Force coersion to uint32. This will also coerce falsey/NaN values to 0. + end >>>= 0 + start >>>= 0 + + if (end <= start) { + return '' + } + + if (!encoding) encoding = 'utf8' + + while (true) { + switch (encoding) { + case 'hex': + return hexSlice(this, start, end) + + case 'utf8': + case 'utf-8': + return utf8Slice(this, start, end) + + case 'ascii': + return asciiSlice(this, start, end) + + case 'latin1': + case 'binary': + return latin1Slice(this, start, end) + + case 'base64': + return base64Slice(this, start, end) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return utf16leSlice(this, start, end) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = (encoding + '').toLowerCase() + loweredCase = true + } + } + } + + // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect + // Buffer instances. + Buffer.prototype._isBuffer = true + + function swap (b, n, m) { + var i = b[n] + b[n] = b[m] + b[m] = i + } + + Buffer.prototype.swap16 = function swap16 () { + var len = this.length + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits') + } + for (var i = 0; i < len; i += 2) { + swap(this, i, i + 1) + } + return this + } + + Buffer.prototype.swap32 = function swap32 () { + var len = this.length + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits') + } + for (var i = 0; i < len; i += 4) { + swap(this, i, i + 3) + swap(this, i + 1, i + 2) + } + return this + } + + Buffer.prototype.swap64 = function swap64 () { + var len = this.length + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits') + } + for (var i = 0; i < len; i += 8) { + swap(this, i, i + 7) + swap(this, i + 1, i + 6) + swap(this, i + 2, i + 5) + swap(this, i + 3, i + 4) + } + return this + } + + Buffer.prototype.toString = function toString () { + var length = this.length | 0 + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) + } + + Buffer.prototype.equals = function equals (b) { + if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') + if (this === b) return true + return Buffer.compare(this, b) === 0 + } + + Buffer.prototype.inspect = function inspect () { + var str = '' + var max = exports.INSPECT_MAX_BYTES + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' + } + + Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (!Buffer.isBuffer(target)) { + throw new TypeError('Argument must be a Buffer') + } + + if (start === undefined) { + start = 0 + } + if (end === undefined) { + end = target ? target.length : 0 + } + if (thisStart === undefined) { + thisStart = 0 + } + if (thisEnd === undefined) { + thisEnd = this.length + } + + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError('out of range index') + } + + if (thisStart >= thisEnd && start >= end) { + return 0 + } + if (thisStart >= thisEnd) { + return -1 + } + if (start >= end) { + return 1 + } + + start >>>= 0 + end >>>= 0 + thisStart >>>= 0 + thisEnd >>>= 0 + + if (this === target) return 0 + + var x = thisEnd - thisStart + var y = end - start + var len = Math.min(x, y) + + var thisCopy = this.slice(thisStart, thisEnd) + var targetCopy = target.slice(start, end) + + for (var i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i] + y = targetCopy[i] + break + } + } + + if (x < y) return -1 + if (y < x) return 1 + return 0 + } + + // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`, + // OR the last index of `val` in `buffer` at offset <= `byteOffset`. + // + // Arguments: + // - buffer - a Buffer to search + // - val - a string, Buffer, or number + // - byteOffset - an index into `buffer`; will be clamped to an int32 + // - encoding - an optional encoding, relevant is val is a string + // - dir - true for indexOf, false for lastIndexOf + function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) { + // Empty buffer means no match + if (buffer.length === 0) return -1 + + // Normalize byteOffset + if (typeof byteOffset === 'string') { + encoding = byteOffset + byteOffset = 0 + } else if (byteOffset > 0x7fffffff) { + byteOffset = 0x7fffffff + } else if (byteOffset < -0x80000000) { + byteOffset = -0x80000000 + } + byteOffset = +byteOffset // Coerce to Number. + if (isNaN(byteOffset)) { + // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer + byteOffset = dir ? 0 : (buffer.length - 1) + } + + // Normalize byteOffset: negative offsets start from the end of the buffer + if (byteOffset < 0) byteOffset = buffer.length + byteOffset + if (byteOffset >= buffer.length) { + if (dir) return -1 + else byteOffset = buffer.length - 1 + } else if (byteOffset < 0) { + if (dir) byteOffset = 0 + else return -1 + } + + // Normalize val + if (typeof val === 'string') { + val = Buffer.from(val, encoding) + } + + // Finally, search either indexOf (if dir is true) or lastIndexOf + if (Buffer.isBuffer(val)) { + // Special case: looking for empty string/buffer always fails + if (val.length === 0) { + return -1 + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir) + } else if (typeof val === 'number') { + val = val & 0xFF // Search for a byte value [0-255] + if (Buffer.TYPED_ARRAY_SUPPORT && + typeof Uint8Array.prototype.indexOf === 'function') { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset) + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset) + } + } + return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir) + } + + throw new TypeError('val must be string, number or Buffer') + } + + function arrayIndexOf (arr, val, byteOffset, encoding, dir) { + var indexSize = 1 + var arrLength = arr.length + var valLength = val.length + + if (encoding !== undefined) { + encoding = String(encoding).toLowerCase() + if (encoding === 'ucs2' || encoding === 'ucs-2' || + encoding === 'utf16le' || encoding === 'utf-16le') { + if (arr.length < 2 || val.length < 2) { + return -1 + } + indexSize = 2 + arrLength /= 2 + valLength /= 2 + byteOffset /= 2 + } + } + + function read (buf, i) { + if (indexSize === 1) { + return buf[i] + } else { + return buf.readUInt16BE(i * indexSize) + } + } + + var i + if (dir) { + var foundIndex = -1 + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) foundIndex = i + if (i - foundIndex + 1 === valLength) return foundIndex * indexSize + } else { + if (foundIndex !== -1) i -= i - foundIndex + foundIndex = -1 + } + } + } else { + if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength + for (i = byteOffset; i >= 0; i--) { + var found = true + for (var j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false + break + } + } + if (found) return i + } + } + + return -1 + } + + Buffer.prototype.includes = function includes (val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1 + } + + Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true) + } + + Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false) + } + + function hexWrite (buf, string, offset, length) { + offset = Number(offset) || 0 + var remaining = buf.length - offset + if (!length) { + length = remaining + } else { + length = Number(length) + if (length > remaining) { + length = remaining + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(parsed)) return i + buf[offset + i] = parsed + } + return i + } + + function utf8Write (buf, string, offset, length) { + return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) + } + + function asciiWrite (buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length) + } + + function latin1Write (buf, string, offset, length) { + return asciiWrite(buf, string, offset, length) + } + + function base64Write (buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length) + } + + function ucs2Write (buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) + } + + Buffer.prototype.write = function write (string, offset, length, encoding) { + // Buffer#write(string) + if (offset === undefined) { + encoding = 'utf8' + length = this.length + offset = 0 + // Buffer#write(string, encoding) + } else if (length === undefined && typeof offset === 'string') { + encoding = offset + length = this.length + offset = 0 + // Buffer#write(string, offset[, length][, encoding]) + } else if (isFinite(offset)) { + offset = offset | 0 + if (isFinite(length)) { + length = length | 0 + if (encoding === undefined) encoding = 'utf8' + } else { + encoding = length + length = undefined + } + // legacy write(string, encoding, offset, length) - remove in v0.13 + } else { + throw new Error( + 'Buffer.write(string, encoding, offset[, length]) is no longer supported' + ) + } + + var remaining = this.length - offset + if (length === undefined || length > remaining) length = remaining + + if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { + throw new RangeError('Attempt to write outside buffer bounds') + } + + if (!encoding) encoding = 'utf8' + + var loweredCase = false + for (;;) { + switch (encoding) { + case 'hex': + return hexWrite(this, string, offset, length) + + case 'utf8': + case 'utf-8': + return utf8Write(this, string, offset, length) + + case 'ascii': + return asciiWrite(this, string, offset, length) + + case 'latin1': + case 'binary': + return latin1Write(this, string, offset, length) + + case 'base64': + // Warning: maxLength not taken into account in base64Write + return base64Write(this, string, offset, length) + + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return ucs2Write(this, string, offset, length) + + default: + if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) + encoding = ('' + encoding).toLowerCase() + loweredCase = true + } + } + } + + Buffer.prototype.toJSON = function toJSON () { + return { + type: 'Buffer', + data: Array.prototype.slice.call(this._arr || this, 0) + } + } + + function base64Slice (buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf) + } else { + return base64.fromByteArray(buf.slice(start, end)) + } + } + + function utf8Slice (buf, start, end) { + end = Math.min(buf.length, end) + var res = [] + + var i = start + while (i < end) { + var firstByte = buf[i] + var codePoint = null + var bytesPerSequence = (firstByte > 0xEF) ? 4 + : (firstByte > 0xDF) ? 3 + : (firstByte > 0xBF) ? 2 + : 1 + + if (i + bytesPerSequence <= end) { + var secondByte, thirdByte, fourthByte, tempCodePoint + + switch (bytesPerSequence) { + case 1: + if (firstByte < 0x80) { + codePoint = firstByte + } + break + case 2: + secondByte = buf[i + 1] + if ((secondByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) + if (tempCodePoint > 0x7F) { + codePoint = tempCodePoint + } + } + break + case 3: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) + if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { + codePoint = tempCodePoint + } + } + break + case 4: + secondByte = buf[i + 1] + thirdByte = buf[i + 2] + fourthByte = buf[i + 3] + if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { + tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) + if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { + codePoint = tempCodePoint + } + } + } + } + + if (codePoint === null) { + // we did not generate a valid codePoint so insert a + // replacement char (U+FFFD) and advance only 1 byte + codePoint = 0xFFFD + bytesPerSequence = 1 + } else if (codePoint > 0xFFFF) { + // encode to utf16 (surrogate pair dance) + codePoint -= 0x10000 + res.push(codePoint >>> 10 & 0x3FF | 0xD800) + codePoint = 0xDC00 | codePoint & 0x3FF + } + + res.push(codePoint) + i += bytesPerSequence + } + + return decodeCodePointsArray(res) + } + + // Based on http://stackoverflow.com/a/22747272/680742, the browser with + // the lowest limit is Chrome, with 0x10000 args. + // We go 1 magnitude less, for safety + var MAX_ARGUMENTS_LENGTH = 0x1000 + + function decodeCodePointsArray (codePoints) { + var len = codePoints.length + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints) // avoid extra slice() + } + + // Decode in chunks to avoid "call stack size exceeded". + var res = '' + var i = 0 + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ) + } + return res + } + + function asciiSlice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F) + } + return ret + } + + function latin1Slice (buf, start, end) { + var ret = '' + end = Math.min(buf.length, end) + + for (var i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]) + } + return ret + } + + function hexSlice (buf, start, end) { + var len = buf.length + + if (!start || start < 0) start = 0 + if (!end || end < 0 || end > len) end = len + + var out = '' + for (var i = start; i < end; ++i) { + out += toHex(buf[i]) + } + return out + } + + function utf16leSlice (buf, start, end) { + var bytes = buf.slice(start, end) + var res = '' + for (var i = 0; i < bytes.length; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) + } + return res + } + + Buffer.prototype.slice = function slice (start, end) { + var len = this.length + start = ~~start + end = end === undefined ? len : ~~end + + if (start < 0) { + start += len + if (start < 0) start = 0 + } else if (start > len) { + start = len + } + + if (end < 0) { + end += len + if (end < 0) end = 0 + } else if (end > len) { + end = len + } + + if (end < start) end = start + + var newBuf + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = this.subarray(start, end) + newBuf.__proto__ = Buffer.prototype + } else { + var sliceLen = end - start + newBuf = new Buffer(sliceLen, undefined) + for (var i = 0; i < sliceLen; ++i) { + newBuf[i] = this[i + start] + } + } + + return newBuf + } + + /* + * Need to make sure that buffer isn't trying to write out of bounds. + */ + function checkOffset (offset, ext, length) { + if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') + if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') + } + + Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + + return val + } + + Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + checkOffset(offset, byteLength, this.length) + } + + var val = this[offset + --byteLength] + var mul = 1 + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul + } + + return val + } + + Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] + } + + Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) + } + + Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] + } + + Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return ((this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16)) + + (this[offset + 3] * 0x1000000) + } + + Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] * 0x1000000) + + ((this[offset + 1] << 16) | + (this[offset + 2] << 8) | + this[offset + 3]) + } + + Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var val = this[offset] + var mul = 1 + var i = 0 + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val + } + + Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) checkOffset(offset, byteLength, this.length) + + var i = byteLength + var mul = 1 + var val = this[offset + --i] + while (i > 0 && (mul *= 0x100)) { + val += this[offset + --i] * mul + } + mul *= 0x80 + + if (val >= mul) val -= Math.pow(2, 8 * byteLength) + + return val + } + + Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { + if (!noAssert) checkOffset(offset, 1, this.length) + if (!(this[offset] & 0x80)) return (this[offset]) + return ((0xff - this[offset] + 1) * -1) + } + + Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset] | (this[offset + 1] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val + } + + Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + var val = this[offset + 1] | (this[offset] << 8) + return (val & 0x8000) ? val | 0xFFFF0000 : val + } + + Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset]) | + (this[offset + 1] << 8) | + (this[offset + 2] << 16) | + (this[offset + 3] << 24) + } + + Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + + return (this[offset] << 24) | + (this[offset + 1] << 16) | + (this[offset + 2] << 8) | + (this[offset + 3]) + } + + Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) + } + + Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) + } + + Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) + } + + Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, false, 52, 8) + } + + function checkInt (buf, value, offset, ext, max, min) { + if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance') + if (value > max || value < min) throw new RangeError('"value" argument is out of bounds') + if (offset + ext > buf.length) throw new RangeError('Index out of range') + } + + Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var mul = 1 + var i = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength + } + + Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + byteLength = byteLength | 0 + if (!noAssert) { + var maxBytes = Math.pow(2, 8 * byteLength) - 1 + checkInt(this, value, offset, byteLength, maxBytes, 0) + } + + var i = byteLength - 1 + var mul = 1 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = (value / mul) & 0xFF + } + + return offset + byteLength + } + + Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = (value & 0xff) + return offset + 1 + } + + function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } + } + + Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 + } + + Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 + } + + function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } + } + + Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 + } + + Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 + } + + Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = 0 + var mul = 1 + var sub = 0 + this[offset] = value & 0xFF + while (++i < byteLength && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength + } + + Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) { + var limit = Math.pow(2, 8 * byteLength - 1) + + checkInt(this, value, offset, byteLength, limit - 1, -limit) + } + + var i = byteLength - 1 + var mul = 1 + var sub = 0 + this[offset + i] = value & 0xFF + while (--i >= 0 && (mul *= 0x100)) { + if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1 + } + this[offset + i] = ((value / mul) >> 0) - sub & 0xFF + } + + return offset + byteLength + } + + Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + if (value < 0) value = 0xff + value + 1 + this[offset] = (value & 0xff) + return offset + 1 + } + + Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + return offset + 2 + } + + Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 + } + + Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else { + objectWriteUInt32(this, value, offset, true) + } + return offset + 4 + } + + Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) + if (value < 0) value = 0xffffffff + value + 1 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + return offset + 4 + } + + function checkIEEE754 (buf, value, offset, ext, max, min) { + if (offset + ext > buf.length) throw new RangeError('Index out of range') + if (offset < 0) throw new RangeError('Index out of range') + } + + function writeFloat (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) + } + ieee754.write(buf, value, offset, littleEndian, 23, 4) + return offset + 4 + } + + Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { + return writeFloat(this, value, offset, true, noAssert) + } + + Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { + return writeFloat(this, value, offset, false, noAssert) + } + + function writeDouble (buf, value, offset, littleEndian, noAssert) { + if (!noAssert) { + checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) + } + ieee754.write(buf, value, offset, littleEndian, 52, 8) + return offset + 8 + } + + Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { + return writeDouble(this, value, offset, true, noAssert) + } + + Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { + return writeDouble(this, value, offset, false, noAssert) + } + + // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) + Buffer.prototype.copy = function copy (target, targetStart, start, end) { + if (!start) start = 0 + if (!end && end !== 0) end = this.length + if (targetStart >= target.length) targetStart = target.length + if (!targetStart) targetStart = 0 + if (end > 0 && end < start) end = start + + // Copy 0 bytes; we're done + if (end === start) return 0 + if (target.length === 0 || this.length === 0) return 0 + + // Fatal error conditions + if (targetStart < 0) { + throw new RangeError('targetStart out of bounds') + } + if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') + if (end < 0) throw new RangeError('sourceEnd out of bounds') + + // Are we oob? + if (end > this.length) end = this.length + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start + } + + var len = end - start + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + // ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start] + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + targetStart + ) + } + + return len + } + + // Usage: + // buffer.fill(number[, offset[, end]]) + // buffer.fill(buffer[, offset[, end]]) + // buffer.fill(string[, offset[, end]][, encoding]) + Buffer.prototype.fill = function fill (val, start, end, encoding) { + // Handle string cases: + if (typeof val === 'string') { + if (typeof start === 'string') { + encoding = start + start = 0 + end = this.length + } else if (typeof end === 'string') { + encoding = end + end = this.length + } + if (val.length === 1) { + var code = val.charCodeAt(0) + if (code < 256) { + val = code + } + } + if (encoding !== undefined && typeof encoding !== 'string') { + throw new TypeError('encoding must be a string') + } + if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) { + throw new TypeError('Unknown encoding: ' + encoding) + } + } else if (typeof val === 'number') { + val = val & 255 + } + + // Invalid ranges are not set to a default, so can range check early. + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError('Out of range index') + } + + if (end <= start) { + return this + } + + start = start >>> 0 + end = end === undefined ? this.length : end >>> 0 + + if (!val) val = 0 + + var i + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val + } + } else { + var bytes = Buffer.isBuffer(val) + ? val + : utf8ToBytes(new Buffer(val, encoding).toString()) + var len = bytes.length + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len] + } + } + + return this + } + + // HELPER FUNCTIONS + // ================ + + var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g + + function base64clean (str) { + // Node strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).replace(INVALID_BASE64_RE, '') + // Node converts strings with length < 2 to '' + if (str.length < 2) return '' + // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not + while (str.length % 4 !== 0) { + str = str + '=' + } + return str + } + + function stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') + } + + function toHex (n) { + if (n < 16) return '0' + n.toString(16) + return n.toString(16) + } + + function utf8ToBytes (string, units) { + units = units || Infinity + var codePoint + var length = string.length + var leadSurrogate = null + var bytes = [] + + for (var i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i) + + // is surrogate component + if (codePoint > 0xD7FF && codePoint < 0xE000) { + // last char was a lead + if (!leadSurrogate) { + // no lead yet + if (codePoint > 0xDBFF) { + // unexpected trail + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } else if (i + 1 === length) { + // unpaired lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + continue + } + + // valid lead + leadSurrogate = codePoint + + continue + } + + // 2 leads in a row + if (codePoint < 0xDC00) { + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + leadSurrogate = codePoint + continue + } + + // valid surrogate pair + codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 + } else if (leadSurrogate) { + // valid bmp char, but last char was a lead + if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) + } + + leadSurrogate = null + + // encode utf8 + if (codePoint < 0x80) { + if ((units -= 1) < 0) break + bytes.push(codePoint) + } else if (codePoint < 0x800) { + if ((units -= 2) < 0) break + bytes.push( + codePoint >> 0x6 | 0xC0, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x10000) { + if ((units -= 3) < 0) break + bytes.push( + codePoint >> 0xC | 0xE0, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else if (codePoint < 0x110000) { + if ((units -= 4) < 0) break + bytes.push( + codePoint >> 0x12 | 0xF0, + codePoint >> 0xC & 0x3F | 0x80, + codePoint >> 0x6 & 0x3F | 0x80, + codePoint & 0x3F | 0x80 + ) + } else { + throw new Error('Invalid code point') + } + } + + return bytes + } + + function asciiToBytes (str) { + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + // Node's code seems to be doing this and not & 0x7F.. + byteArray.push(str.charCodeAt(i) & 0xFF) + } + return byteArray + } + + function utf16leToBytes (str, units) { + var c, hi, lo + var byteArray = [] + for (var i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) break + + c = str.charCodeAt(i) + hi = c >> 8 + lo = c % 256 + byteArray.push(lo) + byteArray.push(hi) + } + + return byteArray + } + + function base64ToBytes (str) { + return base64.toByteArray(base64clean(str)) + } + + function blitBuffer (src, dst, offset, length) { + for (var i = 0; i < length; ++i) { + if ((i + offset >= dst.length) || (i >= src.length)) break + dst[i + offset] = src[i] + } + return i + } + + function isnan (val) { + return val !== val // eslint-disable-line no-self-compare + } + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 179 */ +/***/ function(module, exports) { + + 'use strict' + + exports.byteLength = byteLength + exports.toByteArray = toByteArray + exports.fromByteArray = fromByteArray + + var lookup = [] + var revLookup = [] + var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array + + var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' + for (var i = 0, len = code.length; i < len; ++i) { + lookup[i] = code[i] + revLookup[code.charCodeAt(i)] = i + } + + // Support decoding URL-safe base64 strings, as Node.js does. + // See: https://en.wikipedia.org/wiki/Base64#URL_applications + revLookup['-'.charCodeAt(0)] = 62 + revLookup['_'.charCodeAt(0)] = 63 + + function getLens (b64) { + var len = b64.length + + if (len % 4 > 0) { + throw new Error('Invalid string. Length must be a multiple of 4') + } + + // Trim off extra bytes after placeholder bytes are found + // See: https://github.com/beatgammit/base64-js/issues/42 + var validLen = b64.indexOf('=') + if (validLen === -1) validLen = len + + var placeHoldersLen = validLen === len + ? 0 + : 4 - (validLen % 4) + + return [validLen, placeHoldersLen] + } + + // base64 is 4/3 + up to two characters of the original data + function byteLength (b64) { + var lens = getLens(b64) + var validLen = lens[0] + var placeHoldersLen = lens[1] + return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen + } + + function _byteLength (b64, validLen, placeHoldersLen) { + return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen + } + + function toByteArray (b64) { + var tmp + var lens = getLens(b64) + var validLen = lens[0] + var placeHoldersLen = lens[1] + + var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen)) + + var curByte = 0 + + // if there are placeholders, only get up to the last complete 4 chars + var len = placeHoldersLen > 0 + ? validLen - 4 + : validLen + + var i + for (i = 0; i < len; i += 4) { + tmp = + (revLookup[b64.charCodeAt(i)] << 18) | + (revLookup[b64.charCodeAt(i + 1)] << 12) | + (revLookup[b64.charCodeAt(i + 2)] << 6) | + revLookup[b64.charCodeAt(i + 3)] + arr[curByte++] = (tmp >> 16) & 0xFF + arr[curByte++] = (tmp >> 8) & 0xFF + arr[curByte++] = tmp & 0xFF + } + + if (placeHoldersLen === 2) { + tmp = + (revLookup[b64.charCodeAt(i)] << 2) | + (revLookup[b64.charCodeAt(i + 1)] >> 4) + arr[curByte++] = tmp & 0xFF + } + + if (placeHoldersLen === 1) { + tmp = + (revLookup[b64.charCodeAt(i)] << 10) | + (revLookup[b64.charCodeAt(i + 1)] << 4) | + (revLookup[b64.charCodeAt(i + 2)] >> 2) + arr[curByte++] = (tmp >> 8) & 0xFF + arr[curByte++] = tmp & 0xFF + } + + return arr + } + + function tripletToBase64 (num) { + return lookup[num >> 18 & 0x3F] + + lookup[num >> 12 & 0x3F] + + lookup[num >> 6 & 0x3F] + + lookup[num & 0x3F] + } + + function encodeChunk (uint8, start, end) { + var tmp + var output = [] + for (var i = start; i < end; i += 3) { + tmp = + ((uint8[i] << 16) & 0xFF0000) + + ((uint8[i + 1] << 8) & 0xFF00) + + (uint8[i + 2] & 0xFF) + output.push(tripletToBase64(tmp)) + } + return output.join('') + } + + function fromByteArray (uint8) { + var tmp + var len = uint8.length + var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes + var parts = [] + var maxChunkLength = 16383 // must be multiple of 3 + + // go through the array every three bytes, we'll deal with trailing stuff later + for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) { + parts.push(encodeChunk( + uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength) + )) + } + + // pad the end with zeros, but make sure to not forget the extra bytes + if (extraBytes === 1) { + tmp = uint8[len - 1] + parts.push( + lookup[tmp >> 2] + + lookup[(tmp << 4) & 0x3F] + + '==' + ) + } else if (extraBytes === 2) { + tmp = (uint8[len - 2] << 8) + uint8[len - 1] + parts.push( + lookup[tmp >> 10] + + lookup[(tmp >> 4) & 0x3F] + + lookup[(tmp << 2) & 0x3F] + + '=' + ) + } + + return parts.join('') + } + + +/***/ }, +/* 180 */ +/***/ function(module, exports) { + + exports.read = function (buffer, offset, isLE, mLen, nBytes) { + var e, m + var eLen = (nBytes * 8) - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var nBits = -7 + var i = isLE ? (nBytes - 1) : 0 + var d = isLE ? -1 : 1 + var s = buffer[offset + i] + + i += d + + e = s & ((1 << (-nBits)) - 1) + s >>= (-nBits) + nBits += eLen + for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {} + + m = e & ((1 << (-nBits)) - 1) + e >>= (-nBits) + nBits += mLen + for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {} + + if (e === 0) { + e = 1 - eBias + } else if (e === eMax) { + return m ? NaN : ((s ? -1 : 1) * Infinity) + } else { + m = m + Math.pow(2, mLen) + e = e - eBias + } + return (s ? -1 : 1) * m * Math.pow(2, e - mLen) + } + + exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { + var e, m, c + var eLen = (nBytes * 8) - mLen - 1 + var eMax = (1 << eLen) - 1 + var eBias = eMax >> 1 + var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) + var i = isLE ? 0 : (nBytes - 1) + var d = isLE ? 1 : -1 + var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 + + value = Math.abs(value) + + if (isNaN(value) || value === Infinity) { + m = isNaN(value) ? 1 : 0 + e = eMax + } else { + e = Math.floor(Math.log(value) / Math.LN2) + if (value * (c = Math.pow(2, -e)) < 1) { + e-- + c *= 2 + } + if (e + eBias >= 1) { + value += rt / c + } else { + value += rt * Math.pow(2, 1 - eBias) + } + if (value * c >= 2) { + e++ + c /= 2 + } + + if (e + eBias >= eMax) { + m = 0 + e = eMax + } else if (e + eBias >= 1) { + m = ((value * c) - 1) * Math.pow(2, mLen) + e = e + eBias + } else { + m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) + e = 0 + } + } + + for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + + e = (e << mLen) | m + eLen += mLen + for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + + buffer[offset + i - d] |= s * 128 + } + + +/***/ }, +/* 181 */ +/***/ function(module, exports) { + + var toString = {}.toString; + + module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; }; -/***/ }, -/* 193 */ -/***/ function(module, exports, __webpack_require__) { - /* WEBPACK VAR INJECTION */(function(module) {"use strict"; +/***/ }, +/* 182 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global, Buffer) {(function() { + var g = ('undefined' === typeof window ? global : window) || {} + _crypto = ( + g.crypto || g.msCrypto || __webpack_require__(183) + ) + module.exports = function(size) { + // Modern Browsers + if(_crypto.getRandomValues) { + var bytes = new Buffer(size); //in browserify, this is an extended Uint8Array + /* This will not work in older browsers. + * See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues + */ + + _crypto.getRandomValues(bytes); + return bytes; + } + else if (_crypto.randomBytes) { + return _crypto.randomBytes(size) + } + else + throw new Error( + 'secure random number generation not supported by this browser\n'+ + 'use chrome, FireFox or Internet Explorer 11' + ) + } + }()) + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(178).Buffer)) + +/***/ }, +/* 183 */ +/***/ function(module, exports) { + + /* (ignored) */ + +/***/ }, +/* 184 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(Buffer) {var createHash = __webpack_require__(185) + + var md5 = toConstructor(__webpack_require__(197)) + var rmd160 = toConstructor(__webpack_require__(199)) + + function toConstructor (fn) { + return function () { + var buffers = [] + var m= { + update: function (data, enc) { + if(!Buffer.isBuffer(data)) data = new Buffer(data, enc) + buffers.push(data) + return this + }, + digest: function (enc) { + var buf = Buffer.concat(buffers) + var r = fn(buf) + buffers = null + return enc ? r.toString(enc) : r + } + } + return m + } + } + + module.exports = function (alg) { + if('md5' === alg) return new md5() + if('rmd160' === alg) return new rmd160() + return createHash(alg) + } + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) + +/***/ }, +/* 185 */ +/***/ function(module, exports, __webpack_require__) { + + var exports = module.exports = function (alg) { + var Alg = exports[alg] + if(!Alg) throw new Error(alg + ' is not supported (we accept pull requests)') + return new Alg() + } + + var Buffer = __webpack_require__(178).Buffer + var Hash = __webpack_require__(186)(Buffer) + + exports.sha1 = __webpack_require__(187)(Buffer, Hash) + exports.sha256 = __webpack_require__(195)(Buffer, Hash) + exports.sha512 = __webpack_require__(196)(Buffer, Hash) + + +/***/ }, +/* 186 */ +/***/ function(module, exports) { + + module.exports = function (Buffer) { + + //prototype class for hash functions + function Hash (blockSize, finalSize) { + this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4) + this._finalSize = finalSize + this._blockSize = blockSize + this._len = 0 + this._s = 0 + } + + Hash.prototype.init = function () { + this._s = 0 + this._len = 0 + } + + Hash.prototype.update = function (data, enc) { + if ("string" === typeof data) { + enc = enc || "utf8" + data = new Buffer(data, enc) + } - module["exports"] = ["Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico", "New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania", "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Washington", "West Virginia", "Wisconsin", "Wyoming"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) + var l = this._len += data.length + var s = this._s = (this._s || 0) + var f = 0 + var buffer = this._block -/***/ }, -/* 194 */ -/***/ function(module, exports, __webpack_require__) { + while (s < l) { + var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize)) + var ch = (t - f) - /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + for (var i = 0; i < ch; i++) { + buffer[(s % this._blockSize) + i] = data[i + f] + } + + s += ch + f += ch + + if ((s % this._blockSize) === 0) { + this._update(buffer) + } + } + this._s = s + + return this + } + + Hash.prototype.digest = function (enc) { + // Suppose the length of the message M, in bits, is l + var l = this._len * 8 + + // Append the bit 1 to the end of the message + this._block[this._len % this._blockSize] = 0x80 + + // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize + this._block.fill(0, this._len % this._blockSize + 1) + + if (l % (this._blockSize * 8) >= this._finalSize * 8) { + this._update(this._block) + this._block.fill(0) + } + + // to this append the block which is equal to the number l written in binary + // TODO: handle case where l is > Math.pow(2, 29) + this._block.writeInt32BE(l, this._blockSize - 4) + + var hash = this._update(this._block) || this._hash() + + return enc ? hash.toString(enc) : hash + } + + Hash.prototype._update = function () { + throw new Error('_update must be implemented by subclass') + } + + return Hash + } - module["exports"] = ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) /***/ }, -/* 195 */ +/* 187 */ /***/ function(module, exports, __webpack_require__) { - /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + /* + * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined + * in FIPS PUB 180-1 + * Version 2.1a Copyright Paul Johnston 2000 - 2002. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for details. + */ + + var inherits = __webpack_require__(188).inherits + + module.exports = function (Buffer, Hash) { + + var A = 0|0 + var B = 4|0 + var C = 8|0 + var D = 12|0 + var E = 16|0 + + var W = new (typeof Int32Array === 'undefined' ? Array : Int32Array)(80) + + var POOL = [] + + function Sha1 () { + if(POOL.length) + return POOL.pop().init() + + if(!(this instanceof Sha1)) return new Sha1() + this._w = W + Hash.call(this, 16*4, 14*4) + + this._h = null + this.init() + } + + inherits(Sha1, Hash) + + Sha1.prototype.init = function () { + this._a = 0x67452301 + this._b = 0xefcdab89 + this._c = 0x98badcfe + this._d = 0x10325476 + this._e = 0xc3d2e1f0 + + Hash.prototype.init.call(this) + return this + } + + Sha1.prototype._POOL = POOL + Sha1.prototype._update = function (X) { + + var a, b, c, d, e, _a, _b, _c, _d, _e + + a = _a = this._a + b = _b = this._b + c = _c = this._c + d = _d = this._d + e = _e = this._e + + var w = this._w + + for(var j = 0; j < 80; j++) { + var W = w[j] = j < 16 ? X.readInt32BE(j*4) + : rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1) + + var t = add( + add(rol(a, 5), sha1_ft(j, b, c, d)), + add(add(e, W), sha1_kt(j)) + ) + + e = d + d = c + c = rol(b, 30) + b = a + a = t + } + + this._a = add(a, _a) + this._b = add(b, _b) + this._c = add(c, _c) + this._d = add(d, _d) + this._e = add(e, _e) + } + + Sha1.prototype._hash = function () { + if(POOL.length < 100) POOL.push(this) + var H = new Buffer(20) + //console.log(this._a|0, this._b|0, this._c|0, this._d|0, this._e|0) + H.writeInt32BE(this._a|0, A) + H.writeInt32BE(this._b|0, B) + H.writeInt32BE(this._c|0, C) + H.writeInt32BE(this._d|0, D) + H.writeInt32BE(this._e|0, E) + return H + } + + /* + * Perform the appropriate triplet combination function for the current + * iteration + */ + function sha1_ft(t, b, c, d) { + if(t < 20) return (b & c) | ((~b) & d); + if(t < 40) return b ^ c ^ d; + if(t < 60) return (b & c) | (b & d) | (c & d); + return b ^ c ^ d; + } + + /* + * Determine the appropriate additive constant for the current iteration + */ + function sha1_kt(t) { + return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : + (t < 60) ? -1894007588 : -899497514; + } + + /* + * Add integers, wrapping at 2^32. This uses 16-bit operations internally + * to work around bugs in some JS interpreters. + * //dominictarr: this is 10 years old, so maybe this can be dropped?) + * + */ + function add(x, y) { + return (x + y ) | 0 + //lets see how this goes on testling. + // var lsw = (x & 0xFFFF) + (y & 0xFFFF); + // var msw = (x >> 16) + (y >> 16) + (lsw >> 16); + // return (msw << 16) | (lsw & 0xFFFF); + } + + /* + * Bitwise rotate a 32-bit number to the left. + */ + function rol(num, cnt) { + return (num << cnt) | (num >>> (32 - cnt)); + } + + return Sha1 + } - module["exports"] = ["Alley", "Avenue", "Branch", "Bridge", "Brook", "Brooks", "Burg", "Burgs", "Bypass", "Camp", "Canyon", "Cape", "Causeway", "Center", "Centers", "Circle", "Circles", "Cliff", "Cliffs", "Club", "Common", "Corner", "Corners", "Course", "Court", "Courts", "Cove", "Coves", "Creek", "Crescent", "Crest", "Crossing", "Crossroad", "Curve", "Dale", "Dam", "Divide", "Drive", "Drive", "Drives", "Estate", "Estates", "Expressway", "Extension", "Extensions", "Fall", "Falls", "Ferry", "Field", "Fields", "Flat", "Flats", "Ford", "Fords", "Forest", "Forge", "Forges", "Fork", "Forks", "Fort", "Freeway", "Garden", "Gardens", "Gateway", "Glen", "Glens", "Green", "Greens", "Grove", "Groves", "Harbor", "Harbors", "Haven", "Heights", "Highway", "Hill", "Hills", "Hollow", "Inlet", "Inlet", "Island", "Island", "Islands", "Islands", "Isle", "Isle", "Junction", "Junctions", "Key", "Keys", "Knoll", "Knolls", "Lake", "Lakes", "Land", "Landing", "Lane", "Light", "Lights", "Loaf", "Lock", "Locks", "Locks", "Lodge", "Lodge", "Loop", "Mall", "Manor", "Manors", "Meadow", "Meadows", "Mews", "Mill", "Mills", "Mission", "Mission", "Motorway", "Mount", "Mountain", "Mountain", "Mountains", "Mountains", "Neck", "Orchard", "Oval", "Overpass", "Park", "Parks", "Parkway", "Parkways", "Pass", "Passage", "Path", "Pike", "Pine", "Pines", "Place", "Plain", "Plains", "Plains", "Plaza", "Plaza", "Point", "Points", "Port", "Port", "Ports", "Ports", "Prairie", "Prairie", "Radial", "Ramp", "Ranch", "Rapid", "Rapids", "Rest", "Ridge", "Ridges", "River", "Road", "Road", "Roads", "Roads", "Route", "Row", "Rue", "Run", "Shoal", "Shoals", "Shore", "Shores", "Skyway", "Spring", "Springs", "Springs", "Spur", "Spurs", "Square", "Square", "Squares", "Squares", "Station", "Station", "Stravenue", "Stravenue", "Stream", "Stream", "Street", "Street", "Streets", "Summit", "Summit", "Terrace", "Throughway", "Trace", "Track", "Trafficway", "Trail", "Trail", "Tunnel", "Tunnel", "Turnpike", "Turnpike", "Underpass", "Union", "Unions", "Valley", "Valleys", "Via", "Viaduct", "View", "Views", "Village", "Village", "Villages", "Ville", "Vista", "Vista", "Walk", "Walks", "Wall", "Way", "Ways", "Well", "Wells"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) /***/ }, -/* 196 */ -/***/ function(module, exports) { +/* 188 */ +/***/ function(module, exports, __webpack_require__) { - "use strict"; + /* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. - module.exports = function (coordinate) { - var radius = arguments.length <= 1 || arguments[1] === undefined ? 10.0 : arguments[1]; - var isMetric = arguments.length <= 2 || arguments[2] === undefined ? true : arguments[2]; + var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || + function getOwnPropertyDescriptors(obj) { + var keys = Object.keys(obj); + var descriptors = {}; + for (var i = 0; i < keys.length; i++) { + descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]); + } + return descriptors; + }; + + var formatRegExp = /%[sdj%]/g; + exports.format = function(f) { + if (!isString(f)) { + var objects = []; + for (var i = 0; i < arguments.length; i++) { + objects.push(inspect(arguments[i])); + } + return objects.join(' '); + } + + var i = 1; + var args = arguments; + var len = args.length; + var str = String(f).replace(formatRegExp, function(x) { + if (x === '%%') return '%'; + if (i >= len) return x; + switch (x) { + case '%s': return String(args[i++]); + case '%d': return Number(args[i++]); + case '%j': + try { + return JSON.stringify(args[i++]); + } catch (_) { + return '[Circular]'; + } + default: + return x; + } + }); + for (var x = args[i]; i < len; x = args[++i]) { + if (isNull(x) || !isObject(x)) { + str += ' ' + x; + } else { + str += ' ' + inspect(x); + } + } + return str; + }; - function degreesToRadians(degrees) { - return degrees * (Math.PI / 180.0); - } + // Mark that a method should not be used. + // Returns a modified function which warns once by default. + // If --no-deprecation is set, then it is a no-op. + exports.deprecate = function(fn, msg) { + if (typeof process !== 'undefined' && process.noDeprecation === true) { + return fn; + } - function radiansToDegrees(radians) { - return radians * (180.0 / Math.PI); - } + // Allow for deprecating things in the process of starting up. + if (typeof process === 'undefined') { + return function() { + return exports.deprecate(fn, msg).apply(this, arguments); + }; + } - function milesToKm(miles) { - return miles * 0.621371; - } + var warned = false; + function deprecated() { + if (!warned) { + if (process.throwDeprecation) { + throw new Error(msg); + } else if (process.traceDeprecation) { + console.trace(msg); + } else { + console.error(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } - function coordinateWithOffset(coordinate, bearing, distance, isMetric) { - var R = 6378.137; - var d = isMetric ? distance : milesToKm(distance); + return deprecated; + }; - var lat1 = degreesToRadians(coordinate.latitude); - var lon1 = degreesToRadians(coordinate.longitude); - var lat2 = Math.asin(Math.sin(lat1) * Math.cos(d / R) + Math.cos(lat1) * Math.sin(d / R) * Math.cos(bearing)); + var debugs = {}; + var debugEnvRegex = /^$/; - var lon2 = lon1 + Math.atan2(Math.sin(bearing) * Math.sin(d / R) * Math.cos(lat1), Math.cos(d / R) - Math.sin(lat1) * Math.sin(lat2)); + if (({"NODE_ENV":"production"}).NODE_DEBUG) { + var debugEnv = ({"NODE_ENV":"production"}).NODE_DEBUG; + debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&') + .replace(/\*/g, '.*') + .replace(/,/g, '$|^') + .toUpperCase(); + debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i'); + } + exports.debuglog = function(set) { + set = set.toUpperCase(); + if (!debugs[set]) { + if (debugEnvRegex.test(set)) { + var pid = process.pid; + debugs[set] = function() { + var msg = exports.format.apply(exports, arguments); + console.error('%s %d: %s', set, pid, msg); + }; + } else { + debugs[set] = function() {}; + } + } + return debugs[set]; + }; - if (lon2 > degreesToRadians(180)) { - lon2 = lon2 - degreesToRadians(360); - } else if (lon2 < degreesToRadians(-180)) { - lon2 = lon2 + degreesToRadians(360); - } - return [radiansToDegrees(lat2), radiansToDegrees(lon2)]; - } + /** + * Echos the value of a value. Trys to print the value out + * in the best way possible given the different types. + * + * @param {Object} obj The object to print out. + * @param {Object} opts Optional options object that alters the output. + */ + /* legacy: obj, showHidden, depth, colors*/ + function inspect(obj, opts) { + // default options + var ctx = { + seen: [], + stylize: stylizeNoColor + }; + // legacy... + if (arguments.length >= 3) ctx.depth = arguments[2]; + if (arguments.length >= 4) ctx.colors = arguments[3]; + if (isBoolean(opts)) { + // legacy... + ctx.showHidden = opts; + } else if (opts) { + // got an "options" object + exports._extend(ctx, opts); + } + // set default options + if (isUndefined(ctx.showHidden)) ctx.showHidden = false; + if (isUndefined(ctx.depth)) ctx.depth = 2; + if (isUndefined(ctx.colors)) ctx.colors = false; + if (isUndefined(ctx.customInspect)) ctx.customInspect = true; + if (ctx.colors) ctx.stylize = stylizeWithColor; + return formatValue(ctx, obj, ctx.depth); + } + exports.inspect = inspect; - if (coordinate === undefined) { - return this.address.geoLocation(); - } - var randomCoord = coordinateWithOffset(coordinate, degreesToRadians(this.random.number(360)), radius, isMetric); + // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics + inspect.colors = { + 'bold' : [1, 22], + 'italic' : [3, 23], + 'underline' : [4, 24], + 'inverse' : [7, 27], + 'white' : [37, 39], + 'grey' : [90, 39], + 'black' : [30, 39], + 'blue' : [34, 39], + 'cyan' : [36, 39], + 'green' : [32, 39], + 'magenta' : [35, 39], + 'red' : [31, 39], + 'yellow' : [33, 39] + }; - return { - latitude: randomCoord[0], - longitude: randomCoord[1] - }; + // Don't use 'blue' not visible on cmd.exe + inspect.styles = { + 'special': 'cyan', + 'number': 'yellow', + 'boolean': 'yellow', + 'undefined': 'grey', + 'null': 'bold', + 'string': 'green', + 'date': 'magenta', + // "name": intentionally not styling + 'regexp': 'red' }; -/***/ }, -/* 197 */ -/***/ function(module, exports) { - "use strict"; + function stylizeWithColor(str, styleType) { + var style = inspect.styles[styleType]; - module.exports = { - name: ["#{names.lastName} #{company.suffix}", "#{names.lastName}-#{names.lastName} #{company.suffix}", "#{names.lastName}, #{names.lastName} and #{names.lastName} #{company.suffix}"], + if (style) { + return '\u001b[' + inspect.colors[style][0] + 'm' + str + + '\u001b[' + inspect.colors[style][1] + 'm'; + } else { + return str; + } + } - suffix: ["Ltd.", "Inc.", "Corp.", "LLC", "Group"] - }; -/***/ }, -/* 198 */ -/***/ function(module, exports, __webpack_require__) { + function stylizeNoColor(str, styleType) { + return str; + } - "use strict"; - module.exports = { - month: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], + function arrayToHash(array) { + var hash = {}; - weekday: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], + array.forEach(function(val, idx) { + hash[val] = true; + }); - weekdayShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], + return hash; + } - weekdayMin: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], - timezone: __webpack_require__(199), + function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (ctx.customInspect && + value && + isFunction(value.inspect) && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes, ctx); + if (!isString(ret)) { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } - past: function past() { - var years = arguments.length <= 0 || arguments[0] === undefined ? 1 : arguments[0]; - var refDate = arguments[1]; + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } - var date = refDate ? new Date(Date.parse(refDate)) : new Date(); - var min = 1000; - var max = years * 365 * 24 * 3600 * 1000; + // Look up the keys of the object. + var keys = Object.keys(value); + var visibleKeys = arrayToHash(keys); - var past = date.getTime(); - past -= this.random.number(min, max); - date.setTime(past); + if (ctx.showHidden) { + keys = Object.getOwnPropertyNames(value); + } - return date; - }, - future: function future() { - var years = arguments.length <= 0 || arguments[0] === undefined ? 1 : arguments[0]; - var refDate = arguments[1]; + // IE doesn't make error fields non-enumerable + // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx + if (isError(value) + && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { + return formatError(value); + } + + // Some type of object without properties can be shortcutted. + if (keys.length === 0) { + if (isFunction(value)) { + var name = value.name ? ': ' + value.name : ''; + return ctx.stylize('[Function' + name + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } - var date = refDate ? new Date(Date.parse(refDate)) : new Date(); - var min = 1000; - var max = years * 365 * 24 * 3600 * 1000; + var base = '', array = false, braces = ['{', '}']; - var future = date.getTime(); - future += this.random.number(min, max); - date.setTime(future); + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } - return date; - }, - between: function between(from, to) { - var fromMilli = Date.parse(from); - var dateOffset = this.random.number(Date.parse(to) - fromMilli); + // Make functions say that they are functions + if (isFunction(value)) { + var n = value.name ? ': ' + value.name : ''; + base = ' [Function' + n + ']'; + } - var newDate = new Date(fromMilli + dateOffset); + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } - return newDate; - }, - recent: function recent() { - var days = arguments.length <= 0 || arguments[0] === undefined ? 1 : arguments[0]; + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } - var date = new Date(); - var min = 1000; - var max = days * 24 * 3600 * 1000; + // Make error with message first say the error + if (isError(value)) { + base = ' ' + formatError(value); + } - var past = date.getTime(); - past -= this.random.number(min, max); - date.setTime(past); + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } - return date; - }, - age: function age() { - var min = arguments.length <= 0 || arguments[0] === undefined ? 18 : arguments[0]; - var max = arguments.length <= 1 || arguments[1] === undefined ? 80 : arguments[1]; + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } - return this.random.number(min, max); - } - }; + ctx.seen.push(value); -/***/ }, -/* 199 */ -/***/ function(module, exports, __webpack_require__) { + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } - /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + ctx.seen.pop(); - module["exports"] = ["Pacific/Midway", "Pacific/Pago_Pago", "Pacific/Honolulu", "America/Juneau", "America/Los_Angeles", "America/Tijuana", "America/Denver", "America/Phoenix", "America/Chihuahua", "America/Mazatlan", "America/Chicago", "America/Regina", "America/Mexico_City", "America/Mexico_City", "America/Monterrey", "America/Guatemala", "America/New_York", "America/Indiana/Indianapolis", "America/Bogota", "America/Lima", "America/Lima", "America/Halifax", "America/Caracas", "America/La_Paz", "America/Santiago", "America/St_Johns", "America/Sao_Paulo", "America/Argentina/Buenos_Aires", "America/Guyana", "America/Godthab", "Atlantic/South_Georgia", "Atlantic/Azores", "Atlantic/Cape_Verde", "Europe/Dublin", "Europe/London", "Europe/Lisbon", "Europe/London", "Africa/Casablanca", "Africa/Monrovia", "Etc/UTC", "Europe/Belgrade", "Europe/Bratislava", "Europe/Budapest", "Europe/Ljubljana", "Europe/Prague", "Europe/Sarajevo", "Europe/Skopje", "Europe/Warsaw", "Europe/Zagreb", "Europe/Brussels", "Europe/Copenhagen", "Europe/Madrid", "Europe/Paris", "Europe/Amsterdam", "Europe/Berlin", "Europe/Berlin", "Europe/Rome", "Europe/Stockholm", "Europe/Vienna", "Africa/Algiers", "Europe/Bucharest", "Africa/Cairo", "Europe/Helsinki", "Europe/Kiev", "Europe/Riga", "Europe/Sofia", "Europe/Tallinn", "Europe/Vilnius", "Europe/Athens", "Europe/Istanbul", "Europe/Minsk", "Asia/Jerusalem", "Africa/Harare", "Africa/Johannesburg", "Europe/Moscow", "Europe/Moscow", "Europe/Moscow", "Asia/Kuwait", "Asia/Riyadh", "Africa/Nairobi", "Asia/Baghdad", "Asia/Tehran", "Asia/Muscat", "Asia/Muscat", "Asia/Baku", "Asia/Tbilisi", "Asia/Yerevan", "Asia/Kabul", "Asia/Yekaterinburg", "Asia/Karachi", "Asia/Karachi", "Asia/Tashkent", "Asia/Kolkata", "Asia/Kolkata", "Asia/Kolkata", "Asia/Kolkata", "Asia/Kathmandu", "Asia/Dhaka", "Asia/Dhaka", "Asia/Colombo", "Asia/Almaty", "Asia/Novosibirsk", "Asia/Rangoon", "Asia/Bangkok", "Asia/Bangkok", "Asia/Jakarta", "Asia/Krasnoyarsk", "Asia/Shanghai", "Asia/Chongqing", "Asia/Hong_Kong", "Asia/Urumqi", "Asia/Kuala_Lumpur", "Asia/Singapore", "Asia/Taipei", "Australia/Perth", "Asia/Irkutsk", "Asia/Ulaanbaatar", "Asia/Seoul", "Asia/Tokyo", "Asia/Tokyo", "Asia/Tokyo", "Asia/Yakutsk", "Australia/Darwin", "Australia/Adelaide", "Australia/Melbourne", "Australia/Melbourne", "Australia/Sydney", "Australia/Brisbane", "Australia/Hobart", "Asia/Vladivostok", "Pacific/Guam", "Pacific/Port_Moresby", "Asia/Magadan", "Asia/Magadan", "Pacific/Noumea", "Pacific/Fiji", "Asia/Kamchatka", "Pacific/Majuro", "Pacific/Auckland", "Pacific/Auckland", "Pacific/Tongatapu", "Pacific/Fakaofo", "Pacific/Apia"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) + return reduceToSingleString(output, base, braces); + } -/***/ }, -/* 200 */ -/***/ function(module, exports) { - "use strict"; + function formatPrimitive(ctx, value) { + if (isUndefined(value)) + return ctx.stylize('undefined', 'undefined'); + if (isString(value)) { + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + } + if (isNumber(value)) + return ctx.stylize('' + value, 'number'); + if (isBoolean(value)) + return ctx.stylize('' + value, 'boolean'); + // For some reason typeof null is "object", so special case here. + if (isNull(value)) + return ctx.stylize('null', 'null'); + } - module.exports = { - address: function address() { - var def = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0]; - var country = this.address.countryAndCode(); - return { - country: def.country || country.name, - countryCode: def.countryCode || country.code, - state: def.state || this.address.state(), - city: def.city || this.address.city(), - street: def.street || this.address.street(), - zip: def.zip || this.address.postCode(), - geo: def.geo || this.address.geoLocation() - }; - }, - user: function user(gender) { + function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; + } - var firstName = this.populate("#{names.firstName" + (gender ? gender.toUpperCase() : "") + "}"); - var lastName = this.populate("#{names.lastName" + (gender ? gender.toUpperCase() : "") + "}"); - return { - firstName: firstName, - lastName: lastName, - userName: this.internet.userName(firstName, lastName), - password: this.internet.password(), - email: this.internet.email(firstName, lastName), - phone: this.phone.number(), - dob: this.date.past(80), - website: this.internet.url(), - ip: this.internet.ip(), - avatar: this.internet.avatar(), - gravatar: this.internet.gravatar(), - address: this.entity.address(), - status: this.random.boolean() - }; - }, - company: function company(name) { - name = name || this.company.name(); + function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (hasOwnProperty(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; + } - return { - name: name, - email: this.internet.email(name), - phone: this.phone.number(), - website: this.internet.url(), - ip: this.internet.ip(), - address: this.entity.address() - }; - }, - post: function post() { - var paragraphs = arguments.length <= 0 || arguments[0] === undefined ? 3 : arguments[0]; - return { - title: this.lorem.sentence(), - keywords: this.utimes(this.lorem.word, 3), - created: this.date.recent(7), - content: this.times(this.lorem.paragraph, paragraphs).join("\r\n") - }; - } - }; + function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str, desc; + desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; + if (desc.get) { + if (desc.set) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (desc.set) { + str = ctx.stylize('[Setter]', 'special'); + } + } + if (!hasOwnProperty(visibleKeys, key)) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(desc.value) < 0) { + if (isNull(recurseTimes)) { + str = formatValue(ctx, desc.value, null); + } else { + str = formatValue(ctx, desc.value, recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').substr(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (isUndefined(name)) { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.substr(1, name.length - 2); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } -/***/ }, -/* 201 */ -/***/ function(module, exports, __webpack_require__) { + return name + ': ' + str; + } - "use strict"; - module.exports = { - _meta: { - id: "default", - fallback: null, - mask: "\#\{([A-Za-z0-9_\.]+)\}", - language: "English", - country: "United Kingdom", - countryCode: "UK" - }, + function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } - names: __webpack_require__(202), - phone: __webpack_require__(206), - address: __webpack_require__(191), - company: __webpack_require__(197), - internet: __webpack_require__(207), - lorem: __webpack_require__(234), - date: __webpack_require__(198), - misc: __webpack_require__(237), - entity: __webpack_require__(200) - }; + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; + } -/***/ }, -/* 202 */ -/***/ function(module, exports, __webpack_require__) { - "use strict"; + // NOTE: These type checking functions intentionally don't use `instanceof` + // because it is fragile and can be easily faked with `Object.create()`. + exports.types = __webpack_require__(190); - module.exports = { - firstNameM: __webpack_require__(203), + function isArray(ar) { + return Array.isArray(ar); + } + exports.isArray = isArray; - firstNameF: __webpack_require__(204), + function isBoolean(arg) { + return typeof arg === 'boolean'; + } + exports.isBoolean = isBoolean; - firstName: ["#{names.firstNameM}", "#{names.firstNameF}"], + function isNull(arg) { + return arg === null; + } + exports.isNull = isNull; - lastNameM: __webpack_require__(205), + function isNullOrUndefined(arg) { + return arg == null; + } + exports.isNullOrUndefined = isNullOrUndefined; - lastNameF: __webpack_require__(205), + function isNumber(arg) { + return typeof arg === 'number'; + } + exports.isNumber = isNumber; - lastName: ["#{names.lastNameM}", "#{names.lastNameF}"], + function isString(arg) { + return typeof arg === 'string'; + } + exports.isString = isString; - prefix: ["Mr.", "Mrs.", "Ms.", "Miss", "Dr."], + function isSymbol(arg) { + return typeof arg === 'symbol'; + } + exports.isSymbol = isSymbol; - suffix: ["Jr.", "Sr.", "I", "II", "III", "IV", "V", "MD", "DDS", "PhD", "DVM"], + function isUndefined(arg) { + return arg === void 0; + } + exports.isUndefined = isUndefined; - nameM: ["#{names.prefix} #{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM} #{names.suffix}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}", "#{names.firstNameM} #{names.lastNameM}"], + function isRegExp(re) { + return isObject(re) && objectToString(re) === '[object RegExp]'; + } + exports.isRegExp = isRegExp; + exports.types.isRegExp = isRegExp; - nameF: ["#{names.prefix} #{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF} #{names.suffix}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}", "#{names.firstNameF} #{names.lastNameF}"], + function isObject(arg) { + return typeof arg === 'object' && arg !== null; + } + exports.isObject = isObject; - name: ["#{names.nameM}", "#{names.nameF}"] - }; + function isDate(d) { + return isObject(d) && objectToString(d) === '[object Date]'; + } + exports.isDate = isDate; + exports.types.isDate = isDate; -/***/ }, -/* 203 */ -/***/ function(module, exports, __webpack_require__) { + function isError(e) { + return isObject(e) && + (objectToString(e) === '[object Error]' || e instanceof Error); + } + exports.isError = isError; + exports.types.isNativeError = isError; - /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + function isFunction(arg) { + return typeof arg === 'function'; + } + exports.isFunction = isFunction; - module["exports"] = ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Charles", "Joseph", "Thomas", "Christopher", "Daniel", "Paul", "Mark", "Donald", "George", "Kenneth", "Steven", "Edward", "Brian", "Ronald", "Anthony", "Kevin", "Jason", "Matthew", "Gary", "Timothy", "Jose", "Larry", "Jeffrey", "Frank", "Scott", "Eric", "Stephen", "Andrew", "Raymond", "Gregory", "Joshua", "Jerry", "Dennis", "Walter", "Patrick", "Peter", "Harold", "Douglas", "Henry", "Carl", "Arthur", "Ryan", "Roger", "Joe", "Juan", "Jack", "Albert", "Jonathan", "Justin", "Terry", "Gerald", "Keith", "Samuel", "Willie", "Ralph", "Lawrence", "Nicholas", "Roy", "Benjamin", "Bruce", "Brandon", "Adam", "Harry", "Fred", "Wayne", "Billy", "Steve", "Louis", "Jeremy", "Aaron", "Randy", "Howard", "Eugene", "Carlos", "Russell", "Bobby", "Victor", "Martin", "Ernest", "Phillip", "Todd", "Jesse", "Craig", "Alan", "Shawn", "Clarence", "Sean", "Philip", "Chris", "Johnny", "Earl", "Jimmy", "Antonio", "Danny", "Bryan", "Tony", "Luis", "Mike", "Stanley", "Leonard", "Nathan", "Dale", "Manuel", "Rodney", "Curtis", "Norman", "Allen", "Marvin", "Vincent", "Glenn", "Jeffery", "Travis", "Jeff", "Chad", "Jacob", "Lee", "Melvin", "Alfred", "Kyle", "Francis", "Bradley", "Jesus", "Herbert", "Frederick", "Ray", "Joel", "Edwin", "Don", "Eddie", "Ricky", "Troy", "Randall", "Barry", "Alexander", "Bernard", "Mario", "Leroy", "Francisco", "Marcus", "Micheal", "Theodore", "Clifford", "Miguel", "Oscar", "Jay", "Jim", "Tom", "Calvin", "Alex", "Jon", "Ronnie", "Bill", "Lloyd", "Tommy", "Leon", "Derek", "Warren", "Darrell", "Jerome", "Floyd", "Leo", "Alvin", "Tim", "Wesley", "Gordon", "Dean", "Greg", "Jorge", "Dustin", "Pedro", "Derrick", "Dan", "Lewis", "Zachary", "Corey", "Herman", "Maurice", "Vernon", "Roberto", "Clyde", "Glen", "Hector", "Shane", "Ricardo", "Sam", "Rick", "Lester", "Brent", "Ramon", "Charlie", "Tyler", "Gilbert", "Gene", "Marc", "Reginald", "Ruben", "Brett", "Angel", "Nathaniel", "Rafael", "Leslie", "Edgar", "Milton", "Raul", "Ben", "Chester", "Cecil", "Duane", "Franklin", "Andre", "Elmer", "Brad", "Gabriel", "Ron", "Mitchell", "Roland", "Arnold", "Harvey", "Jared", "Adrian", "Karl", "Cory", "Claude", "Erik", "Darryl", "Jamie", "Neil", "Jessie", "Christian", "Javier", "Fernando", "Clinton", "Ted", "Mathew", "Tyrone", "Darren", "Lonnie", "Lance", "Cody", "Julio", "Kelly", "Kurt", "Allan", "Nelson", "Guy", "Clayton", "Hugh", "Max", "Dwayne", "Dwight", "Armando", "Felix", "Jimmie", "Everett", "Jordan", "Ian", "Wallace", "Ken", "Bob", "Jaime", "Casey", "Alfredo", "Alberto", "Dave", "Ivan", "Johnnie", "Sidney", "Byron", "Julian", "Isaac", "Morris", "Clifton", "Willard", "Daryl", "Ross", "Virgil", "Andy", "Marshall", "Salvador", "Perry", "Kirk", "Sergio", "Marion", "Tracy", "Seth", "Kent", "Terrance", "Rene", "Eduardo", "Terrence", "Enrique", "Freddie", "Wade", "Austin", "Stuart", "Fredrick", "Arturo", "Alejandro", "Jackie", "Joey", "Nick", "Luther", "Wendell", "Jeremiah", "Evan", "Julius", "Dana", "Donnie", "Otis", "Shannon", "Trevor", "Oliver", "Luke", "Homer", "Gerard", "Doug", "Kenny", "Hubert", "Angelo", "Shaun", "Lyle", "Matt", "Lynn", "Alfonso", "Orlando", "Rex", "Carlton", "Ernesto", "Cameron", "Neal", "Pablo", "Lorenzo", "Omar", "Wilbur", "Blake", "Grant", "Horace", "Roderick", "Kerry", "Abraham", "Willis", "Rickey", "Jean", "Ira", "Andres", "Cesar", "Johnathan", "Malcolm", "Rudolph", "Damon", "Kelvin", "Rudy", "Preston", "Alton", "Archie", "Marco", "Wm", "Pete", "Randolph", "Garry", "Geoffrey", "Jonathon", "Felipe", "Bennie", "Gerardo", "Ed", "Dominic", "Robin", "Loren", "Delbert", "Colin", "Guillermo", "Earnest", "Lucas", "Benny", "Noel", "Spencer", "Rodolfo", "Myron", "Edmund", "Garrett", "Salvatore", "Cedric", "Lowell", "Gregg", "Sherman", "Wilson", "Devin", "Sylvester", "Kim", "Roosevelt", "Israel", "Jermaine", "Forrest", "Wilbert", "Leland", "Simon", "Guadalupe", "Clark", "Irving", "Carroll", "Bryant", "Owen", "Rufus", "Woodrow", "Sammy", "Kristopher", "Mack", "Levi", "Marcos", "Gustavo", "Jake", "Lionel", "Marty", "Taylor", "Ellis", "Dallas", "Gilberto", "Clint", "Nicolas", "Laurence", "Ismael", "Orville", "Drew", "Jody", "Ervin", "Dewey", "Al", "Wilfred", "Josh", "Hugo", "Ignacio", "Caleb", "Tomas", "Sheldon", "Erick", "Frankie", "Stewart", "Doyle", "Darrel", "Rogelio", "Terence", "Santiago", "Alonzo", "Elias", "Bert", "Elbert", "Ramiro", "Conrad", "Pat", "Noah", "Grady", "Phil", "Cornelius", "Lamar", "Rolando", "Clay", "Percy", "Dexter", "Bradford", "Merle", "Darin", "Amos", "Terrell", "Moses", "Irvin", "Saul", "Roman", "Darnell", "Randal", "Tommie", "Timmy", "Darrin", "Winston", "Brendan", "Toby", "Van", "Abel", "Dominick", "Boyd", "Courtney", "Jan", "Emilio", "Elijah", "Cary", "Domingo", "Santos", "Aubrey", "Emmett", "Marlon", "Emanuel", "Jerald", "Edmond"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) + function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; + } + exports.isPrimitive = isPrimitive; -/***/ }, -/* 204 */ -/***/ function(module, exports, __webpack_require__) { + exports.isBuffer = __webpack_require__(191); - /* WEBPACK VAR INJECTION */(function(module) {"use strict"; + function objectToString(o) { + return Object.prototype.toString.call(o); + } - module["exports"] = ["Mary", "Patricia", "Linda", "Barbara", "Elizabeth", "Jennifer", "Maria", "Susan", "Margaret", "Dorothy", "Lisa", "Nancy", "Karen", "Betty", "Helen", "Sandra", "Donna", "Carol", "Ruth", "Sharon", "Michelle", "Laura", "Sarah", "Kimberly", "Deborah", "Jessica", "Shirley", "Cynthia", "Angela", "Melissa", "Brenda", "Amy", "Anna", "Rebecca", "Virginia", "Kathleen", "Pamela", "Martha", "Debra", "Amanda", "Stephanie", "Carolyn", "Christine", "Marie", "Janet", "Catherine", "Frances", "Ann", "Joyce", "Diane", "Alice", "Julie", "Heather", "Teresa", "Doris", "Gloria", "Evelyn", "Jean", "Cheryl", "Mildred", "Katherine", "Joan", "Ashley", "Judith", "Rose", "Janice", "Kelly", "Nicole", "Judy", "Christina", "Kathy", "Theresa", "Beverly", "Denise", "Tammy", "Irene", "Jane", "Lori", "Rachel", "Marilyn", "Andrea", "Kathryn", "Louise", "Sara", "Anne", "Jacqueline", "Wanda", "Bonnie", "Julia", "Ruby", "Lois", "Tina", "Phyllis", "Norma", "Paula", "Diana", "Annie", "Lillian", "Emily", "Robin", "Peggy", "Crystal", "Gladys", "Rita", "Dawn", "Connie", "Florence", "Tracy", "Edna", "Tiffany", "Carmen", "Rosa", "Cindy", "Grace", "Wendy", "Victoria", "Edith", "Kim", "Sherry", "Sylvia", "Josephine", "Thelma", "Shannon", "Sheila", "Ethel", "Ellen", "Elaine", "Marjorie", "Carrie", "Charlotte", "Monica", "Esther", "Pauline", "Emma", "Juanita", "Anita", "Rhonda", "Hazel", "Amber", "Eva", "Debbie", "April", "Leslie", "Clara", "Lucille", "Jamie", "Joanne", "Eleanor", "Valerie", "Danielle", "Megan", "Alicia", "Suzanne", "Michele", "Gail", "Bertha", "Darlene", "Veronica", "Jill", "Erin", "Geraldine", "Lauren", "Cathy", "Joann", "Lorraine", "Lynn", "Sally", "Regina", "Erica", "Beatrice", "Dolores", "Bernice", "Audrey", "Yvonne", "Annette", "June", "Samantha", "Marion", "Dana", "Stacy", "Ana", "Renee", "Ida", "Vivian", "Roberta", "Holly", "Brittany", "Melanie", "Loretta", "Yolanda", "Jeanette", "Laurie", "Katie", "Kristen", "Vanessa", "Alma", "Sue", "Elsie", "Beth", "Jeanne", "Vicki", "Carla", "Tara", "Rosemary", "Eileen", "Terri", "Gertrude", "Lucy", "Tonya", "Ella", "Stacey", "Wilma", "Gina", "Kristin", "Jessie", "Natalie", "Agnes", "Vera", "Willie", "Charlene", "Bessie", "Delores", "Melinda", "Pearl", "Arlene", "Maureen", "Colleen", "Allison", "Tamara", "Joy", "Georgia", "Constance", "Lillie", "Claudia", "Jackie", "Marcia", "Tanya", "Nellie", "Minnie", "Marlene", "Heidi", "Glenda", "Lydia", "Viola", "Courtney", "Marian", "Stella", "Caroline", "Dora", "Jo", "Vickie", "Mattie", "Terry", "Maxine", "Irma", "Mabel", "Marsha", "Myrtle", "Lena", "Christy", "Deanna", "Patsy", "Hilda", "Gwendolyn", "Jennie", "Nora", "Margie", "Nina", "Cassandra", "Leah", "Penny", "Kay", "Priscilla", "Naomi", "Carole", "Brandy", "Olga", "Billie", "Dianne", "Tracey", "Leona", "Jenny", "Felicia", "Sonia", "Miriam", "Velma", "Becky", "Bobbie", "Violet", "Kristina", "Toni", "Misty", "Mae", "Shelly", "Daisy", "Ramona", "Sherri", "Erika", "Katrina", "Claire", "Lindsey", "Lindsay", "Geneva", "Guadalupe", "Belinda", "Margarita", "Sheryl", "Cora", "Faye", "Ada", "Natasha", "Sabrina", "Isabel", "Marguerite", "Hattie", "Harriet", "Molly", "Cecilia", "Kristi", "Brandi", "Blanche", "Sandy", "Rosie", "Joanna", "Iris", "Eunice", "Angie", "Inez", "Lynda", "Madeline", "Amelia", "Alberta", "Genevieve", "Monique", "Jodi", "Janie", "Maggie", "Kayla", "Sonya", "Jan", "Lee", "Kristine", "Candace", "Fannie", "Maryann", "Opal", "Alison", "Yvette", "Melody", "Luz", "Susie", "Olivia", "Flora", "Shelley", "Kristy", "Mamie", "Lula", "Lola", "Verna", "Beulah", "Antoinette", "Candice", "Juana", "Jeannette", "Pam", "Kelli", "Hannah", "Whitney", "Bridget", "Karla", "Celia", "Latoya", "Patty", "Shelia", "Gayle", "Della", "Vicky", "Lynne", "Sheri", "Marianne", "Kara", "Jacquelyn", "Erma", "Blanca", "Myra", "Leticia", "Pat", "Krista", "Roxanne", "Angelica", "Johnnie", "Robyn", "Francis", "Adrienne", "Rosalie", "Alexandra", "Brooke", "Bethany", "Sadie", "Bernadette", "Traci", "Jody", "Kendra", "Jasmine", "Nichole", "Rachael", "Chelsea", "Mable", "Ernestine", "Muriel", "Marcella", "Elena", "Krystal", "Angelina", "Nadine", "Kari", "Estelle", "Dianna", "Paulette", "Lora", "Mona", "Doreen", "Rosemarie", "Angel", "Desiree", "Antonia", "Hope", "Ginger", "Janis", "Betsy", "Christie", "Freda", "Mercedes", "Meredith", "Lynette", "Teri", "Cristina", "Eula", "Leigh", "Meghan", "Sophia", "Eloise", "Rochelle", "Gretchen", "Cecelia", "Raquel", "Henrietta", "Alyssa", "Jana", "Kelley", "Gwen", "Kerry", "Jenna", "Tricia", "Laverne", "Olive", "Alexis", "Tasha", "Silvia", "Elvira", "Casey", "Delia", "Sophie", "Kate", "Patti", "Lorena", "Kellie", "Sonja", "Lila", "Lana", "Darla", "May", "Mindy", "Essie", "Mandy", "Lorene", "Elsa", "Josefina", "Jeannie", "Miranda", "Dixie", "Lucia", "Marta", "Faith", "Lela", "Johanna", "Shari", "Camille", "Tami", "Shawna", "Elisa", "Ebony", "Melba", "Ora", "Nettie", "Tabitha", "Ollie", "Jaime", "Winifred", "Kristie"]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(101)(module))) -/***/ }, -/* 205 */ -/***/ function(module, exports) { + function pad(n) { + return n < 10 ? '0' + n.toString(10) : n.toString(10); + } - "use strict"; - module.exports = ["Abbott", "Abernathy", "Abshire", "Adams", "Altenwerth", "Anderson", "Ankunding", "Armstrong", "Auer", "Aufderhar", "Bahringer", "Bailey", "Balistreri", "Barrows", "Bartell", "Bartoletti", "Barton", "Bashirian", "Batz", "Bauch", "Baumbach", "Bayer", "Beahan", "Beatty", "Bechtelar", "Becker", "Bednar", "Beer", "Beier", "Berge", "Bergnaum", "Bergstrom", "Bernhard", "Bernier", "Bins", "Blanda", "Blick", "Block", "Bode", "Boehm", "Bogan", "Bogisich", "Borer", "Bosco", "Botsford", "Boyer", "Boyle", "Bradtke", "Brakus", "Braun", "Breitenberg", "Brekke", "Brown", "Bruen", "Buckridge", "Carroll", "Carter", "Cartwright", "Casper", "Cassin", "Champlin", "Christiansen", "Cole", "Collier", "Collins", "Conn", "Connelly", "Conroy", "Considine", "Corkery", "Cormier", "Corwin", "Cremin", "Crist", "Crona", "Cronin", "Crooks", "Cruickshank", "Cummerata", "Cummings", "Dach", "D'Amore", "Daniel", "Dare", "Daugherty", "Davis", "Deckow", "Denesik", "Dibbert", "Dickens", "Dicki", "Dickinson", "Dietrich", "Donnelly", "Dooley", "Douglas", "Doyle", "DuBuque", "Durgan", "Ebert", "Effertz", "Eichmann", "Emard", "Emmerich", "Erdman", "Ernser", "Fadel", "Fahey", "Farrell", "Fay", "Feeney", "Feest", "Feil", "Ferry", "Fisher", "Flatley", "Frami", "Franecki", "Friesen", "Fritsch", "Funk", "Gaylord", "Gerhold", "Gerlach", "Gibson", "Gislason", "Gleason", "Gleichner", "Glover", "Goldner", "Goodwin", "Gorczany", "Gottlieb", "Goyette", "Grady", "Graham", "Grant", "Green", "Greenfelder", "Greenholt", "Grimes", "Gulgowski", "Gusikowski", "Gutkowski", "Gutmann", "Haag", "Hackett", "Hagenes", "Hahn", "Haley", "Halvorson", "Hamill", "Hammes", "Hand", "Hane", "Hansen", "Harber", "Harris", "Hartmann", "Harvey", "Hauck", "Hayes", "Heaney", "Heathcote", "Hegmann", "Heidenreich", "Heller", "Herman", "Hermann", "Hermiston", "Herzog", "Hessel", "Hettinger", "Hickle", "Hilll", "Hills", "Hilpert", "Hintz", "Hirthe", "Hodkiewicz", "Hoeger", "Homenick", "Hoppe", "Howe", "Howell", "Hudson", "Huel", "Huels", "Hyatt", "Jacobi", "Jacobs", "Jacobson", "Jakubowski", "Jaskolski", "Jast", "Jenkins", "Jerde", "Johns", "Johnson", "Johnston", "Jones", "Kassulke", "Kautzer", "Keebler", "Keeling", "Kemmer", "Kerluke", "Kertzmann", "Kessler", "Kiehn", "Kihn", "Kilback", "King", "Kirlin", "Klein", "Kling", "Klocko", "Koch", "Koelpin", "Koepp", "Kohler", "Konopelski", "Koss", "Kovacek", "Kozey", "Krajcik", "Kreiger", "Kris", "Kshlerin", "Kub", "Kuhic", "Kuhlman", "Kuhn", "Kulas", "Kunde", "Kunze", "Kuphal", "Kutch", "Kuvalis", "Labadie", "Lakin", "Lang", "Langosh", "Langworth", "Larkin", "Larson", "Leannon", "Lebsack", "Ledner", "Leffler", "Legros", "Lehner", "Lemke", "Lesch", "Leuschke", "Lind", "Lindgren", "Littel", "Little", "Lockman", "Lowe", "Lubowitz", "Lueilwitz", "Luettgen", "Lynch", "Macejkovic", "MacGyver", "Maggio", "Mann", "Mante", "Marks", "Marquardt", "Marvin", "Mayer", "Mayert", "McClure", "McCullough", "McDermott", "McGlynn", "McKenzie", "McLaughlin", "Medhurst", "Mertz", "Metz", "Miller", "Mills", "Mitchell", "Moen", "Mohr", "Monahan", "Moore", "Morar", "Morissette", "Mosciski", "Mraz", "Mueller", "Muller", "Murazik", "Murphy", "Murray", "Nader", "Nicolas", "Nienow", "Nikolaus", "Nitzsche", "Nolan", "Oberbrunner", "O'Connell", "O'Conner", "O'Hara", "O'Keefe", "O'Kon", "Okuneva", "Olson", "Ondricka", "O'Reilly", "Orn", "Ortiz", "Osinski", "Pacocha", "Padberg", "Pagac", "Parisian", "Parker", "Paucek", "Pfannerstill", "Pfeffer", "Pollich", "Pouros", "Powlowski", "Predovic", "Price", "Prohaska", "Prosacco", "Purdy", "Quigley", "Quitzon", "Rath", "Ratke", "Rau", "Raynor", "Reichel", "Reichert", "Reilly", "Reinger", "Rempel", "Renner", "Reynolds", "Rice", "Rippin", "Ritchie", "Robel", "Roberts", "Rodriguez", "Rogahn", "Rohan", "Rolfson", "Romaguera", "Roob", "Rosenbaum", "Rowe", "Ruecker", "Runolfsdottir", "Runolfsson", "Runte", "Russel", "Rutherford", "Ryan", "Sanford", "Satterfield", "Sauer", "Sawayn", "Schaden", "Schaefer", "Schamberger", "Schiller", "Schimmel", "Schinner", "Schmeler", "Schmidt", "Schmitt", "Schneider", "Schoen", "Schowalter", "Schroeder", "Schulist", "Schultz", "Schumm", "Schuppe", "Schuster", "Senger", "Shanahan", "Shields", "Simonis", "Sipes", "Skiles", "Smith", "Smitham", "Spencer", "Spinka", "Sporer", "Stamm", "Stanton", "Stark", "Stehr", "Steuber", "Stiedemann", "Stokes", "Stoltenberg", "Stracke", "Streich", "Stroman", "Strosin", "Swaniawski", "Swift", "Terry", "Thiel", "Thompson", "Tillman", "Torp", "Torphy", "Towne", "Toy", "Trantow", "Tremblay", "Treutel", "Tromp", "Turcotte", "Turner", "Ullrich", "Upton", "Vandervort", "Veum", "Volkman", "Von", "VonRueden", "Waelchi", "Walker", "Walsh", "Walter", "Ward", "Waters", "Watsica", "Weber", "Wehner", "Weimann", "Weissnat", "Welch", "West", "White", "Wiegand", "Wilderman", "Wilkinson", "Will", "Williamson", "Willms", "Windler", "Wintheiser", "Wisoky", "Wisozk", "Witting", "Wiza", "Wolf", "Wolff", "Wuckert", "Wunsch", "Wyman", "Yost", "Yundt", "Zboncak", "Zemlak", "Ziemann", "Zieme", "Zulauf"]; + var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', + 'Oct', 'Nov', 'Dec']; -/***/ }, -/* 206 */ -/***/ function(module, exports) { + // 26 Feb 16:19:34 + function timestamp() { + var d = new Date(); + var time = [pad(d.getHours()), + pad(d.getMinutes()), + pad(d.getSeconds())].join(':'); + return [d.getDate(), months[d.getMonth()], time].join(' '); + } - "use strict"; - module.exports = { - number: ["###-###-####", "(###) ###-####", "1-###-###-####", "###.###.####", "###-###-####", "(###) ###-####", "1-###-###-####", "###.###.####", "###-###-#### x###", "(###) ###-#### x###", "1-###-###-#### x###", "###.###.#### x###", "###-###-#### x####", "(###) ###-#### x####", "1-###-###-#### x####", "###.###.#### x####", "###-###-#### x#####", "(###) ###-#### x#####", "1-###-###-#### x#####", "###.###.#### x#####"] + // log is just a thin wrapper to console.log that prepends a timestamp + exports.log = function() { + console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); }; -/***/ }, -/* 207 */ -/***/ function(module, exports, __webpack_require__) { - "use strict"; + /** + * Inherit the prototype methods from one constructor into another. + * + * The Function.prototype.inherits from lang.js rewritten as a standalone + * function (not on Function.prototype). NOTE: If this file is to be loaded + * during bootstrapping this function needs to be rewritten using some native + * functions as prototype setup using normal JavaScript does not work as + * expected during bootstrapping (see mirror.js in r114903). + * + * @param {function} ctor Constructor function which needs to inherit the + * prototype. + * @param {function} superCtor Constructor function to inherit prototype from. + */ + exports.inherits = __webpack_require__(194); - var _passwordGenerator = __webpack_require__(208); + exports._extend = function(origin, add) { + // Don't do anything if add isn't an object + if (!add || !isObject(add)) return origin; - var _passwordGenerator2 = _interopRequireDefault(_passwordGenerator); + var keys = Object.keys(add); + var i = keys.length; + while (i--) { + origin[keys[i]] = add[keys[i]]; + } + return origin; + }; - var _crypto = __webpack_require__(209); + function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); + } - var _crypto2 = _interopRequireDefault(_crypto); + var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined; - var _uifaces = __webpack_require__(232); + exports.promisify = function promisify(original) { + if (typeof original !== 'function') + throw new TypeError('The "original" argument must be of type Function'); - var _uifaces2 = _interopRequireDefault(_uifaces); + if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) { + var fn = original[kCustomPromisifiedSymbol]; + if (typeof fn !== 'function') { + throw new TypeError('The "util.promisify.custom" argument must be of type Function'); + } + Object.defineProperty(fn, kCustomPromisifiedSymbol, { + value: fn, enumerable: false, writable: false, configurable: true + }); + return fn; + } - function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + function fn() { + var promiseResolve, promiseReject; + var promise = new Promise(function (resolve, reject) { + promiseResolve = resolve; + promiseReject = reject; + }); - module.exports = { - tld: __webpack_require__(233), + var args = []; + for (var i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } + args.push(function (err, value) { + if (err) { + promiseReject(err); + } else { + promiseResolve(value); + } + }); - userName: function userName(firstName, lastName) { - firstName = this.slugify(firstName ? firstName : this.populate("#{names.firstName}")).toLowerCase(); - lastName = this.slugify(lastName ? lastName : this.populate("#{names.lastName}")).toLowerCase(); + try { + original.apply(this, args); + } catch (err) { + promiseReject(err); + } - return this.populate(this.random.arrayElement([firstName + "." + lastName, firstName + "." + lastName + "##", firstName + "." + lastName + "####", firstName + "_" + lastName, firstName + "_" + lastName + "##", "" + firstName + lastName + "##", firstName + "##"])); - }, - password: function password(length, memorable, pattern, prefix) { - return (0, _passwordGenerator2.default)(length, memorable, pattern, prefix); - }, - domain: function domain() { - return this.slugify(this.populate(this.random.arrayElement(["#{names.firstName}", "#{names.firstName}#{names.lastName}", "#{names.firstName}-#{names.lastName}"]))).toLowerCase() + "." + this.random.arrayElement(module.exports.tld); - }, - url: function url(https://github.com/isHttps,%20hasWWW) { - if (isHttps == null) isHttps = this.random.boolean(); + return promise; + } - if (hasWWW == null) hasWWW = !this.random.boolean(); + Object.setPrototypeOf(fn, Object.getPrototypeOf(original)); - var prefix = isHttps ? "https://" : "http://"; - if (hasWWW) prefix += "www."; + if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, { + value: fn, enumerable: false, writable: false, configurable: true + }); + return Object.defineProperties( + fn, + getOwnPropertyDescriptors(original) + ); + } - return prefix + this.internet.domain(); - }, + exports.promisify.custom = kCustomPromisifiedSymbol + function callbackifyOnRejected(reason, cb) { + // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M). + // Because `null` is a special error value in callbacks which means "no error + // occurred", we error-wrap so the callback consumer can distinguish between + // "the promise rejected with null" or "the promise fulfilled with undefined". + if (!reason) { + var newReason = new Error('Promise was rejected with a falsy value'); + newReason.reason = reason; + reason = newReason; + } + return cb(reason); + } - emailDomain: ["gmail.com", "yahoo.com", "hotmail.com"], + function callbackify(original) { + if (typeof original !== 'function') { + throw new TypeError('The "original" argument must be of type Function'); + } - email: function email(firstName, lastName, domain) { - firstName = this.slugify(firstName ? firstName : this.populate("#{names.firstName}")).toLowerCase(); - lastName = this.slugify(lastName ? lastName : this.populate("#{names.lastName}")).toLowerCase(); - domain = domain ? domain : this.populate("#{internet.emailDomain}"); + // We DO NOT return the promise as it gives the user a false sense that + // the promise is actually somehow related to the callback's execution + // and that the callback throwing will reject the promise. + function callbackified() { + var args = []; + for (var i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } - return [firstName + "." + lastName + "@" + domain, firstName + "." + lastName + "##@" + domain, "" + firstName + lastName + "##@" + domain, firstName + "##@" + domain]; - }, + var maybeCb = args.pop(); + if (typeof maybeCb !== 'function') { + throw new TypeError('The last argument must be of type Function'); + } + var self = this; + var cb = function() { + return maybeCb.apply(self, arguments); + }; + // In true node style we process the callback on `nextTick` with all the + // implications (stack, `uncaughtException`, `async_hooks`) + original.apply(this, args) + .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) }, + function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) }); + } + Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original)); + Object.defineProperties(callbackified, + getOwnPropertyDescriptors(original)); + return callbackified; + } + exports.callbackify = callbackify; - imageCategories: ["abstract", "animals", "business", "cats", "city", "food", "nightlife", "fashion", "people", "nature", "sports", "technics", "transport"], + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(189))) - image: function image() { - var width = arguments.length <= 0 || arguments[0] === undefined ? 640 : arguments[0]; - var height = arguments.length <= 1 || arguments[1] === undefined ? 480 : arguments[1]; - var category = arguments[2]; +/***/ }, +/* 189 */ +/***/ function(module, exports) { - var url = "http://lorempixel.com/" + width + "/" + height; - if (category) url += "/" + category; + // shim for using process in browser + var process = module.exports = {}; - return url; - }, - mac: function mac() { - return this.times(this.random.hex, 6, 2).join(":"); - }, - ip: function ip() { - return this.times(this.random.number, 4, 1, 254).join("."); - }, - ipv6: function ipv6() { - return this.times(this.random.hex, 8, 4).join(":"); - }, - color: function color() { - var baseRed255 = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0]; - var baseGreen255 = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1]; - var baseBlue255 = arguments.length <= 2 || arguments[2] === undefined ? 0 : arguments[2]; + // cached from whatever global is present so that test runners that stub it + // don't break things. But we need to wrap it in a try catch in case it is + // wrapped in strict mode code which doesn't define any globals. It's inside a + // function because try/catches deoptimize in certain engines. - var red = Math.floor((this.random.number(256) + baseRed255) / 2); - var green = Math.floor((this.random.number(256) + baseGreen255) / 2); - var blue = Math.floor((this.random.number(256) + baseBlue255) / 2); - var redStr = red.toString(16); - var greenStr = green.toString(16); - var blueStr = blue.toString(16); - return (redStr.length === 1 ? "0" : "") + redStr + (greenStr.length === 1 ? "0" : "") + greenStr + (blueStr.length === 1 ? "0" : "") + blueStr; - }, - avatar: function avatar() { - return "https://s3.amazonaws.com/uifaces/faces/twitter/" + this.random.arrayElement(_uifaces2.default) + "/128.jpg"; - }, - gravatar: function gravatar(email) { - if (email == null) { - email = this.internet.email(); - } + var cachedSetTimeout; + var cachedClearTimeout; + + function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); + } + function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); + } + (function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } + } ()) + function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } - return "https://www.gravatar.com/avatar/" + _crypto2.default.createHash("md5").update(email).digest("hex"); - } - }; -/***/ }, -/* 208 */ -/***/ function(module, exports, __webpack_require__) { + } + function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } - "use strict"; - (function (root) { - var localName, consonant, letter, _password, vowel; - letter = /[a-zA-Z]$/; - vowel = /[aeiouAEIOU]$/; - consonant = /[bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ]$/; + } + var queue = []; + var draining = false; + var currentQueue; + var queueIndex = -1; - localName = "generatePassword", _password = function password(length, memorable, pattern, prefix) { - var char, n; - if (length == null) { - length = 10; - } - if (memorable == null) { - memorable = true; + function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; } - if (pattern == null) { - pattern = /\w/; + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; } - if (prefix == null) { - prefix = ''; + if (queue.length) { + drainQueue(); } - if (prefix.length >= length) { - return prefix; + } + + function drainQueue() { + if (draining) { + return; } - if (memorable) { - if (prefix.match(consonant)) { - pattern = vowel; - } else { - pattern = consonant; - } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; } - n = Math.floor(Math.random() * 94) + 33; - char = String.fromCharCode(n); - if (memorable) { - char = char.toLowerCase(); + currentQueue = null; + draining = false; + runClearTimeout(timeout); + } + + process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } } - if (!char.match(pattern)) { - return _password(length, memorable, pattern, prefix); + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); } - return _password(length, memorable, pattern, "" + prefix + char); - }; + }; + + // v8 likes predictible objects + function Item(fun, array) { + this.fun = fun; + this.array = array; + } + Item.prototype.run = function () { + this.fun.apply(null, this.array); + }; + process.title = 'browser'; + process.browser = true; + process.env = {}; + process.argv = []; + process.version = ''; // empty string to avoid regexp issues + process.versions = {}; + + function noop() {} + + process.on = noop; + process.addListener = noop; + process.once = noop; + process.off = noop; + process.removeListener = noop; + process.removeAllListeners = noop; + process.emit = noop; + process.prependListener = noop; + process.prependOnceListener = noop; + + process.listeners = function (name) { return [] } + + process.binding = function (name) { + throw new Error('process.binding is not supported'); + }; + + process.cwd = function () { return '/' }; + process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); + }; + process.umask = function() { return 0; }; - ( true ? exports : root)[localName] = _password; - if (true) { - if (typeof module !== 'undefined' && module.exports) { - module.exports = _password; - } - } - })(undefined); /***/ }, -/* 209 */ +/* 190 */ /***/ function(module, exports, __webpack_require__) { - /* WEBPACK VAR INJECTION */(function(Buffer) {var rng = __webpack_require__(214) + // Currently in sync with Node.js lib/internal/util/types.js + // https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9 - function error () { - var m = [].slice.call(arguments).join(' ') - throw new Error([ - m, - 'we accept pull requests', - 'http://github.com/dominictarr/crypto-browserify' - ].join('\n')) - } + 'use strict'; - exports.createHash = __webpack_require__(216) + var isBuffer = __webpack_require__(191); - exports.createHmac = __webpack_require__(229) + var isArgumentsObject = __webpack_require__(192); + var isGeneratorFunction = __webpack_require__(193); - exports.randomBytes = function(size, callback) { - if (callback && callback.call) { - try { - callback.call(this, undefined, new Buffer(rng(size))) - } catch (err) { callback(err) } - } else { - return new Buffer(rng(size)) - } + function uncurryThis(f) { + return f.call.bind(f); } - function each(a, f) { - for(var i in a) - f(a[i], i) - } + var BigIntSupported = typeof BigInt !== 'undefined'; + var SymbolSupported = typeof Symbol !== 'undefined'; + var SymbolToStringTagSupported = SymbolSupported && typeof Symbol.toStringTag !== 'undefined'; + var Uint8ArraySupported = typeof Uint8Array !== 'undefined'; + var ArrayBufferSupported = typeof ArrayBuffer !== 'undefined'; - exports.getHashes = function () { - return ['sha1', 'sha256', 'sha512', 'md5', 'rmd160'] - } + if (Uint8ArraySupported && SymbolToStringTagSupported) { + var TypedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype); - var p = __webpack_require__(230)(exports) - exports.pbkdf2 = p.pbkdf2 - exports.pbkdf2Sync = p.pbkdf2Sync + var TypedArrayProto_toStringTag = + uncurryThis( + Object.getOwnPropertyDescriptor(TypedArrayPrototype, + Symbol.toStringTag).get); + } - // the least I can do is make error messages for the rest of the node.js/crypto api. - each(['createCredentials' - , 'createCipher' - , 'createCipheriv' - , 'createDecipher' - , 'createDecipheriv' - , 'createSign' - , 'createVerify' - , 'createDiffieHellman' - ], function (name) { - exports[name] = function () { - error('sorry,', name, 'is not implemented yet') - } - }) + var ObjectToString = uncurryThis(Object.prototype.toString); - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(210).Buffer)) + var numberValue = uncurryThis(Number.prototype.valueOf); + var stringValue = uncurryThis(String.prototype.valueOf); + var booleanValue = uncurryThis(Boolean.prototype.valueOf); -/***/ }, -/* 210 */ -/***/ function(module, exports, __webpack_require__) { + if (BigIntSupported) { + var bigIntValue = uncurryThis(BigInt.prototype.valueOf); + } - /* WEBPACK VAR INJECTION */(function(Buffer, global) {/*! - * The buffer module from node.js, for the browser. - * - * @author Feross Aboukhadijeh - * @license MIT - */ - /* eslint-disable no-proto */ + if (SymbolSupported) { + var symbolValue = uncurryThis(Symbol.prototype.valueOf); + } - 'use strict' + function checkBoxedPrimitive(value, prototypeValueOf) { + if (typeof value !== 'object') { + return false; + } + try { + prototypeValueOf(value); + return true; + } catch(e) { + return false; + } + } - var base64 = __webpack_require__(211) - var ieee754 = __webpack_require__(212) - var isArray = __webpack_require__(213) + exports.isArgumentsObject = isArgumentsObject; - exports.Buffer = Buffer - exports.SlowBuffer = SlowBuffer - exports.INSPECT_MAX_BYTES = 50 - Buffer.poolSize = 8192 // not used by this implementation + exports.isGeneratorFunction = isGeneratorFunction; - var rootParent = {} + // Taken from here and modified for better browser support + // https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js + function isPromise(input) { + return ( + ( + typeof Promise !== 'undefined' && + input instanceof Promise + ) || + ( + input !== null && + typeof input === 'object' && + typeof input.then === 'function' && + typeof input.catch === 'function' + ) + ); + } + exports.isPromise = isPromise; - /** - * If `Buffer.TYPED_ARRAY_SUPPORT`: - * === true Use Uint8Array implementation (fastest) - * === false Use Object implementation (most compatible, even IE6) - * - * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+, - * Opera 11.6+, iOS 4.2+. - * - * Due to various browser bugs, sometimes the Object implementation will be used even - * when the browser supports typed arrays. - * - * Note: - * - * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, - * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. - * - * - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property - * on objects. - * - * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. - * - * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of - * incorrect length in some situations. + function isArrayBufferView(value) { + if (ArrayBufferSupported && ArrayBuffer.isView) { + return ArrayBuffer.isView(value); + } - * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they - * get the Object implementation, which is slower but behaves correctly. - */ - Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined - ? global.TYPED_ARRAY_SUPPORT - : typedArraySupport() + return ( + isTypedArray(value) || + isDataView(value) + ); + } + exports.isArrayBufferView = isArrayBufferView; - function typedArraySupport () { - function Bar () {} - try { - var arr = new Uint8Array(1) - arr.foo = function () { return 42 } - arr.constructor = Bar - return arr.foo() === 42 && // typed array instances can be augmented - arr.constructor === Bar && // constructor can be set - typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` - arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` - } catch (e) { - return false + function isTypedArray(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) !== undefined; + } else { + return ( + isUint8Array(value) || + isUint8ClampedArray(value) || + isUint16Array(value) || + isUint32Array(value) || + isInt8Array(value) || + isInt16Array(value) || + isInt32Array(value) || + isFloat32Array(value) || + isFloat64Array(value) || + isBigInt64Array(value) || + isBigUint64Array(value) + ); + } + } + exports.isTypedArray = isTypedArray; + + function isUint8Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Uint8Array'; + } else { + return ( + ObjectToString(value) === '[object Uint8Array]' || + // If it's a Buffer instance _and_ has a `.buffer` property, + // this is an ArrayBuffer based buffer; thus it's an Uint8Array + // (Old Node.js had a custom non-Uint8Array implementation) + isBuffer(value) && value.buffer !== undefined + ); + } + } + exports.isUint8Array = isUint8Array; + + function isUint8ClampedArray(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Uint8ClampedArray'; + } else { + return ObjectToString(value) === '[object Uint8ClampedArray]'; } } + exports.isUint8ClampedArray = isUint8ClampedArray; - function kMaxLength () { - return Buffer.TYPED_ARRAY_SUPPORT - ? 0x7fffffff - : 0x3fffffff + function isUint16Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Uint16Array'; + } else { + return ObjectToString(value) === '[object Uint16Array]'; + } } + exports.isUint16Array = isUint16Array; - /** - * Class: Buffer - * ============= - * - * The Buffer constructor returns instances of `Uint8Array` that are augmented - * with function properties for all the node `Buffer` API functions. We use - * `Uint8Array` so that square bracket notation works as expected -- it returns - * a single octet. - * - * By augmenting the instances, we can avoid modifying the `Uint8Array` - * prototype. - */ - function Buffer (arg) { - if (!(this instanceof Buffer)) { - // Avoid going through an ArgumentsAdaptorTrampoline in the common case. - if (arguments.length > 1) return new Buffer(arg, arguments[1]) - return new Buffer(arg) + function isUint32Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Uint32Array'; + } else { + return ObjectToString(value) === '[object Uint32Array]'; } + } + exports.isUint32Array = isUint32Array; - if (!Buffer.TYPED_ARRAY_SUPPORT) { - this.length = 0 - this.parent = undefined + function isInt8Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Int8Array'; + } else { + return ObjectToString(value) === '[object Int8Array]'; } + } + exports.isInt8Array = isInt8Array; - // Common case. - if (typeof arg === 'number') { - return fromNumber(this, arg) + function isInt16Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Int16Array'; + } else { + return ObjectToString(value) === '[object Int16Array]'; } + } + exports.isInt16Array = isInt16Array; - // Slightly less common case. - if (typeof arg === 'string') { - return fromString(this, arg, arguments.length > 1 ? arguments[1] : 'utf8') + function isInt32Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Int32Array'; + } else { + return ObjectToString(value) === '[object Int32Array]'; } + } + exports.isInt32Array = isInt32Array; - // Unusual. - return fromObject(this, arg) + function isFloat32Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Float32Array'; + } else { + return ObjectToString(value) === '[object Float32Array]'; + } } + exports.isFloat32Array = isFloat32Array; - function fromNumber (that, length) { - that = allocate(that, length < 0 ? 0 : checked(length) | 0) - if (!Buffer.TYPED_ARRAY_SUPPORT) { - for (var i = 0; i < length; i++) { - that[i] = 0 - } + function isFloat64Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'Float64Array'; + } else { + return ObjectToString(value) === '[object Float64Array]'; } - return that } + exports.isFloat64Array = isFloat64Array; - function fromString (that, string, encoding) { - if (typeof encoding !== 'string' || encoding === '') encoding = 'utf8' + function isBigInt64Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'BigInt64Array'; + } else { + return ObjectToString(value) === '[object BigInt64Array]'; + } + } + exports.isBigInt64Array = isBigInt64Array; - // Assumption: byteLength() return value is always < kMaxLength. - var length = byteLength(string, encoding) | 0 - that = allocate(that, length) + function isBigUint64Array(value) { + if (Uint8ArraySupported && SymbolToStringTagSupported) { + return TypedArrayProto_toStringTag(value) === 'BigUint64Array'; + } else { + return ObjectToString(value) === '[object BigUint64Array]'; + } + } + exports.isBigUint64Array = isBigUint64Array; - that.write(string, encoding) - return that + function isMapToString(value) { + return ObjectToString(value) === '[object Map]'; } + isMapToString.working = ( + typeof Map !== 'undefined' && + isMapToString(new Map()) + ); - function fromObject (that, object) { - if (Buffer.isBuffer(object)) return fromBuffer(that, object) + function isMap(value) { + if (typeof Map === 'undefined') { + return false; + } - if (isArray(object)) return fromArray(that, object) + return isMapToString.working + ? isMapToString(value) + : value instanceof Map; + } + exports.isMap = isMap; - if (object == null) { - throw new TypeError('must start with number, buffer, array or string') + function isSetToString(value) { + return ObjectToString(value) === '[object Set]'; + } + isSetToString.working = ( + typeof Set !== 'undefined' && + isSetToString(new Set()) + ); + function isSet(value) { + if (typeof Set === 'undefined') { + return false; } - if (typeof ArrayBuffer !== 'undefined') { - if (object.buffer instanceof ArrayBuffer) { - return fromTypedArray(that, object) - } - if (object instanceof ArrayBuffer) { - return fromArrayBuffer(that, object) - } + return isSetToString.working + ? isSetToString(value) + : value instanceof Set; + } + exports.isSet = isSet; + + function isWeakMapToString(value) { + return ObjectToString(value) === '[object WeakMap]'; + } + isWeakMapToString.working = ( + typeof WeakMap !== 'undefined' && + isWeakMapToString(new WeakMap()) + ); + function isWeakMap(value) { + if (typeof WeakMap === 'undefined') { + return false; } - if (object.length) return fromArrayLike(that, object) + return isWeakMapToString.working + ? isWeakMapToString(value) + : value instanceof WeakMap; + } + exports.isWeakMap = isWeakMap; - return fromJsonObject(that, object) + function isWeakSetToString(value) { + return ObjectToString(value) === '[object WeakSet]'; } + isWeakSetToString.working = ( + typeof WeakSet !== 'undefined' && + isWeakSetToString(new WeakSet()) + ); + function isWeakSet(value) { + return isWeakSetToString(value); + if (typeof WeakSet === 'undefined') { + return false; + } - function fromBuffer (that, buffer) { - var length = checked(buffer.length) | 0 - that = allocate(that, length) - buffer.copy(that, 0, 0, length) - return that + return isWeakSetToString.working + ? isWeakSetToString(value) + : value instanceof WeakSet; } + exports.isWeakSet = isWeakSet; - function fromArray (that, array) { - var length = checked(array.length) | 0 - that = allocate(that, length) - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 + function isArrayBufferToString(value) { + return ObjectToString(value) === '[object ArrayBuffer]'; + } + isArrayBufferToString.working = ( + typeof ArrayBuffer !== 'undefined' && + isArrayBufferToString(new ArrayBuffer()) + ); + function isArrayBuffer(value) { + if (typeof ArrayBuffer === 'undefined') { + return false; } - return that + + return isArrayBufferToString.working + ? isArrayBufferToString(value) + : value instanceof ArrayBuffer; } + exports.isArrayBuffer = isArrayBuffer; - // Duplicate of fromArray() to keep fromArray() monomorphic. - function fromTypedArray (that, array) { - var length = checked(array.length) | 0 - that = allocate(that, length) - // Truncating the elements is probably not what people expect from typed - // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior - // of the old Buffer constructor. - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 + function isDataViewToString(value) { + return ObjectToString(value) === '[object DataView]'; + } + isDataViewToString.working = ( + typeof ArrayBuffer !== 'undefined' && + typeof DataView !== 'undefined' && + isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1)) + ); + function isDataView(value) { + if (typeof DataView === 'undefined') { + return false; } - return that + + return isDataViewToString.working + ? isDataViewToString(value) + : value instanceof DataView; } + exports.isDataView = isDataView; - function fromArrayBuffer (that, array) { - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - array.byteLength - that = Buffer._augment(new Uint8Array(array)) - } else { - // Fallback: Return an object instance of the Buffer class - that = fromTypedArray(that, new Uint8Array(array)) + function isSharedArrayBufferToString(value) { + return ObjectToString(value) === '[object SharedArrayBuffer]'; + } + isSharedArrayBufferToString.working = ( + typeof SharedArrayBuffer !== 'undefined' && + isSharedArrayBufferToString(new SharedArrayBuffer()) + ); + function isSharedArrayBuffer(value) { + if (typeof SharedArrayBuffer === 'undefined') { + return false; } - return that + + return isSharedArrayBufferToString.working + ? isSharedArrayBufferToString(value) + : value instanceof SharedArrayBuffer; } + exports.isSharedArrayBuffer = isSharedArrayBuffer; - function fromArrayLike (that, array) { - var length = checked(array.length) | 0 - that = allocate(that, length) - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 - } - return that + function isAsyncFunction(value) { + return ObjectToString(value) === '[object AsyncFunction]'; } + exports.isAsyncFunction = isAsyncFunction; - // Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object. - // Returns a zero-length buffer for inputs that don't conform to the spec. - function fromJsonObject (that, object) { - var array - var length = 0 + function isMapIterator(value) { + return ObjectToString(value) === '[object Map Iterator]'; + } + exports.isMapIterator = isMapIterator; - if (object.type === 'Buffer' && isArray(object.data)) { - array = object.data - length = checked(array.length) | 0 - } - that = allocate(that, length) + function isSetIterator(value) { + return ObjectToString(value) === '[object Set Iterator]'; + } + exports.isSetIterator = isSetIterator; - for (var i = 0; i < length; i += 1) { - that[i] = array[i] & 255 - } - return that + function isGeneratorObject(value) { + return ObjectToString(value) === '[object Generator]'; } + exports.isGeneratorObject = isGeneratorObject; - if (Buffer.TYPED_ARRAY_SUPPORT) { - Buffer.prototype.__proto__ = Uint8Array.prototype - Buffer.__proto__ = Uint8Array - } else { - // pre-set for values that may exist in the future - Buffer.prototype.length = undefined - Buffer.prototype.parent = undefined + function isWebAssemblyCompiledModule(value) { + return ObjectToString(value) === '[object WebAssembly.Module]'; } + exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule; - function allocate (that, length) { - if (Buffer.TYPED_ARRAY_SUPPORT) { - // Return an augmented `Uint8Array` instance, for best performance - that = Buffer._augment(new Uint8Array(length)) - that.__proto__ = Buffer.prototype - } else { - // Fallback: Return an object instance of the Buffer class - that.length = length - that._isBuffer = true - } + function isNumberObject(value) { + return checkBoxedPrimitive(value, numberValue); + } + exports.isNumberObject = isNumberObject; - var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1 - if (fromPool) that.parent = rootParent + function isStringObject(value) { + return checkBoxedPrimitive(value, stringValue); + } + exports.isStringObject = isStringObject; - return that + function isBooleanObject(value) { + return checkBoxedPrimitive(value, booleanValue); } + exports.isBooleanObject = isBooleanObject; - function checked (length) { - // Note: cannot use `length < kMaxLength` here because that fails when - // length is NaN (which is otherwise coerced to zero.) - if (length >= kMaxLength()) { - throw new RangeError('Attempt to allocate Buffer larger than maximum ' + - 'size: 0x' + kMaxLength().toString(16) + ' bytes') - } - return length | 0 + function isBigIntObject(value) { + return BigIntSupported && checkBoxedPrimitive(value, bigIntValue); } + exports.isBigIntObject = isBigIntObject; - function SlowBuffer (subject, encoding) { - if (!(this instanceof SlowBuffer)) return new SlowBuffer(subject, encoding) + function isSymbolObject(value) { + return SymbolSupported && checkBoxedPrimitive(value, symbolValue); + } + exports.isSymbolObject = isSymbolObject; - var buf = new Buffer(subject, encoding) - delete buf.parent - return buf + function isBoxedPrimitive(value) { + return ( + isNumberObject(value) || + isStringObject(value) || + isBooleanObject(value) || + isBigIntObject(value) || + isSymbolObject(value) + ); } + exports.isBoxedPrimitive = isBoxedPrimitive; - Buffer.isBuffer = function isBuffer (b) { - return !!(b != null && b._isBuffer) + function isAnyArrayBuffer(value) { + return Uint8ArraySupported && ( + isArrayBuffer(value) || + isSharedArrayBuffer(value) + ); } + exports.isAnyArrayBuffer = isAnyArrayBuffer; - Buffer.compare = function compare (a, b) { - if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { - throw new TypeError('Arguments must be Buffers') - } + ['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) { + Object.defineProperty(exports, method, { + enumerable: false, + value: function() { + throw new Error(method + ' is not supported in userland'); + } + }); + }); - if (a === b) return 0 - var x = a.length - var y = b.length +/***/ }, +/* 191 */ +/***/ function(module, exports) { + + module.exports = function isBuffer(arg) { + return arg && typeof arg === 'object' + && typeof arg.copy === 'function' + && typeof arg.fill === 'function' + && typeof arg.readUInt8 === 'function'; + } + +/***/ }, +/* 192 */ +/***/ function(module, exports) { + + 'use strict'; + + var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; + var toStr = Object.prototype.toString; + + var isStandardArguments = function isArguments(value) { + if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) { + return false; + } + return toStr.call(value) === '[object Arguments]'; + }; + + var isLegacyArguments = function isArguments(value) { + if (isStandardArguments(value)) { + return true; + } + return value !== null && + typeof value === 'object' && + typeof value.length === 'number' && + value.length >= 0 && + toStr.call(value) !== '[object Array]' && + toStr.call(value.callee) === '[object Function]'; + }; + + var supportsStandardArguments = (function () { + return isStandardArguments(arguments); + }()); + + isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests + + module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments; + + +/***/ }, +/* 193 */ +/***/ function(module, exports) { + + 'use strict'; + + var toStr = Object.prototype.toString; + var fnToStr = Function.prototype.toString; + var isFnRegex = /^\s*(?:function)?\*/; + var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol'; + var getProto = Object.getPrototypeOf; + var getGeneratorFunc = function () { // eslint-disable-line consistent-return + if (!hasToStringTag) { + return false; + } + try { + return Function('return function*() {}')(); + } catch (e) { + } + }; + var generatorFunc = getGeneratorFunc(); + var GeneratorFunction = generatorFunc ? getProto(generatorFunc) : {}; + + module.exports = function isGeneratorFunction(fn) { + if (typeof fn !== 'function') { + return false; + } + if (isFnRegex.test(fnToStr.call(fn))) { + return true; + } + if (!hasToStringTag) { + var str = toStr.call(fn); + return str === '[object GeneratorFunction]'; + } + return getProto(fn) === GeneratorFunction; + }; - var i = 0 - var len = Math.min(x, y) - while (i < len) { - if (a[i] !== b[i]) break - ++i +/***/ }, +/* 194 */ +/***/ function(module, exports) { + + if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }) + } + }; + } else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } } + } + - if (i !== len) { - x = a[i] - y = b[i] +/***/ }, +/* 195 */ +/***/ function(module, exports, __webpack_require__) { + + + /** + * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined + * in FIPS 180-2 + * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * + */ + + var inherits = __webpack_require__(188).inherits + + module.exports = function (Buffer, Hash) { + + var K = [ + 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, + 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, + 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, + 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, + 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, + 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, + 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, + 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, + 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, + 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, + 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, + 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, + 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, + 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, + 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, + 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 + ] + + var W = new Array(64) + + function Sha256() { + this.init() + + this._w = W //new Array(64) + + Hash.call(this, 16*4, 14*4) } - if (x < y) return -1 - if (y < x) return 1 - return 0 - } + inherits(Sha256, Hash) + + Sha256.prototype.init = function () { + + this._a = 0x6a09e667|0 + this._b = 0xbb67ae85|0 + this._c = 0x3c6ef372|0 + this._d = 0xa54ff53a|0 + this._e = 0x510e527f|0 + this._f = 0x9b05688c|0 + this._g = 0x1f83d9ab|0 + this._h = 0x5be0cd19|0 + + this._len = this._s = 0 + + return this + } - Buffer.isEncoding = function isEncoding (encoding) { - switch (String(encoding).toLowerCase()) { - case 'hex': - case 'utf8': - case 'utf-8': - case 'ascii': - case 'binary': - case 'base64': - case 'raw': - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return true - default: - return false + function S (X, n) { + return (X >>> n) | (X << (32 - n)); } - } - Buffer.concat = function concat (list, length) { - if (!isArray(list)) throw new TypeError('list argument must be an Array of Buffers.') + function R (X, n) { + return (X >>> n); + } - if (list.length === 0) { - return new Buffer(0) + function Ch (x, y, z) { + return ((x & y) ^ ((~x) & z)); } - var i - if (length === undefined) { - length = 0 - for (i = 0; i < list.length; i++) { - length += list[i].length - } + function Maj (x, y, z) { + return ((x & y) ^ (x & z) ^ (y & z)); } - var buf = new Buffer(length) - var pos = 0 - for (i = 0; i < list.length; i++) { - var item = list[i] - item.copy(buf, pos) - pos += item.length + function Sigma0256 (x) { + return (S(x, 2) ^ S(x, 13) ^ S(x, 22)); } - return buf - } - function byteLength (string, encoding) { - if (typeof string !== 'string') string = '' + string + function Sigma1256 (x) { + return (S(x, 6) ^ S(x, 11) ^ S(x, 25)); + } - var len = string.length - if (len === 0) return 0 + function Gamma0256 (x) { + return (S(x, 7) ^ S(x, 18) ^ R(x, 3)); + } - // Use a for loop to avoid recursion - var loweredCase = false - for (;;) { - switch (encoding) { - case 'ascii': - case 'binary': - // Deprecated - case 'raw': - case 'raws': - return len - case 'utf8': - case 'utf-8': - return utf8ToBytes(string).length - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return len * 2 - case 'hex': - return len >>> 1 - case 'base64': - return base64ToBytes(string).length - default: - if (loweredCase) return utf8ToBytes(string).length // assume utf8 - encoding = ('' + encoding).toLowerCase() - loweredCase = true - } + function Gamma1256 (x) { + return (S(x, 17) ^ S(x, 19) ^ R(x, 10)); } - } - Buffer.byteLength = byteLength - function slowToString (encoding, start, end) { - var loweredCase = false + Sha256.prototype._update = function(M) { - start = start | 0 - end = end === undefined || end === Infinity ? this.length : end | 0 + var W = this._w + var a, b, c, d, e, f, g, h + var T1, T2 - if (!encoding) encoding = 'utf8' - if (start < 0) start = 0 - if (end > this.length) end = this.length - if (end <= start) return '' + a = this._a | 0 + b = this._b | 0 + c = this._c | 0 + d = this._d | 0 + e = this._e | 0 + f = this._f | 0 + g = this._g | 0 + h = this._h | 0 - while (true) { - switch (encoding) { - case 'hex': - return hexSlice(this, start, end) + for (var j = 0; j < 64; j++) { + var w = W[j] = j < 16 + ? M.readInt32BE(j * 4) + : Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16] - case 'utf8': - case 'utf-8': - return utf8Slice(this, start, end) + T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w - case 'ascii': - return asciiSlice(this, start, end) + T2 = Sigma0256(a) + Maj(a, b, c); + h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2; + } - case 'binary': - return binarySlice(this, start, end) + this._a = (a + this._a) | 0 + this._b = (b + this._b) | 0 + this._c = (c + this._c) | 0 + this._d = (d + this._d) | 0 + this._e = (e + this._e) | 0 + this._f = (f + this._f) | 0 + this._g = (g + this._g) | 0 + this._h = (h + this._h) | 0 - case 'base64': - return base64Slice(this, start, end) + }; - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return utf16leSlice(this, start, end) + Sha256.prototype._hash = function () { + var H = new Buffer(32) - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = (encoding + '').toLowerCase() - loweredCase = true - } + H.writeInt32BE(this._a, 0) + H.writeInt32BE(this._b, 4) + H.writeInt32BE(this._c, 8) + H.writeInt32BE(this._d, 12) + H.writeInt32BE(this._e, 16) + H.writeInt32BE(this._f, 20) + H.writeInt32BE(this._g, 24) + H.writeInt32BE(this._h, 28) + + return H } - } - Buffer.prototype.toString = function toString () { - var length = this.length | 0 - if (length === 0) return '' - if (arguments.length === 0) return utf8Slice(this, 0, length) - return slowToString.apply(this, arguments) - } + return Sha256 - Buffer.prototype.equals = function equals (b) { - if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return true - return Buffer.compare(this, b) === 0 } - Buffer.prototype.inspect = function inspect () { - var str = '' - var max = exports.INSPECT_MAX_BYTES - if (this.length > 0) { - str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') - if (this.length > max) str += ' ... ' - } - return '' - } - Buffer.prototype.compare = function compare (b) { - if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer') - if (this === b) return 0 - return Buffer.compare(this, b) - } +/***/ }, +/* 196 */ +/***/ function(module, exports, __webpack_require__) { - Buffer.prototype.indexOf = function indexOf (val, byteOffset) { - if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff - else if (byteOffset < -0x80000000) byteOffset = -0x80000000 - byteOffset >>= 0 + var inherits = __webpack_require__(188).inherits - if (this.length === 0) return -1 - if (byteOffset >= this.length) return -1 + module.exports = function (Buffer, Hash) { + var K = [ + 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, + 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, + 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, + 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, + 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, + 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, + 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, + 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, + 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, + 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, + 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, + 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, + 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, + 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, + 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, + 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, + 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, + 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, + 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, + 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, + 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, + 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, + 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, + 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, + 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, + 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, + 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, + 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, + 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, + 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, + 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, + 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, + 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, + 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, + 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, + 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, + 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, + 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, + 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, + 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 + ] - // Negative offsets start from the end of the buffer - if (byteOffset < 0) byteOffset = Math.max(this.length + byteOffset, 0) + var W = new Array(160) - if (typeof val === 'string') { - if (val.length === 0) return -1 // special case: looking for empty string always fails - return String.prototype.indexOf.call(this, val, byteOffset) - } - if (Buffer.isBuffer(val)) { - return arrayIndexOf(this, val, byteOffset) - } - if (typeof val === 'number') { - if (Buffer.TYPED_ARRAY_SUPPORT && Uint8Array.prototype.indexOf === 'function') { - return Uint8Array.prototype.indexOf.call(this, val, byteOffset) - } - return arrayIndexOf(this, [ val ], byteOffset) - } + function Sha512() { + this.init() + this._w = W - function arrayIndexOf (arr, val, byteOffset) { - var foundIndex = -1 - for (var i = 0; byteOffset + i < arr.length; i++) { - if (arr[byteOffset + i] === val[foundIndex === -1 ? 0 : i - foundIndex]) { - if (foundIndex === -1) foundIndex = i - if (i - foundIndex + 1 === val.length) return byteOffset + foundIndex - } else { - foundIndex = -1 - } - } - return -1 + Hash.call(this, 128, 112) } - throw new TypeError('val must be string, number or Buffer') - } + inherits(Sha512, Hash) - // `get` is deprecated - Buffer.prototype.get = function get (offset) { - console.log('.get() is deprecated. Access using array indexes instead.') - return this.readUInt8(offset) - } + Sha512.prototype.init = function () { - // `set` is deprecated - Buffer.prototype.set = function set (v, offset) { - console.log('.set() is deprecated. Access using array indexes instead.') - return this.writeUInt8(v, offset) - } + this._a = 0x6a09e667|0 + this._b = 0xbb67ae85|0 + this._c = 0x3c6ef372|0 + this._d = 0xa54ff53a|0 + this._e = 0x510e527f|0 + this._f = 0x9b05688c|0 + this._g = 0x1f83d9ab|0 + this._h = 0x5be0cd19|0 - function hexWrite (buf, string, offset, length) { - offset = Number(offset) || 0 - var remaining = buf.length - offset - if (!length) { - length = remaining - } else { - length = Number(length) - if (length > remaining) { - length = remaining - } - } + this._al = 0xf3bcc908|0 + this._bl = 0x84caa73b|0 + this._cl = 0xfe94f82b|0 + this._dl = 0x5f1d36f1|0 + this._el = 0xade682d1|0 + this._fl = 0x2b3e6c1f|0 + this._gl = 0xfb41bd6b|0 + this._hl = 0x137e2179|0 - // must be an even number of digits - var strLen = string.length - if (strLen % 2 !== 0) throw new Error('Invalid hex string') + this._len = this._s = 0 - if (length > strLen / 2) { - length = strLen / 2 + return this } - for (var i = 0; i < length; i++) { - var parsed = parseInt(string.substr(i * 2, 2), 16) - if (isNaN(parsed)) throw new Error('Invalid hex string') - buf[offset + i] = parsed + + function S (X, Xl, n) { + return (X >>> n) | (Xl << (32 - n)) } - return i - } - function utf8Write (buf, string, offset, length) { - return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length) - } + function Ch (x, y, z) { + return ((x & y) ^ ((~x) & z)); + } - function asciiWrite (buf, string, offset, length) { - return blitBuffer(asciiToBytes(string), buf, offset, length) - } + function Maj (x, y, z) { + return ((x & y) ^ (x & z) ^ (y & z)); + } - function binaryWrite (buf, string, offset, length) { - return asciiWrite(buf, string, offset, length) - } + Sha512.prototype._update = function(M) { - function base64Write (buf, string, offset, length) { - return blitBuffer(base64ToBytes(string), buf, offset, length) - } + var W = this._w + var a, b, c, d, e, f, g, h + var al, bl, cl, dl, el, fl, gl, hl - function ucs2Write (buf, string, offset, length) { - return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length) - } + a = this._a | 0 + b = this._b | 0 + c = this._c | 0 + d = this._d | 0 + e = this._e | 0 + f = this._f | 0 + g = this._g | 0 + h = this._h | 0 - Buffer.prototype.write = function write (string, offset, length, encoding) { - // Buffer#write(string) - if (offset === undefined) { - encoding = 'utf8' - length = this.length - offset = 0 - // Buffer#write(string, encoding) - } else if (length === undefined && typeof offset === 'string') { - encoding = offset - length = this.length - offset = 0 - // Buffer#write(string, offset[, length][, encoding]) - } else if (isFinite(offset)) { - offset = offset | 0 - if (isFinite(length)) { - length = length | 0 - if (encoding === undefined) encoding = 'utf8' - } else { - encoding = length - length = undefined - } - // legacy write(string, encoding, offset, length) - remove in v0.13 - } else { - var swap = encoding - encoding = offset - offset = length | 0 - length = swap - } + al = this._al | 0 + bl = this._bl | 0 + cl = this._cl | 0 + dl = this._dl | 0 + el = this._el | 0 + fl = this._fl | 0 + gl = this._gl | 0 + hl = this._hl | 0 - var remaining = this.length - offset - if (length === undefined || length > remaining) length = remaining + for (var i = 0; i < 80; i++) { + var j = i * 2 - if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) { - throw new RangeError('attempt to write outside buffer bounds') - } + var Wi, Wil - if (!encoding) encoding = 'utf8' + if (i < 16) { + Wi = W[j] = M.readInt32BE(j * 4) + Wil = W[j + 1] = M.readInt32BE(j * 4 + 4) - var loweredCase = false - for (;;) { - switch (encoding) { - case 'hex': - return hexWrite(this, string, offset, length) + } else { + var x = W[j - 15*2] + var xl = W[j - 15*2 + 1] + var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ (x >>> 7) + var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7) - case 'utf8': - case 'utf-8': - return utf8Write(this, string, offset, length) + x = W[j - 2*2] + xl = W[j - 2*2 + 1] + var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ (x >>> 6) + var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6) - case 'ascii': - return asciiWrite(this, string, offset, length) + // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] + var Wi7 = W[j - 7*2] + var Wi7l = W[j - 7*2 + 1] - case 'binary': - return binaryWrite(this, string, offset, length) + var Wi16 = W[j - 16*2] + var Wi16l = W[j - 16*2 + 1] - case 'base64': - // Warning: maxLength not taken into account in base64Write - return base64Write(this, string, offset, length) + Wil = gamma0l + Wi7l + Wi = gamma0 + Wi7 + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0) + Wil = Wil + gamma1l + Wi = Wi + gamma1 + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0) + Wil = Wil + Wi16l + Wi = Wi + Wi16 + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0) - case 'ucs2': - case 'ucs-2': - case 'utf16le': - case 'utf-16le': - return ucs2Write(this, string, offset, length) + W[j] = Wi + W[j + 1] = Wil + } - default: - if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding) - encoding = ('' + encoding).toLowerCase() - loweredCase = true - } - } - } + var maj = Maj(a, b, c) + var majl = Maj(al, bl, cl) - Buffer.prototype.toJSON = function toJSON () { - return { - type: 'Buffer', - data: Array.prototype.slice.call(this._arr || this, 0) - } - } + var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7) + var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7) + var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9) + var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9) - function base64Slice (buf, start, end) { - if (start === 0 && end === buf.length) { - return base64.fromByteArray(buf) - } else { - return base64.fromByteArray(buf.slice(start, end)) - } - } + // t1 = h + sigma1 + ch + K[i] + W[i] + var Ki = K[j] + var Kil = K[j + 1] - function utf8Slice (buf, start, end) { - end = Math.min(buf.length, end) - var res = [] + var ch = Ch(e, f, g) + var chl = Ch(el, fl, gl) - var i = start - while (i < end) { - var firstByte = buf[i] - var codePoint = null - var bytesPerSequence = (firstByte > 0xEF) ? 4 - : (firstByte > 0xDF) ? 3 - : (firstByte > 0xBF) ? 2 - : 1 + var t1l = hl + sigma1l + var t1 = h + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0) + t1l = t1l + chl + t1 = t1 + ch + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0) + t1l = t1l + Kil + t1 = t1 + Ki + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0) + t1l = t1l + Wil + t1 = t1 + Wi + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0) - if (i + bytesPerSequence <= end) { - var secondByte, thirdByte, fourthByte, tempCodePoint + // t2 = sigma0 + maj + var t2l = sigma0l + majl + var t2 = sigma0h + maj + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0) - switch (bytesPerSequence) { - case 1: - if (firstByte < 0x80) { - codePoint = firstByte - } - break - case 2: - secondByte = buf[i + 1] - if ((secondByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F) - if (tempCodePoint > 0x7F) { - codePoint = tempCodePoint - } - } - break - case 3: - secondByte = buf[i + 1] - thirdByte = buf[i + 2] - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F) - if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) { - codePoint = tempCodePoint - } - } - break - case 4: - secondByte = buf[i + 1] - thirdByte = buf[i + 2] - fourthByte = buf[i + 3] - if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) { - tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F) - if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) { - codePoint = tempCodePoint - } - } - } + h = g + hl = gl + g = f + gl = fl + f = e + fl = el + el = (dl + t1l) | 0 + e = (d + t1 + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0 + d = c + dl = cl + c = b + cl = bl + b = a + bl = al + al = (t1l + t2l) | 0 + a = (t1 + t2 + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0 } - if (codePoint === null) { - // we did not generate a valid codePoint so insert a - // replacement char (U+FFFD) and advance only 1 byte - codePoint = 0xFFFD - bytesPerSequence = 1 - } else if (codePoint > 0xFFFF) { - // encode to utf16 (surrogate pair dance) - codePoint -= 0x10000 - res.push(codePoint >>> 10 & 0x3FF | 0xD800) - codePoint = 0xDC00 | codePoint & 0x3FF - } + this._al = (this._al + al) | 0 + this._bl = (this._bl + bl) | 0 + this._cl = (this._cl + cl) | 0 + this._dl = (this._dl + dl) | 0 + this._el = (this._el + el) | 0 + this._fl = (this._fl + fl) | 0 + this._gl = (this._gl + gl) | 0 + this._hl = (this._hl + hl) | 0 - res.push(codePoint) - i += bytesPerSequence + this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0 + this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0 + this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0 + this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0 + this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0 + this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0 + this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0 + this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0 } - return decodeCodePointsArray(res) - } + Sha512.prototype._hash = function () { + var H = new Buffer(64) - // Based on http://stackoverflow.com/a/22747272/680742, the browser with - // the lowest limit is Chrome, with 0x10000 args. - // We go 1 magnitude less, for safety - var MAX_ARGUMENTS_LENGTH = 0x1000 + function writeInt64BE(h, l, offset) { + H.writeInt32BE(h, offset) + H.writeInt32BE(l, offset + 4) + } - function decodeCodePointsArray (codePoints) { - var len = codePoints.length - if (len <= MAX_ARGUMENTS_LENGTH) { - return String.fromCharCode.apply(String, codePoints) // avoid extra slice() - } + writeInt64BE(this._a, this._al, 0) + writeInt64BE(this._b, this._bl, 8) + writeInt64BE(this._c, this._cl, 16) + writeInt64BE(this._d, this._dl, 24) + writeInt64BE(this._e, this._el, 32) + writeInt64BE(this._f, this._fl, 40) + writeInt64BE(this._g, this._gl, 48) + writeInt64BE(this._h, this._hl, 56) - // Decode in chunks to avoid "call stack size exceeded". - var res = '' - var i = 0 - while (i < len) { - res += String.fromCharCode.apply( - String, - codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) - ) + return H } - return res - } - function asciiSlice (buf, start, end) { - var ret = '' - end = Math.min(buf.length, end) + return Sha512 - for (var i = start; i < end; i++) { - ret += String.fromCharCode(buf[i] & 0x7F) - } - return ret } - function binarySlice (buf, start, end) { - var ret = '' - end = Math.min(buf.length, end) - for (var i = start; i < end; i++) { - ret += String.fromCharCode(buf[i]) - } - return ret - } +/***/ }, +/* 197 */ +/***/ function(module, exports, __webpack_require__) { - function hexSlice (buf, start, end) { - var len = buf.length + /* + * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message + * Digest Algorithm, as defined in RFC 1321. + * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for more info. + */ - if (!start || start < 0) start = 0 - if (!end || end < 0 || end > len) end = len + var helpers = __webpack_require__(198); - var out = '' - for (var i = start; i < end; i++) { - out += toHex(buf[i]) - } - return out - } + /* + * Calculate the MD5 of an array of little-endian words, and a bit length + */ + function core_md5(x, len) + { + /* append padding */ + x[len >> 5] |= 0x80 << ((len) % 32); + x[(((len + 64) >>> 9) << 4) + 14] = len; - function utf16leSlice (buf, start, end) { - var bytes = buf.slice(start, end) - var res = '' - for (var i = 0; i < bytes.length; i += 2) { - res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256) - } - return res - } + var a = 1732584193; + var b = -271733879; + var c = -1732584194; + var d = 271733878; - Buffer.prototype.slice = function slice (start, end) { - var len = this.length - start = ~~start - end = end === undefined ? len : ~~end + for(var i = 0; i < x.length; i += 16) + { + var olda = a; + var oldb = b; + var oldc = c; + var oldd = d; - if (start < 0) { - start += len - if (start < 0) start = 0 - } else if (start > len) { - start = len - } + a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936); + d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586); + c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819); + b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330); + a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897); + d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426); + c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341); + b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983); + a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416); + d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417); + c = md5_ff(c, d, a, b, x[i+10], 17, -42063); + b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162); + a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682); + d = md5_ff(d, a, b, c, x[i+13], 12, -40341101); + c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290); + b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329); - if (end < 0) { - end += len - if (end < 0) end = 0 - } else if (end > len) { - end = len - } + a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510); + d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632); + c = md5_gg(c, d, a, b, x[i+11], 14, 643717713); + b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302); + a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691); + d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083); + c = md5_gg(c, d, a, b, x[i+15], 14, -660478335); + b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848); + a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438); + d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690); + c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961); + b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501); + a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467); + d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784); + c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473); + b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734); - if (end < start) end = start + a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558); + d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463); + c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562); + b = md5_hh(b, c, d, a, x[i+14], 23, -35309556); + a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060); + d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353); + c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632); + b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640); + a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174); + d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222); + c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979); + b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189); + a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487); + d = md5_hh(d, a, b, c, x[i+12], 11, -421815835); + c = md5_hh(c, d, a, b, x[i+15], 16, 530742520); + b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651); - var newBuf - if (Buffer.TYPED_ARRAY_SUPPORT) { - newBuf = Buffer._augment(this.subarray(start, end)) - } else { - var sliceLen = end - start - newBuf = new Buffer(sliceLen, undefined) - for (var i = 0; i < sliceLen; i++) { - newBuf[i] = this[i + start] - } + a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844); + d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415); + c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905); + b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055); + a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571); + d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606); + c = md5_ii(c, d, a, b, x[i+10], 15, -1051523); + b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799); + a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359); + d = md5_ii(d, a, b, c, x[i+15], 10, -30611744); + c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380); + b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649); + a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070); + d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379); + c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259); + b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551); + + a = safe_add(a, olda); + b = safe_add(b, oldb); + c = safe_add(c, oldc); + d = safe_add(d, oldd); } + return Array(a, b, c, d); - if (newBuf.length) newBuf.parent = this.parent || this + } - return newBuf + /* + * These functions implement the four basic operations the algorithm uses. + */ + function md5_cmn(q, a, b, x, s, t) + { + return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b); + } + function md5_ff(a, b, c, d, x, s, t) + { + return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t); + } + function md5_gg(a, b, c, d, x, s, t) + { + return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t); + } + function md5_hh(a, b, c, d, x, s, t) + { + return md5_cmn(b ^ c ^ d, a, b, x, s, t); + } + function md5_ii(a, b, c, d, x, s, t) + { + return md5_cmn(c ^ (b | (~d)), a, b, x, s, t); } /* - * Need to make sure that buffer isn't trying to write out of bounds. + * Add integers, wrapping at 2^32. This uses 16-bit operations internally + * to work around bugs in some JS interpreters. */ - function checkOffset (offset, ext, length) { - if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint') - if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length') + function safe_add(x, y) + { + var lsw = (x & 0xFFFF) + (y & 0xFFFF); + var msw = (x >> 16) + (y >> 16) + (lsw >> 16); + return (msw << 16) | (lsw & 0xFFFF); } - Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) + /* + * Bitwise rotate a 32-bit number to the left. + */ + function bit_rol(num, cnt) + { + return (num << cnt) | (num >>> (32 - cnt)); + } + + module.exports = function md5(buf) { + return helpers.hash(buf, core_md5, 16); + }; + - var val = this[offset] - var mul = 1 - var i = 0 - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul - } +/***/ }, +/* 198 */ +/***/ function(module, exports, __webpack_require__) { - return val - } + /* WEBPACK VAR INJECTION */(function(Buffer) {var intSize = 4; + var zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0); + var chrsz = 8; - Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) { - checkOffset(offset, byteLength, this.length) + function toArray(buf, bigEndian) { + if ((buf.length % intSize) !== 0) { + var len = buf.length + (intSize - (buf.length % intSize)); + buf = Buffer.concat([buf, zeroBuffer], len); } - var val = this[offset + --byteLength] - var mul = 1 - while (byteLength > 0 && (mul *= 0x100)) { - val += this[offset + --byteLength] * mul + var arr = []; + var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE; + for (var i = 0; i < buf.length; i += intSize) { + arr.push(fn.call(buf, i)); } - - return val + return arr; } - Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length) - return this[offset] + function toBuffer(arr, size, bigEndian) { + var buf = new Buffer(size); + var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE; + for (var i = 0; i < arr.length; i++) { + fn.call(buf, arr[i], i * 4, true); + } + return buf; } - Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - return this[offset] | (this[offset + 1] << 8) + function hash(buf, fn, hashSize, bigEndian) { + if (!Buffer.isBuffer(buf)) buf = new Buffer(buf); + var arr = fn(toArray(buf, bigEndian), buf.length * chrsz); + return toBuffer(arr, hashSize, bigEndian); } - Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - return (this[offset] << 8) | this[offset + 1] - } + module.exports = { hash: hash }; - Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - return ((this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16)) + - (this[offset + 3] * 0x1000000) - } +/***/ }, +/* 199 */ +/***/ function(module, exports, __webpack_require__) { - Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + /* WEBPACK VAR INJECTION */(function(Buffer) { + module.exports = ripemd160 - return (this[offset] * 0x1000000) + - ((this[offset + 1] << 16) | - (this[offset + 2] << 8) | - this[offset + 3]) - } - Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) - var val = this[offset] - var mul = 1 - var i = 0 - while (++i < byteLength && (mul *= 0x100)) { - val += this[offset + i] * mul - } - mul *= 0x80 + /* + CryptoJS v3.1.2 + code.google.com/p/crypto-js + (c) 2009-2013 by Jeff Mott. All rights reserved. + code.google.com/p/crypto-js/wiki/License + */ + /** @preserve + (c) 2012 by Cédric Mesnil. All rights reserved. - if (val >= mul) val -= Math.pow(2, 8 * byteLength) + Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - return val - } + - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. + - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) { - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkOffset(offset, byteLength, this.length) + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ - var i = byteLength - var mul = 1 - var val = this[offset + --i] - while (i > 0 && (mul *= 0x100)) { - val += this[offset + --i] * mul - } - mul *= 0x80 + // Constants table + var zl = [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, + 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12, + 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, + 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13]; + var zr = [ + 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, + 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, + 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13, + 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14, + 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11]; + var sl = [ + 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, + 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, + 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5, + 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12, + 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ]; + var sr = [ + 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, + 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, + 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5, + 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8, + 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ]; - if (val >= mul) val -= Math.pow(2, 8 * byteLength) + var hl = [ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E]; + var hr = [ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000]; - return val - } + var bytesToWords = function (bytes) { + var words = []; + for (var i = 0, b = 0; i < bytes.length; i++, b += 8) { + words[b >>> 5] |= bytes[i] << (24 - b % 32); + } + return words; + }; - Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) { - if (!noAssert) checkOffset(offset, 1, this.length) - if (!(this[offset] & 0x80)) return (this[offset]) - return ((0xff - this[offset] + 1) * -1) - } + var wordsToBytes = function (words) { + var bytes = []; + for (var b = 0; b < words.length * 32; b += 8) { + bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF); + } + return bytes; + }; - Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - var val = this[offset] | (this[offset + 1] << 8) - return (val & 0x8000) ? val | 0xFFFF0000 : val - } + var processBlock = function (H, M, offset) { - Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 2, this.length) - var val = this[offset + 1] | (this[offset] << 8) - return (val & 0x8000) ? val | 0xFFFF0000 : val - } + // Swap endian + for (var i = 0; i < 16; i++) { + var offset_i = offset + i; + var M_offset_i = M[offset_i]; - Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + // Swap + M[offset_i] = ( + (((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) | + (((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00) + ); + } - return (this[offset]) | - (this[offset + 1] << 8) | - (this[offset + 2] << 16) | - (this[offset + 3] << 24) - } + // Working variables + var al, bl, cl, dl, el; + var ar, br, cr, dr, er; - Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) + ar = al = H[0]; + br = bl = H[1]; + cr = cl = H[2]; + dr = dl = H[3]; + er = el = H[4]; + // Computation + var t; + for (var i = 0; i < 80; i += 1) { + t = (al + M[offset+zl[i]])|0; + if (i<16){ + t += f1(bl,cl,dl) + hl[0]; + } else if (i<32) { + t += f2(bl,cl,dl) + hl[1]; + } else if (i<48) { + t += f3(bl,cl,dl) + hl[2]; + } else if (i<64) { + t += f4(bl,cl,dl) + hl[3]; + } else {// if (i<80) { + t += f5(bl,cl,dl) + hl[4]; + } + t = t|0; + t = rotl(t,sl[i]); + t = (t+el)|0; + al = el; + el = dl; + dl = rotl(cl, 10); + cl = bl; + bl = t; - return (this[offset] << 24) | - (this[offset + 1] << 16) | - (this[offset + 2] << 8) | - (this[offset + 3]) - } + t = (ar + M[offset+zr[i]])|0; + if (i<16){ + t += f5(br,cr,dr) + hr[0]; + } else if (i<32) { + t += f4(br,cr,dr) + hr[1]; + } else if (i<48) { + t += f3(br,cr,dr) + hr[2]; + } else if (i<64) { + t += f2(br,cr,dr) + hr[3]; + } else {// if (i<80) { + t += f1(br,cr,dr) + hr[4]; + } + t = t|0; + t = rotl(t,sr[i]) ; + t = (t+er)|0; + ar = er; + er = dr; + dr = rotl(cr, 10); + cr = br; + br = t; + } + // Intermediate hash value + t = (H[1] + cl + dr)|0; + H[1] = (H[2] + dl + er)|0; + H[2] = (H[3] + el + ar)|0; + H[3] = (H[4] + al + br)|0; + H[4] = (H[0] + bl + cr)|0; + H[0] = t; + }; - Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) - return ieee754.read(this, offset, true, 23, 4) + function f1(x, y, z) { + return ((x) ^ (y) ^ (z)); } - Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 4, this.length) - return ieee754.read(this, offset, false, 23, 4) + function f2(x, y, z) { + return (((x)&(y)) | ((~x)&(z))); } - Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length) - return ieee754.read(this, offset, true, 52, 8) + function f3(x, y, z) { + return (((x) | (~(y))) ^ (z)); } - Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { - if (!noAssert) checkOffset(offset, 8, this.length) - return ieee754.read(this, offset, false, 52, 8) + function f4(x, y, z) { + return (((x) & (z)) | ((y)&(~(z)))); } - function checkInt (buf, value, offset, ext, max, min) { - if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance') - if (value > max || value < min) throw new RangeError('value is out of bounds') - if (offset + ext > buf.length) throw new RangeError('index out of range') + function f5(x, y, z) { + return ((x) ^ ((y) |(~(z)))); } - Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) - - var mul = 1 - var i = 0 - this[offset] = value & 0xFF - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF - } - - return offset + byteLength + function rotl(x,n) { + return (x<>>(32-n)); } - Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - byteLength = byteLength | 0 - if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0) - - var i = byteLength - 1 - var mul = 1 - this[offset + i] = value & 0xFF - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = (value / mul) & 0xFF - } + function ripemd160(message) { + var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0]; - return offset + byteLength - } + if (typeof message == 'string') + message = new Buffer(message, 'utf8'); - Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0) - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) - this[offset] = (value & 0xff) - return offset + 1 - } + var m = bytesToWords(message); - function objectWriteUInt16 (buf, value, offset, littleEndian) { - if (value < 0) value = 0xffff + value + 1 - for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) { - buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> - (littleEndian ? i : 1 - i) * 8 - } - } + var nBitsLeft = message.length * 8; + var nBitsTotal = message.length * 8; - Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - } else { - objectWriteUInt16(this, value, offset, true) - } - return offset + 2 - } + // Add padding + m[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32); + m[(((nBitsLeft + 64) >>> 9) << 4) + 14] = ( + (((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) | + (((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00) + ); - Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8) - this[offset + 1] = (value & 0xff) - } else { - objectWriteUInt16(this, value, offset, false) + for (var i=0 ; i>> (littleEndian ? i : 3 - i) * 8) & 0xff - } - } + // Swap endian + for (var i = 0; i < 5; i++) { + // Shortcut + var H_i = H[i]; - Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset + 3] = (value >>> 24) - this[offset + 2] = (value >>> 16) - this[offset + 1] = (value >>> 8) - this[offset] = (value & 0xff) - } else { - objectWriteUInt32(this, value, offset, true) + // Swap + H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) | + (((H_i << 24) | (H_i >>> 8)) & 0xff00ff00); } - return offset + 4 - } - Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24) - this[offset + 1] = (value >>> 16) - this[offset + 2] = (value >>> 8) - this[offset + 3] = (value & 0xff) - } else { - objectWriteUInt32(this, value, offset, false) - } - return offset + 4 + var digestbytes = wordsToBytes(H); + return new Buffer(digestbytes); } - Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1) - checkInt(this, value, offset, byteLength, limit - 1, -limit) - } - var i = 0 - var mul = 1 - var sub = value < 0 ? 1 : 0 - this[offset] = value & 0xFF - while (++i < byteLength && (mul *= 0x100)) { - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF - } + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - return offset + byteLength - } +/***/ }, +/* 200 */ +/***/ function(module, exports, __webpack_require__) { - Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) { - var limit = Math.pow(2, 8 * byteLength - 1) + /* WEBPACK VAR INJECTION */(function(Buffer) {var createHash = __webpack_require__(184) - checkInt(this, value, offset, byteLength, limit - 1, -limit) - } + var zeroBuffer = new Buffer(128) + zeroBuffer.fill(0) - var i = byteLength - 1 - var mul = 1 - var sub = value < 0 ? 1 : 0 - this[offset + i] = value & 0xFF - while (--i >= 0 && (mul *= 0x100)) { - this[offset + i] = ((value / mul) >> 0) - sub & 0xFF - } + module.exports = Hmac - return offset + byteLength - } + function Hmac (alg, key) { + if(!(this instanceof Hmac)) return new Hmac(alg, key) + this._opad = opad + this._alg = alg - Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80) - if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) - if (value < 0) value = 0xff + value + 1 - this[offset] = (value & 0xff) - return offset + 1 - } + var blocksize = (alg === 'sha512') ? 128 : 64 - Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - } else { - objectWriteUInt16(this, value, offset, true) - } - return offset + 2 - } + key = this._key = !Buffer.isBuffer(key) ? new Buffer(key) : key - Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 8) - this[offset + 1] = (value & 0xff) - } else { - objectWriteUInt16(this, value, offset, false) + if(key.length > blocksize) { + key = createHash(alg).update(key).digest() + } else if(key.length < blocksize) { + key = Buffer.concat([key, zeroBuffer], blocksize) } - return offset + 2 - } - Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value & 0xff) - this[offset + 1] = (value >>> 8) - this[offset + 2] = (value >>> 16) - this[offset + 3] = (value >>> 24) - } else { - objectWriteUInt32(this, value, offset, true) - } - return offset + 4 - } + var ipad = this._ipad = new Buffer(blocksize) + var opad = this._opad = new Buffer(blocksize) - Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) { - value = +value - offset = offset | 0 - if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) - if (value < 0) value = 0xffffffff + value + 1 - if (Buffer.TYPED_ARRAY_SUPPORT) { - this[offset] = (value >>> 24) - this[offset + 1] = (value >>> 16) - this[offset + 2] = (value >>> 8) - this[offset + 3] = (value & 0xff) - } else { - objectWriteUInt32(this, value, offset, false) - } - return offset + 4 - } + for(var i = 0; i < blocksize; i++) { + ipad[i] = key[i] ^ 0x36 + opad[i] = key[i] ^ 0x5C + } - function checkIEEE754 (buf, value, offset, ext, max, min) { - if (value > max || value < min) throw new RangeError('value is out of bounds') - if (offset + ext > buf.length) throw new RangeError('index out of range') - if (offset < 0) throw new RangeError('index out of range') + this._hash = createHash(alg).update(ipad) } - function writeFloat (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38) - } - ieee754.write(buf, value, offset, littleEndian, 23, 4) - return offset + 4 + Hmac.prototype.update = function (data, enc) { + this._hash.update(data, enc) + return this } - Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) { - return writeFloat(this, value, offset, true, noAssert) + Hmac.prototype.digest = function (enc) { + var h = this._hash.digest() + return createHash(this._alg).update(this._opad).update(h).digest(enc) } - Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) { - return writeFloat(this, value, offset, false, noAssert) - } - function writeDouble (buf, value, offset, littleEndian, noAssert) { - if (!noAssert) { - checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308) - } - ieee754.write(buf, value, offset, littleEndian, 52, 8) - return offset + 8 - } + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) { - return writeDouble(this, value, offset, true, noAssert) - } +/***/ }, +/* 201 */ +/***/ function(module, exports, __webpack_require__) { - Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) { - return writeDouble(this, value, offset, false, noAssert) - } + var pbkdf2Export = __webpack_require__(202) - // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length) - Buffer.prototype.copy = function copy (target, targetStart, start, end) { - if (!start) start = 0 - if (!end && end !== 0) end = this.length - if (targetStart >= target.length) targetStart = target.length - if (!targetStart) targetStart = 0 - if (end > 0 && end < start) end = start + module.exports = function (crypto, exports) { + exports = exports || {} - // Copy 0 bytes; we're done - if (end === start) return 0 - if (target.length === 0 || this.length === 0) return 0 + var exported = pbkdf2Export(crypto) - // Fatal error conditions - if (targetStart < 0) { - throw new RangeError('targetStart out of bounds') - } - if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds') - if (end < 0) throw new RangeError('sourceEnd out of bounds') + exports.pbkdf2 = exported.pbkdf2 + exports.pbkdf2Sync = exported.pbkdf2Sync - // Are we oob? - if (end > this.length) end = this.length - if (target.length - targetStart < end - start) { - end = target.length - targetStart + start - } + return exports + } - var len = end - start - var i - if (this === target && start < targetStart && targetStart < end) { - // descending copy from end - for (i = len - 1; i >= 0; i--) { - target[i + targetStart] = this[i + start] - } - } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { - // ascending copy from start - for (i = 0; i < len; i++) { - target[i + targetStart] = this[i + start] +/***/ }, +/* 202 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(Buffer) {module.exports = function(crypto) { + function pbkdf2(password, salt, iterations, keylen, digest, callback) { + if ('function' === typeof digest) { + callback = digest + digest = undefined } - } else { - target._set(this.subarray(start, start + len), targetStart) + + if ('function' !== typeof callback) + throw new Error('No callback provided to pbkdf2') + + setTimeout(function() { + var result + + try { + result = pbkdf2Sync(password, salt, iterations, keylen, digest) + } catch (e) { + return callback(e) + } + + callback(undefined, result) + }) } - return len - } + function pbkdf2Sync(password, salt, iterations, keylen, digest) { + if ('number' !== typeof iterations) + throw new TypeError('Iterations not a number') - // fill(value, start=0, end=buffer.length) - Buffer.prototype.fill = function fill (value, start, end) { - if (!value) value = 0 - if (!start) start = 0 - if (!end) end = this.length + if (iterations < 0) + throw new TypeError('Bad iterations') - if (end < start) throw new RangeError('end < start') + if ('number' !== typeof keylen) + throw new TypeError('Key length not a number') - // Fill 0 bytes; we're done - if (end === start) return - if (this.length === 0) return + if (keylen < 0) + throw new TypeError('Bad key length') - if (start < 0 || start >= this.length) throw new RangeError('start out of bounds') - if (end < 0 || end > this.length) throw new RangeError('end out of bounds') + digest = digest || 'sha1' - var i - if (typeof value === 'number') { - for (i = start; i < end; i++) { - this[i] = value - } - } else { - var bytes = utf8ToBytes(value.toString()) - var len = bytes.length - for (i = start; i < end; i++) { - this[i] = bytes[i % len] - } - } + if (!Buffer.isBuffer(password)) password = new Buffer(password) + if (!Buffer.isBuffer(salt)) salt = new Buffer(salt) - return this - } + var hLen, l = 1, r, T + var DK = new Buffer(keylen) + var block1 = new Buffer(salt.length + 4) + salt.copy(block1, 0, 0, salt.length) - /** - * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance. - * Added in Node 0.12. Only available in browsers that support ArrayBuffer. - */ - Buffer.prototype.toArrayBuffer = function toArrayBuffer () { - if (typeof Uint8Array !== 'undefined') { - if (Buffer.TYPED_ARRAY_SUPPORT) { - return (new Buffer(this)).buffer - } else { - var buf = new Uint8Array(this.length) - for (var i = 0, len = buf.length; i < len; i += 1) { - buf[i] = this[i] + for (var i = 1; i <= l; i++) { + block1.writeUInt32BE(i, salt.length) + + var U = crypto.createHmac(digest, password).update(block1).digest() + + if (!hLen) { + hLen = U.length + T = new Buffer(hLen) + l = Math.ceil(keylen / hLen) + r = keylen - (l - 1) * hLen + + if (keylen > (Math.pow(2, 32) - 1) * hLen) + throw new TypeError('keylen exceeds maximum length') + } + + U.copy(T, 0, 0, hLen) + + for (var j = 1; j < iterations; j++) { + U = crypto.createHmac(digest, password).update(U).digest() + + for (var k = 0; k < hLen; k++) { + T[k] ^= U[k] + } } - return buf.buffer + + var destPos = (i - 1) * hLen + var len = (i == l ? r : hLen) + T.copy(DK, destPos, 0, len) } - } else { - throw new TypeError('Buffer.toArrayBuffer not supported in this browser') + + return DK + } + + return { + pbkdf2: pbkdf2, + pbkdf2Sync: pbkdf2Sync } } - // HELPER FUNCTIONS - // ================ + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - var BP = Buffer.prototype - - /** - * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods - */ - Buffer._augment = function _augment (arr) { - arr.constructor = Buffer - arr._isBuffer = true - - // save reference to original Uint8Array set method before overwriting - arr._set = arr.set - - // deprecated - arr.get = BP.get - arr.set = BP.set - - arr.write = BP.write - arr.toString = BP.toString - arr.toLocaleString = BP.toString - arr.toJSON = BP.toJSON - arr.equals = BP.equals - arr.compare = BP.compare - arr.indexOf = BP.indexOf - arr.copy = BP.copy - arr.slice = BP.slice - arr.readUIntLE = BP.readUIntLE - arr.readUIntBE = BP.readUIntBE - arr.readUInt8 = BP.readUInt8 - arr.readUInt16LE = BP.readUInt16LE - arr.readUInt16BE = BP.readUInt16BE - arr.readUInt32LE = BP.readUInt32LE - arr.readUInt32BE = BP.readUInt32BE - arr.readIntLE = BP.readIntLE - arr.readIntBE = BP.readIntBE - arr.readInt8 = BP.readInt8 - arr.readInt16LE = BP.readInt16LE - arr.readInt16BE = BP.readInt16BE - arr.readInt32LE = BP.readInt32LE - arr.readInt32BE = BP.readInt32BE - arr.readFloatLE = BP.readFloatLE - arr.readFloatBE = BP.readFloatBE - arr.readDoubleLE = BP.readDoubleLE - arr.readDoubleBE = BP.readDoubleBE - arr.writeUInt8 = BP.writeUInt8 - arr.writeUIntLE = BP.writeUIntLE - arr.writeUIntBE = BP.writeUIntBE - arr.writeUInt16LE = BP.writeUInt16LE - arr.writeUInt16BE = BP.writeUInt16BE - arr.writeUInt32LE = BP.writeUInt32LE - arr.writeUInt32BE = BP.writeUInt32BE - arr.writeIntLE = BP.writeIntLE - arr.writeIntBE = BP.writeIntBE - arr.writeInt8 = BP.writeInt8 - arr.writeInt16LE = BP.writeInt16LE - arr.writeInt16BE = BP.writeInt16BE - arr.writeInt32LE = BP.writeInt32LE - arr.writeInt32BE = BP.writeInt32BE - arr.writeFloatLE = BP.writeFloatLE - arr.writeFloatBE = BP.writeFloatBE - arr.writeDoubleLE = BP.writeDoubleLE - arr.writeDoubleBE = BP.writeDoubleBE - arr.fill = BP.fill - arr.inspect = BP.inspect - arr.toArrayBuffer = BP.toArrayBuffer +/***/ }, +/* 203 */ +/***/ function(module, exports, __webpack_require__) { - return arr - } + module.exports = function (crypto, exports) { + exports = exports || {}; + var ciphers = __webpack_require__(204)(crypto); + exports.createCipher = ciphers.createCipher; + exports.createCipheriv = ciphers.createCipheriv; + var deciphers = __webpack_require__(235)(crypto); + exports.createDecipher = deciphers.createDecipher; + exports.createDecipheriv = deciphers.createDecipheriv; + var modes = __webpack_require__(226); + function listCiphers () { + return Object.keys(modes); + } + exports.listCiphers = listCiphers; + }; - var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g - function base64clean (str) { - // Node strips out invalid characters like \n and \t from the string, base64-js does not - str = stringtrim(str).replace(INVALID_BASE64_RE, '') - // Node converts strings with length < 2 to '' - if (str.length < 2) return '' - // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not - while (str.length % 4 !== 0) { - str = str + '=' + +/***/ }, +/* 204 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(Buffer) {var aes = __webpack_require__(205); + var Transform = __webpack_require__(206); + var inherits = __webpack_require__(194); + var modes = __webpack_require__(226); + var ebtk = __webpack_require__(227); + var StreamCipher = __webpack_require__(228); + inherits(Cipher, Transform); + function Cipher(mode, key, iv) { + if (!(this instanceof Cipher)) { + return new Cipher(mode, key, iv); + } + Transform.call(this); + this._cache = new Splitter(); + this._cipher = new aes.AES(key); + this._prev = new Buffer(iv.length); + iv.copy(this._prev); + this._mode = mode; + } + Cipher.prototype._transform = function (data, _, next) { + this._cache.add(data); + var chunk; + var thing; + while ((chunk = this._cache.get())) { + thing = this._mode.encrypt(this, chunk); + this.push(thing); + } + next(); + }; + Cipher.prototype._flush = function (next) { + var chunk = this._cache.flush(); + this.push(this._mode.encrypt(this, chunk)); + this._cipher.scrub(); + next(); + }; + + + function Splitter() { + if (!(this instanceof Splitter)) { + return new Splitter(); } - return str + this.cache = new Buffer(''); } + Splitter.prototype.add = function (data) { + this.cache = Buffer.concat([this.cache, data]); + }; - function stringtrim (str) { - if (str.trim) return str.trim() - return str.replace(/^\s+|\s+$/g, '') - } + Splitter.prototype.get = function () { + if (this.cache.length > 15) { + var out = this.cache.slice(0, 16); + this.cache = this.cache.slice(16); + return out; + } + return null; + }; + Splitter.prototype.flush = function () { + var len = 16 - this.cache.length; + var padBuff = new Buffer(len); - function toHex (n) { - if (n < 16) return '0' + n.toString(16) - return n.toString(16) - } + var i = -1; + while (++i < len) { + padBuff.writeUInt8(len, i); + } + var out = Buffer.concat([this.cache, padBuff]); + return out; + }; + var modelist = { + ECB: __webpack_require__(229), + CBC: __webpack_require__(230), + CFB: __webpack_require__(232), + OFB: __webpack_require__(233), + CTR: __webpack_require__(234) + }; + module.exports = function (crypto) { + function createCipheriv(suite, password, iv) { + var config = modes[suite]; + if (!config) { + throw new TypeError('invalid suite type'); + } + if (typeof iv === 'string') { + iv = new Buffer(iv); + } + if (typeof password === 'string') { + password = new Buffer(password); + } + if (password.length !== config.key/8) { + throw new TypeError('invalid key length ' + password.length); + } + if (iv.length !== config.iv) { + throw new TypeError('invalid iv length ' + iv.length); + } + if (config.type === 'stream') { + return new StreamCipher(modelist[config.mode], password, iv); + } + return new Cipher(modelist[config.mode], password, iv); + } + function createCipher (suite, password) { + var config = modes[suite]; + if (!config) { + throw new TypeError('invalid suite type'); + } + var keys = ebtk(crypto, password, config.key, config.iv); + return createCipheriv(suite, keys.key, keys.iv); + } + return { + createCipher: createCipher, + createCipheriv: createCipheriv + }; + }; - function utf8ToBytes (string, units) { - units = units || Infinity - var codePoint - var length = string.length - var leadSurrogate = null - var bytes = [] + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - for (var i = 0; i < length; i++) { - codePoint = string.charCodeAt(i) +/***/ }, +/* 205 */ +/***/ function(module, exports, __webpack_require__) { - // is surrogate component - if (codePoint > 0xD7FF && codePoint < 0xE000) { - // last char was a lead - if (!leadSurrogate) { - // no lead yet - if (codePoint > 0xDBFF) { - // unexpected trail - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - continue - } else if (i + 1 === length) { - // unpaired lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - continue - } + /* WEBPACK VAR INJECTION */(function(Buffer) {var uint_max = Math.pow(2, 32); + function fixup_uint32(x) { + var ret, x_pos; + ret = x > uint_max || x < 0 ? (x_pos = Math.abs(x) % uint_max, x < 0 ? uint_max - x_pos : x_pos) : x; + return ret; + } + function scrub_vec(v) { + var i, _i, _ref; + for (i = _i = 0, _ref = v.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) { + v[i] = 0; + } + return false; + } + + function Global() { + var i; + this.SBOX = []; + this.INV_SBOX = []; + this.SUB_MIX = (function() { + var _i, _results; + _results = []; + for (i = _i = 0; _i < 4; i = ++_i) { + _results.push([]); + } + return _results; + })(); + this.INV_SUB_MIX = (function() { + var _i, _results; + _results = []; + for (i = _i = 0; _i < 4; i = ++_i) { + _results.push([]); + } + return _results; + })(); + this.init(); + this.RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; + } + + Global.prototype.init = function() { + var d, i, sx, t, x, x2, x4, x8, xi, _i; + d = (function() { + var _i, _results; + _results = []; + for (i = _i = 0; _i < 256; i = ++_i) { + if (i < 128) { + _results.push(i << 1); + } else { + _results.push((i << 1) ^ 0x11b); + } + } + return _results; + })(); + x = 0; + xi = 0; + for (i = _i = 0; _i < 256; i = ++_i) { + sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4); + sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63; + this.SBOX[x] = sx; + this.INV_SBOX[sx] = x; + x2 = d[x]; + x4 = d[x2]; + x8 = d[x4]; + t = (d[sx] * 0x101) ^ (sx * 0x1010100); + this.SUB_MIX[0][x] = (t << 24) | (t >>> 8); + this.SUB_MIX[1][x] = (t << 16) | (t >>> 16); + this.SUB_MIX[2][x] = (t << 8) | (t >>> 24); + this.SUB_MIX[3][x] = t; + t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100); + this.INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8); + this.INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16); + this.INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24); + this.INV_SUB_MIX[3][sx] = t; + if (x === 0) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + return true; + }; - // valid lead - leadSurrogate = codePoint + var G = new Global(); - continue - } - // 2 leads in a row - if (codePoint < 0xDC00) { - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - leadSurrogate = codePoint - continue - } + AES.blockSize = 4 * 4; - // valid surrogate pair - codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000 - } else if (leadSurrogate) { - // valid bmp char, but last char was a lead - if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD) - } + AES.prototype.blockSize = AES.blockSize; - leadSurrogate = null + AES.keySize = 256 / 8; - // encode utf8 - if (codePoint < 0x80) { - if ((units -= 1) < 0) break - bytes.push(codePoint) - } else if (codePoint < 0x800) { - if ((units -= 2) < 0) break - bytes.push( - codePoint >> 0x6 | 0xC0, - codePoint & 0x3F | 0x80 - ) - } else if (codePoint < 0x10000) { - if ((units -= 3) < 0) break - bytes.push( - codePoint >> 0xC | 0xE0, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ) - } else if (codePoint < 0x110000) { - if ((units -= 4) < 0) break - bytes.push( - codePoint >> 0x12 | 0xF0, - codePoint >> 0xC & 0x3F | 0x80, - codePoint >> 0x6 & 0x3F | 0x80, - codePoint & 0x3F | 0x80 - ) - } else { - throw new Error('Invalid code point') - } - } + AES.prototype.keySize = AES.keySize; - return bytes - } + AES.ivSize = AES.blockSize; - function asciiToBytes (str) { - var byteArray = [] - for (var i = 0; i < str.length; i++) { - // Node's code seems to be doing this and not & 0x7F.. - byteArray.push(str.charCodeAt(i) & 0xFF) + AES.prototype.ivSize = AES.ivSize; + + function bufferToArray(buf) { + var len = buf.length/4; + var out = new Array(len); + var i = -1; + while (++i < len) { + out[i] = buf.readUInt32BE(i * 4); } - return byteArray + return out; + } + function AES(key) { + this._key = bufferToArray(key); + this._doReset(); } - function utf16leToBytes (str, units) { - var c, hi, lo - var byteArray = [] - for (var i = 0; i < str.length; i++) { - if ((units -= 2) < 0) break - - c = str.charCodeAt(i) - hi = c >> 8 - lo = c % 256 - byteArray.push(lo) - byteArray.push(hi) + AES.prototype._doReset = function() { + var invKsRow, keySize, keyWords, ksRow, ksRows, t, _i, _j; + keyWords = this._key; + keySize = keyWords.length; + this._nRounds = keySize + 6; + ksRows = (this._nRounds + 1) * 4; + this._keySchedule = []; + for (ksRow = _i = 0; 0 <= ksRows ? _i < ksRows : _i > ksRows; ksRow = 0 <= ksRows ? ++_i : --_i) { + this._keySchedule[ksRow] = ksRow < keySize ? keyWords[ksRow] : (t = this._keySchedule[ksRow - 1], (ksRow % keySize) === 0 ? (t = (t << 8) | (t >>> 24), t = (G.SBOX[t >>> 24] << 24) | (G.SBOX[(t >>> 16) & 0xff] << 16) | (G.SBOX[(t >>> 8) & 0xff] << 8) | G.SBOX[t & 0xff], t ^= G.RCON[(ksRow / keySize) | 0] << 24) : keySize > 6 && ksRow % keySize === 4 ? t = (G.SBOX[t >>> 24] << 24) | (G.SBOX[(t >>> 16) & 0xff] << 16) | (G.SBOX[(t >>> 8) & 0xff] << 8) | G.SBOX[t & 0xff] : void 0, this._keySchedule[ksRow - keySize] ^ t); + } + this._invKeySchedule = []; + for (invKsRow = _j = 0; 0 <= ksRows ? _j < ksRows : _j > ksRows; invKsRow = 0 <= ksRows ? ++_j : --_j) { + ksRow = ksRows - invKsRow; + t = this._keySchedule[ksRow - (invKsRow % 4 ? 0 : 4)]; + this._invKeySchedule[invKsRow] = invKsRow < 4 || ksRow <= 4 ? t : G.INV_SUB_MIX[0][G.SBOX[t >>> 24]] ^ G.INV_SUB_MIX[1][G.SBOX[(t >>> 16) & 0xff]] ^ G.INV_SUB_MIX[2][G.SBOX[(t >>> 8) & 0xff]] ^ G.INV_SUB_MIX[3][G.SBOX[t & 0xff]]; } + return true; + }; - return byteArray - } + AES.prototype.encryptBlock = function(M) { + M = bufferToArray(new Buffer(M)); + var out = this._doCryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX); + var buf = new Buffer(16); + buf.writeUInt32BE(out[0], 0); + buf.writeUInt32BE(out[1], 4); + buf.writeUInt32BE(out[2], 8); + buf.writeUInt32BE(out[3], 12); + return buf; + }; - function base64ToBytes (str) { - return base64.toByteArray(base64clean(str)) - } + AES.prototype.decryptBlock = function(M) { + M = bufferToArray(new Buffer(M)); + var temp = [M[3], M[1]]; + M[1] = temp[0]; + M[3] = temp[1]; + var out = this._doCryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX); + var buf = new Buffer(16); + buf.writeUInt32BE(out[0], 0); + buf.writeUInt32BE(out[3], 4); + buf.writeUInt32BE(out[2], 8); + buf.writeUInt32BE(out[1], 12); + return buf; + }; - function blitBuffer (src, dst, offset, length) { - for (var i = 0; i < length; i++) { - if ((i + offset >= dst.length) || (i >= src.length)) break - dst[i + offset] = src[i] - } - return i - } + AES.prototype.scrub = function() { + scrub_vec(this._keySchedule); + scrub_vec(this._invKeySchedule); + scrub_vec(this._key); + }; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(210).Buffer, (function() { return this; }()))) + AES.prototype._doCryptBlock = function(M, keySchedule, SUB_MIX, SBOX) { + var ksRow, round, s0, s1, s2, s3, t0, t1, t2, t3, _i, _ref; + + s0 = M[0] ^ keySchedule[0]; + s1 = M[1] ^ keySchedule[1]; + s2 = M[2] ^ keySchedule[2]; + s3 = M[3] ^ keySchedule[3]; + ksRow = 4; + for (round = _i = 1, _ref = this._nRounds; 1 <= _ref ? _i < _ref : _i > _ref; round = 1 <= _ref ? ++_i : --_i) { + t0 = SUB_MIX[0][s0 >>> 24] ^ SUB_MIX[1][(s1 >>> 16) & 0xff] ^ SUB_MIX[2][(s2 >>> 8) & 0xff] ^ SUB_MIX[3][s3 & 0xff] ^ keySchedule[ksRow++]; + t1 = SUB_MIX[0][s1 >>> 24] ^ SUB_MIX[1][(s2 >>> 16) & 0xff] ^ SUB_MIX[2][(s3 >>> 8) & 0xff] ^ SUB_MIX[3][s0 & 0xff] ^ keySchedule[ksRow++]; + t2 = SUB_MIX[0][s2 >>> 24] ^ SUB_MIX[1][(s3 >>> 16) & 0xff] ^ SUB_MIX[2][(s0 >>> 8) & 0xff] ^ SUB_MIX[3][s1 & 0xff] ^ keySchedule[ksRow++]; + t3 = SUB_MIX[0][s3 >>> 24] ^ SUB_MIX[1][(s0 >>> 16) & 0xff] ^ SUB_MIX[2][(s1 >>> 8) & 0xff] ^ SUB_MIX[3][s2 & 0xff] ^ keySchedule[ksRow++]; + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]; + t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]; + t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]; + t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]; + return [ + fixup_uint32(t0), + fixup_uint32(t1), + fixup_uint32(t2), + fixup_uint32(t3) + ]; -/***/ }, -/* 211 */ -/***/ function(module, exports, __webpack_require__) { + }; - var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; - - ;(function (exports) { - 'use strict'; - - var Arr = (typeof Uint8Array !== 'undefined') - ? Uint8Array - : Array - - var PLUS = '+'.charCodeAt(0) - var SLASH = '/'.charCodeAt(0) - var NUMBER = '0'.charCodeAt(0) - var LOWER = 'a'.charCodeAt(0) - var UPPER = 'A'.charCodeAt(0) - var PLUS_URL_SAFE = '-'.charCodeAt(0) - var SLASH_URL_SAFE = '_'.charCodeAt(0) - - function decode (elt) { - var code = elt.charCodeAt(0) - if (code === PLUS || - code === PLUS_URL_SAFE) - return 62 // '+' - if (code === SLASH || - code === SLASH_URL_SAFE) - return 63 // '/' - if (code < NUMBER) - return -1 //no match - if (code < NUMBER + 10) - return code - NUMBER + 26 + 26 - if (code < UPPER + 26) - return code - UPPER - if (code < LOWER + 26) - return code - LOWER + 26 - } - function b64ToByteArray (b64) { - var i, j, l, tmp, placeHolders, arr - if (b64.length % 4 > 0) { - throw new Error('Invalid string. Length must be a multiple of 4') - } - // the number of equal signs (place holders) - // if there are two placeholders, than the two characters before it - // represent one byte - // if there is only one, then the three characters before it represent 2 bytes - // this is just a cheap hack to not do indexOf twice - var len = b64.length - placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0 + exports.AES = AES; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - // base64 is 4/3 + up to two characters of the original data - arr = new Arr(b64.length * 3 / 4 - placeHolders) +/***/ }, +/* 206 */ +/***/ function(module, exports, __webpack_require__) { - // if there are placeholders, only get up to the last complete 4 chars - l = placeHolders > 0 ? b64.length - 4 : b64.length + /* WEBPACK VAR INJECTION */(function(Buffer) {var Transform = __webpack_require__(207).Transform; + var inherits = __webpack_require__(194); - var L = 0 + module.exports = CipherBase; + inherits(CipherBase, Transform); + function CipherBase() { + Transform.call(this); + } + CipherBase.prototype.update = function (data, inputEnd, outputEnc) { + this.write(data, inputEnd); + var outData = new Buffer(''); + var chunk; + while ((chunk = this.read())) { + outData = Buffer.concat([outData, chunk]); + } + if (outputEnc) { + outData = outData.toString(outputEnc); + } + return outData; + }; + CipherBase.prototype.final = function (outputEnc) { + this.end(); + var outData = new Buffer(''); + var chunk; + while ((chunk = this.read())) { + outData = Buffer.concat([outData, chunk]); + } + if (outputEnc) { + outData = outData.toString(outputEnc); + } + return outData; + }; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - function push (v) { - arr[L++] = v - } +/***/ }, +/* 207 */ +/***/ function(module, exports, __webpack_require__) { - for (i = 0, j = 0; i < l; i += 4, j += 3) { - tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3)) - push((tmp & 0xFF0000) >> 16) - push((tmp & 0xFF00) >> 8) - push(tmp & 0xFF) - } + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. - if (placeHolders === 2) { - tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4) - push(tmp & 0xFF) - } else if (placeHolders === 1) { - tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2) - push((tmp >> 8) & 0xFF) - push(tmp & 0xFF) - } + module.exports = Stream; - return arr - } + var EE = __webpack_require__(208).EventEmitter; + var inherits = __webpack_require__(194); - function uint8ToBase64 (uint8) { - var i, - extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes - output = "", - temp, length + inherits(Stream, EE); + Stream.Readable = __webpack_require__(209); + Stream.Writable = __webpack_require__(222); + Stream.Duplex = __webpack_require__(223); + Stream.Transform = __webpack_require__(224); + Stream.PassThrough = __webpack_require__(225); - function encode (num) { - return lookup.charAt(num) - } + // Backwards-compat with node 0.4.x + Stream.Stream = Stream; - function tripletToBase64 (num) { - return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F) - } - // go through the array every three bytes, we'll deal with trailing stuff later - for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) { - temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]) - output += tripletToBase64(temp) - } - // pad the end with zeros, but make sure to not forget the extra bytes - switch (extraBytes) { - case 1: - temp = uint8[uint8.length - 1] - output += encode(temp >> 2) - output += encode((temp << 4) & 0x3F) - output += '==' - break - case 2: - temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1]) - output += encode(temp >> 10) - output += encode((temp >> 4) & 0x3F) - output += encode((temp << 2) & 0x3F) - output += '=' - break - } + // old-style streams. Note that the pipe method (the only relevant + // part of this class) is overridden in the Readable class. - return output - } + function Stream() { + EE.call(this); + } - exports.toByteArray = b64ToByteArray - exports.fromByteArray = uint8ToBase64 - }( false ? (this.base64js = {}) : exports)) + Stream.prototype.pipe = function(dest, options) { + var source = this; + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } -/***/ }, -/* 212 */ -/***/ function(module, exports) { + source.on('data', ondata); - exports.read = function (buffer, offset, isLE, mLen, nBytes) { - var e, m - var eLen = nBytes * 8 - mLen - 1 - var eMax = (1 << eLen) - 1 - var eBias = eMax >> 1 - var nBits = -7 - var i = isLE ? (nBytes - 1) : 0 - var d = isLE ? -1 : 1 - var s = buffer[offset + i] + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } - i += d + dest.on('drain', ondrain); - e = s & ((1 << (-nBits)) - 1) - s >>= (-nBits) - nBits += eLen - for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {} + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } - m = e & ((1 << (-nBits)) - 1) - e >>= (-nBits) - nBits += mLen - for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {} + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; - if (e === 0) { - e = 1 - eBias - } else if (e === eMax) { - return m ? NaN : ((s ? -1 : 1) * Infinity) - } else { - m = m + Math.pow(2, mLen) - e = e - eBias + dest.end(); } - return (s ? -1 : 1) * m * Math.pow(2, e - mLen) - } - exports.write = function (buffer, value, offset, isLE, mLen, nBytes) { - var e, m, c - var eLen = nBytes * 8 - mLen - 1 - var eMax = (1 << eLen) - 1 - var eBias = eMax >> 1 - var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0) - var i = isLE ? 0 : (nBytes - 1) - var d = isLE ? 1 : -1 - var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0 - value = Math.abs(value) + function onclose() { + if (didOnEnd) return; + didOnEnd = true; - if (isNaN(value) || value === Infinity) { - m = isNaN(value) ? 1 : 0 - e = eMax - } else { - e = Math.floor(Math.log(value) / Math.LN2) - if (value * (c = Math.pow(2, -e)) < 1) { - e-- - c *= 2 - } - if (e + eBias >= 1) { - value += rt / c - } else { - value += rt * Math.pow(2, 1 - eBias) - } - if (value * c >= 2) { - e++ - c /= 2 - } + if (typeof dest.destroy === 'function') dest.destroy(); + } - if (e + eBias >= eMax) { - m = 0 - e = eMax - } else if (e + eBias >= 1) { - m = (value * c - 1) * Math.pow(2, mLen) - e = e + eBias - } else { - m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen) - e = 0 + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. } } - for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {} + source.on('error', onerror); + dest.on('error', onerror); - e = (e << mLen) | m - eLen += mLen - for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {} + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); - buffer[offset + i - d] |= s * 128 - } + source.removeListener('end', onend); + source.removeListener('close', onclose); + source.removeListener('error', onerror); + dest.removeListener('error', onerror); -/***/ }, -/* 213 */ -/***/ function(module, exports) { + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); - var toString = {}.toString; + dest.removeListener('close', cleanup); + } - module.exports = Array.isArray || function (arr) { - return toString.call(arr) == '[object Array]'; + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; }; /***/ }, -/* 214 */ -/***/ function(module, exports, __webpack_require__) { +/* 208 */ +/***/ function(module, exports) { - /* WEBPACK VAR INJECTION */(function(global, Buffer) {(function() { - var g = ('undefined' === typeof window ? global : window) || {} - _crypto = ( - g.crypto || g.msCrypto || __webpack_require__(215) - ) - module.exports = function(size) { - // Modern Browsers - if(_crypto.getRandomValues) { - var bytes = new Buffer(size); //in browserify, this is an extended Uint8Array - /* This will not work in older browsers. - * See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues - */ - - _crypto.getRandomValues(bytes); - return bytes; - } - else if (_crypto.randomBytes) { - return _crypto.randomBytes(size) - } - else - throw new Error( - 'secure random number generation not supported by this browser\n'+ - 'use chrome, FireFox or Internet Explorer 11' - ) - } - }()) + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. - /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(210).Buffer)) + function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; + } + module.exports = EventEmitter; -/***/ }, -/* 215 */ -/***/ function(module, exports) { + // Backwards-compat with node 0.10.x + EventEmitter.EventEmitter = EventEmitter; - /* (ignored) */ + EventEmitter.prototype._events = undefined; + EventEmitter.prototype._maxListeners = undefined; -/***/ }, -/* 216 */ -/***/ function(module, exports, __webpack_require__) { + // By default EventEmitters will print a warning if more than 10 listeners are + // added to it. This is a useful default which helps finding memory leaks. + EventEmitter.defaultMaxListeners = 10; - /* WEBPACK VAR INJECTION */(function(Buffer) {var createHash = __webpack_require__(217) + // Obviously not all Emitters should be limited to 10. This function allows + // that to be increased. Set to zero for unlimited. + EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; + }; - var md5 = toConstructor(__webpack_require__(226)) - var rmd160 = toConstructor(__webpack_require__(228)) + EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; - function toConstructor (fn) { - return function () { - var buffers = [] - var m= { - update: function (data, enc) { - if(!Buffer.isBuffer(data)) data = new Buffer(data, enc) - buffers.push(data) - return this - }, - digest: function (enc) { - var buf = Buffer.concat(buffers) - var r = fn(buf) - buffers = null - return enc ? r.toString(enc) : r + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } else { + // At least give some kind of context to the user + var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); + err.context = er; + throw err; } } - return m } - } - module.exports = function (alg) { - if('md5' === alg) return new md5() - if('rmd160' === alg) return new rmd160() - return createHash(alg) - } + handler = this._events[type]; - /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(210).Buffer)) + if (isUndefined(handler)) + return false; -/***/ }, -/* 217 */ -/***/ function(module, exports, __webpack_require__) { + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + args = Array.prototype.slice.call(arguments, 1); + handler.apply(this, args); + } + } else if (isObject(handler)) { + args = Array.prototype.slice.call(arguments, 1); + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } - var exports = module.exports = function (alg) { - var Alg = exports[alg] - if(!Alg) throw new Error(alg + ' is not supported (we accept pull requests)') - return new Alg() - } + return true; + }; + + EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } - var Buffer = __webpack_require__(210).Buffer - var Hash = __webpack_require__(218)(Buffer) + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } - exports.sha1 = __webpack_require__(219)(Buffer, Hash) - exports.sha256 = __webpack_require__(224)(Buffer, Hash) - exports.sha512 = __webpack_require__(225)(Buffer, Hash) + return this; + }; + EventEmitter.prototype.on = EventEmitter.prototype.addListener; -/***/ }, -/* 218 */ -/***/ function(module, exports) { + EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); - module.exports = function (Buffer) { + var fired = false; - //prototype class for hash functions - function Hash (blockSize, finalSize) { - this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4) - this._finalSize = finalSize - this._blockSize = blockSize - this._len = 0 - this._s = 0 - } + function g() { + this.removeListener(type, g); - Hash.prototype.init = function () { - this._s = 0 - this._len = 0 + if (!fired) { + fired = true; + listener.apply(this, arguments); + } } - Hash.prototype.update = function (data, enc) { - if ("string" === typeof data) { - enc = enc || "utf8" - data = new Buffer(data, enc) - } + g.listener = listener; + this.on(type, g); - var l = this._len += data.length - var s = this._s = (this._s || 0) - var f = 0 - var buffer = this._block + return this; + }; - while (s < l) { - var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize)) - var ch = (t - f) + // emits a 'removeListener' event iff the listener was removed + EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; - for (var i = 0; i < ch; i++) { - buffer[(s % this._blockSize) + i] = data[i + f] - } + if (!isFunction(listener)) + throw TypeError('listener must be a function'); - s += ch - f += ch + if (!this._events || !this._events[type]) + return this; - if ((s % this._blockSize) === 0) { - this._update(buffer) + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; } } - this._s = s - return this + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); } - Hash.prototype.digest = function (enc) { - // Suppose the length of the message M, in bits, is l - var l = this._len * 8 + return this; + }; - // Append the bit 1 to the end of the message - this._block[this._len % this._blockSize] = 0x80 + EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; - // and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize - this._block.fill(0, this._len % this._blockSize + 1) + if (!this._events) + return this; - if (l % (this._blockSize * 8) >= this._finalSize * 8) { - this._update(this._block) - this._block.fill(0) - } + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } - // to this append the block which is equal to the number l written in binary - // TODO: handle case where l is > Math.pow(2, 29) - this._block.writeInt32BE(l, this._blockSize - 4) + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } - var hash = this._update(this._block) || this._hash() + listeners = this._events[type]; - return enc ? hash.toString(enc) : hash + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else if (listeners) { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); } + delete this._events[type]; - Hash.prototype._update = function () { - throw new Error('_update must be implemented by subclass') + return this; + }; + + EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; + }; + + EventEmitter.prototype.listenerCount = function(type) { + if (this._events) { + var evlistener = this._events[type]; + + if (isFunction(evlistener)) + return 1; + else if (evlistener) + return evlistener.length; } + return 0; + }; - return Hash + EventEmitter.listenerCount = function(emitter, type) { + return emitter.listenerCount(type); + }; + + function isFunction(arg) { + return typeof arg === 'function'; + } + + function isNumber(arg) { + return typeof arg === 'number'; + } + + function isObject(arg) { + return typeof arg === 'object' && arg !== null; + } + + function isUndefined(arg) { + return arg === void 0; } /***/ }, -/* 219 */ +/* 209 */ /***/ function(module, exports, __webpack_require__) { - /* - * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined - * in FIPS PUB 180-1 - * Version 2.1a Copyright Paul Johnston 2000 - 2002. - * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet - * Distributed under the BSD License - * See http://pajhome.org.uk/crypt/md5 for details. - */ + var Stream = (function (){ + try { + return __webpack_require__(207); // hack to fix a circular dependency issue when used with browserify + } catch(_){} + }()); + exports = module.exports = __webpack_require__(210); + exports.Stream = Stream || exports; + exports.Readable = exports; + exports.Writable = __webpack_require__(215); + exports.Duplex = __webpack_require__(214); + exports.Transform = __webpack_require__(220); + exports.PassThrough = __webpack_require__(221); - var inherits = __webpack_require__(220).inherits - module.exports = function (Buffer, Hash) { +/***/ }, +/* 210 */ +/***/ function(module, exports, __webpack_require__) { - var A = 0|0 - var B = 4|0 - var C = 8|0 - var D = 12|0 - var E = 16|0 + /* WEBPACK VAR INJECTION */(function(process) {'use strict'; - var W = new (typeof Int32Array === 'undefined' ? Array : Int32Array)(80) + module.exports = Readable; - var POOL = [] + /**/ + var processNextTick = __webpack_require__(211); + /**/ - function Sha1 () { - if(POOL.length) - return POOL.pop().init() + /**/ + var isArray = __webpack_require__(181); + /**/ - if(!(this instanceof Sha1)) return new Sha1() - this._w = W - Hash.call(this, 16*4, 14*4) + /**/ + var Buffer = __webpack_require__(178).Buffer; + /**/ - this._h = null - this.init() - } + Readable.ReadableState = ReadableState; - inherits(Sha1, Hash) + var EE = __webpack_require__(208); - Sha1.prototype.init = function () { - this._a = 0x67452301 - this._b = 0xefcdab89 - this._c = 0x98badcfe - this._d = 0x10325476 - this._e = 0xc3d2e1f0 + /**/ + var EElistenerCount = function (emitter, type) { + return emitter.listeners(type).length; + }; + /**/ - Hash.prototype.init.call(this) - return this + /**/ + var Stream; + (function () { + try { + Stream = __webpack_require__(207); + } catch (_) {} finally { + if (!Stream) Stream = __webpack_require__(208).EventEmitter; } + })(); + /**/ - Sha1.prototype._POOL = POOL - Sha1.prototype._update = function (X) { + var Buffer = __webpack_require__(178).Buffer; - var a, b, c, d, e, _a, _b, _c, _d, _e + /**/ + var util = __webpack_require__(212); + util.inherits = __webpack_require__(194); + /**/ - a = _a = this._a - b = _b = this._b - c = _c = this._c - d = _d = this._d - e = _e = this._e + /**/ + var debugUtil = __webpack_require__(213); + var debug = undefined; + if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); + } else { + debug = function () {}; + } + /**/ - var w = this._w + var StringDecoder; - for(var j = 0; j < 80; j++) { - var W = w[j] = j < 16 ? X.readInt32BE(j*4) - : rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1) + util.inherits(Readable, Stream); - var t = add( - add(rol(a, 5), sha1_ft(j, b, c, d)), - add(add(e, W), sha1_kt(j)) - ) + var Duplex; + function ReadableState(options, stream) { + Duplex = Duplex || __webpack_require__(214); - e = d - d = c - c = rol(b, 30) - b = a - a = t - } + options = options || {}; - this._a = add(a, _a) - this._b = add(b, _b) - this._c = add(c, _c) - this._d = add(d, _d) - this._e = add(e, _e) - } + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; - Sha1.prototype._hash = function () { - if(POOL.length < 100) POOL.push(this) - var H = new Buffer(20) - //console.log(this._a|0, this._b|0, this._c|0, this._d|0, this._e|0) - H.writeInt32BE(this._a|0, A) - H.writeInt32BE(this._b|0, B) - H.writeInt32BE(this._c|0, C) - H.writeInt32BE(this._d|0, D) - H.writeInt32BE(this._e|0, E) - return H - } + if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + var hwm = options.highWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = ~ ~this.highWaterMark; + + this.buffer = []; + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // when piping, we only care about 'readable' events that happen + // after read()ing all the bytes and not getting any pushback. + this.ranOut = false; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; - /* - * Perform the appropriate triplet combination function for the current - * iteration - */ - function sha1_ft(t, b, c, d) { - if(t < 20) return (b & c) | ((~b) & d); - if(t < 40) return b ^ c ^ d; - if(t < 60) return (b & c) | (b & d) | (c & d); - return b ^ c ^ d; - } + // if true, a maybeReadMore has been scheduled + this.readingMore = false; - /* - * Determine the appropriate additive constant for the current iteration - */ - function sha1_kt(t) { - return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : - (t < 60) ? -1894007588 : -899497514; + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = __webpack_require__(219).StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; } + } - /* - * Add integers, wrapping at 2^32. This uses 16-bit operations internally - * to work around bugs in some JS interpreters. - * //dominictarr: this is 10 years old, so maybe this can be dropped?) - * - */ - function add(x, y) { - return (x + y ) | 0 - //lets see how this goes on testling. - // var lsw = (x & 0xFFFF) + (y & 0xFFFF); - // var msw = (x >> 16) + (y >> 16) + (lsw >> 16); - // return (msw << 16) | (lsw & 0xFFFF); - } + var Duplex; + function Readable(options) { + Duplex = Duplex || __webpack_require__(214); - /* - * Bitwise rotate a 32-bit number to the left. - */ - function rol(num, cnt) { - return (num << cnt) | (num >>> (32 - cnt)); - } + if (!(this instanceof Readable)) return new Readable(options); - return Sha1 - } + this._readableState = new ReadableState(options, this); + // legacy + this.readable = true; -/***/ }, -/* 220 */ -/***/ function(module, exports, __webpack_require__) { + if (options && typeof options.read === 'function') this._read = options.read; - /* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors. - // - // Permission is hereby granted, free of charge, to any person obtaining a - // copy of this software and associated documentation files (the - // "Software"), to deal in the Software without restriction, including - // without limitation the rights to use, copy, modify, merge, publish, - // distribute, sublicense, and/or sell copies of the Software, and to permit - // persons to whom the Software is furnished to do so, subject to the - // following conditions: - // - // The above copyright notice and this permission notice shall be included - // in all copies or substantial portions of the Software. - // - // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS - // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN - // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, - // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - // USE OR OTHER DEALINGS IN THE SOFTWARE. + Stream.call(this); + } - var formatRegExp = /%[sdj%]/g; - exports.format = function(f) { - if (!isString(f)) { - var objects = []; - for (var i = 0; i < arguments.length; i++) { - objects.push(inspect(arguments[i])); - } - return objects.join(' '); - } + // Manually shove something into the read() buffer. + // This returns true if the highWaterMark has not been hit yet, + // similar to how Writable.write() returns true if you should + // write() some more. + Readable.prototype.push = function (chunk, encoding) { + var state = this._readableState; - var i = 1; - var args = arguments; - var len = args.length; - var str = String(f).replace(formatRegExp, function(x) { - if (x === '%%') return '%'; - if (i >= len) return x; - switch (x) { - case '%s': return String(args[i++]); - case '%d': return Number(args[i++]); - case '%j': - try { - return JSON.stringify(args[i++]); - } catch (_) { - return '[Circular]'; - } - default: - return x; - } - }); - for (var x = args[i]; i < len; x = args[++i]) { - if (isNull(x) || !isObject(x)) { - str += ' ' + x; - } else { - str += ' ' + inspect(x); + if (!state.objectMode && typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = new Buffer(chunk, encoding); + encoding = ''; } } - return str; + + return readableAddChunk(this, state, chunk, encoding, false); }; + // Unshift should *always* be something directly out of read() + Readable.prototype.unshift = function (chunk) { + var state = this._readableState; + return readableAddChunk(this, state, chunk, '', true); + }; - // Mark that a method should not be used. - // Returns a modified function which warns once by default. - // If --no-deprecation is set, then it is a no-op. - exports.deprecate = function(fn, msg) { - // Allow for deprecating things in the process of starting up. - if (isUndefined(global.process)) { - return function() { - return exports.deprecate(fn, msg).apply(this, arguments); - }; - } + Readable.prototype.isPaused = function () { + return this._readableState.flowing === false; + }; - if (process.noDeprecation === true) { - return fn; - } + function readableAddChunk(stream, state, chunk, encoding, addToFront) { + var er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (state.ended && !addToFront) { + var e = new Error('stream.push() after EOF'); + stream.emit('error', e); + } else if (state.endEmitted && addToFront) { + var e = new Error('stream.unshift() after end event'); + stream.emit('error', e); + } else { + var skipAdd; + if (state.decoder && !addToFront && !encoding) { + chunk = state.decoder.write(chunk); + skipAdd = !state.objectMode && chunk.length === 0; + } - var warned = false; - function deprecated() { - if (!warned) { - if (process.throwDeprecation) { - throw new Error(msg); - } else if (process.traceDeprecation) { - console.trace(msg); - } else { - console.error(msg); + if (!addToFront) state.reading = false; + + // Don't add to the buffer if we've decoded to an empty string chunk and + // we're not in object mode + if (!skipAdd) { + // if we want the data now, just emit it. + if (state.flowing && state.length === 0 && !state.sync) { + stream.emit('data', chunk); + stream.read(0); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); + + if (state.needReadable) emitReadable(stream); + } } - warned = true; + + maybeReadMore(stream, state); } - return fn.apply(this, arguments); + } else if (!addToFront) { + state.reading = false; } - return deprecated; + return needMoreData(state); + } + + // if it's past the high water mark, we can push in some more. + // Also, if we have no data yet, we can stand some + // more bytes. This is to work around cases where hwm=0, + // such as the repl. Also, if the push() triggered a + // readable event, and the user called read(largeNumber) such that + // needReadable was set, then we ought to push more, so that another + // 'readable' event will be triggered. + function needMoreData(state) { + return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); + } + + // backwards compatibility. + Readable.prototype.setEncoding = function (enc) { + if (!StringDecoder) StringDecoder = __webpack_require__(219).StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; + return this; }; + // Don't raise the hwm > 8MB + var MAX_HWM = 0x800000; + function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + // Get the next highest power of 2 + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; + } - var debugs = {}; - var debugEnviron; - exports.debuglog = function(set) { - if (isUndefined(debugEnviron)) - debugEnviron = ({"NODE_ENV":"production"}).NODE_DEBUG || ''; - set = set.toUpperCase(); - if (!debugs[set]) { - if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) { - var pid = process.pid; - debugs[set] = function() { - var msg = exports.format.apply(exports, arguments); - console.error('%s %d: %s', set, pid, msg); - }; - } else { - debugs[set] = function() {}; - } + function howMuchToRead(n, state) { + if (state.length === 0 && state.ended) return 0; + + if (state.objectMode) return n === 0 ? 0 : 1; + + if (n === null || isNaN(n)) { + // only flow one buffer at a time + if (state.flowing && state.buffer.length) return state.buffer[0].length;else return state.length; } - return debugs[set]; - }; + if (n <= 0) return 0; - /** - * Echos the value of a value. Trys to print the value out - * in the best way possible given the different types. - * - * @param {Object} obj The object to print out. - * @param {Object} opts Optional options object that alters the output. - */ - /* legacy: obj, showHidden, depth, colors*/ - function inspect(obj, opts) { - // default options - var ctx = { - seen: [], - stylize: stylizeNoColor - }; - // legacy... - if (arguments.length >= 3) ctx.depth = arguments[2]; - if (arguments.length >= 4) ctx.colors = arguments[3]; - if (isBoolean(opts)) { - // legacy... - ctx.showHidden = opts; - } else if (opts) { - // got an "options" object - exports._extend(ctx, opts); + // If we're asking for more than the target buffer level, + // then raise the water mark. Bump up to the next highest + // power of 2, to prevent increasing it excessively in tiny + // amounts. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + + // don't have that much. return null, unless we've ended. + if (n > state.length) { + if (!state.ended) { + state.needReadable = true; + return 0; + } else { + return state.length; + } } - // set default options - if (isUndefined(ctx.showHidden)) ctx.showHidden = false; - if (isUndefined(ctx.depth)) ctx.depth = 2; - if (isUndefined(ctx.colors)) ctx.colors = false; - if (isUndefined(ctx.customInspect)) ctx.customInspect = true; - if (ctx.colors) ctx.stylize = stylizeWithColor; - return formatValue(ctx, obj, ctx.depth); + + return n; } - exports.inspect = inspect; + // you can override either this method, or the async _read(n) below. + Readable.prototype.read = function (n) { + debug('read', n); + var state = this._readableState; + var nOrig = n; - // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics - inspect.colors = { - 'bold' : [1, 22], - 'italic' : [3, 23], - 'underline' : [4, 24], - 'inverse' : [7, 27], - 'white' : [37, 39], - 'grey' : [90, 39], - 'black' : [30, 39], - 'blue' : [34, 39], - 'cyan' : [36, 39], - 'green' : [32, 39], - 'magenta' : [35, 39], - 'red' : [31, 39], - 'yellow' : [33, 39] - }; + if (typeof n !== 'number' || n > 0) state.emittedReadable = false; - // Don't use 'blue' not visible on cmd.exe - inspect.styles = { - 'special': 'cyan', - 'number': 'yellow', - 'boolean': 'yellow', - 'undefined': 'grey', - 'null': 'bold', - 'string': 'green', - 'date': 'magenta', - // "name": intentionally not styling - 'regexp': 'red' - }; + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); + return null; + } + n = howMuchToRead(n, state); - function stylizeWithColor(str, styleType) { - var style = inspect.styles[styleType]; + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } - if (style) { - return '\u001b[' + inspect.colors[style][0] + 'm' + str + - '\u001b[' + inspect.colors[style][1] + 'm'; - } else { - return str; + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); } - } + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } - function stylizeNoColor(str, styleType) { - return str; - } + if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + } + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (doRead && !state.reading) n = howMuchToRead(nOrig, state); - function arrayToHash(array) { - var hash = {}; + var ret; + if (n > 0) ret = fromList(n, state);else ret = null; - array.forEach(function(val, idx) { - hash[val] = true; - }); + if (ret === null) { + state.needReadable = true; + n = 0; + } - return hash; - } + state.length -= n; + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (state.length === 0 && !state.ended) state.needReadable = true; - function formatValue(ctx, value, recurseTimes) { - // Provide a hook for user-specified inspect functions. - // Check that value is an object with an inspect function on it - if (ctx.customInspect && - value && - isFunction(value.inspect) && - // Filter out the util module, it's inspect function is special - value.inspect !== exports.inspect && - // Also filter out any prototype objects using the circular check. - !(value.constructor && value.constructor.prototype === value)) { - var ret = value.inspect(recurseTimes, ctx); - if (!isString(ret)) { - ret = formatValue(ctx, ret, recurseTimes); + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended && state.length === 0) endReadable(this); + + if (ret !== null) this.emit('data', ret); + + return ret; + }; + + function chunkInvalid(state, chunk) { + var er = null; + if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; + } + + function onEofChunk(stream, state) { + if (state.ended) return; + if (state.decoder) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; } - return ret; } + state.ended = true; - // Primitive types cannot have properties - var primitive = formatPrimitive(ctx, value); - if (primitive) { - return primitive; + // emit 'readable' now to make sure it gets picked up. + emitReadable(stream); + } + + // Don't emit readable right away in sync mode, because this can trigger + // another read() call => stack overflow. This way, it might trigger + // a nextTick recursion warning, but that's not so bad. + function emitReadable(stream) { + var state = stream._readableState; + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + if (state.sync) processNextTick(emitReadable_, stream);else emitReadable_(stream); } + } - // Look up the keys of the object. - var keys = Object.keys(value); - var visibleKeys = arrayToHash(keys); + function emitReadable_(stream) { + debug('emit readable'); + stream.emit('readable'); + flow(stream); + } - if (ctx.showHidden) { - keys = Object.getOwnPropertyNames(value); + // at this point, the user has presumably seen the 'readable' event, + // and called read() to consume some data. that may have triggered + // in turn another _read(n) call, in which case reading = true if + // it's in progress. + // However, if we're not ended, or reading, and the length < hwm, + // then go ahead and try to read some more preemptively. + function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + processNextTick(maybeReadMore_, stream, state); } + } - // IE doesn't make error fields non-enumerable - // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx - if (isError(value) - && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { - return formatError(value); + function maybeReadMore_(stream, state) { + var len = state.length; + while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break;else len = state.length; } + state.readingMore = false; + } - // Some type of object without properties can be shortcutted. - if (keys.length === 0) { - if (isFunction(value)) { - var name = value.name ? ': ' + value.name : ''; - return ctx.stylize('[Function' + name + ']', 'special'); - } - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } - if (isDate(value)) { - return ctx.stylize(Date.prototype.toString.call(value), 'date'); - } - if (isError(value)) { - return formatError(value); - } + // abstract method. to be overridden in specific implementation classes. + // call cb(er, data) where data is <= n in length. + // for virtual (non-string, non-buffer) streams, "length" is somewhat + // arbitrary, and perhaps not very meaningful. + Readable.prototype._read = function (n) { + this.emit('error', new Error('not implemented')); + }; + + Readable.prototype.pipe = function (dest, pipeOpts) { + var src = this; + var state = this._readableState; + + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); - var base = '', array = false, braces = ['{', '}']; + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; - // Make Array say that they are Array - if (isArray(value)) { - array = true; - braces = ['[', ']']; + var endFn = doEnd ? onend : cleanup; + if (state.endEmitted) processNextTick(endFn);else src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable) { + debug('onunpipe'); + if (readable === src) { + cleanup(); + } } - // Make functions say that they are functions - if (isFunction(value)) { - var n = value.name ? ': ' + value.name : ''; - base = ' [Function' + n + ']'; + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + + var cleanedUp = false; + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', cleanup); + src.removeListener('data', ondata); + + cleanedUp = true; + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + var ret = dest.write(chunk); + if (false === ret) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + if (state.pipesCount === 1 && state.pipes[0] === dest && src.listenerCount('data') === 1 && !cleanedUp) { + debug('false write response, pause', src._readableState.awaitDrain); + src._readableState.awaitDrain++; + } + src.pause(); + } } - // Make RegExps say that they are RegExps - if (isRegExp(value)) { - base = ' ' + RegExp.prototype.toString.call(value); + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); } + // This is a brutally ugly hack to make sure that our error handler + // is attached before any userland ones. NEVER DO THIS. + if (!dest._events || !dest._events.error) dest.on('error', onerror);else if (isArray(dest._events.error)) dest._events.error.unshift(onerror);else dest._events.error = [onerror, dest._events.error]; - // Make dates with properties first say the date - if (isDate(value)) { - base = ' ' + Date.prototype.toUTCString.call(value); + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); } + dest.once('finish', onfinish); - // Make error with message first say the error - if (isError(value)) { - base = ' ' + formatError(value); + function unpipe() { + debug('unpipe'); + src.unpipe(dest); } - if (keys.length === 0 && (!array || value.length == 0)) { - return braces[0] + base + braces[1]; + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); } - if (recurseTimes < 0) { - if (isRegExp(value)) { - return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); - } else { - return ctx.stylize('[Object]', 'special'); + return dest; + }; + + function pipeOnDrain(src) { + return function () { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) state.awaitDrain--; + if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { + state.flowing = true; + flow(src); } + }; + } + + Readable.prototype.unpipe = function (dest) { + var state = this._readableState; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) return this; + + if (!dest) dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) dest.emit('unpipe', this); + return this; } - ctx.seen.push(value); + // slow case. multiple pipe destinations. - var output; - if (array) { - output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); - } else { - output = keys.map(function(key) { - return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); - }); + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + + for (var _i = 0; _i < len; _i++) { + dests[_i].emit('unpipe', this); + }return this; } - ctx.seen.pop(); + // try to find the right one. + var i = indexOf(state.pipes, dest); + if (i === -1) return this; - return reduceToSingleString(output, base, braces); - } + state.pipes.splice(i, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) state.pipes = state.pipes[0]; + dest.emit('unpipe', this); - function formatPrimitive(ctx, value) { - if (isUndefined(value)) - return ctx.stylize('undefined', 'undefined'); - if (isString(value)) { - var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + '\''; - return ctx.stylize(simple, 'string'); + return this; + }; + + // set up data events if they are asked for + // Ensure readable listeners eventually get something + Readable.prototype.on = function (ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + + // If listening to data, and it has not explicitly been paused, + // then call resume to start the flow of data on the next tick. + if (ev === 'data' && false !== this._readableState.flowing) { + this.resume(); + } + + if (ev === 'readable' && !this._readableState.endEmitted) { + var state = this._readableState; + if (!state.readableListening) { + state.readableListening = true; + state.emittedReadable = false; + state.needReadable = true; + if (!state.reading) { + processNextTick(nReadingNextTick, this); + } else if (state.length) { + emitReadable(this, state); + } + } } - if (isNumber(value)) - return ctx.stylize('' + value, 'number'); - if (isBoolean(value)) - return ctx.stylize('' + value, 'boolean'); - // For some reason typeof null is "object", so special case here. - if (isNull(value)) - return ctx.stylize('null', 'null'); + + return res; + }; + Readable.prototype.addListener = Readable.prototype.on; + + function nReadingNextTick(self) { + debug('readable nexttick read 0'); + self.read(0); } + // pause() and resume() are remnants of the legacy readable stream API + // If the user uses them, then switch into old mode. + Readable.prototype.resume = function () { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + state.flowing = true; + resume(this, state); + } + return this; + }; - function formatError(value) { - return '[' + Error.prototype.toString.call(value) + ']'; + function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + processNextTick(resume_, stream, state); + } } + function resume_(stream, state) { + if (!state.reading) { + debug('resume read 0'); + stream.read(0); + } - function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { - var output = []; - for (var i = 0, l = value.length; i < l; ++i) { - if (hasOwnProperty(value, String(i))) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - String(i), true)); - } else { - output.push(''); - } + state.resumeScheduled = false; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); + } + + Readable.prototype.pause = function () { + debug('call pause flowing=%j', this._readableState.flowing); + if (false !== this._readableState.flowing) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); } - keys.forEach(function(key) { - if (!key.match(/^\d+$/)) { - output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, - key, true)); + return this; + }; + + function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + if (state.flowing) { + do { + var chunk = stream.read(); + } while (null !== chunk && state.flowing); + } + } + + // wrap an old-style stream as the async data source. + // This is *not* part of the readable stream interface. + // It is an ugly unfortunate mess of history. + Readable.prototype.wrap = function (stream) { + var state = this._readableState; + var paused = false; + + var self = this; + stream.on('end', function () { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) self.push(chunk); } + + self.push(null); }); - return output; - } + stream.on('data', function (chunk) { + debug('wrapped data'); + if (state.decoder) chunk = state.decoder.write(chunk); - function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { - var name, str, desc; - desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; - if (desc.get) { - if (desc.set) { - str = ctx.stylize('[Getter/Setter]', 'special'); - } else { - str = ctx.stylize('[Getter]', 'special'); - } - } else { - if (desc.set) { - str = ctx.stylize('[Setter]', 'special'); + // don't skip over falsy values in objectMode + if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; + + var ret = self.push(chunk); + if (!ret) { + paused = true; + stream.pause(); } - } - if (!hasOwnProperty(visibleKeys, key)) { - name = '[' + key + ']'; - } - if (!str) { - if (ctx.seen.indexOf(desc.value) < 0) { - if (isNull(recurseTimes)) { - str = formatValue(ctx, desc.value, null); - } else { - str = formatValue(ctx, desc.value, recurseTimes - 1); - } - if (str.indexOf('\n') > -1) { - if (array) { - str = str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n').substr(2); - } else { - str = '\n' + str.split('\n').map(function(line) { - return ' ' + line; - }).join('\n'); - } - } - } else { - str = ctx.stylize('[Circular]', 'special'); + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = function (method) { + return function () { + return stream[method].apply(stream, arguments); + }; + }(i); } } - if (isUndefined(name)) { - if (array && key.match(/^\d+$/)) { - return str; + + // proxy certain important events. + var events = ['error', 'close', 'destroy', 'pause', 'resume']; + forEach(events, function (ev) { + stream.on(ev, self.emit.bind(self, ev)); + }); + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + self._read = function (n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); } - name = JSON.stringify('' + key); - if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { - name = name.substr(1, name.length - 2); - name = ctx.stylize(name, 'name'); + }; + + return self; + }; + + // exposed for testing purposes only. + Readable._fromList = fromList; + + // Pluck off n bytes from an array of buffers. + // Length is the combined lengths of all the buffers in the list. + function fromList(n, state) { + var list = state.buffer; + var length = state.length; + var stringMode = !!state.decoder; + var objectMode = !!state.objectMode; + var ret; + + // nothing in the list, definitely empty. + if (list.length === 0) return null; + + if (length === 0) ret = null;else if (objectMode) ret = list.shift();else if (!n || n >= length) { + // read it all, truncate the array. + if (stringMode) ret = list.join('');else if (list.length === 1) ret = list[0];else ret = Buffer.concat(list, length); + list.length = 0; + } else { + // read just some of it. + if (n < list[0].length) { + // just take a part of the first list item. + // slice is the same for buffers and strings. + var buf = list[0]; + ret = buf.slice(0, n); + list[0] = buf.slice(n); + } else if (n === list[0].length) { + // first list is a perfect match + ret = list.shift(); } else { - name = name.replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'"); - name = ctx.stylize(name, 'string'); + // complex case. + // we have enough to cover it, but it spans past the first buffer. + if (stringMode) ret = '';else ret = new Buffer(n); + + var c = 0; + for (var i = 0, l = list.length; i < l && c < n; i++) { + var buf = list[0]; + var cpy = Math.min(n - c, buf.length); + + if (stringMode) ret += buf.slice(0, cpy);else buf.copy(ret, c, 0, cpy); + + if (cpy < buf.length) list[0] = buf.slice(cpy);else list.shift(); + + c += cpy; + } } } - return name + ': ' + str; + return ret; } + function endReadable(stream) { + var state = stream._readableState; - function reduceToSingleString(output, base, braces) { - var numLinesEst = 0; - var length = output.reduce(function(prev, cur) { - numLinesEst++; - if (cur.indexOf('\n') >= 0) numLinesEst++; - return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; - }, 0); + // If we get here before consuming all the bytes, then that is a + // bug in node. Should never happen. + if (state.length > 0) throw new Error('endReadable called on non-empty stream'); - if (length > 60) { - return braces[0] + - (base === '' ? '' : base + '\n ') + - ' ' + - output.join(',\n ') + - ' ' + - braces[1]; + if (!state.endEmitted) { + state.ended = true; + processNextTick(endReadableNT, state, stream); } + } - return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; + function endReadableNT(state, stream) { + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + } + } + + function forEach(xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } + } + + function indexOf(xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; + } + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(189))) + +/***/ }, +/* 211 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {'use strict'; + + if (!process.version || + process.version.indexOf('v0.') === 0 || + process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { + module.exports = nextTick; + } else { + module.exports = process.nextTick; + } + + function nextTick(fn, arg1, arg2, arg3) { + if (typeof fn !== 'function') { + throw new TypeError('"callback" argument must be a function'); + } + var len = arguments.length; + var args, i; + switch (len) { + case 0: + case 1: + return process.nextTick(fn); + case 2: + return process.nextTick(function afterTickOne() { + fn.call(null, arg1); + }); + case 3: + return process.nextTick(function afterTickTwo() { + fn.call(null, arg1, arg2); + }); + case 4: + return process.nextTick(function afterTickThree() { + fn.call(null, arg1, arg2, arg3); + }); + default: + args = new Array(len - 1); + i = 0; + while (i < args.length) { + args[i++] = arguments[i]; + } + return process.nextTick(function afterTick() { + fn.apply(null, args); + }); + } } + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(189))) + +/***/ }, +/* 212 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(Buffer) {// Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. // NOTE: These type checking functions intentionally don't use `instanceof` // because it is fragile and can be easily faked with `Object.create()`. - function isArray(ar) { - return Array.isArray(ar); + + function isArray(arg) { + if (Array.isArray) { + return Array.isArray(arg); + } + return objectToString(arg) === '[object Array]'; } exports.isArray = isArray; @@ -10565,7 +13167,7 @@ return /******/ (function(modules) { // webpackBootstrap exports.isUndefined = isUndefined; function isRegExp(re) { - return isObject(re) && objectToString(re) === '[object RegExp]'; + return objectToString(re) === '[object RegExp]'; } exports.isRegExp = isRegExp; @@ -10575,13 +13177,12 @@ return /******/ (function(modules) { // webpackBootstrap exports.isObject = isObject; function isDate(d) { - return isObject(d) && objectToString(d) === '[object Date]'; + return objectToString(d) === '[object Date]'; } exports.isDate = isDate; function isError(e) { - return isObject(e) && - (objectToString(e) === '[object Error]' || e instanceof Error); + return (objectToString(e) === '[object Error]' || e instanceof Error); } exports.isError = isError; @@ -10600,1238 +13201,1915 @@ return /******/ (function(modules) { // webpackBootstrap } exports.isPrimitive = isPrimitive; - exports.isBuffer = __webpack_require__(222); + exports.isBuffer = Buffer.isBuffer; function objectToString(o) { return Object.prototype.toString.call(o); } + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(178).Buffer)) - function pad(n) { - return n < 10 ? '0' + n.toString(10) : n.toString(10); - } - +/***/ }, +/* 213 */ +183, +/* 214 */ +/***/ function(module, exports, __webpack_require__) { - var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', - 'Oct', 'Nov', 'Dec']; + // a duplex stream is just a stream that is both readable and writable. + // Since JS doesn't have multiple prototypal inheritance, this class + // prototypally inherits from Readable, and then parasitically from + // Writable. - // 26 Feb 16:19:34 - function timestamp() { - var d = new Date(); - var time = [pad(d.getHours()), - pad(d.getMinutes()), - pad(d.getSeconds())].join(':'); - return [d.getDate(), months[d.getMonth()], time].join(' '); - } + 'use strict'; + /**/ - // log is just a thin wrapper to console.log that prepends a timestamp - exports.log = function() { - console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); + var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + keys.push(key); + }return keys; }; + /**/ + module.exports = Duplex; - /** - * Inherit the prototype methods from one constructor into another. - * - * The Function.prototype.inherits from lang.js rewritten as a standalone - * function (not on Function.prototype). NOTE: If this file is to be loaded - * during bootstrapping this function needs to be rewritten using some native - * functions as prototype setup using normal JavaScript does not work as - * expected during bootstrapping (see mirror.js in r114903). - * - * @param {function} ctor Constructor function which needs to inherit the - * prototype. - * @param {function} superCtor Constructor function to inherit prototype from. - */ - exports.inherits = __webpack_require__(223); + /**/ + var processNextTick = __webpack_require__(211); + /**/ - exports._extend = function(origin, add) { - // Don't do anything if add isn't an object - if (!add || !isObject(add)) return origin; + /**/ + var util = __webpack_require__(212); + util.inherits = __webpack_require__(194); + /**/ - var keys = Object.keys(add); - var i = keys.length; - while (i--) { - origin[keys[i]] = add[keys[i]]; - } - return origin; - }; + var Readable = __webpack_require__(210); + var Writable = __webpack_require__(215); - function hasOwnProperty(obj, prop) { - return Object.prototype.hasOwnProperty.call(obj, prop); + util.inherits(Duplex, Readable); + + var keys = objectKeys(Writable.prototype); + for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; } - /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(221))) + function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); -/***/ }, -/* 221 */ -/***/ function(module, exports) { + Readable.call(this, options); + Writable.call(this, options); - // shim for using process in browser + if (options && options.readable === false) this.readable = false; - var process = module.exports = {}; + if (options && options.writable === false) this.writable = false; - // cached from whatever global is present so that test runners that stub it - // don't break things. But we need to wrap it in a try catch in case it is - // wrapped in strict mode code which doesn't define any globals. It's inside a - // function because try/catches deoptimize in certain engines. + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; - var cachedSetTimeout; - var cachedClearTimeout; + this.once('end', onend); + } - (function () { - try { - cachedSetTimeout = setTimeout; - } catch (e) { - cachedSetTimeout = function () { - throw new Error('setTimeout is not defined'); - } - } - try { - cachedClearTimeout = clearTimeout; - } catch (e) { - cachedClearTimeout = function () { - throw new Error('clearTimeout is not defined'); - } - } - } ()) - var queue = []; - var draining = false; - var currentQueue; - var queueIndex = -1; + // the no-half-open enforcer + function onend() { + // if we allow half-open state, or if the writable side ended, + // then we're ok. + if (this.allowHalfOpen || this._writableState.ended) return; - function cleanUpNextTick() { - if (!draining || !currentQueue) { - return; - } - draining = false; - if (currentQueue.length) { - queue = currentQueue.concat(queue); - } else { - queueIndex = -1; - } - if (queue.length) { - drainQueue(); - } + // no more data can be written. + // But allow more writes to happen in this tick. + processNextTick(onEndNT, this); } - function drainQueue() { - if (draining) { - return; - } - var timeout = cachedSetTimeout(cleanUpNextTick); - draining = true; + function onEndNT(self) { + self.end(); + } - var len = queue.length; - while(len) { - currentQueue = queue; - queue = []; - while (++queueIndex < len) { - if (currentQueue) { - currentQueue[queueIndex].run(); - } - } - queueIndex = -1; - len = queue.length; - } - currentQueue = null; - draining = false; - cachedClearTimeout(timeout); + function forEach(xs, f) { + for (var i = 0, l = xs.length; i < l; i++) { + f(xs[i], i); + } } - process.nextTick = function (fun) { - var args = new Array(arguments.length - 1); - if (arguments.length > 1) { - for (var i = 1; i < arguments.length; i++) { - args[i - 1] = arguments[i]; - } - } - queue.push(new Item(fun, args)); - if (queue.length === 1 && !draining) { - cachedSetTimeout(drainQueue, 0); - } - }; +/***/ }, +/* 215 */ +/***/ function(module, exports, __webpack_require__) { - // v8 likes predictible objects - function Item(fun, array) { - this.fun = fun; - this.array = array; - } - Item.prototype.run = function () { - this.fun.apply(null, this.array); - }; - process.title = 'browser'; - process.browser = true; - process.env = {}; - process.argv = []; - process.version = ''; // empty string to avoid regexp issues - process.versions = {}; + /* WEBPACK VAR INJECTION */(function(process, setImmediate) {// A bit simpler than readable streams. + // Implement an async ._write(chunk, encoding, cb), and it'll handle all + // the drain event emission and buffering. - function noop() {} + 'use strict'; - process.on = noop; - process.addListener = noop; - process.once = noop; - process.off = noop; - process.removeListener = noop; - process.removeAllListeners = noop; - process.emit = noop; + module.exports = Writable; - process.binding = function (name) { - throw new Error('process.binding is not supported'); - }; + /**/ + var processNextTick = __webpack_require__(211); + /**/ - process.cwd = function () { return '/' }; - process.chdir = function (dir) { - throw new Error('process.chdir is not supported'); + /**/ + var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : processNextTick; + /**/ + + /**/ + var Buffer = __webpack_require__(178).Buffer; + /**/ + + Writable.WritableState = WritableState; + + /**/ + var util = __webpack_require__(212); + util.inherits = __webpack_require__(194); + /**/ + + /**/ + var internalUtil = { + deprecate: __webpack_require__(218) }; - process.umask = function() { return 0; }; + /**/ + /**/ + var Stream; + (function () { + try { + Stream = __webpack_require__(207); + } catch (_) {} finally { + if (!Stream) Stream = __webpack_require__(208).EventEmitter; + } + })(); + /**/ -/***/ }, -/* 222 */ -/***/ function(module, exports) { + var Buffer = __webpack_require__(178).Buffer; - module.exports = function isBuffer(arg) { - return arg && typeof arg === 'object' - && typeof arg.copy === 'function' - && typeof arg.fill === 'function' - && typeof arg.readUInt8 === 'function'; + util.inherits(Writable, Stream); + + function nop() {} + + function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; } -/***/ }, -/* 223 */ -/***/ function(module, exports) { + var Duplex; + function WritableState(options, stream) { + Duplex = Duplex || __webpack_require__(214); - if (typeof Object.create === 'function') { - // implementation from standard node.js 'util' module - module.exports = function inherits(ctor, superCtor) { - ctor.super_ = superCtor - ctor.prototype = Object.create(superCtor.prototype, { - constructor: { - value: ctor, - enumerable: false, - writable: true, - configurable: true - } - }); + options = options || {}; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + var hwm = options.highWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm; + + // cast to ints. + this.highWaterMark = ~ ~this.highWaterMark; + + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function (er) { + onwrite(stream, er); }; - } else { - // old school shim for old browsers - module.exports = function inherits(ctor, superCtor) { - ctor.super_ = superCtor - var TempCtor = function () {} - TempCtor.prototype = superCtor.prototype - ctor.prototype = new TempCtor() - ctor.prototype.constructor = ctor - } - } + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; -/***/ }, -/* 224 */ -/***/ function(module, exports, __webpack_require__) { + // the amount that is being written when _write is called. + this.writelen = 0; - - /** - * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined - * in FIPS 180-2 - * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009. - * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet - * - */ + this.bufferedRequest = null; + this.lastBufferedRequest = null; - var inherits = __webpack_require__(220).inherits + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; - module.exports = function (Buffer, Hash) { + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; - var K = [ - 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, - 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, - 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, - 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, - 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, - 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, - 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, - 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, - 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, - 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, - 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, - 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, - 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, - 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, - 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, - 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 - ] + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; + + // count buffered requests + this.bufferedRequestCount = 0; + + // create the two objects needed to store the corked requests + // they are not a linked list, as no new elements are inserted in there + this.corkedRequestsFree = new CorkedRequest(this); + this.corkedRequestsFree.next = new CorkedRequest(this); + } + + WritableState.prototype.getBuffer = function writableStateGetBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; + }; + + (function () { + try { + Object.defineProperty(WritableState.prototype, 'buffer', { + get: internalUtil.deprecate(function () { + return this.getBuffer(); + }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.') + }); + } catch (_) {} + })(); - var W = new Array(64) + var Duplex; + function Writable(options) { + Duplex = Duplex || __webpack_require__(214); - function Sha256() { - this.init() + // Writable ctor is applied to Duplexes, though they're not + // instanceof Writable, they're instanceof Readable. + if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options); - this._w = W //new Array(64) + this._writableState = new WritableState(options, this); - Hash.call(this, 16*4, 14*4) + // legacy. + this.writable = true; + + if (options) { + if (typeof options.write === 'function') this._write = options.write; + + if (typeof options.writev === 'function') this._writev = options.writev; } - inherits(Sha256, Hash) + Stream.call(this); + } - Sha256.prototype.init = function () { + // Otherwise people can pipe Writable streams, which is just wrong. + Writable.prototype.pipe = function () { + this.emit('error', new Error('Cannot pipe. Not readable.')); + }; - this._a = 0x6a09e667|0 - this._b = 0xbb67ae85|0 - this._c = 0x3c6ef372|0 - this._d = 0xa54ff53a|0 - this._e = 0x510e527f|0 - this._f = 0x9b05688c|0 - this._g = 0x1f83d9ab|0 - this._h = 0x5be0cd19|0 + function writeAfterEnd(stream, cb) { + var er = new Error('write after end'); + // TODO: defer error events consistently everywhere, not just the cb + stream.emit('error', er); + processNextTick(cb, er); + } - this._len = this._s = 0 + // If we get something that is not a buffer, string, null, or undefined, + // and we're not in objectMode, then that's an error. + // Otherwise stream chunks are all considered to be of length=1, and the + // watermarks determine how many objects to keep in the buffer, rather than + // how many bytes or characters. + function validChunk(stream, state, chunk, cb) { + var valid = true; - return this + if (!Buffer.isBuffer(chunk) && typeof chunk !== 'string' && chunk !== null && chunk !== undefined && !state.objectMode) { + var er = new TypeError('Invalid non-string/buffer chunk'); + stream.emit('error', er); + processNextTick(cb, er); + valid = false; } + return valid; + } - function S (X, n) { - return (X >>> n) | (X << (32 - n)); - } + Writable.prototype.write = function (chunk, encoding, cb) { + var state = this._writableState; + var ret = false; - function R (X, n) { - return (X >>> n); + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; } - function Ch (x, y, z) { - return ((x & y) ^ ((~x) & z)); - } + if (Buffer.isBuffer(chunk)) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; - function Maj (x, y, z) { - return ((x & y) ^ (x & z) ^ (y & z)); - } + if (typeof cb !== 'function') cb = nop; - function Sigma0256 (x) { - return (S(x, 2) ^ S(x, 13) ^ S(x, 22)); + if (state.ended) writeAfterEnd(this, cb);else if (validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, chunk, encoding, cb); } - function Sigma1256 (x) { - return (S(x, 6) ^ S(x, 11) ^ S(x, 25)); - } + return ret; + }; - function Gamma0256 (x) { - return (S(x, 7) ^ S(x, 18) ^ R(x, 3)); - } + Writable.prototype.cork = function () { + var state = this._writableState; - function Gamma1256 (x) { - return (S(x, 17) ^ S(x, 19) ^ R(x, 10)); + state.corked++; + }; + + Writable.prototype.uncork = function () { + var state = this._writableState; + + if (state.corked) { + state.corked--; + + if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); } + }; - Sha256.prototype._update = function(M) { + Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + // node::ParseEncoding() requires lower case. + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); + this._writableState.defaultEncoding = encoding; + }; - var W = this._w - var a, b, c, d, e, f, g, h - var T1, T2 + function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { + chunk = new Buffer(chunk, encoding); + } + return chunk; + } - a = this._a | 0 - b = this._b | 0 - c = this._c | 0 - d = this._d | 0 - e = this._e | 0 - f = this._f | 0 - g = this._g | 0 - h = this._h | 0 + // if we're already writing something, then just put this + // in the queue, and wait our turn. Otherwise, call _write + // If we return false, then we need a drain event, so set that flag. + function writeOrBuffer(stream, state, chunk, encoding, cb) { + chunk = decodeChunk(state, chunk, encoding); - for (var j = 0; j < 64; j++) { - var w = W[j] = j < 16 - ? M.readInt32BE(j * 4) - : Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16] + if (Buffer.isBuffer(chunk)) encoding = 'buffer'; + var len = state.objectMode ? 1 : chunk.length; - T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w + state.length += len; - T2 = Sigma0256(a) + Maj(a, b, c); - h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2; + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + + if (state.writing || state.corked) { + var last = state.lastBufferedRequest; + state.lastBufferedRequest = new WriteReq(chunk, encoding, cb); + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; } + state.bufferedRequestCount += 1; + } else { + doWrite(stream, state, false, len, chunk, encoding, cb); + } - this._a = (a + this._a) | 0 - this._b = (b + this._b) | 0 - this._c = (c + this._c) | 0 - this._d = (d + this._d) | 0 - this._e = (e + this._e) | 0 - this._f = (f + this._f) | 0 - this._g = (g + this._g) | 0 - this._h = (h + this._h) | 0 + return ret; + } - }; + function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); + state.sync = false; + } - Sha256.prototype._hash = function () { - var H = new Buffer(32) + function onwriteError(stream, state, sync, er, cb) { + --state.pendingcb; + if (sync) processNextTick(cb, er);else cb(er); - H.writeInt32BE(this._a, 0) - H.writeInt32BE(this._b, 4) - H.writeInt32BE(this._c, 8) - H.writeInt32BE(this._d, 12) - H.writeInt32BE(this._e, 16) - H.writeInt32BE(this._f, 20) - H.writeInt32BE(this._g, 24) - H.writeInt32BE(this._h, 28) + stream._writableState.errorEmitted = true; + stream.emit('error', er); + } - return H - } + function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; + } - return Sha256 + function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + + onwriteStateUpdate(state); + + if (er) onwriteError(stream, state, sync, er, cb);else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(state); + if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { + clearBuffer(stream, state); + } + + if (sync) { + /**/ + asyncWrite(afterWrite, stream, state, finished, cb); + /**/ + } else { + afterWrite(stream, state, finished, cb); + } + } } + function afterWrite(stream, state, finished, cb) { + if (!finished) onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); + } -/***/ }, -/* 225 */ -/***/ function(module, exports, __webpack_require__) { + // Must force callback to be called on nextTick, so that we don't + // emit 'drain' before the write() consumer gets the 'false' return + // value, and has a chance to attach a 'drain' listener. + function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } + } - var inherits = __webpack_require__(220).inherits + // if there's something in the buffer waiting, then process it + function clearBuffer(stream, state) { + state.bufferProcessing = true; + var entry = state.bufferedRequest; - module.exports = function (Buffer, Hash) { - var K = [ - 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, - 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, - 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, - 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, - 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, - 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, - 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, - 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, - 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, - 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, - 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, - 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5, - 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, - 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4, - 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, - 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70, - 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, - 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df, - 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, - 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, - 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, - 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, - 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, - 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, - 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, - 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, - 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, - 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, - 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, - 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec, - 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, - 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b, - 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, - 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178, - 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, - 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b, - 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, - 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, - 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, - 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817 - ] + if (stream._writev && entry && entry.next) { + // Fast case, write everything using _writev() + var l = state.bufferedRequestCount; + var buffer = new Array(l); + var holder = state.corkedRequestsFree; + holder.entry = entry; - var W = new Array(160) + var count = 0; + while (entry) { + buffer[count] = entry; + entry = entry.next; + count += 1; + } - function Sha512() { - this.init() - this._w = W + doWrite(stream, state, true, state.length, buffer, '', holder.finish); - Hash.call(this, 128, 112) - } + // doWrite is always async, defer these to save a bit of time + // as the hot path ends with doWrite + state.pendingcb++; + state.lastBufferedRequest = null; + state.corkedRequestsFree = holder.next; + holder.next = null; + } else { + // Slow case, write chunks one-by-one + while (entry) { + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + + doWrite(stream, state, false, len, chunk, encoding, cb); + entry = entry.next; + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + break; + } + } - inherits(Sha512, Hash) + if (entry === null) state.lastBufferedRequest = null; + } - Sha512.prototype.init = function () { + state.bufferedRequestCount = 0; + state.bufferedRequest = entry; + state.bufferProcessing = false; + } - this._a = 0x6a09e667|0 - this._b = 0xbb67ae85|0 - this._c = 0x3c6ef372|0 - this._d = 0xa54ff53a|0 - this._e = 0x510e527f|0 - this._f = 0x9b05688c|0 - this._g = 0x1f83d9ab|0 - this._h = 0x5be0cd19|0 + Writable.prototype._write = function (chunk, encoding, cb) { + cb(new Error('not implemented')); + }; - this._al = 0xf3bcc908|0 - this._bl = 0x84caa73b|0 - this._cl = 0xfe94f82b|0 - this._dl = 0x5f1d36f1|0 - this._el = 0xade682d1|0 - this._fl = 0x2b3e6c1f|0 - this._gl = 0xfb41bd6b|0 - this._hl = 0x137e2179|0 + Writable.prototype._writev = null; - this._len = this._s = 0 + Writable.prototype.end = function (chunk, encoding, cb) { + var state = this._writableState; - return this + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; } - function S (X, Xl, n) { - return (X >>> n) | (Xl << (32 - n)) + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); } - function Ch (x, y, z) { - return ((x & y) ^ ((~x) & z)); + // ignore unnecessary end() calls. + if (!state.ending && !state.finished) endWritable(this, state, cb); + }; + + function needFinish(state) { + return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; + } + + function prefinish(stream, state) { + if (!state.prefinished) { + state.prefinished = true; + stream.emit('prefinish'); } + } - function Maj (x, y, z) { - return ((x & y) ^ (x & z) ^ (y & z)); + function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + if (state.pendingcb === 0) { + prefinish(stream, state); + state.finished = true; + stream.emit('finish'); + } else { + prefinish(stream, state); + } } + return need; + } - Sha512.prototype._update = function(M) { + function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) processNextTick(cb);else stream.once('finish', cb); + } + state.ended = true; + stream.writable = false; + } - var W = this._w - var a, b, c, d, e, f, g, h - var al, bl, cl, dl, el, fl, gl, hl + // It seems a linked list but it is not + // there will be only 2 of these for each stream + function CorkedRequest(state) { + var _this = this; - a = this._a | 0 - b = this._b | 0 - c = this._c | 0 - d = this._d | 0 - e = this._e | 0 - f = this._f | 0 - g = this._g | 0 - h = this._h | 0 + this.next = null; + this.entry = null; - al = this._al | 0 - bl = this._bl | 0 - cl = this._cl | 0 - dl = this._dl | 0 - el = this._el | 0 - fl = this._fl | 0 - gl = this._gl | 0 - hl = this._hl | 0 + this.finish = function (err) { + var entry = _this.entry; + _this.entry = null; + while (entry) { + var cb = entry.callback; + state.pendingcb--; + cb(err); + entry = entry.next; + } + if (state.corkedRequestsFree) { + state.corkedRequestsFree.next = _this; + } else { + state.corkedRequestsFree = _this; + } + }; + } + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(189), __webpack_require__(216).setImmediate)) - for (var i = 0; i < 80; i++) { - var j = i * 2 +/***/ }, +/* 216 */ +/***/ function(module, exports, __webpack_require__) { - var Wi, Wil + /* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) || + (typeof self !== "undefined" && self) || + window; + var apply = Function.prototype.apply; - if (i < 16) { - Wi = W[j] = M.readInt32BE(j * 4) - Wil = W[j + 1] = M.readInt32BE(j * 4 + 4) + // DOM APIs, for completeness - } else { - var x = W[j - 15*2] - var xl = W[j - 15*2 + 1] - var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ (x >>> 7) - var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7) + exports.setTimeout = function() { + return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout); + }; + exports.setInterval = function() { + return new Timeout(apply.call(setInterval, scope, arguments), clearInterval); + }; + exports.clearTimeout = + exports.clearInterval = function(timeout) { + if (timeout) { + timeout.close(); + } + }; - x = W[j - 2*2] - xl = W[j - 2*2 + 1] - var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ (x >>> 6) - var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6) + function Timeout(id, clearFn) { + this._id = id; + this._clearFn = clearFn; + } + Timeout.prototype.unref = Timeout.prototype.ref = function() {}; + Timeout.prototype.close = function() { + this._clearFn.call(scope, this._id); + }; - // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16] - var Wi7 = W[j - 7*2] - var Wi7l = W[j - 7*2 + 1] + // Does not start the time, just sets up the members needed. + exports.enroll = function(item, msecs) { + clearTimeout(item._idleTimeoutId); + item._idleTimeout = msecs; + }; - var Wi16 = W[j - 16*2] - var Wi16l = W[j - 16*2 + 1] + exports.unenroll = function(item) { + clearTimeout(item._idleTimeoutId); + item._idleTimeout = -1; + }; - Wil = gamma0l + Wi7l - Wi = gamma0 + Wi7 + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0) - Wil = Wil + gamma1l - Wi = Wi + gamma1 + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0) - Wil = Wil + Wi16l - Wi = Wi + Wi16 + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0) + exports._unrefActive = exports.active = function(item) { + clearTimeout(item._idleTimeoutId); - W[j] = Wi - W[j + 1] = Wil - } + var msecs = item._idleTimeout; + if (msecs >= 0) { + item._idleTimeoutId = setTimeout(function onTimeout() { + if (item._onTimeout) + item._onTimeout(); + }, msecs); + } + }; - var maj = Maj(a, b, c) - var majl = Maj(al, bl, cl) + // setimmediate attaches itself to the global object + __webpack_require__(217); + // On some exotic environments, it's not clear which object `setimmediate` was + // able to install onto. Search each possibility in the same order as the + // `setimmediate` library. + exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) || + (typeof global !== "undefined" && global.setImmediate) || + (this && this.setImmediate); + exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) || + (typeof global !== "undefined" && global.clearImmediate) || + (this && this.clearImmediate); - var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7) - var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7) - var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9) - var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9) + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) - // t1 = h + sigma1 + ch + K[i] + W[i] - var Ki = K[j] - var Kil = K[j + 1] +/***/ }, +/* 217 */ +/***/ function(module, exports, __webpack_require__) { - var ch = Ch(e, f, g) - var chl = Ch(el, fl, gl) + /* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) { + "use strict"; - var t1l = hl + sigma1l - var t1 = h + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0) - t1l = t1l + chl - t1 = t1 + ch + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0) - t1l = t1l + Kil - t1 = t1 + Ki + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0) - t1l = t1l + Wil - t1 = t1 + Wi + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0) + if (global.setImmediate) { + return; + } - // t2 = sigma0 + maj - var t2l = sigma0l + majl - var t2 = sigma0h + maj + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0) + var nextHandle = 1; // Spec says greater than zero + var tasksByHandle = {}; + var currentlyRunningATask = false; + var doc = global.document; + var registerImmediate; - h = g - hl = gl - g = f - gl = fl - f = e - fl = el - el = (dl + t1l) | 0 - e = (d + t1 + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0 - d = c - dl = cl - c = b - cl = bl - b = a - bl = al - al = (t1l + t2l) | 0 - a = (t1 + t2 + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0 + function setImmediate(callback) { + // Callback can either be a function or a string + if (typeof callback !== "function") { + callback = new Function("" + callback); + } + // Copy function arguments + var args = new Array(arguments.length - 1); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i + 1]; + } + // Store and register the task + var task = { callback: callback, args: args }; + tasksByHandle[nextHandle] = task; + registerImmediate(nextHandle); + return nextHandle++; } - this._al = (this._al + al) | 0 - this._bl = (this._bl + bl) | 0 - this._cl = (this._cl + cl) | 0 - this._dl = (this._dl + dl) | 0 - this._el = (this._el + el) | 0 - this._fl = (this._fl + fl) | 0 - this._gl = (this._gl + gl) | 0 - this._hl = (this._hl + hl) | 0 + function clearImmediate(handle) { + delete tasksByHandle[handle]; + } - this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0 - this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0 - this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0 - this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0 - this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0 - this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0 - this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0 - this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0 - } + function run(task) { + var callback = task.callback; + var args = task.args; + switch (args.length) { + case 0: + callback(); + break; + case 1: + callback(args[0]); + break; + case 2: + callback(args[0], args[1]); + break; + case 3: + callback(args[0], args[1], args[2]); + break; + default: + callback.apply(undefined, args); + break; + } + } - Sha512.prototype._hash = function () { - var H = new Buffer(64) + function runIfPresent(handle) { + // From the spec: "Wait until any invocations of this algorithm started before this one have completed." + // So if we're currently running a task, we'll need to delay this invocation. + if (currentlyRunningATask) { + // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a + // "too much recursion" error. + setTimeout(runIfPresent, 0, handle); + } else { + var task = tasksByHandle[handle]; + if (task) { + currentlyRunningATask = true; + try { + run(task); + } finally { + clearImmediate(handle); + currentlyRunningATask = false; + } + } + } + } - function writeInt64BE(h, l, offset) { - H.writeInt32BE(h, offset) - H.writeInt32BE(l, offset + 4) + function installNextTickImplementation() { + registerImmediate = function(handle) { + process.nextTick(function () { runIfPresent(handle); }); + }; } - writeInt64BE(this._a, this._al, 0) - writeInt64BE(this._b, this._bl, 8) - writeInt64BE(this._c, this._cl, 16) - writeInt64BE(this._d, this._dl, 24) - writeInt64BE(this._e, this._el, 32) - writeInt64BE(this._f, this._fl, 40) - writeInt64BE(this._g, this._gl, 48) - writeInt64BE(this._h, this._hl, 56) + function canUsePostMessage() { + // The test against `importScripts` prevents this implementation from being installed inside a web worker, + // where `global.postMessage` means something completely different and can't be used for this purpose. + if (global.postMessage && !global.importScripts) { + var postMessageIsAsynchronous = true; + var oldOnMessage = global.onmessage; + global.onmessage = function() { + postMessageIsAsynchronous = false; + }; + global.postMessage("", "*"); + global.onmessage = oldOnMessage; + return postMessageIsAsynchronous; + } + } - return H - } + function installPostMessageImplementation() { + // Installs an event handler on `global` for the `message` event: see + // * https://developer.mozilla.org/en/DOM/window.postMessage + // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages + + var messagePrefix = "setImmediate$" + Math.random() + "$"; + var onGlobalMessage = function(event) { + if (event.source === global && + typeof event.data === "string" && + event.data.indexOf(messagePrefix) === 0) { + runIfPresent(+event.data.slice(messagePrefix.length)); + } + }; - return Sha512 + if (global.addEventListener) { + global.addEventListener("message", onGlobalMessage, false); + } else { + global.attachEvent("onmessage", onGlobalMessage); + } - } + registerImmediate = function(handle) { + global.postMessage(messagePrefix + handle, "*"); + }; + } + function installMessageChannelImplementation() { + var channel = new MessageChannel(); + channel.port1.onmessage = function(event) { + var handle = event.data; + runIfPresent(handle); + }; -/***/ }, -/* 226 */ -/***/ function(module, exports, __webpack_require__) { + registerImmediate = function(handle) { + channel.port2.postMessage(handle); + }; + } - /* - * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message - * Digest Algorithm, as defined in RFC 1321. - * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002. - * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet - * Distributed under the BSD License - * See http://pajhome.org.uk/crypt/md5 for more info. - */ + function installReadyStateChangeImplementation() { + var html = doc.documentElement; + registerImmediate = function(handle) { + // Create a