Added logging, changed some directory structure

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/.npmignore

@@ -0,0 +1,11 @@
+docs
+examples
+test
+lib-cov
+.editorconfig
+.jshintignore
+.jshintrc
+.travis.yml
+lcov.info
+logo.svg
+CHANGELOG.MD

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/.svgo.yml

@@ -0,0 +1,68 @@
+# replace default config
+
+# multipass: true
+# full: true
+
+plugins:
+
+  # - name
+  #
+  # or:
+  # - name: false
+  # - name: true
+  #
+  # or:
+  # - name:
+  #     param1: 1
+  #     param2: 2
+
+  - removeDoctype
+  - removeXMLProcInst
+  - removeComments
+  - removeMetadata
+  - removeXMLNS
+  - removeEditorsNSData
+  - cleanupAttrs
+  - minifyStyles
+  - convertStyleToAttrs
+  - cleanupIDs
+  - removeRasterImages
+  - removeUselessDefs
+  - cleanupNumericValues
+  - cleanupListOfValues
+  - convertColors
+  - removeUnknownsAndDefaults
+  - removeNonInheritableGroupAttrs
+  - removeUselessStrokeAndFill
+  - removeViewBox
+  - cleanupEnableBackground
+  - removeHiddenElems
+  - removeEmptyText
+  - convertShapeToPath
+  - moveElemsAttrsToGroup
+  - moveGroupAttrsToElems
+  - collapseGroups
+  - convertPathData
+  - convertTransform
+  - removeEmptyAttrs
+  - removeEmptyContainers
+  - mergePaths
+  - removeUnusedNS
+  - transformsWithOnePath
+  - sortAttrs
+  - removeTitle
+  - removeDesc
+  - removeDimensions
+  - removeAttrs
+  - removeElementsByAttr
+  - addClassesToSVGElement
+  - removeStyleElement
+  - addAttributesToSVGElement
+
+# configure the indent (default 4 spaces) used by `--pretty` here:
+#
+# @see https://github.com/svg/svgo/blob/master/lib/svgo/js2svg.js#L6 for more config options
+#
+# js2svg:
+#  pretty: true
+#  indent: '  '

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/CHANGELOG.md

@@ -0,0 +1,421 @@
+### [ [>](https://github.com/svg/svgo/tree/v0.7.2) ] 0.7.2 / 29.01.2017
+* Extended `currentColor` match conditions (string, rx, bool) (by @AlimovSV)
+* Fixed removing `<animate>` in `<stop>`.
+* Fixed removing same transform in inner element in `removeUnknownsAndDefaults`.
+* Fixed collapsing groups with same non-inheritable attribue.
+* Corrected removing of leading zero in case of exponential notation.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.7.1) ] 0.7.1 / 27.09.2016
+* Reverted the requirement of Node.js to version 0.10.
+* Added `addAttributesToSVGElement` to the default config to allow using it with `--enable` option.
+* Added korean translation of “How it works” doc (by @primeiros).
+
+### [ [>](https://github.com/svg/svgo/tree/v0.7.0) ] 0.7.0 / 25.08.2016
+* Required Node.js version has increased to 0.12.
+* New plugins: `removeElementsByAttr` (by IDs or classes) by @elidupuis,
+  `addAttributesToSVGElement` by @gjjones,
+  `removeXMLNS` (for SVG inlining) by @ricardobeat.
+* Tests now correctly pass in Windows with CRLF line endings. Pretty print now accounts system line endings.
+* Fixed bugs with collapsing groups with masks and transforms in `collapseGroups`.
+* Fixed bugs with erroneous removing IDs in `cleanupIDs`.
+* Improved attributes sorting in `sortAttrs` by @darktrojan.
+* `addClassesToSVGElement` no more repeats classes (by @ricardobeat).
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.6) ] 0.6.6 / 25.04.2016
+* Corrected CSSO API usage
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.5) ] 0.6.5 / 25.04.2016
+* Extra content inserted by editors are now being removed within `<foreignObject>` as well thus fixing bug “Namespace prefix … is not defined“ after applying SVGO.
+* Doctype with entities declartion is now also being removed since svgo correctly parses them starting from the version [0.6.2](https://github.com/svg/svgo/tree/v0.6.2).
+* Corrected `moveGroupAttrsToElems` not to move attributes to `g` content if it's referenced (has an `id`).
+* `collapseGroups` now don't collapse a group if it has an animated attribute (SMIL).
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.4) ] 0.6.4 / 05.04.2016
+* Fixed bug in “[convertStyleToAttrs](https://github.com/svg/svgo/blob/master/plugins/convertStyleToAttrs.js)” plugin with converting styling properties to non-existent attributes (which are normally removed later by `removeUnknownsAndDefaults`).
+* Added `--indent` option to style pretty-printed SVG. (e.g. `--indent 2`) (by @scurker).
+* Added `currentColor` param to `convertColors` plugin for converting values like `fill` and `stroke` to `currentColor` (by @scurker).
+* Bumped CSSO to the current version and used [its new shiny API](https://github.com/css/csso#api) (thanks to @lahmatiy).
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.3) ] 0.6.3 / 20.03.2016
+* Smart rounding (introduced in 0.4.5) now applies only when rounding is needed, thus making subsequent passes more stable.
+* Fixed regression in converting curves to arcs.
+* `xlink:href` references are now being checked by local name `href`, thus correctly working with another namespace prefix.
+* Fixed `id` removing with disabled `plugins/convertStyleToAttrs.js`.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.2) ] 0.6.2 / 08.03.2016
+* Better error handling and messaging improvements.
+* SVG files with XML entities (e.g. from Adobe Illustrator) are now correctly being parsed.
+* Fixed error on converting curves to arcs.
+* Corrected rounding in subsequent passes with `--multipass` option.
+* Data URI option now handles charset (by @holymonson)
+* Tranformations are no longer moved to group if there is a mask (`plugins/moveElemsAttrsToGroup.js`).
+* Fixed matrix decomposition losing sign in case like `[1, 0, 0, -1, 0, 0]` (`scale(1 -1)`).
+* Fixed crash on uppercased color name.
+* Paths with `id` and without `stroke-width` aren't being trasformed now since `stroke-width` may be applied later.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.1) ] 0.6.1 / 21.11.2015
+* Added option `--quiet` to suppress output (by @phihag).
+* Removed `lib-cov` folder from the package, which was erroneously included before.
+* Fixed errors in “[minifyStyles](https://github.com/svg/svgo/blob/master/plugins/minifyStyles.js)” when there are `<style>` elements with `CDATA` content or without content at all.
+* Amended transform functions parsing to prevent errors when there are no separators between numbers (which isn't allowed by syntax, but understood by browsers).
+
+### [ [>](https://github.com/svg/svgo/tree/v0.6.0) ] 0.6.0 / 08.11.2015
+* New optimization: circular curves now being converted to arcs. A notable improvement for circles within paths.
+* New plugin “[minifyStyles](https://github.com/svg/svgo/blob/master/plugins/minifyStyles.js)” which minifies `<style>` elments content with CSSO by @strarsis (svgo still doesn't understand its content)
+* New plugin “[removeStyleElement](https://github.com/svg/svgo/blob/master/plugins/removeStyleElement.js)” (disabled by default) by @betsydupuis.
+* Fixed issues wuth parsing numbers with exponent fraction (could happen with high precision >= 7).
+* Fixed rounding error due to incorrect preserving of precision in transformations.
+* Fixed shortand curve distortion due to converted previous curve to not a curve.
+* Fixed interoperability issue with `precision` cli-option and `full` config.
+* Fixed an error produced by “[removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js)” by @thiakil
+* Another Inkscape prefix namespace is being removed.
+* Fixed an issue in [moveElemsAttrsToGroup“](https://github.com/svg/svgo/blob/master/plugins/moveElemsAttrsToGroup“.js)” with transforms moved around `clip-path`.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.6) ] 0.5.6 / 13.08.2015
+* Fixed paths removing.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.5) ] 0.5.5 / 05.08.2015
+* Reverted debugging changes.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.4) ] 0.5.4 / 05.08.2015
+* New parameter `useShortTags` by @bradbarrow. Now svgo can produce correct non-selfclosing tags (useful in HTML in old browsers).
+* Fixed failing on empty transformation (which could be produced by two opposite).
+* Fixed removing paths which have numbers with exponent notation.
+* Fixed a bug with arc transformation.
+* Some typo fixes.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.3) ] 0.5.3 / 21.06.2015
+* Fixed breaking related to rounding functions in “[convertTransform](https://github.com/svg/svgo/blob/master/plugins/convertTransform.js)”.
+* Fixed a bug with ID in animations not being worked on by “[cleanupIDs](https://github.com/svg/svgo/blob/master/plugins/cleanupIDs.js)”.
+* Fixed a bug with quoted reference in `url()`.
+* Now, if there are several same IDs in the document, then the first one is used and others are being removed.
+* New command-line option `--show-plugins` displaying list of plugins.
+* Two new optional plugins: “[removeDimensions](https://github.com/svg/svgo/blob/master/plugins/removeDimensions.js)” (removes `width` and `height` if there is `viewBox`) and “[removeAttrsPlugin](https://github.com/svg/svgo/blob/master/plugins/removeAttrs.js)” (by @bennyschudel).
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.2) ] 0.5.2 / 24.05.2015
+* Introduced new `transformPrecision` option for better image quality (defaults to 5) in “[convertTransform](https://github.com/svg/svgo/blob/master/plugins/convertTransform.js)” and “[convertPathData](https://github.com/svg/svgo/blob/master/plugins/convertPathData.js)” (for the purpose of applying transformations) plugins.
+* Matrix transformations now can be decomposed into a combination of few simple transforms like `translate`, `rotate`, `scale`.
+* Arcs (paths `arcto` command) are now correctly being transformed into another arcs without being converting to Bezier curves.
+* Fixed an issue with “[mergePaths](https://github.com/svg/svgo/blob/master/plugins/mergePaths.js)” failing to detect paths intersection in some cases.
+* Fixed a bug with “[removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js)” removing some paths, which was introduced in [v0.5.1](https://github.com/svg/svgo/tree/v0.5.1).
+* Fixed a bug with transformation having `rotate()` with optional parameters.
+* Patterns with inherited attributes are no longer being removed.
+* Styles are no longer being removed from `<desc>` (by @dennari).
+* SVGO no longer breaks during parsing.
+* Added `clone()` method to JSAPI (by @jakearchibald)
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.1) ] 0.5.1 / 30.03.2015
+* added new command-line option to set precision in floating point numbers.
+* fixed all known image-disruptive bugs
+* Notably [mergePaths](https://github.com/svg/svgo/blob/master/plugins/mergePaths.js) plugin now checks for possible intersections to avoid side-effects
+* new plugin [removeUselessDefs](https://github.com/svg/svgo/blob/master/plugins/removeUselessDefs.js) to remove elements in ``<defs>`` and similar non-rendering elements without an ``id`` and thus cannot be used
+* fix for ``--multipass`` command line option (by @dfilatov)
+* improved [cleanupEnableBackground](https://github.com/svg/svgo/blob/master/plugins/cleanupEnableBackground.js) and [convertColors](https://github.com/svg/svgo/blob/master/plugins/convertColors.js) plugins (by @YetiOr)
+* new plugin for image manipulation [cleanupListOfValues](https://github.com/svg/svgo/blob/master/plugins/cleanupListOfValues.js) (by @kiyopikko)
+* fixed fail on comments after closing root ``</svg>`` tag
+* updated parsing to account meaningful spaces in ``<text>``
+* ``data-*`` attributes are now preserved in [removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js)
+* prevented plugins from failing in ``<foreignObject>``
+* [cleanupNumericValues](https://github.com/svg/svgo/blob/master/plugins/cleanupNumericValues.js) plugin now converts other units to pixels (if it's better)
+* [removeUselessStrokeAndFill](https://github.com/svg/svgo/blob/master/plugins/removeUselessStrokeAndFill.js) plugin is enabled again with correct work in case of inherited attributes
+* fixed fail on images with incorrect paths like ``<path d="z"/>``
+* svgo now understands if an input is a folder (remember, you can set output to folder as well)
+* added support for some properties from SVG 2 like ``vector-effect="non-scaling-stroke"``
+* removed option to remove an ``id`` on root ``<svg>`` tag in [removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js) since it's already being done in [cleanupIDs](https://github.com/svg/svgo/blob/master/plugins/cleanupIDs.js)
+
+### [ [>](https://github.com/svg/svgo/tree/v0.5.0) ] 0.5.0 / 05.11.2014
+* added ``--multipass`` command line option which repeatedly applies optimizations like collapsing groups (by @dfilatov)
+* exposed JSAPI as a factory method (by @mistakster)
+* added removeDesc plugin (by @dwabyick), disabled by default
+* [removeUselessStrokeAndFill](https://github.com/svg/svgo/blob/master/plugins/removeUselessStrokeAndFill.js) plugin is disabled by default since it's unable to check inherited properties
+* transformations now apply to paths with arcs in [plugins/convertPathData](https://github.com/svg/svgo/blob/master/plugins/convertPathData.js)
+* a lot of bug fixes mostly related to transformations
+
+### [ [>](https://github.com/svg/svgo/tree/v0.4.5) ] 0.4.5 / 02.08.2014
+* significally improved plugin [plugins/convertPathData](https://github.com/svg/svgo/blob/master/plugins/convertPathData.js):
+  - Now data is being written relative or absolute whichever is shorter. You can turn it off by setting ``utilizeAbsolute`` to ``false``.
+  - Smarter rounding: values like 2.499 now rounds to 2.5. Rounding now takes in account accumulutive error meaning that points will not be misplaced due to rounding more than it neccessary.
+  - Fixed couple bugs.
+* ``--output`` option now can be a folder along with ``--folder``, thanks to @mako-taco.
+* [plugins/cleanupIDs](https://github.com/svg/svgo/blob/master/plugins/cleanupIDs.js) now have ``prefix`` option in case you want to combine multiple svg later (by @DanielMazurkiewicz).
+* Quotes now being escaped in attributes (by @ditesh).
+* Minor bugfixes.
+
+### [ [>](https://github.com/svg/svgo/tree/v0.4.4) ] 0.4.4 / 14.01.2014
+* new plugin [plugins/removeTitle](https://github.com/svg/svgo/blob/master/plugins/removeTitle.js) (disabled by default, close [#159](https://github.com/svg/svgo/issues/159))
+* plugins/convertPathData: skip data concatenation for z instruction in collapseRepeated
+* plugins/removeUnknownsAndDefaults: do not remove overriden attributes with default values (fix [#161](https://github.com/svg/svgo/issues/161) and [#168](https://github.com/svg/svgo/issues/168))
+* plugins/removeViewBox: disable by default (fix [#139](https://github.com/svg/svgo/issues/139))
+* update README with [gulp task](https://github.com/ben-eb/gulp-svgmin)
+
+### [ [>](https://github.com/svg/svgo/tree/v0.4.3) ] 0.4.3 / 02.01.2014
+* new plugin [plugins/convertShapeToPath](https://github.com/svg/svgo/blob/master/plugins/convertShapeToPath.js) (close [#96](https://github.com/svg/svgo/issues/96))
+* update sax version to fix [#140](https://github.com/svg/svgo/issues/140)
+* update deps
+
+### [ [>](https://github.com/svg/svgo/tree/v0.4.2) ] 0.4.2 / 19.12.2013
+* add `lcov.info` to npmignore
+* fix `js-yaml` version to suppress deprecation warning in stdout
+
+### [ [>](https://github.com/svg/svgo/tree/v0.4.1) ] 0.4.1 / 18.11.2013
+* node >=0.8.0
+
+### [ [>](https://github.com/svg/svgo/tree/v0.4.0) ] 0.4.0 / 18.11.2013
+* merge almost all pull-requests
+* update dependencies
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.7) ] 0.3.7 / 24.06.2013
+* do not remove `result` attribute from filter primitives (fix [#122](https://github.com/svg/svgo/issues/122))
+* plugins/cleanupAttrs: replace newline with space when needed (fix [#119](https://github.com/svg/svgo/issues/119))
+* lib/coa: look for config file in current folder
+* lib/coa: always traverse all files in the given folder
+* deprecate svgo-grunt in favor of [grunt-svgmin](https://github.com/sindresorhus/grunt-svgmin)
+* re-enable node-coveralls
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.6) ] 0.3.6 / 06.06.2013
+* plugins/removeNonInheritableGroupAttrs: more attrs groups to exclude (fix [#116](https://github.com/svg/svgo/issues/116) & [#118](https://github.com/svg/svgo/issues/118))
+* lib/coa: optimize folder file by file (temp fix [#114](https://github.com/svg/svgo/issues/114))
+* `.jshintrc`: JSHint 2.0
+* temporarily disable node-coveralls
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.5) ] 0.3.5 / 07.05.2013
+* plugins/transformsWithOnePath: fix curves bounding box calculation
+* plugins/transformsWithOnePath: fix possible c+t or q+s bug
+
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.4) ] 0.3.4 / 06.05.2013
+* plugins/convertPathData: fix m->M bug in some cases
+* plugins/transformsWithOnePath: fix last point calculation for C/S/Q/T
+* plugins/mergePaths: add space delimiter between z and m
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.3) ] 0.3.3 / 05.05.2013
+* plugins/convertPathData: convert very first m to M, fix applyTransforms with translate() (fix [#112](https://github.com/svg/svgo/issues/112))
+* plugins/transformsWithOnePath: fix real width/height rounding; fix scale transform origin; reorder transforms
+* plugins/transformsWithOnePath: ability to set new width or height independently with auto rescaling
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.2) ] 0.3.2 / 03.05.2013
+* new plugin [plugins/sortAttrs](https://github.com/svg/svgo/blob/master/plugins/sortAttrs.js)
+* plugins/transformsWithOnePath: buggy hcrop (fix [#111](https://github.com/svg/svgo/issues/111))
+* Impossible to set output presision to 0 (no fractional part) (fix [#110](https://github.com/svg/svgo/issues/110))
+* Istanbul + coveralls.io
+* update README with NPM version from badge.fury.io
+* update README with dependency status from gemnasium.com
+* npmignore unneeded files
+* reoptimized project logo
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.1) ] 0.3.1 / 15.04.2013
+* plugins/transformsWithOnePath: resize SVG and automatically rescale inner Path
+* better errors handling
+
+### [ [>](https://github.com/svg/svgo/tree/v0.3.0) ] 0.3.0 / 12.04.2013
+* global refactoring: getting rid of the many dependencies
+* new plugin [plugins/mergePaths](https://github.com/svg/svgo/blob/master/plugins/mergePaths.js)
+* new plugin [plugins/transformsWithOnePath](https://github.com/svg/svgo/blob/master/plugins/transformsWithOnePath.js) (renamed and featured `cropAndCenterAlongPath`)
+* config: replace default config with `full: true`
+* coa: JSON string as value of `--config`
+* coa: different types of Data URI strings (close [#105](https://github.com/svg/svgo/issues/105))
+* plugins/_transforms: allow spaces at the beginning of transform
+* Travis CI: Nodejs 0.10 & 0.11
+* `node.extend` → `whet.extend`
+* update `.gitignore`
+* update docs
+
+### [ [>](https://github.com/svg/svgo/tree/v0.2.4) ] 0.2.4 / 05.04.2013
+* new plugin [plugins/cropAndCenterAlongPath](https://github.com/svg/svgo/blob/master/plugins/cropAndCenterAlongPath.js) for the [Fontello](https://github.com/fontello) project
+
+### [ [>](https://github.com/svg/svgo/tree/v0.2.3) ] 0.2.3 / 22.02.2013
+* new plugin [plugins/removeNonInheritableGroupAttrs](https://github.com/svg/svgo/blob/master/plugins/removeNonInheritableGroupAttrs.js) (fix [#101](https://github.com/svg/svgo/issues/101))
+* new plugin [plugins/removeRasterImages](https://github.com/svg/svgo/blob/master/plugins/removeRasterImages.js) (close [#98](https://github.com/svg/svgo/issues/98))
+* plugins/convertTransform: bug with trailing spaces in transform value string (fix [#103](https://github.com/svg/svgo/issues/103))
+
+### [ [>](https://github.com/svg/svgo/tree/v0.2.2) ] 0.2.2 / 09.02.2013
+* plugins/convertTransforms: wrong translate() shorthand (fix [#94](https://github.com/svg/svgo/issues/94))
+* [yaml.js](https://github.com/jeremyfa/yaml.js) → [js-yaml](https://github.com/nodeca/js-yaml)
+* update outdated deps
+
+### [ [>](https://github.com/svg/svgo/tree/v0.2.1) ] 0.2.1 / 18.01.2013
+* plugins/moveElemsAttrsToGroup + plugins/moveGroupAttrsToElems: move or just leave transform attr from Group to the inner Path Elems (close [#86](https://github.com/svg/svgo/issues/86))
+* plugins/removeViewBox: doesn't catch floating-point numbers (fix [#88](https://github.com/svg/svgo/issues/88))
+* plugins/cleanupEnableBackground: doesn't catch floating-point numbers (fix [#89](https://github.com/svg/svgo/issues/89))
+* plugins/cleanupNumericValues: wrong floating-point numbers regexp (fix [#92](https://github.com/svg/svgo/issues/92))
+* SVG file generated by fontcustom.com not properly compressed (fix [#90](https://github.com/svg/svgo/issues/90))
+* `README.ru.md`: стилизация русского языка, улучшение языковых конструкций, правка ошибок (close [#91](https://github.com/svg/svgo/issues/91))
+* minor JSHint warning fix
+
+### [ [>](https://github.com/svg/svgo/tree/v0.2.0) ] 0.2.0 / 23.12.2012
+* plugins/convertPathData: apply transforms to Path pata (close [#33](https://github.com/svg/svgo/issues/33))
+* plugins/convertPathData: `-1.816-9.278.682-13.604` parsing error (fix [#85](https://github.com/svg/svgo/issues/85))
+* plugins/convertTransform: `translate(10, 0)` eq `translate(10)`, but not `translate(10, 10)` eq `translate(10)` (fix [#83](https://github.com/svg/svgo/issues/83))
+* run plugins/cleanupIDs before plugins/collapseGroups (fix [#84](https://github.com/svg/svgo/issues/84))
+* update `.gitignore`
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.9) ] 0.1.9 / 17.12.2012
+* plugins/cleanupIDs: renamed from removeUnusedIDs; minify used IDs (fix [#7](https://github.com/svg/svgo/issues/7))
+* lib/svgo/js2svg: restore HTML entities back (fix [#80](https://github.com/svg/svgo/issues/80) + [#81](https://github.com/svg/svgo/issues/81))
+* plugins/removeDoctype: do not remove if custom XML entities presents (fix [#77](https://github.com/svg/svgo/issues/77))
+* lib/svgo/coa: refactoring, colors and fix [#70](https://github.com/svg/svgo/issues/70)
+* lib/svgo: store elapsed time in result object
+* usage examples with SVGZ (close [#18](https://github.com/svg/svgo/issues/18))
+* more optimized logo
+* update `.gitignore`
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.8) ] 0.1.8 / 11.12.2012
+* new plugin [plugins/removeUselessStrokeAndFill](https://github.com/svg/svgo/blob/master/plugins/removeUselessStrokeAndFill.js) (close [#75](https://github.com/svg/svgo/issues/75))
+* new plugin [plugins/removeUnusedIDs](https://github.com/svg/svgo/blob/master/plugins/removeUnusedIDs.js) (close [#76](https://github.com/svg/svgo/issues/76))
+* plugins/convertPathData: wrong M interpretation in some cases (fix [#73](https://github.com/svg/svgo/issues/73))
+* plugins/cleanupAttrs: use `isElem()` API
+* `.travis.yml`: check all branches
+
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.7) ] 0.1.7 / 08.12.2012
+* plugins/convertPathData: incorrect interpretation of `z + m` (fix [#69](https://github.com/svg/svgo/issues/69))
+* plugins/convertTransform: do a more accurate floating numbers rounding in `matrixToTransform()` (fix [#68](https://github.com/svg/svgo/issues/68))
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.6) ] 0.1.6 / 07.12.2012
+* plugins/convertPathData: collapse repeated instructions only after curveSmoothShorthands (fix [#64](https://github.com/svg/svgo/issues/64))
+* lib/svgo/coa: handle 'there is nothing to optimize' case and display a message about it (fix [#61](https://github.com/svg/svgo/issues/61))
+* plugins/cleanupSVGElem: delete as useless artefact
+
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.5) ] 0.1.5 / 06.12.2012
+* E-notated numbers in paths not recognised (fix [#63](https://github.com/svg/svgo/issues/63))
+* update README with `svgo-grunt` and `svgo-osx-folder-action`
+* fix `mocha-as-promised` plug in node 0.6
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.4) ] 0.1.4 / 05.12.2012
+* plugins/_collections: more defaults
+* `README.ru.md`
+* `docs/how-it-works/ru.md`
+* mocha + mocha-as-promised + chai + chai-as-promised + should + istanbul = <3
+* update dependencies semvers in `package.json`
+* `v0.1.x` and `v0.2.x` milestones
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.3) ] 0.1.3 / 30.11.2012
+* new plugin [plugins/cleanupNumericValues](https://github.com/svg/svgo/blob/master/plugins/cleanupNumericValues.js) (close [#8](https://github.com/svg/svgo/issues/8))
+* plugins/removeDefaultPx functionality now included in plugins/removeUnknownsAndDefaults
+* plugins/removeUnknownsAndDefaults: refactoring and picking up the complete elems+attrs collection (close [#59](https://github.com/svg/svgo/issues/59))
+* plugins/convertTransform: error in matrices multiplication (fix [#58](https://github.com/svg/svgo/issues/58))
+* plugins/convertTransform: mark translate() and scale() as useless only with one param (fix [#57](https://github.com/svg/svgo/issues/57))
+* plugins/convertPathData: drastic speed improvement with huge Path data
+* plugins/convertPathData: fix the very first Mm with multiple points (fix [#56](https://github.com/svg/svgo/issues/56))
+* plugins/moveElemsAttrsToGroup: additional check for transform attr
+* brand-new project `logo.svg`
+* `.travis.yml`: build only master branch
+* global `'use strict'`
+* `.jshintignore`
+* README and CHANGELOG: minor corrections
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.2) ] 0.1.2 / 24.11.2012
+* lib/svgo/svg2js: correct 'onerror' failure (fix [#51](https://github.com/svg/svgo/issues/51))
+* config: disable sax-js position tracking by default (fix [#52](https://github.com/svg/svgo/issues/52))
+* lib/svgo: rename 'startBytes' to 'inBytes' and 'endBytes' to 'outBytes' (close [#53](https://github.com/svg/svgo/issues/53))
+* plugins/removeUnknownsAndDefaults: remove SVG id attr (close [#54](https://github.com/svg/svgo/issues/54))
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.1) ] 0.1.1 / 23.11.2012
+* plugins/moveElemsAttrsToGroup: fix inheitable only attrs array (fix [#47](https://github.com/svg/svgo/issues/47))
+* plugins/removeEmptyContainers: do not remove an empty 'svg' element (fix [#48](https://github.com/svg/svgo/issues/48))
+* plugins/removeDefaultPx: should also understand a floating-numbers too (fix [#49](https://github.com/svg/svgo/issues/49))
+* plugins/removeUnknownsAndDefaults: merge multiple groupDefaults attrs (close [#50](https://github.com/svg/svgo/issues/50))
+
+### [ [>](https://github.com/svg/svgo/tree/v0.1.0) ] 0.1.0 / 22.11.2012
+* new plugin [plugins/removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js) (close [#6](https://github.com/svg/svgo/issues/6))
+* plugins/convertPathData: convert straight curves into lines segments (close [#17](https://github.com/svg/svgo/issues/17)); remove an absolute coords conversions
+* plugins/convertPathData: convert quadratic Bézier curveto into smooth shorthand (close [#31](https://github.com/svg/svgo/issues/31))
+* plugins/convertPathData: convert curveto into smooth shorthand (close [#30](https://github.com/svg/svgo/issues/30))
+* lib/svgo: global API refactoring (close [#37](https://github.com/svg/svgo/issues/37))
+* lib/svgo: fatal and stupid error in stream chunks concatenation (fix [#40](https://github.com/svg/svgo/issues/40))
+* lib/coa: batch folder optimization (close [#29](https://github.com/svg/svgo/issues/29))
+* lib/coa: support arguments as aliases to `--input` and `--output` (close [#28](https://github.com/svg/svgo/issues/28))
+* project logo by [Egor Bolhshakov](http://xizzzy.ru/)
+* move modules to `./lib/svgo/`
+* rename and convert `config.json` to `.svgo.yml`
+* add [./docs/](https://github.com/svg/svgo/tree/master/docs)
+* plugins/convertPathData: don't remove first `M` even if it's `0,0`
+* plugins/convertPathData: stronger defense from infinite loop
+* plugins/moveElemsAttrsToGroup: should affect only inheritable attributes (fix [#46](https://github.com/svg/svgo/issues/46))*
+* plugins/removeComments: ignore comments which starts with '!' (close [#43](https://github.com/svg/svgo/issues/43))
+* config: `cleanupAttrs` should be before `convertStyleToAttrs` (fix [#44](https://github.com/svg/svgo/issues/44))*
+* lib/svgo/jsAPI: add `eachAttr()` optional context param
+* temporarily remove PhantomJS and `--test` (close [#38](https://github.com/svg/svgo/issues/38))
+* q@0.8.10 compatibility: 'end is deprecated, use done instead' fix
+* add [Istanbul](https://github.com/gotwarlost/istanbul) code coverage
+* update dependencies versions and gitignore
+* README: add TODO section with versions milestones
+* update README with License section
+* update LICENSE with russian translation
+* `.editorconfig`: 2 spaces for YAML
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.9) ] 0.0.9 / 29.10.2012
+* [plugins how-to](https://github.com/svg/svgo/tree/master/plugins#readme) (close [#27](https://github.com/svg/svgo/issues/27))
+* allow any plugin of any type to go in any order (close [#14](https://github.com/svg/svgo/issues/14))
+* allow to do a multiple optimizations with one init (close [#25](https://github.com/svg/svgo/issues/25))
+* plugins/convertPathData: global refactoring
+* plugins/convertPathData: do all the tricks with absolute coords too (fix [#22](https://github.com/svg/svgo/issues/22))
+* plugins/convertPathData: accumulation of rounding errors (fix [#23](https://github.com/svg/svgo/issues/23))
+* plugins/convertPathData: prevent an infinity loop on invalid path data (fix [#26](https://github.com/svg/svgo/issues/26))
+* plugins/convertPathData: do not remove very first M from the path data (fix [#24](https://github.com/svg/svgo/issues/24))
+* plugins/convertPathData: optimize path data in &lt;glyph&gt; and &lt;missing-glyph&gt; (close [#20](https://github.com/svg/svgo/issues/20))
+* plugins/convertTransform: add patternTransform attribute to the process (close [#15](https://github.com/svg/svgo/issues/15))
+* plugins/convertTransform: Firefox: removing extra space in front of negative number is alowed only in path data, but not in transform (fix [#12](https://github.com/svg/svgo/issues/12))
+* plugins/removeXMLProcInst: remove only 'xml' but not 'xml-stylesheet' (fix [#21](https://github.com/svg/svgo/issues/15))
+* plugins/collapseGroups: merge split-level transforms (fix [#13](https://github.com/svg/svgo/issues/13))
+* jsdoc corrections
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.8) ] 0.0.8 / 20.10.2012
+* new plugin [convertTransform](plugins/convertTransform.js) (close [#5](https://github.com/svg/svgo/issues/5))
+* new plugin [removeUnusedNS](plugins/removeUnusedNS.js)
+* plugins/convertPathData: remove useless segments
+* plugins/convertPathData: a lot of refactoring
+* plugins/convertPathData: round numbers before conditions because of exponential notation (fix [#3](https://github.com/svg/svgo/issues/3))
+* plugins/moveElemsAttrsToGroup: merge split-level transforms instead of replacing (fix [#10](https://github.com/svg/svgo/issues/10))
+* lib/svg2js: catch and output xml parser errors (fix [#4](https://github.com/svg/svgo/issues/4))
+* lib/coa: open file for writing only when we are ready (fix [#2](https://github.com/svg/svgo/issues/2))
+* lib/tools: node.extend module
+* lib/plugins: refactoring
+* lib/js2svg: refactoring
+* lib/jsAPI: simplification and refactoring
+* absolute urls in README
+* update .editorconfig
+* update .travis.yml with nodejs 0.9
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.7) ] 0.0.7 / 14.10.2012
+* new plugin [convertPathData](plugins/convertPathData.js)
+* --input data now can be a Data URI base64 string
+* --output data now can be a Data URI base64 string with --datauri flag
+* Travis CI
+* JSHint corrections + .jshintrc
+* [.editorconfig](http://editorconfig.org/)
+* display time spent on optimization
+* .svgo → config.json
+* lib/phantom_wrapper.js → lib/phantom.js
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.6) ] 0.0.6 / 04.10.2012
+* add --test option to make a visual comparison of two files (PhantomJS pre-required)
+* update README and CHANGELOG with the correct relative urls
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.5) ] 0.0.5 / 03.10.2012
+* every plugin now has [at least one test](plugins)
+* removeViewBox, cleanupEnableBackground, removeEditorsNSData, convertStyleToAttrs and collapseGroups plugins fixes
+* new --pretty option for the pretty printed SVG
+* lib/config refactoring
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.4) ] 0.0.4 / 30.09.2012
+* new plugin [removeViewBox](plugins/removeViewBox.js)
+* new plugin [cleanupEnableBackground](plugins/cleanupEnableBackground.js)
+* display useful info after successful optimization
+* 'npm test' with 'spec' mocha output by default
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.3) ] 0.0.3 / 29.09.2012
+* plugins/collapseGroups bugfix
+* plugins/moveElemsAttrsToGroup bugfix
+* svgo now display --help if running w/o arguments
+* massive jsdoc updates
+* plugins engine main filter function optimization
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.2) ] 0.0.2 / 28.09.2012
+* add --disable and --enable command line options
+* add an empty values rejecting to coa.js
+* update README
+
+### [ [>](https://github.com/svg/svgo/tree/v0.0.1) ] 0.0.1 / 27.09.2012
+* initial public version

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/LICENSE

@@ -0,0 +1,55 @@
+The MIT License
+
+Copyright © 2012–2016 Kir Belevich
+
+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.
+
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+Лицензия MIT
+
+Copyright © 2012–2016 Кир Белевич
+
+Данная лицензия разрешает лицам, получившим копию данного
+программного обеспечения и сопутствующей документации
+(в дальнейшем именуемыми «Программное Обеспечение»), безвозмездно
+использовать Программное Обеспечение без ограничений, включая
+неограниченное право на использование, копирование, изменение,
+добавление, публикацию, распространение, сублицензирование
+и/или продажу копий Программного Обеспечения, также как и лицам,
+которым предоставляется данное Программное Обеспечение,
+при соблюдении следующих условий:
+
+Указанное выше уведомление об авторском праве и данные условия
+должны быть включены во все копии или значимые части данного
+Программного Обеспечения.
+
+ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ»,
+БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ,
+ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ ГАРАНТИЯМИ ТОВАРНОЙ ПРИГОДНОСТИ,
+СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ НАРУШЕНИЙ
+ПРАВ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
+ОТВЕТСТВЕННОСТИ ПО ИСКАМ О ВОЗМЕЩЕНИИ УЩЕРБА, УБЫТКОВ ИЛИ ДРУГИХ
+ТРЕБОВАНИЙ ПО ДЕЙСТВУЮЩИМ КОНТРАКТАМ, ДЕЛИКТАМ ИЛИ ИНОМУ,
+ВОЗНИКШИМ ИЗ, ИМЕЮЩИМ ПРИЧИНОЙ ИЛИ СВЯЗАННЫМ С ПРОГРАММНЫМ
+ОБЕСПЕЧЕНИЕМ ИЛИ ИСПОЛЬЗОВАНИЕМ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
+ИЛИ ИНЫМИ ДЕЙСТВИЯМИ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/Makefile

@@ -0,0 +1,21 @@
+test:
+	@npm run test
+
+lib-cov:
+	@./node_modules/.bin/istanbul instrument --output lib-cov --no-compact --variable global.__coverage__ lib
+
+coverage: lib-cov
+	@COVERAGE=1 ISTANBUL_REPORTERS=text-summary ./node_modules/.bin/mocha --reporter mocha-istanbul
+	@rm -rf lib-cov
+
+coveralls: lib-cov
+	@COVERAGE=1 ISTANBUL_REPORTERS=lcovonly ./node_modules/.bin/mocha --reporter mocha-istanbul
+	@cat lcov.info | ./node_modules/.bin/coveralls
+	@rm -rf lib-cov lcov.info
+
+travis: jshint test coveralls
+
+jshint:
+	@npm run jshint
+
+.PHONY: test

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/README.md

@@ -0,0 +1,155 @@
+**english** | [русский](https://github.com/svg/svgo/blob/master/README.ru.md)
+- - -
+
+<img src="https://svg.github.io/svgo-logo.svg" width="200" height="200" alt="logo"/>
+
+## SVGO [![NPM version](https://badge.fury.io/js/svgo.svg)](https://npmjs.org/package/svgo) [![Dependency Status](https://gemnasium.com/svg/svgo.svg)](https://gemnasium.com/svg/svgo) [![Build Status](https://secure.travis-ci.org/svg/svgo.svg)](https://travis-ci.org/svg/svgo) [![Coverage Status](https://img.shields.io/coveralls/svg/svgo.svg)](https://coveralls.io/r/svg/svgo?branch=master)
+
+**SVG O**ptimizer is a Nodejs-based tool for optimizing SVG vector graphics files.
+![](https://mc.yandex.ru/watch/18431326)
+
+## Why?
+
+SVG files, especially exported from various editors, usually contain a lot of redundant and useless information such as editor metadata, comments, hidden elements, default or non-optimal values and other stuff that can be safely removed or converted without affecting SVG rendering result.
+
+## What it can do
+
+SVGO has a plugin-based architecture, so almost every optimization is a separate plugin.
+
+Today we have:
+
+| Plugin | Description |
+| ------ | ----------- | 
+| [cleanupAttrs](https://github.com/svg/svgo/blob/master/plugins/cleanupAttrs.js) | cleanup attributes from newlines, trailing, and repeating spaces |
+| [removeDoctype](https://github.com/svg/svgo/blob/master/plugins/removeDoctype.js) | remove doctype declaration |
+| [removeXMLProcInst](https://github.com/svg/svgo/blob/master/plugins/removeXMLProcInst.js) | remove XML processing instructions |
+| [removeComments](https://github.com/svg/svgo/blob/master/plugins/removeComments.js) | remove comments |
+| [removeMetadata](https://github.com/svg/svgo/blob/master/plugins/removeMetadata.js) | remove `<metadata>` |
+| [removeTitle](https://github.com/svg/svgo/blob/master/plugins/removeTitle.js) | remove `<title>` (disabled by default) |
+| [removeDesc](https://github.com/svg/svgo/blob/master/plugins/removeDesc.js) | remove `<desc>` (only non-meaningful by default) |
+| [removeUselessDefs](https://github.com/svg/svgo/blob/master/plugins/removeUselessDefs.js) | remove elements of `<defs>` without `id` |
+| [removeXMLNS](https://github.com/svg/svgo/blob/master/plugins/removeXMLNS.js) | removes `xmlns` attribute (for inline svg, disabled by default) |
+| [removeEditorsNSData](https://github.com/svg/svgo/blob/master/plugins/removeEditorsNSData.js) | remove editors namespaces, elements, and attributes |
+| [removeEmptyAttrs](https://github.com/svg/svgo/blob/master/plugins/removeEmptyAttrs.js) | remove empty attributes |
+| [removeHiddenElems](https://github.com/svg/svgo/blob/master/plugins/removeHiddenElems.js) | remove hidden elements |
+| [removeEmptyText](https://github.com/svg/svgo/blob/master/plugins/removeEmptyText.js) | remove empty Text elements |
+| [removeEmptyContainers](https://github.com/svg/svgo/blob/master/plugins/removeEmptyContainers.js) | remove empty Container elements |
+| [removeViewBox](https://github.com/svg/svgo/blob/master/plugins/removeViewBox.js) | remove `viewBox` attribute when possible (disabled by default) |
+| [cleanupEnableBackground](https://github.com/svg/svgo/blob/master/plugins/cleanupEnableBackground.js) | remove or cleanup `enable-background` attribute when possible |
+| [minifyStyles](https://github.com/svg/svgo/blob/master/plugins/minifyStyles.js) | minify `<style>` elements content with [CSSO](https://github.com/css/csso) |
+| [convertStyleToAttrs](https://github.com/svg/svgo/blob/master/plugins/convertStyleToAttrs.js) | convert styles into attributes |
+| [convertColors](https://github.com/svg/svgo/blob/master/plugins/convertColors.js) | convert colors (from `rgb()` to `#rrggbb`, from `#rrggbb` to `#rgb`) |
+| [convertPathData](https://github.com/svg/svgo/blob/master/plugins/convertPathData.js) | convert Path data to relative or absolute (whichever is shorter), convert one segment to another, trim useless delimiters, smart rounding, and much more |
+| [convertTransform](https://github.com/svg/svgo/blob/master/plugins/convertTransform.js) | collapse multiple transforms into one, convert matrices to the short aliases, and much more |
+| [removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js) | remove unknown elements content and attributes, remove attrs with default values |
+| [removeNonInheritableGroupAttrs](https://github.com/svg/svgo/blob/master/plugins/removeNonInheritableGroupAttrs.js) | remove non-inheritable group's "presentation" attributes |
+| [removeUselessStrokeAndFill](https://github.com/svg/svgo/blob/master/plugins/removeUselessStrokeAndFill.js) | remove useless `stroke` and `fill` attrs |
+| [removeUnusedNS](https://github.com/svg/svgo/blob/master/plugins/removeUnusedNS.js) | remove unused namespaces declaration |
+| [cleanupIDs](https://github.com/svg/svgo/blob/master/plugins/cleanupIDs.js) | remove unused and minify used IDs |
+| [cleanupNumericValues](https://github.com/svg/svgo/blob/master/plugins/cleanupNumericValues.js) | round numeric values to the fixed precision, remove default `px` units |
+| [cleanupListOfValues](https://github.com/svg/svgo/blob/master/plugins/cleanupListOfValues.js) | round numeric values in attributes that take a list of numbers (like `viewBox` or `enableBackground`) |
+| [moveElemsAttrsToGroup](https://github.com/svg/svgo/blob/master/plugins/moveElemsAttrsToGroup.js) | move elements' attributes to their enclosing group |
+| [moveGroupAttrsToElems](https://github.com/svg/svgo/blob/master/plugins/moveGroupAttrsToElems.js) | move some group attributes to the contained elements |
+| [collapseGroups](https://github.com/svg/svgo/blob/master/plugins/collapseGroups.js) | collapse useless groups |
+| [removeRasterImages](https://github.com/svg/svgo/blob/master/plugins/removeRasterImages.js) | remove raster images (disabled by default) |
+| [mergePaths](https://github.com/svg/svgo/blob/master/plugins/mergePaths.js) | merge multiple Paths into one |
+| [convertShapeToPath](https://github.com/svg/svgo/blob/master/plugins/convertShapeToPath.js) | convert some basic shapes to `<path>` |
+| [sortAttrs](https://github.com/svg/svgo/blob/master/plugins/sortAttrs.js) | sort element attributes for epic readability (disabled by default) |
+| [transformsWithOnePath](https://github.com/svg/svgo/blob/master/plugins/transformsWithOnePath.js) | apply transforms, crop by real width, center vertical alignment, and resize SVG with one Path inside (disabled by default) |
+| [removeDimensions](https://github.com/svg/svgo/blob/master/plugins/removeDimensions.js) | remove `width`/`height` attributes if `viewBox` is present (disabled by default) |
+| [removeAttrs](https://github.com/svg/svgo/blob/master/plugins/removeAttrs.js) | remove attributes by pattern (disabled by default) |
+| [removeElementsByAttr](https://github.com/svg/svgo/blob/master/plugins/removeElementsByAttr.js) | remove arbitrary elements by ID or className (disabled by default) |
+| [addClassesToSVGElement](https://github.com/svg/svgo/blob/master/plugins/addClassesToSVGElement.js) | add classnames to an outer `<svg>` element (disabled by default) |
+| [addAttributesToSVGElement](https://github.com/svg/svgo/blob/master/plugins/addAttributesToSVGElement.js) | adds attributes to an outer `<svg>` element (disabled by default) |
+| [removeStyleElement](https://github.com/svg/svgo/blob/master/plugins/removeStyleElement.js) | remove `<style>` elements (disabled by default) |
+
+Want to know how it works and how to write your own plugin? [Of course you want to](https://github.com/svg/svgo/blob/master/docs/how-it-works/en.md). ([동작방법](https://github.com/svg/svgo/blob/master/docs/how-it-works/ko.md))
+
+
+## How to use
+
+```sh
+$ [sudo] npm install -g svgo
+```
+
+```
+Usage:
+  svgo [OPTIONS] [ARGS]
+
+Options:
+  -h, --help : Help
+  -v, --version : Version
+  -i INPUT, --input=INPUT : Input file, "-" for STDIN
+  -s STRING, --string=STRING : Input SVG data string
+  -f FOLDER, --folder=FOLDER : Input folder, optimize and rewrite all *.svg files
+  -o OUTPUT, --output=OUTPUT : Output file or folder (by default the same as the input), "-" for STDOUT
+  -p PRECISION, --precision=PRECISION : Set number of digits in the fractional part, overrides plugins params
+  --config=CONFIG : Config file or JSON string to extend or replace default
+  --disable=DISABLE : Disable plugin by name
+  --enable=ENABLE : Enable plugin by name
+  --datauri=DATAURI : Output as Data URI string (base64, URI encoded or unencoded)
+  --multipass : Enable multipass
+  --pretty : Make SVG pretty printed
+  --indent=INDENT : Indent number when pretty printing SVGs
+  -q, --quiet : Only output error messages, not regular status messages
+  --show-plugins : Show available plugins and exit
+
+Arguments:
+  INPUT : Alias to --input
+  OUTPUT : Alias to --output
+```
+
+* with files:
+
+        $ svgo test.svg
+
+    or:
+
+        $ svgo test.svg test.min.svg
+
+* with STDIN / STDOUT:
+
+        $ cat test.svg | svgo -i - -o - > test.min.svg
+
+* with folder
+
+        $ svgo -f ../path/to/folder/with/svg/files
+
+    or:
+
+        $ svgo -f ../path/to/folder/with/svg/files -o ../path/to/folder/with/svg/output
+
+* with strings:
+
+        $ svgo -s '<svg version="1.1">test</svg>' -o test.min.svg
+
+    or even with Data URI base64:
+
+        $ svgo -s 'data:image/svg+xml;base64,…' -o test.min.svg
+
+* with SVGZ:
+
+    from `.svgz` to `.svg`:
+
+        $ gunzip -c test.svgz | svgo -i - -o test.min.svg
+
+    from `.svg` to `.svgz`:
+
+        $ svgo test.svg -o - | gzip -cfq9 > test.svgz
+
+* with GUI – [svgo-gui](https://github.com/svg/svgo-gui)
+* as a web app - [SVGOMG](https://jakearchibald.github.io/svgomg/)
+* as a Nodejs module – [examples](https://github.com/svg/svgo/tree/master/examples)
+* as a Grunt task – [grunt-svgmin](https://github.com/sindresorhus/grunt-svgmin)
+* as a Gulp task – [gulp-svgmin](https://github.com/ben-eb/gulp-svgmin)
+* as a Mimosa module – [mimosa-minify-svg](https://github.com/dbashford/mimosa-minify-svg)
+* as an OSX Folder Action – [svgo-osx-folder-action](https://github.com/svg/svgo-osx-folder-action)
+* as a webpack loader – [image-webpack-loader](https://github.com/tcoopman/image-webpack-loader)
+* as a Telegram Bot – [svgo_bot](https://github.com/maksugr/svgo_bot)
+* as a PostCSS plugin - [postcss-svgo](https://github.com/ben-eb/postcss-svgo)
+
+## License and copyrights
+
+This software is released under the terms of the [MIT license](https://github.com/svg/svgo/blob/master/LICENSE).
+
+Logo by [Yegor Bolshakov](http://xizzzy.ru/).

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/README.ru.md

@@ -0,0 +1,155 @@
+[english](https://github.com/svg/svgo/blob/master/README.md) | **русский**
+- - -
+
+<img src="https://svg.github.io/svgo-logo.svg" width="200" height="200" alt="logo"/>
+
+## SVGO [![NPM version](https://badge.fury.io/js/svgo.svg)](https://npmjs.org/package/svgo) [![Dependency Status](https://gemnasium.com/svg/svgo.svg)](https://gemnasium.com/svg/svgo) [![Build Status](https://secure.travis-ci.org/svg/svgo.svg)](https://travis-ci.org/svg/svgo) [![Coverage Status](https://img.shields.io/coveralls/svg/svgo.svg)](https://coveralls.io/r/svg/svgo?branch=master)
+
+**SVG** **O**ptimizer – это инструмент для оптимизации векторной графики в формате SVG, написанный на Node.js.
+![](https://mc.yandex.ru/watch/18431326)
+
+## Зачем?
+
+SVG-файлы, особенно – экспортированные из различных редакторов, содержат много избыточной и бесполезной информации, комментариев, скрытых элементов, неоптимальные или стандартные значения и другой мусор, удаление которого безопасно и не влияет на конечный результат отрисовки.
+
+## Возможности
+
+SVGO имеет расширяемую архитектуру, в которой почти каждая оптимизация является отдельным расширением.
+
+Сегодня у нас есть:
+
+| Plugin | Description |
+| ------ | ----------- | 
+| [cleanupAttrs](https://github.com/svg/svgo/blob/master/plugins/cleanupAttrs.js) | удаление переносов строк и лишних пробелов |
+| [removeDoctype](https://github.com/svg/svgo/blob/master/plugins/removeDoctype.js) | удаление doctype |
+| [removeXMLProcInst](https://github.com/svg/svgo/blob/master/plugins/removeXMLProcInst.js) | удаление XML-инструкций |
+| [removeComments](https://github.com/svg/svgo/blob/master/plugins/removeComments.js) | удаление комментариев |
+| [removeMetadata](https://github.com/svg/svgo/blob/master/plugins/removeMetadata.js) | удаление `<metadata>` |
+| [removeTitle](https://github.com/svg/svgo/blob/master/plugins/removeTitle.js) | удаление `<title>` (выключено по умолчанию) |
+| [removeDesc](https://github.com/svg/svgo/blob/master/plugins/removeDesc.js) | удаление `<desc>` (по умолчанию только незначимых) |
+| [removeUselessDefs](https://github.com/svg/svgo/blob/master/plugins/removeUselessDefs.js) | удаление элементов в `<defs>` без `id` |
+| [removeXMLNS](https://github.com/svg/svgo/blob/master/plugins/removeXMLNS.js) | удаление атрибута xmlns (для заинлайненных svg, выключено по умолчанию) |
+| [removeEditorsNSData](https://github.com/svg/svgo/blob/master/plugins/removeEditorsNSData.js) | удаление пространств имён различных редакторов, их элементов и атрибутов |
+| [removeEmptyAttrs](https://github.com/svg/svgo/blob/master/plugins/removeEmptyAttrs.js) | удаление пустых атрибутов |
+| [removeHiddenElems](https://github.com/svg/svgo/blob/master/plugins/removeHiddenElems.js) | удаление скрытых элементов |
+| [removeEmptyText](https://github.com/svg/svgo/blob/master/plugins/removeEmptyText.js) | удаление пустых текстовых элементов |
+| [removeEmptyContainers](https://github.com/svg/svgo/blob/master/plugins/removeEmptyContainers.js) | удаление пустых элементов-контейнеров |
+| [removeViewBox](https://github.com/svg/svgo/blob/master/plugins/removeViewBox.js) | удаление атрибута `viewBox`, когда это возможно |
+| [cleanupEnableBackground](https://github.com/svg/svgo/blob/master/plugins/cleanupEnableBackground.js) | удаление или оптимизация атрибута `enable-background`, когда это возможно |
+| [minifyStyles](https://github.com/svg/svgo/blob/master/plugins/minifyStyles.js) | уменьшает содержимое элементов `<style>` с помощью [CSSO](https://github.com/css/csso). |
+| [convertStyleToAttrs](https://github.com/svg/svgo/blob/master/plugins/convertStyleToAttrs.js) | конвертирование стилей в атрибуте `style` в отдельные svg-атрибуты |
+| [convertColors](https://github.com/svg/svgo/blob/master/plugins/convertColors.js) | конвертирование цветовых значений: из `rgb()` в `#rrggbb`, из `#rrggbb` в `#rgb` |
+| [convertPathData](https://github.com/svg/svgo/blob/master/plugins/convertPathData.js) | конвертирование данных Path в относительные или абсолютные координаты, смотря что  |короче; конвертирование одних типов сегментов в другие; удаление ненужных разделителей; умное округление и тому подобное
+| [convertTransform](https://github.com/svg/svgo/blob/master/plugins/convertTransform.js) | схлопывание нескольких трансформаций в одну, конвертирование матриц в короткие алиасы  |и многое другое
+| [removeUnknownsAndDefaults](https://github.com/svg/svgo/blob/master/plugins/removeUnknownsAndDefaults.js) | удаление неизвестных элементов, контента и атрибутов |
+| [removeNonInheritableGroupAttrs](https://github.com/svg/svgo/blob/master/plugins/removeNonInheritableGroupAttrs.js) | удаление ненаследуемых "презентационных" атрибутов групп |
+| [removeUselessStrokeAndFill](https://github.com/svg/svgo/blob/master/plugins/removeUselessStrokeAndFill.js) | удаление неиспользуемых атрибутов stroke-* и fill-* |
+| [removeUnusedNS](https://github.com/svg/svgo/blob/master/plugins/removeUnusedNS.js) | удаление  деклараций неиспользуемых пространств имён |
+| [cleanupIDs](https://github.com/svg/svgo/blob/master/plugins/cleanupIDs.js) | удаление неиспользуемых и сокращение используемых ID |
+| [cleanupNumericValues](https://github.com/svg/svgo/blob/master/plugins/cleanupNumericValues.js) | округление дробных чисел до заданной точности, удаление `px` как единицы  |измерения по-умолчанию
+| [cleanupListOfValues](https://github.com/svg/svgo/blob/master/plugins/cleanupListOfValues.js) | округление числовых значений в атрибутах со списком чисел, таких как `viewBox`  |или `enableBackground`
+| [moveElemsAttrsToGroup](https://github.com/svg/svgo/blob/master/plugins/moveElemsAttrsToGroup.js) | перемещение совпадающих атрибутов у всех элементов внутри группы `<g>` |
+| [moveGroupAttrsToElems](https://github.com/svg/svgo/blob/master/plugins/moveGroupAttrsToElems.js) | перемещение некоторых атрибутов группы на элементы внутри |
+| [collapseGroups](https://github.com/svg/svgo/blob/master/plugins/collapseGroups.js) | схлопывание бесполезных групп `<g>` |
+| [removeRasterImage](https://github.com/svg/svgo/blob/master/plugins/removeRasterImages.js) | удаление растровых изображений (выключено по умолчанию) |
+| [mergePaths](https://github.com/svg/svgo/blob/master/plugins/mergePaths.js) | склеивание нескольких Path в одну кривую |
+| [convertShapeToPath](https://github.com/svg/svgo/blob/master/plugins/convertShapeToPath.js) | конвертирование простых форм в Path |
+| [sortAttrs](https://github.com/svg/svgo/blob/master/plugins/sortAttrs.js) | сортировка атрибутов элементов для удобочитаемости (выключено по умолчанию) |
+| [transformsWithOnePath](https://github.com/svg/svgo/blob/master/plugins/transformsWithOnePath.js) | применение трансформаций, обрезка по реальной ширине, вертикальное  |выравнивание по центру и изменение размеров SVG с одним Path внутри
+| [removeDimensions](https://github.com/svg/svgo/blob/master/plugins/removeDimensions.js) | удаляет атрибуты width/height при наличии viewBox (выключено по умолчанию) |
+| [removeAttrs](https://github.com/svg/svgo/blob/master/plugins/removeAttrs.js) | удаляет атрибуты по указанному паттерну (выключено по умолчанию) |
+| [removeElementsByAttr](https://github.com/svg/svgo/blob/master/plugins/removeElementsByAttr.js) | удаляет элементы по указанным ID или классам (выключено по умолчанию) |
+| [addClassesToSVGElement](https://github.com/svg/svgo/blob/master/plugins/addClassesToSVGElement.js) | добавляет имена классов корневому элементу `<svg>` (выключено по умолчанию) |
+| [addAttributesToSVGElement](https://github.com/svg/svgo/blob/master/plugins/addAttributesToSVGElement.js) | добавляет атрибуты корневому элементу `<svg>` (выключено  |по умолчанию)
+| [removeStyleElement](https://github.com/svg/svgo/blob/master/plugins/removeStyleElement.js) | удаляет элементы `<style>` (выключено по умолчанию) |
+
+Хотите узнать, как это работает и как написать свой плагин? [Конечно же, да!](https://github.com/svg/svgo/blob/master/docs/how-it-works/ru.md).
+
+
+## Как использовать
+
+```sh
+$ [sudo] npm install -g svgo
+```
+
+```
+Выполнение:
+  svgo [OPTIONS] [ARGS]
+
+Параметры:
+  -h, --help : Помощь
+  -v, --version : Версия программы
+  -i INPUT, --input=INPUT : Входной файл, "-" для STDIN
+  -s STRING, --string=STRING : Входная строка SVG
+  -f FOLDER, --folder=FOLDER : Входная папка, оптимизирует и перезаписывает все файлы *.svg
+  -o OUTPUT, --output=OUTPUT : Выходной файл или папка (совпадает с входным по умолчанию), "-" для STDOUT
+  -p PRECISION, --precision=PRECISION : Число цифр после запятой, переопределяет параметры плагинов
+  --config=CONFIG : Файл конфигурации (или строка JSON) для расширения и замены настроек
+  --disable=DISABLE : Выключение плагина по имени
+  --enable=ENABLE : Включение плагина по имени
+  --datauri=DATAURI : Результат в виде строки Data URI (base64, URI encoded или unencoded)
+  --multipass : Оптимизация в несколько проходов
+  --pretty : Удобочитаемое форматирование SVG
+  --indent=INDENT : Размер отступа для удобочитаемого форматирования
+  -q, --quiet : Подавляет вывод информации, выводятся только сообщения об ошибках
+  --show-plugins : Доступные плагины
+
+Аргументы:
+  INPUT : Аналогично --input
+  OUTPUT : Аналогично --output
+```
+
+* с файлами:
+
+        $ svgo test.svg
+
+    или:
+
+        $ svgo test.svg test.min.svg
+
+* со STDIN / STDOUT:
+
+        $ cat test.svg | svgo -i - -o - > test.min.svg
+
+* с папками
+
+        $ svgo -f ../path/to/folder/with/svg/files
+
+    или:
+
+        $ svgo -f ../path/to/folder/with/svg/files -o ../path/to/folder/with/svg/output
+
+* со строками:
+
+        $ svgo -s '<svg version="1.1">test</svg>' -o test.min.svg
+
+    или даже с Data URI base64:
+
+        $ svgo -s 'data:image/svg+xml;base64,…' -o test.min.svg
+
+* с SVGZ:
+
+    из `.svgz` в `.svg`:
+
+        $ gunzip -c test.svgz | svgo -i - -o test.min.svg
+
+    из `.svg` в `.svgz`:
+
+        $ svgo test.svg -o - | gzip -cfq9 > test.svgz
+
+* с помощью GUI – [svgo-gui](https://github.com/svg/svgo-gui)
+* в виде веб-приложения - [SVGOMG](https://jakearchibald.github.io/svgomg/)
+* как модуль Node.js – [examples](https://github.com/svg/svgo/tree/master/examples)
+* как таск для Grunt – [grunt-svgmin](https://github.com/sindresorhus/grunt-svgmin)
+* как таск для Gulp – [gulp-svgmin](https://github.com/ben-eb/gulp-svgmin)
+* как таск для Mimosa – [mimosa-minify-svg](https://github.com/dbashford/mimosa-minify-svg)
+* как действие папки в OSX – [svgo-osx-folder-action](https://github.com/svg/svgo-osx-folder-action)
+* через загрузчик в webpack – [image-webpack-loader](https://github.com/tcoopman/image-webpack-loader)
+* с помощью бота в Telegram – [svgo_bot](https://github.com/maksugr/svgo_bot)
+* как плагин PostCSS - [postcss-svgo](https://github.com/ben-eb/postcss-svgo)
+
+## Лицензия и копирайты
+
+Данное программное обеспечение выпускается под [лицензией MIT](https://github.com/svg/svgo/blob/master/LICENSE).
+
+Логотип – [Егор Большаков](http://xizzzy.ru/).

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/bin/svgo

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../lib/svgo/coa').run();

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo.js

@@ -0,0 +1,80 @@
+'use strict';
+
+/**
+ * SVGO is a Nodejs-based tool for optimizing SVG vector graphics files.
+ *
+ * @see https://github.com/svg/svgo
+ *
+ * @author Kir Belevich <kir@soulshine.in> (https://github.com/deepsweet)
+ * @copyright © 2012 Kir Belevich
+ * @license MIT https://raw.githubusercontent.com/svg/svgo/master/LICENSE
+ */
+
+var CONFIG = require('./svgo/config.js'),
+    SVG2JS = require('./svgo/svg2js.js'),
+    PLUGINS = require('./svgo/plugins.js'),
+    JSAPI = require('./svgo/jsAPI.js'),
+    JS2SVG = require('./svgo/js2svg.js');
+
+var SVGO = module.exports = function(config) {
+
+    this.config = CONFIG(config);
+
+};
+
+SVGO.prototype.optimize = function(svgstr, callback) {
+    if (this.config.error) return callback(this.config);
+
+    var _this = this,
+        config = this.config,
+        maxPassCount = config.multipass ? 10 : 1,
+        counter = 0,
+        prevResultSize = Number.POSITIVE_INFINITY,
+        optimizeOnceCallback = function(svgjs) {
+
+            if (svgjs.error) {
+                callback(svgjs);
+                return;
+            }
+
+            if (++counter < maxPassCount && svgjs.data.length < prevResultSize) {
+                prevResultSize = svgjs.data.length;
+                _this._optimizeOnce(svgjs.data, optimizeOnceCallback);
+            } else {
+                callback(svgjs);
+            }
+
+        };
+
+    _this._optimizeOnce(svgstr, optimizeOnceCallback);
+
+};
+
+SVGO.prototype._optimizeOnce = function(svgstr, callback) {
+    var config = this.config;
+
+    SVG2JS(svgstr, function(svgjs) {
+
+        if (svgjs.error) {
+            callback(svgjs);
+            return;
+        }
+
+        svgjs = PLUGINS(svgjs, config.plugins);
+
+        callback(JS2SVG(svgjs, config.js2svg));
+
+    });
+};
+
+/**
+ * The factory that creates a content item with the helper methods.
+ *
+ * @param {Object} data which passed to jsAPI constructor
+ * @returns {JSAPI} content item
+ */
+SVGO.prototype.createContentItem = function(data) {
+
+    return new JSAPI(data);
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/coa.js

@@ -0,0 +1,581 @@
+/* jshint quotmark: false */
+'use strict';
+
+require('colors');
+
+var FS = require('fs'),
+    PATH = require('path'),
+    SVGO = require('../svgo.js'),
+    YAML = require('js-yaml'),
+    PKG = require('../../package.json'),
+    mkdirp = require('mkdirp'),
+    encodeSVGDatauri = require('./tools.js').encodeSVGDatauri,
+    decodeSVGDatauri = require('./tools.js').decodeSVGDatauri,
+    regSVGFile = /\.svg$/;
+
+/**
+ * Command-Option-Argument.
+ *
+ * @see https://github.com/veged/coa
+ */
+module.exports = require('coa').Cmd()
+    .helpful()
+    .name(PKG.name)
+    .title(PKG.description)
+    .opt()
+        .name('version').title('Version')
+        .short('v').long('version')
+        .only()
+        .flag()
+        .act(function() {
+            // output the version to stdout instead of stderr if returned
+            process.stdout.write(PKG.version + '\n');
+            // coa will run `.toString` on the returned value and send it to stderr
+            return '';
+        })
+        .end()
+    .opt()
+        .name('input').title('Input file, "-" for STDIN')
+        .short('i').long('input')
+        .val(function(val) {
+            return val || this.reject("Option '--input' must have a value.");
+        })
+        .end()
+    .opt()
+        .name('string').title('Input SVG data string')
+        .short('s').long('string')
+        .end()
+    .opt()
+        .name('folder').title('Input folder, optimize and rewrite all *.svg files')
+        .short('f').long('folder')
+        .val(function(val) {
+            return val || this.reject("Option '--folder' must have a value.");
+        })
+        .end()
+    .opt()
+        .name('output').title('Output file or folder (by default the same as the input), "-" for STDOUT')
+        .short('o').long('output')
+        .val(function(val) {
+            return val || this.reject("Option '--output' must have a value.");
+        })
+        .end()
+    .opt()
+        .name('precision').title('Set number of digits in the fractional part, overrides plugins params')
+        .short('p').long('precision')
+        .val(function(val) {
+            return !isNaN(val) ? val : this.reject("Option '--precision' must be an integer number");
+        })
+        .end()
+    .opt()
+        .name('config').title('Config file or JSON string to extend or replace default')
+        .long('config')
+        .val(function(val) {
+            return val || this.reject("Option '--config' must have a value.");
+        })
+        .end()
+    .opt()
+        .name('disable').title('Disable plugin by name')
+        .long('disable')
+        .arr()
+        .val(function(val) {
+            return val || this.reject("Option '--disable' must have a value.");
+        })
+        .end()
+    .opt()
+        .name('enable').title('Enable plugin by name')
+        .long('enable')
+        .arr()
+        .val(function(val) {
+            return val || this.reject("Option '--enable' must have a value.");
+        })
+        .end()
+    .opt()
+        .name('datauri').title('Output as Data URI string (base64, URI encoded or unencoded)')
+        .long('datauri')
+        .val(function(val) {
+            return val || this.reject("Option '--datauri' must have one of the following values: 'base64', 'enc' or 'unenc'");
+        })
+        .end()
+    .opt()
+        .name('multipass').title('Enable multipass')
+        .long('multipass')
+        .flag()
+        .end()
+    .opt()
+        .name('pretty').title('Make SVG pretty printed')
+        .long('pretty')
+        .flag()
+        .end()
+    .opt()
+        .name('indent').title('Indent number when pretty printing SVGs')
+        .long('indent')
+        .val(function(val) {
+            return !isNaN(val) ? val : this.reject("Option '--indent' must be an integer number");
+        })
+        .end()
+    .opt()
+        .name('quiet').title('Only output error messages, not regular status messages')
+        .short('q').long('quiet')
+        .flag()
+        .end()
+    .opt()
+        .name('show-plugins').title('Show available plugins and exit')
+        .long('show-plugins')
+        .flag()
+        .end()
+    .arg()
+        .name('input').title('Alias to --input')
+        .end()
+    .arg()
+        .name('output').title('Alias to --output')
+        .end()
+    .act(function(opts, args) {
+
+        var input = args && args.input ? args.input : opts.input,
+            output = args && args.output ? args.output : opts.output,
+            config = {};
+
+        // --show-plugins
+        if (opts['show-plugins']) {
+
+            showAvailablePlugins();
+            process.exit(0);
+
+        }
+
+        // w/o anything
+        if (
+            (!input || input === '-') &&
+            !opts.string &&
+            !opts.stdin &&
+            !opts.folder &&
+            process.stdin.isTTY
+        ) return this.usage();
+
+
+        // --config
+        if (opts.config) {
+
+            // string
+            if (opts.config.charAt(0) === '{') {
+                try {
+                    config = JSON.parse(opts.config);
+                } catch (e) {
+                    console.error("Error: Couldn't parse config JSON.");
+                    console.error(String(e));
+                    return;
+                }
+
+            // external file
+            } else {
+                var configPath = PATH.resolve(opts.config);
+                try {
+                    // require() adds some weird output on YML files
+                    config = JSON.parse(FS.readFileSync(configPath, 'utf8'));
+                } catch (err) {
+                    if (err.code === 'ENOENT') {
+                        console.error('Error: couldn\'t find config file \'' + opts.config + '\'.');
+                        return;
+                    } else if (err.code === 'EISDIR') {
+                        console.error('Error: directory \'' + opts.config + '\' is not a config file.');
+                        return;
+                    }
+                    config = YAML.safeLoad(FS.readFileSync(configPath, 'utf8'));
+
+                    if (!config || Array.isArray(config)) {
+                        console.error('Error: invalid config file \'' + opts.config + '\'.');
+                        return;
+                    }
+                }
+            }
+
+        }
+
+        // --quiet
+        if (opts.quiet) {
+            config.quiet = opts.quiet;
+        }
+
+        // --precision
+        if (opts.precision) {
+            config.floatPrecision = Math.max(0, parseInt(opts.precision));
+        }
+
+        // --disable
+        if (opts.disable) {
+            changePluginsState(opts.disable, false, config);
+        }
+
+        // --enable
+        if (opts.enable) {
+            changePluginsState(opts.enable, true, config);
+        }
+
+        // --multipass
+        if (opts.multipass) {
+
+            config.multipass = true;
+
+        }
+
+        // --pretty
+        if (opts.pretty) {
+
+            config.js2svg = config.js2svg || {};
+            config.js2svg.pretty = true;
+            if (opts.indent) {
+                config.js2svg.indent = parseInt(opts.indent, 10);
+            }
+
+        }
+
+        // --output
+        if (opts.output) {
+            config.output = opts.output;
+        }
+
+        // --folder
+        if (opts.folder) {
+            optimizeFolder(opts.folder, config, output);
+
+            return;
+        }
+
+        // --input
+        if (input) {
+
+            // STDIN
+            if (input === '-') {
+
+                var data = '';
+
+                process.stdin.pause();
+
+                process.stdin
+                    .on('data', function(chunk) {
+                        data += chunk;
+                    })
+                    .once('end', function() {
+                        optimizeFromString(data, config, opts.datauri, input, output);
+                    })
+                    .resume();
+
+            // file
+            } else {
+
+                FS.readFile(input, 'utf8', function(err, data) {
+                    if (err) {
+                        if (err.code === 'EISDIR')
+                            optimizeFolder(input, config, output);
+                        else if (err.code === 'ENOENT')
+                            console.error('Error: no such file or directory \'' + input + '\'.');
+                        else
+                            console.error(err);
+                        return;
+                    }
+                    optimizeFromString(data, config, opts.datauri, input, output);
+                });
+
+            }
+
+        // --string
+        } else if (opts.string) {
+
+            opts.string = decodeSVGDatauri(opts.string);
+
+            optimizeFromString(opts.string, config, opts.datauri, input, output);
+
+        }
+    });
+
+function optimizeFromString(svgstr, config, datauri, input, output) {
+
+    var startTime = Date.now(config),
+        time,
+        inBytes = Buffer.byteLength(svgstr, 'utf8'),
+        outBytes,
+        svgo = new SVGO(config);
+
+    svgo.optimize(svgstr, function(result) {
+
+        if (result.error) {
+            console.error(result.error);
+            return;
+        }
+
+        if (datauri) {
+            result.data = encodeSVGDatauri(result.data, datauri);
+        }
+
+        outBytes = Buffer.byteLength(result.data, 'utf8');
+        time = Date.now() - startTime;
+
+        // stdout
+        if (output === '-' || (!input || input === '-') && !output) {
+
+            process.stdout.write(result.data + '\n');
+
+        // file
+        } else {
+
+            // overwrite input file if there is no output
+            if (!output && input) {
+                output = input;
+            }
+
+            if (!config.quiet) {
+                console.log('\r');
+            }
+
+            saveFileAndPrintInfo(config, result.data, output, inBytes, outBytes, time);
+
+        }
+
+    });
+
+}
+
+function saveFileAndPrintInfo(config, data, path, inBytes, outBytes, time) {
+
+    FS.writeFile(path, data, 'utf8', function() {
+        if (config.quiet) {
+            return;
+        }
+
+        // print time info
+        printTimeInfo(time);
+
+        // print optimization profit info
+        printProfitInfo(inBytes, outBytes);
+
+    });
+
+}
+
+function printTimeInfo(time) {
+    console.log('Done in ' + time + ' ms!');
+
+}
+
+function printProfitInfo(inBytes, outBytes) {
+
+    var profitPercents = 100 - outBytes * 100 / inBytes;
+
+    console.log(
+        (Math.round((inBytes / 1024) * 1000) / 1000) + ' KiB' +
+        (profitPercents < 0 ? ' + ' : ' - ') +
+        String(Math.abs((Math.round(profitPercents * 10) / 10)) + '%').green + ' = ' +
+        (Math.round((outBytes / 1024) * 1000) / 1000) + ' KiB\n'
+    );
+
+}
+
+/**
+ * Change plugins state by names array.
+ *
+ * @param {Array} names plugins names
+ * @param {Boolean} state active state
+ * @param {Object} config original config
+ * @return {Object} changed config
+ */
+function changePluginsState(names, state, config) {
+
+    // extend config
+    if (config.plugins) {
+
+        names.forEach(function(name) {
+
+            var matched,
+                key;
+
+            config.plugins.forEach(function(plugin) {
+
+                // get plugin name
+                if (typeof plugin === 'object') {
+                    key = Object.keys(plugin)[0];
+                } else {
+                    key = plugin;
+                }
+
+                // if there is such a plugin name
+                if (key === name) {
+                    // don't replace plugin's params with true
+                    if (typeof plugin[key] !== 'object' || !state) {
+                        plugin[key] = state;
+                    }
+
+                    // mark it as matched
+                    matched = true;
+                }
+
+            });
+
+            // if not matched and current config is not full
+            if (!matched && !config.full) {
+
+                var obj = {};
+
+                obj[name] = state;
+
+                // push new plugin Object
+                config.plugins.push(obj);
+
+                matched = true;
+
+            }
+
+        });
+
+    // just push
+    } else {
+
+        config.plugins = [];
+
+        names.forEach(function(name) {
+            var obj = {};
+
+            obj[name] = state;
+
+            config.plugins.push(obj);
+        });
+
+    }
+
+    return config;
+
+}
+
+function optimizeFolder(dir, config, output) {
+
+    var svgo = new SVGO(config);
+
+    if (!config.quiet) {
+        console.log('Processing directory \'' + dir + '\':\n');
+    }
+
+    // absoluted folder path
+    var path = PATH.resolve(dir);
+
+    // list folder content
+    FS.readdir(path, function(err, files) {
+
+        if (err) {
+            console.error(err);
+            return;
+        }
+
+        if (!files.length) {
+            console.log('Directory \'' + dir + '\' is empty.');
+            return;
+        }
+
+        var i = 0,
+            found = false;
+
+        function optimizeFile(file) {
+
+            // absoluted file path
+            var filepath = PATH.resolve(path, file);
+            var outfilepath = output ? PATH.resolve(output, file) : filepath;
+
+            // check if file name matches *.svg
+            if (regSVGFile.test(filepath)) {
+
+                found = true;
+                FS.readFile(filepath, 'utf8', function(err, data) {
+
+                    if (err) {
+                        console.error(err);
+                        return;
+                    }
+
+                    var startTime = Date.now(),
+                        time,
+                        inBytes = Buffer.byteLength(data, 'utf8'),
+                        outBytes;
+
+                    svgo.optimize(data, function(result) {
+
+                        if (result.error) {
+                            console.error(result.error);
+                            return;
+                        }
+
+                        outBytes = Buffer.byteLength(result.data, 'utf8');
+                        time = Date.now() - startTime;
+
+                        writeOutput();
+
+                        function writeOutput() {
+                            FS.writeFile(outfilepath, result.data, 'utf8', report);
+                        }
+
+                        function report(err) {
+
+                            if (err) {
+                                if (err.code === 'ENOENT') {
+                                    mkdirp(output, writeOutput);
+                                    return;
+                                } else if (err.code === 'ENOTDIR') {
+                                    console.error('Error: output \'' + output + '\' is not a directory.');
+                                    return;
+                                }
+                                console.error(err);
+                                return;
+                            }
+
+                            if (!config.quiet) {
+                                console.log(file + ':');
+
+                                // print time info
+                                printTimeInfo(time);
+
+                                // print optimization profit info
+                                printProfitInfo(inBytes, outBytes);
+                            }
+
+                            //move on to the next file
+                            if (++i < files.length) {
+                                optimizeFile(files[i]);
+                            }
+
+                        }
+
+                    });
+
+                });
+
+            }
+            //move on to the next file
+            else if (++i < files.length) {
+                optimizeFile(files[i]);
+            } else if (!found) {
+                console.log('No SVG files have been found.');
+            }
+
+
+        }
+
+        optimizeFile(files[i]);
+
+    });
+
+}
+
+
+var showAvailablePlugins = function () {
+
+    var svgo = new SVGO(),
+        // Flatten an array of plugins grouped per type and sort alphabetically
+        list = Array.prototype.concat.apply([], svgo.config.plugins).sort(function(a, b) {
+            return a.name > b.name ? 1 : -1;
+        });
+
+    console.log('Currently available plugins:');
+
+    list.forEach(function (plugin) {
+        console.log(' [ ' + plugin.name.green + ' ] ' + plugin.description);
+    });
+
+    //console.log(JSON.stringify(svgo, null, 4));
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/config.js

@@ -0,0 +1,212 @@
+'use strict';
+
+var FS = require('fs');
+var yaml = require('js-yaml');
+
+var EXTEND = require('whet.extend');
+
+/**
+ * Read and/or extend/replace default config file,
+ * prepare and optimize plugins array.
+ *
+ * @param {Object} [config] input config
+ * @return {Object} output config
+ */
+module.exports = function(config) {
+
+    var defaults;
+    config = typeof config == 'object' && config || {};
+
+    if (config.plugins && !Array.isArray(config.plugins)) {
+        return { error: 'Error: Invalid plugins list. Provided \'plugins\' in config should be an array.' };
+    }
+
+    if (config.full) {
+        defaults = config;
+
+        if (Array.isArray(defaults.plugins)) {
+            defaults.plugins = preparePluginsArray(defaults.plugins);
+        }
+    } else {
+        defaults = EXTEND({}, yaml.safeLoad(FS.readFileSync(__dirname + '/../../.svgo.yml', 'utf8')));
+        defaults.plugins = preparePluginsArray(defaults.plugins);
+        defaults = extendConfig(defaults, config);
+    }
+
+    if ('floatPrecision' in config && Array.isArray(defaults.plugins)) {
+        defaults.plugins.forEach(function(plugin) {
+            if (plugin.params && ('floatPrecision' in plugin.params)) {
+                // Don't touch default plugin params
+                plugin.params = EXTEND({}, plugin.params, { floatPrecision: config.floatPrecision });
+            }
+        });
+    }
+
+    if (Array.isArray(defaults.plugins)) {
+        defaults.plugins = optimizePluginsArray(defaults.plugins);
+    }
+
+    return defaults;
+
+};
+
+/**
+ * Require() all plugins in array.
+ *
+ * @param {Array} plugins input plugins array
+ * @return {Array} input plugins array of arrays
+ */
+function preparePluginsArray(plugins) {
+
+    var plugin,
+        key;
+
+    return plugins.map(function(item) {
+
+        // {}
+        if (typeof item === 'object') {
+
+            key = Object.keys(item)[0];
+
+            // custom
+            if (typeof item[key] === 'object' && item[key].fn && typeof item[key].fn === 'function') {
+                plugin = setupCustomPlugin(key, item[key]);
+
+            } else {
+
+              plugin = EXTEND({}, require('../../plugins/' + key));
+
+              // name: {}
+              if (typeof item[key] === 'object') {
+                  plugin.params = EXTEND({}, plugin.params || {}, item[key]);
+                  plugin.active = true;
+
+              // name: false
+              } else if (item[key] === false) {
+                 plugin.active = false;
+
+              // name: true
+              } else if (item[key] === true) {
+                 plugin.active = true;
+              }
+
+              plugin.name = key;
+            }
+
+        // name
+        } else {
+
+            plugin = EXTEND({}, require('../../plugins/' + item));
+            plugin.name = item;
+
+        }
+
+        return plugin;
+
+    });
+
+}
+
+/**
+ * Extend plugins with the custom config object.
+ *
+ * @param {Array} plugins input plugins
+ * @param {Object} config config
+ * @return {Array} output plugins
+ */
+function extendConfig(defaults, config) {
+
+    var key;
+
+    // plugins
+    if (config.plugins) {
+
+        config.plugins.forEach(function(item) {
+
+            // {}
+            if (typeof item === 'object') {
+
+                key = Object.keys(item)[0];
+
+                // custom
+                if (typeof item[key] === 'object' && item[key].fn && typeof item[key].fn === 'function') {
+                    defaults.plugins.push(setupCustomPlugin(key, item[key]));
+
+                } else {
+                    defaults.plugins.forEach(function(plugin) {
+
+                        if (plugin.name === key) {
+                            // name: {}
+                            if (typeof item[key] === 'object') {
+                                plugin.params = EXTEND({}, plugin.params || {}, item[key]);
+                                plugin.active = true;
+
+                            // name: false
+                            } else if (item[key] === false) {
+                               plugin.active = false;
+
+                            // name: true
+                            } else if (item[key] === true) {
+                               plugin.active = true;
+                            }
+                        }
+                    });
+                }
+
+            }
+
+        });
+
+    }
+
+    defaults.multipass = config.multipass;
+
+    // svg2js
+    if (config.svg2js) {
+        defaults.svg2js = config.svg2js;
+    }
+
+    // js2svg
+    if (config.js2svg) {
+        defaults.js2svg = config.js2svg;
+    }
+
+    return defaults;
+
+}
+
+/**
+ * Setup and enable a custom plugin
+ *
+ * @param {String} plugin name
+ * @param {Object} custom plugin
+ * @return {Array} enabled plugin
+ */
+function setupCustomPlugin(name, plugin) {
+    plugin.active = true;
+    plugin.params = EXTEND({}, plugin.params || {});
+    plugin.name = name;
+
+    return plugin;
+}
+
+/**
+ * Try to group sequential elements of plugins array.
+ *
+ * @param {Object} plugins input plugins
+ * @return {Array} output plugins
+ */
+function optimizePluginsArray(plugins) {
+
+    var prev;
+
+    return plugins.reduce(function(plugins, item) {
+        if (prev && item.type == prev[0].type) {
+            prev.push(item);
+        } else {
+            plugins.push(prev = [item]);
+        }
+        return plugins;
+    }, []);
+
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/js2svg.js

@@ -0,0 +1,352 @@
+'use strict';
+
+var EOL = require('os').EOL,
+    EXTEND = require('whet.extend'),
+    textElem = require('../../plugins/_collections.js').elemsGroups.textContent.concat('title');
+
+var defaults = {
+    doctypeStart: '<!DOCTYPE',
+    doctypeEnd: '>',
+    procInstStart: '<?',
+    procInstEnd: '?>',
+    tagOpenStart: '<',
+    tagOpenEnd: '>',
+    tagCloseStart: '</',
+    tagCloseEnd: '>',
+    tagShortStart: '<',
+    tagShortEnd: '/>',
+    attrStart: '="',
+    attrEnd: '"',
+    commentStart: '<!--',
+    commentEnd: '-->',
+    cdataStart: '<![CDATA[',
+    cdataEnd: ']]>',
+    textStart: '',
+    textEnd: '',
+    indent: 4,
+    regEntities: /[&'"<>]/g,
+    regValEntities: /[&"<>]/g,
+    encodeEntity: encodeEntity,
+    pretty: false,
+    useShortTags: true
+};
+
+var entities = {
+      '&': '&amp;',
+      '\'': '&apos;',
+      '"': '&quot;',
+      '>': '&gt;',
+      '<': '&lt;',
+    };
+
+/**
+ * Convert SVG-as-JS object to SVG (XML) string.
+ *
+ * @param {Object} data input data
+ * @param {Object} config config
+ *
+ * @return {Object} output data
+ */
+module.exports = function(data, config) {
+
+    return new JS2SVG(config).convert(data);
+
+};
+
+function JS2SVG(config) {
+
+    if (config) {
+        this.config = EXTEND(true, {}, defaults, config);
+    } else {
+        this.config = defaults;
+    }
+
+    var indent = this.config.indent;
+    if (typeof indent == 'number' && !isNaN(indent)) {
+        this.config.indent = '';
+        for (var i = indent; i-- > 0;) this.config.indent += ' ';
+    } else if (typeof indent != 'string') {
+        this.config.indent = '    ';
+    }
+
+    if (this.config.pretty) {
+        this.config.doctypeEnd += EOL;
+        this.config.procInstEnd += EOL;
+        this.config.commentEnd += EOL;
+        this.config.cdataEnd += EOL;
+        this.config.tagShortEnd += EOL;
+        this.config.tagOpenEnd += EOL;
+        this.config.tagCloseEnd += EOL;
+        this.config.textEnd += EOL;
+    }
+
+    this.indentLevel = 0;
+    this.textContext = null;
+
+}
+
+function encodeEntity(char) {
+    return entities[char];
+}
+
+/**
+ * Start conversion.
+ *
+ * @param {Object} data input data
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.convert = function(data) {
+
+    var svg = '';
+
+    if (data.content) {
+
+        this.indentLevel++;
+
+        data.content.forEach(function(item) {
+
+            if (item.elem) {
+               svg += this.createElem(item);
+            } else if (item.text) {
+               svg += this.createText(item.text);
+            } else if (item.doctype) {
+                svg += this.createDoctype(item.doctype);
+            } else if (item.processinginstruction) {
+                svg += this.createProcInst(item.processinginstruction);
+            } else if (item.comment) {
+                svg += this.createComment(item.comment);
+            } else if (item.cdata) {
+                svg += this.createCDATA(item.cdata);
+            }
+
+        }, this);
+
+    }
+
+    this.indentLevel--;
+
+    return {
+        data: svg,
+        info: {
+            width: this.width,
+            height: this.height
+        }
+    };
+
+};
+
+/**
+ * Create indent string in accordance with the current node level.
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createIndent = function() {
+
+    var indent = '';
+
+    if (this.config.pretty && !this.textContext) {
+        for (var i = 1; i < this.indentLevel; i++) {
+            indent += this.config.indent;
+        }
+    }
+
+    return indent;
+
+};
+
+/**
+ * Create doctype tag.
+ *
+ * @param {String} doctype doctype body string
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createDoctype = function(doctype) {
+
+    return  this.config.doctypeStart +
+            doctype +
+            this.config.doctypeEnd;
+
+};
+
+/**
+ * Create XML Processing Instruction tag.
+ *
+ * @param {Object} instruction instruction object
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createProcInst = function(instruction) {
+
+    return  this.config.procInstStart +
+            instruction.name +
+            ' ' +
+            instruction.body +
+            this.config.procInstEnd;
+
+};
+
+/**
+ * Create comment tag.
+ *
+ * @param {String} comment comment body
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createComment = function(comment) {
+
+    return  this.config.commentStart +
+            comment +
+            this.config.commentEnd;
+
+};
+
+/**
+ * Create CDATA section.
+ *
+ * @param {String} cdata CDATA body
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createCDATA = function(cdata) {
+
+    return  this.createIndent() +
+            this.config.cdataStart +
+            cdata +
+            this.config.cdataEnd;
+
+};
+
+/**
+ * Create element tag.
+ *
+ * @param {Object} data element object
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createElem = function(data) {
+
+    // beautiful injection for obtaining SVG information :)
+    if (
+        data.isElem('svg') &&
+        data.hasAttr('width') &&
+        data.hasAttr('height')
+    ) {
+        this.width = data.attr('width').value;
+        this.height = data.attr('height').value;
+    }
+
+    // empty element and short tag
+    if (data.isEmpty()) {
+        if (this.config.useShortTags) {
+            return this.createIndent() +
+                   this.config.tagShortStart +
+                   data.elem +
+                   this.createAttrs(data) +
+                   this.config.tagShortEnd;
+        } else {
+            return this.createIndent() +
+                   this.config.tagShortStart +
+                   data.elem +
+                   this.createAttrs(data) +
+                   this.config.tagOpenEnd +
+                   this.config.tagCloseStart +
+                   data.elem +
+                   this.config.tagCloseEnd;
+        }
+    // non-empty element
+    } else {
+        var tagOpenStart = this.config.tagOpenStart,
+            tagOpenEnd = this.config.tagOpenEnd,
+            tagCloseStart = this.config.tagCloseStart,
+            tagCloseEnd = this.config.tagCloseEnd,
+            openIndent = this.createIndent(),
+            textIndent = '',
+            processedData = '',
+            dataEnd = '';
+
+        if (this.textContext) {
+            tagOpenStart = defaults.tagOpenStart;
+            tagOpenEnd = defaults.tagOpenEnd;
+            tagCloseStart = defaults.tagCloseStart;
+            tagCloseEnd = defaults.tagCloseEnd;
+            openIndent = '';
+        } else if (data.isElem(textElem)) {
+            if (this.config.pretty) {
+                textIndent += openIndent + this.config.indent;
+            }
+            this.textContext = data;
+        }
+
+        processedData += this.convert(data).data;
+
+        if (this.textContext == data) {
+            this.textContext = null;
+            if (this.config.pretty) dataEnd = EOL;
+        }
+
+        return  openIndent +
+                tagOpenStart +
+                data.elem +
+                this.createAttrs(data) +
+                tagOpenEnd +
+                textIndent +
+                processedData +
+                dataEnd +
+                this.createIndent() +
+                tagCloseStart +
+                data.elem +
+                tagCloseEnd;
+
+    }
+
+};
+
+/**
+ * Create element attributes.
+ *
+ * @param {Object} elem attributes object
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createAttrs = function(elem) {
+
+    var attrs = '';
+
+    elem.eachAttr(function(attr) {
+
+        if (attr.value !== undefined) {
+            attrs +=    ' ' +
+                        attr.name +
+                        this.config.attrStart +
+                        String(attr.value).replace(this.config.regValEntities, this.config.encodeEntity) +
+                        this.config.attrEnd;
+        }
+        else {
+            attrs +=    ' ' +
+                        attr.name;
+        }
+
+
+    }, this);
+
+    return attrs;
+
+};
+
+/**
+ * Create text node.
+ *
+ * @param {String} text text
+ *
+ * @return {String}
+ */
+JS2SVG.prototype.createText = function(text) {
+
+    return  this.createIndent() +
+            this.config.textStart +
+            text.replace(this.config.regEntities, this.config.encodeEntity) +
+            (this.textContext ? '' : this.config.textEnd);
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/jsAPI.js

@@ -0,0 +1,298 @@
+'use strict';
+
+var EXTEND = require('whet.extend');
+
+var JSAPI = module.exports = function(data, parentNode) {
+    EXTEND(this, data);
+    if (parentNode) {
+        Object.defineProperty(this, 'parentNode', {
+            writable: true,
+            value: parentNode
+        });
+    }
+};
+
+/**
+ * Perform a deep clone of this node.
+ *
+ * @return {Object} element
+ */
+JSAPI.prototype.clone = function() {
+    var node = this;
+    var nodeData = {};
+
+    Object.keys(node).forEach(function(key) {
+        if (key !== 'content') {
+            nodeData[key] = node[key];
+        }
+    });
+
+    // Deep-clone node data
+    // This is still faster than using EXTEND(true…)
+    nodeData = JSON.parse(JSON.stringify(nodeData));
+
+    // parentNode gets set to a proper object by the parent clone,
+    // but it needs to be true/false now to do the right thing
+    // in the constructor.
+    var clonedNode = new JSAPI(nodeData, !!node.parentNode);
+
+    if (node.content) {
+        clonedNode.content = node.content.map(function(childNode) {
+            var clonedChild = childNode.clone();
+            clonedChild.parentNode = clonedNode;
+            return clonedChild;
+        });
+    }
+
+    return clonedNode;
+};
+
+/**
+ * Determine if item is an element
+ * (any, with a specific name or in a names array).
+ *
+ * @param {String|Array} [param] element name or names arrays
+ * @return {Boolean}
+ */
+JSAPI.prototype.isElem = function(param) {
+
+    if (!param) return !!this.elem;
+
+    if (Array.isArray(param)) return !!this.elem && (param.indexOf(this.elem) > -1);
+
+    return !!this.elem && this.elem === param;
+
+};
+
+/**
+ * Renames an element
+ *
+ * @param {String} name new element name
+ * @return {Object} element
+ */
+JSAPI.prototype.renameElem = function(name) {
+
+    if (name && typeof name === 'string')
+        this.elem = this.local = name;
+
+    return this;
+
+};
+
+/**
+ * Determine if element is empty.
+ *
+ * @return {Boolean}
+ */
+ JSAPI.prototype.isEmpty = function() {
+
+    return !this.content || !this.content.length;
+
+};
+
+/**
+ * Changes content by removing elements and/or adding new elements.
+ *
+ * @param {Number} start Index at which to start changing the content.
+ * @param {Number} n Number of elements to remove.
+ * @param {Array|Object} [insertion] Elements to add to the content.
+ * @return {Array} Removed elements.
+ */
+ JSAPI.prototype.spliceContent = function(start, n, insertion) {
+
+    if (arguments.length < 2) return [];
+
+    if (!Array.isArray(insertion))
+        insertion = Array.apply(null, arguments).slice(2);
+
+    insertion.forEach(function(inner) { inner.parentNode = this }, this);
+
+    return this.content.splice.apply(this.content, [start, n].concat(insertion));
+
+
+};
+
+/**
+ * Determine if element has an attribute
+ * (any, or by name or by name + value).
+ *
+ * @param {String} [name] attribute name
+ * @param {String} [val] attribute value (will be toString()'ed)
+ * @return {Boolean}
+ */
+ JSAPI.prototype.hasAttr = function(name, val) {
+
+    if (!this.attrs || !Object.keys(this.attrs).length) return false;
+
+    if (!arguments.length) return !!this.attrs;
+
+    if (val !== undefined) return !!this.attrs[name] && this.attrs[name].value === val.toString();
+
+    return !!this.attrs[name];
+
+};
+
+/**
+ * Determine if element has an attribute by local name
+ * (any, or by name or by name + value).
+ *
+ * @param {String} [localName] local attribute name
+ * @param {Number|String|RegExp|Function} [val] attribute value (will be toString()'ed or executed, otherwise ignored)
+ * @return {Boolean}
+ */
+ JSAPI.prototype.hasAttrLocal = function(localName, val) {
+
+    if (!this.attrs || !Object.keys(this.attrs).length) return false;
+
+    if (!arguments.length) return !!this.attrs;
+
+    var callback;
+
+    switch (val != null && val.constructor && val.constructor.name) {
+        case 'Number':   // same as String
+        case 'String':   callback = stringValueTest; break;
+        case 'RegExp':   callback = regexpValueTest; break;
+        case 'Function': callback = funcValueTest; break;
+        default:         callback = nameTest;
+    }
+    return this.someAttr(callback);
+
+    function nameTest(attr) {
+        return attr.local === localName;
+    }
+
+    function stringValueTest(attr) {
+        return attr.local === localName && val == attr.value;
+    }
+
+    function regexpValueTest(attr) {
+        return attr.local === localName && val.test(attr.value);
+    }
+
+    function funcValueTest(attr) {
+        return attr.local === localName && val(attr.value);
+    }
+
+};
+
+/**
+ * Get a specific attribute from an element
+ * (by name or name + value).
+ *
+ * @param {String} name attribute name
+ * @param {String} [val] attribute value (will be toString()'ed)
+ * @return {Object|Undefined}
+ */
+ JSAPI.prototype.attr = function(name, val) {
+
+    if (!this.hasAttr() || !arguments.length) return undefined;
+
+    if (val !== undefined) return this.hasAttr(name, val) ? this.attrs[name] : undefined;
+
+    return this.attrs[name];
+
+};
+
+/**
+ * Get computed attribute value from an element
+ *
+ * @param {String} name attribute name
+ * @return {Object|Undefined}
+ */
+ JSAPI.prototype.computedAttr = function(name, val) {
+    /* jshint eqnull: true */
+    if (!arguments.length) return;
+
+    for (var elem = this; elem && (!elem.hasAttr(name) || !elem.attr(name).value); elem = elem.parentNode);
+
+    if (val != null) {
+        return elem ? elem.hasAttr(name, val) : false;
+    } else if (elem && elem.hasAttr(name)) {
+        return elem.attrs[name].value;
+    }
+
+};
+
+/**
+ * Remove a specific attribute.
+ *
+ * @param {String|Array} name attribute name
+ * @param {String} [val] attribute value
+ * @return {Boolean}
+ */
+ JSAPI.prototype.removeAttr = function(name, val, recursive) {
+
+    if (!arguments.length) return false;
+
+    if (Array.isArray(name)) name.forEach(this.removeAttr, this);
+
+    if (!this.hasAttr(name)) return false;
+
+    if (!recursive && val && this.attrs[name].value !== val) return false;
+
+    delete this.attrs[name];
+
+    if (!Object.keys(this.attrs).length) delete this.attrs;
+
+    return true;
+
+};
+
+/**
+ * Add attribute.
+ *
+ * @param {Object} [attr={}] attribute object
+ * @return {Object|Boolean} created attribute or false if no attr was passed in
+ */
+ JSAPI.prototype.addAttr = function(attr) {
+    attr = attr || {};
+
+    if (attr.name === undefined ||
+        attr.prefix === undefined ||
+        attr.local === undefined
+    ) return false;
+
+    this.attrs = this.attrs || {};
+    this.attrs[attr.name] = attr;
+
+    return this.attrs[attr.name];
+
+};
+
+/**
+ * Iterates over all attributes.
+ *
+ * @param {Function} callback callback
+ * @param {Object} [context] callback context
+ * @return {Boolean} false if there are no any attributes
+ */
+ JSAPI.prototype.eachAttr = function(callback, context) {
+
+    if (!this.hasAttr()) return false;
+
+    for (var name in this.attrs) {
+        callback.call(context, this.attrs[name]);
+    }
+
+    return true;
+
+};
+
+/**
+ * Tests whether some attribute passes the test.
+ *
+ * @param {Function} callback callback
+ * @param {Object} [context] callback context
+ * @return {Boolean} false if there are no any attributes
+ */
+ JSAPI.prototype.someAttr = function(callback, context) {
+
+    if (!this.hasAttr()) return false;
+
+    for (var name in this.attrs) {
+        if (callback.call(context, this.attrs[name])) return true;
+    }
+
+    return false;
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/plugins.js

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * Plugins engine.
+ *
+ * @module plugins
+ *
+ * @param {Object} data input data
+ * @param {Object} plugins plugins object from config
+ * @return {Object} output data
+ */
+module.exports = function(data, plugins) {
+
+    plugins.forEach(function(group) {
+
+        switch(group[0].type) {
+            case 'perItem':
+                data = perItem(data, group);
+                break;
+            case 'perItemReverse':
+                data = perItem(data, group, true);
+                break;
+            case 'full':
+                data = full(data, group);
+                break;
+        }
+
+    });
+
+    return data;
+
+};
+
+/**
+ * Direct or reverse per-item loop.
+ *
+ * @param {Object} data input data
+ * @param {Array} plugins plugins list to process
+ * @param {Boolean} [reverse] reverse pass?
+ * @return {Object} output data
+ */
+function perItem(data, plugins, reverse) {
+
+    function monkeys(items) {
+
+        items.content = items.content.filter(function(item) {
+
+            // reverse pass
+            if (reverse && item.content) {
+                monkeys(item);
+            }
+
+            // main filter
+            var filter = true;
+
+            for (var i = 0; filter && i < plugins.length; i++) {
+                var plugin = plugins[i];
+
+                if (plugin.active && plugin.fn(item, plugin.params) === false) {
+                    filter = false;
+                }
+            }
+
+            // direct pass
+            if (!reverse && item.content) {
+                monkeys(item);
+            }
+
+            return filter;
+
+        });
+
+        return items;
+
+    }
+
+    return monkeys(data);
+
+}
+
+/**
+ * "Full" plugins.
+ *
+ * @param {Object} data input data
+ * @param {Array} plugins plugins list to process
+ * @return {Object} output data
+ */
+function full(data, plugins) {
+
+    plugins.forEach(function(plugin) {
+        if (plugin.active) {
+            data = plugin.fn(data, plugin.params);
+        }
+    });
+
+    return data;
+
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/svg2js.js

@@ -0,0 +1,187 @@
+'use strict';
+
+var SAX = require('sax'),
+    JSAPI = require('./jsAPI.js'),
+    entityDeclaration = /<!ENTITY\s+(\S+)\s+(?:'([^\']+)'|"([^\"]+)")\s*>/g;
+
+var config = {
+    strict: true,
+    trim: false,
+    normalize: true,
+    lowercase: true,
+    xmlns: true,
+    position: true
+};
+
+/**
+ * Convert SVG (XML) string to SVG-as-JS object.
+ *
+ * @param {String} data input data
+ * @param {Function} callback
+ */
+module.exports = function(data, callback) {
+
+    var sax = SAX.parser(config.strict, config),
+        root = new JSAPI({ elem: '#document' }),
+        current = root,
+        stack = [root],
+        textContext = null,
+        parsingError = false;
+
+    function pushToContent(content) {
+
+        content = new JSAPI(content, current);
+
+        (current.content = current.content || []).push(content);
+
+        return content;
+
+    }
+
+    sax.ondoctype = function(doctype) {
+
+        pushToContent({
+            doctype: doctype
+        });
+
+        var subsetStart = doctype.indexOf('['),
+            entityMatch;
+
+        if (subsetStart >= 0) {
+            entityDeclaration.lastIndex = subsetStart;
+
+            while ((entityMatch = entityDeclaration.exec(data)) != null) {
+                sax.ENTITIES[entityMatch[1]] = entityMatch[2] || entityMatch[3];
+            }
+        }
+    };
+
+    sax.onprocessinginstruction = function(data) {
+
+        pushToContent({
+            processinginstruction: data
+        });
+
+    };
+
+    sax.oncomment = function(comment) {
+
+        pushToContent({
+            comment: comment.trim()
+        });
+
+    };
+
+    sax.oncdata = function(cdata) {
+
+        pushToContent({
+            cdata: cdata
+        });
+
+    };
+
+    sax.onopentag = function(data) {
+
+        var elem = {
+            elem: data.name,
+            prefix: data.prefix,
+            local: data.local
+        };
+
+        if (Object.keys(data.attributes).length) {
+            elem.attrs = {};
+
+            for (var name in data.attributes) {
+                elem.attrs[name] = {
+                    name: name,
+                    value: data.attributes[name].value,
+                    prefix: data.attributes[name].prefix,
+                    local: data.attributes[name].local
+                };
+            }
+        }
+
+        elem = pushToContent(elem);
+        current = elem;
+
+        // Save info about <text> tag to prevent trimming of meaningful whitespace
+        if (data.name == 'text' && !data.prefix) {
+            textContext = current;
+        }
+
+        stack.push(elem);
+
+    };
+
+    sax.ontext = function(text) {
+
+        if (/\S/.test(text) || textContext) {
+
+            if (!textContext)
+                text = text.trim();
+
+            pushToContent({
+                text: text
+            });
+
+        }
+
+    };
+
+    sax.onclosetag = function() {
+
+        var last = stack.pop();
+
+        // Trim text inside <text> tag.
+        if (last == textContext) {
+            trim(textContext);
+            textContext = null;
+        }
+        current = stack[stack.length - 1];
+
+    };
+
+    sax.onerror = function(e) {
+
+        e.message = 'Error in parsing SVG: ' + e.message;
+        if (e.message.indexOf('Unexpected end') < 0) {
+            throw e;
+        }
+
+    };
+
+    sax.onend = function() {
+
+        if (!this.error) {
+            callback(root);
+        } else {
+            callback({ error: this.error.message });
+        }
+
+    };
+
+    try {
+        sax.write(data);
+    } catch (e) {
+        callback({ error: e.message });
+        parsingError = true;
+    }
+    if (!parsingError) sax.close();
+
+    function trim(elem) {
+        if (!elem.content) return elem;
+
+        var start = elem.content[0],
+            end = elem.content[elem.content.length - 1];
+
+        while (start && start.content && !start.text) start = start.content[0];
+        if (start && start.text) start.text = start.text.replace(/^\s+/, '');
+
+        while (end && end.content && !end.text) end = end.content[end.content.length - 1];
+        if (end && end.text) end.text = end.text.replace(/\s+$/, '');
+
+        return elem;
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/lib/svgo/tools.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/**
+ * Encode plain SVG data string into Data URI string.
+ *
+ * @param {String} str input string
+ * @param {String} type Data URI type
+ * @return {String} output string
+ */
+exports.encodeSVGDatauri = function(str, type) {
+
+    var prefix = 'data:image/svg+xml';
+
+    // base64
+    if (!type || type === 'base64') {
+
+        prefix += ';base64,';
+
+        str = prefix + new Buffer(str).toString('base64');
+
+    // URI encoded
+    } else if (type === 'enc') {
+
+        str = prefix + ',' + encodeURIComponent(str);
+
+    // unencoded
+    } else if (type === 'unenc') {
+
+        str = prefix + ',' + str;
+
+    }
+
+    return str;
+
+};
+
+/**
+ * Decode SVG Data URI string into plain SVG string.
+ *
+ * @param {string} str input string
+ * @return {String} output string
+ */
+exports.decodeSVGDatauri = function(str) {
+    var regexp = /data:image\/svg\+xml(;charset=[^;,]*)?(;base64)?,(.*)/;
+    var match = regexp.exec(str);
+
+    // plain string
+    if (!match) return str;
+
+    var data = match[3];
+
+    // base64
+    if (match[2]) {
+
+        str = new Buffer(data, 'base64').toString('utf8');
+
+    // URI encoded
+    } else if (data.charAt(0) === '%') {
+
+        str = decodeURIComponent(data);
+
+    // unencoded
+    } else if (data.charAt(0) === '<') {
+
+        str = data;
+
+    }
+
+    return str;
+};
+
+exports.intersectArrays = function(a, b) {
+    return a.filter(function(n) {
+        return b.indexOf(n) > -1;
+    });
+};
+
+exports.cleanupOutData = function(data, params) {
+
+    var str = '',
+        delimiter,
+        prev;
+
+    data.forEach(function(item, i) {
+
+        // space delimiter by default
+        delimiter = ' ';
+
+        // no extra space in front of first number
+        if (i === 0) {
+            delimiter = '';
+        }
+
+        // remove floating-point numbers leading zeros
+        // 0.5 → .5
+        // -0.5 → -.5
+        if (params.leadingZero) {
+            item = removeLeadingZero(item);
+        }
+
+        // no extra space in front of negative number or
+        // in front of a floating number if a previous number is floating too
+        if (
+            params.negativeExtraSpace &&
+            (item < 0 ||
+                (String(item).charCodeAt(0) == 46 && prev % 1 !== 0)
+            )
+        ) {
+            delimiter = '';
+        }
+
+        // save prev item value
+        prev = item;
+
+        str += delimiter + item;
+
+    });
+
+    return str;
+
+};
+
+/**
+ * Remove floating-point numbers leading zero.
+ *
+ * @example
+ * 0.5 → .5
+ *
+ * @example
+ * -0.5 → -.5
+ *
+ * @param {Float} num input number
+ *
+ * @return {String} output number as string
+ */
+var removeLeadingZero = exports.removeLeadingZero = function(num) {
+    var strNum = num.toString();
+
+    if (0 < num && num < 1 && strNum.charCodeAt(0) == 48) {
+        strNum = strNum.slice(1);
+    } else if (-1 < num && num < 0 && strNum.charCodeAt(1) == 48) {
+        strNum = strNum.charAt(0) + strNum.slice(2);
+    }
+
+    return strNum;
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/package.json

@@ -0,0 +1,98 @@
+{
+  "_args": [
+    [
+      "svgo@0.7.2",
+      "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project"
+    ]
+  ],
+  "_from": "svgo@0.7.2",
+  "_id": "svgo@0.7.2",
+  "_inBundle": false,
+  "_integrity": "sha1-n1dyQTlSE1xv779Ar+ak+qiLS7U=",
+  "_location": "/css-loader/svgo",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "svgo@0.7.2",
+    "name": "svgo",
+    "escapedName": "svgo",
+    "rawSpec": "0.7.2",
+    "saveSpec": null,
+    "fetchSpec": "0.7.2"
+  },
+  "_requiredBy": [
+    "/css-loader/postcss-svgo"
+  ],
+  "_resolved": "https://registry.npmjs.org/svgo/-/svgo-0.7.2.tgz",
+  "_spec": "0.7.2",
+  "_where": "C:\\Users\\deranjer\\go\\src\\github.com\\deranjer\\goTorrent\\torrent-project",
+  "author": {
+    "name": "Kir Belevich",
+    "email": "kir@soulshine.in",
+    "url": "https://github.com/deepsweet"
+  },
+  "bin": {
+    "svgo": "./bin/svgo"
+  },
+  "bugs": {
+    "url": "https://github.com/svg/svgo/issues",
+    "email": "kir@soulshine.in"
+  },
+  "contributors": [
+    {
+      "name": "Sergey Belov",
+      "email": "peimei@ya.ru",
+      "url": "http://github.com/arikon"
+    },
+    {
+      "name": "Lev Solntsev",
+      "email": "lev.sun@ya.ru",
+      "url": "http://github.com/GreLI"
+    }
+  ],
+  "dependencies": {
+    "coa": "~1.0.1",
+    "colors": "~1.1.2",
+    "csso": "~2.3.1",
+    "js-yaml": "~3.7.0",
+    "mkdirp": "~0.5.1",
+    "sax": "~1.2.1",
+    "whet.extend": "~0.9.9"
+  },
+  "description": "Nodejs-based tool for optimizing SVG vector graphics files",
+  "devDependencies": {
+    "coveralls": "~2.11.14",
+    "istanbul": "~0.4.5",
+    "mocha": "~3.2.0",
+    "mocha-istanbul": "~0.3.0",
+    "should": "11.2.0"
+  },
+  "directories": {
+    "bin": "./bin",
+    "lib": "./lib",
+    "example": "./examples"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "homepage": "https://github.com/svg/svgo",
+  "keywords": [
+    "svgo",
+    "svg",
+    "optimize",
+    "minify"
+  ],
+  "license": "MIT",
+  "main": "./lib/svgo.js",
+  "name": "svgo",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/svg/svgo.git"
+  },
+  "scripts": {
+    "jshint": "jshint --show-non-errors .",
+    "test": "set NODE_ENV=test && mocha"
+  },
+  "version": "0.7.2"
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/_path.js

@@ -0,0 +1,962 @@
+/* global a2c */
+'use strict';
+
+var regPathInstructions = /([MmLlHhVvCcSsQqTtAaZz])\s*/,
+    regPathData = /[-+]?(?:\d*\.\d+|\d+\.?)([eE][-+]?\d+)?/g,
+    regNumericValues = /[-+]?(\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/,
+    transform2js = require('./_transforms').transform2js,
+    transformsMultiply = require('./_transforms').transformsMultiply,
+    transformArc = require('./_transforms').transformArc,
+    collections = require('./_collections.js'),
+    referencesProps = collections.referencesProps,
+    defaultStrokeWidth = collections.attrsGroupsDefaults.presentation['stroke-width'],
+    cleanupOutData = require('../lib/svgo/tools').cleanupOutData,
+    removeLeadingZero = require('../lib/svgo/tools').removeLeadingZero,
+    prevCtrlPoint;
+
+/**
+ * Convert path string to JS representation.
+ *
+ * @param {String} pathString input string
+ * @param {Object} params plugin params
+ * @return {Array} output array
+ */
+exports.path2js = function(path) {
+    if (path.pathJS) return path.pathJS;
+
+    var paramsLength = { // Number of parameters of every path command
+            H: 1, V: 1, M: 2, L: 2, T: 2, Q: 4, S: 4, C: 6, A: 7,
+            h: 1, v: 1, m: 2, l: 2, t: 2, q: 4, s: 4, c: 6, a: 7
+        },
+        pathData = [],   // JS representation of the path data
+        instruction, // current instruction context
+        startMoveto = false;
+
+    // splitting path string into array like ['M', '10 50', 'L', '20 30']
+    path.attr('d').value.split(regPathInstructions).forEach(function(data) {
+        if (!data) return;
+        if (!startMoveto) {
+            if (data == 'M' || data == 'm') {
+                startMoveto = true;
+            } else return;
+        }
+
+        // instruction item
+        if (regPathInstructions.test(data)) {
+            instruction = data;
+
+            // z - instruction w/o data
+            if (instruction == 'Z' || instruction == 'z') {
+                pathData.push({
+                    instruction: 'z'
+                });
+            }
+        // data item
+        } else {
+            data = data.match(regPathData);
+            if (!data) return;
+
+            data = data.map(Number);
+
+            // Subsequent moveto pairs of coordinates are threated as implicit lineto commands
+            // http://www.w3.org/TR/SVG/paths.html#PathDataMovetoCommands
+            if (instruction == 'M' || instruction == 'm') {
+                pathData.push({
+                    instruction: pathData.length == 0 ? 'M' : instruction,
+                    data: data.splice(0, 2)
+                });
+                instruction = instruction == 'M' ? 'L' : 'l';
+            }
+
+            for (var pair = paramsLength[instruction]; data.length;) {
+                pathData.push({
+                    instruction: instruction,
+                    data: data.splice(0, pair)
+                });
+            }
+        }
+    });
+
+    // First moveto is actually absolute. Subsequent coordinates were separated above.
+    if (pathData.length && pathData[0].instruction == 'm') {
+        pathData[0].instruction = 'M';
+    }
+    path.pathJS = pathData;
+
+    return pathData;
+};
+
+/**
+ * Convert relative Path data to absolute.
+ *
+ * @param {Array} data input data
+ * @return {Array} output data
+ */
+var relative2absolute = exports.relative2absolute = function(data) {
+    var currentPoint = [0, 0],
+        subpathPoint = [0, 0],
+        i;
+
+    data = data.map(function(item) {
+
+        var instruction = item.instruction,
+            itemData = item.data && item.data.slice();
+
+        if (instruction == 'M') {
+
+            set(currentPoint, itemData);
+            set(subpathPoint, itemData);
+
+        } else if ('mlcsqt'.indexOf(instruction) > -1) {
+
+            for (i = 0; i < itemData.length; i++) {
+                itemData[i] += currentPoint[i % 2];
+            }
+            set(currentPoint, itemData);
+
+            if (instruction == 'm') {
+                set(subpathPoint, itemData);
+            }
+
+        } else if (instruction == 'a') {
+
+            itemData[5] += currentPoint[0];
+            itemData[6] += currentPoint[1];
+            set(currentPoint, itemData);
+
+        } else if (instruction == 'h') {
+
+            itemData[0] += currentPoint[0];
+            currentPoint[0] = itemData[0];
+
+        } else if (instruction == 'v') {
+
+            itemData[0] += currentPoint[1];
+            currentPoint[1] = itemData[0];
+
+        } else if ('MZLCSQTA'.indexOf(instruction) > -1) {
+
+            set(currentPoint, itemData);
+
+        } else if (instruction == 'H') {
+
+            currentPoint[0] = itemData[0];
+
+        } else if (instruction == 'V') {
+
+            currentPoint[1] = itemData[0];
+
+        } else if (instruction == 'z') {
+
+            set(currentPoint, subpathPoint);
+
+        }
+
+        return instruction == 'z' ?
+            { instruction: 'z' } :
+            {
+                instruction: instruction.toUpperCase(),
+                data: itemData
+            };
+
+    });
+
+    return data;
+};
+
+/**
+ * Apply transformation(s) to the Path data.
+ *
+ * @param {Object} elem current element
+ * @param {Array} path input path data
+ * @param {Object} params whether to apply transforms to stroked lines and transform precision (used for stroke width)
+ * @return {Array} output path data
+ */
+exports.applyTransforms = function(elem, path, params) {
+    // if there are no 'stroke' attr and references to other objects such as
+    // gradiends or clip-path which are also subjects to transform.
+    if (!elem.hasAttr('transform') || !elem.attr('transform').value ||
+        elem.someAttr(function(attr) {
+            return ~referencesProps.indexOf(attr.name) && ~attr.value.indexOf('url(');
+        }))
+        return path;
+
+    var matrix = transformsMultiply(transform2js(elem.attr('transform').value)),
+        stroke = elem.computedAttr('stroke'),
+        id = elem.computedAttr('id'),
+        transformPrecision = params.transformPrecision,
+        newPoint, scale;
+
+    if (stroke && stroke != 'none') {
+        if (!params.applyTransformsStroked ||
+            (matrix.data[0] != matrix.data[3] || matrix.data[1] != -matrix.data[2]) &&
+            (matrix.data[0] != -matrix.data[3] || matrix.data[1] != matrix.data[2]))
+            return path;
+
+        // "stroke-width" should be inside the part with ID, otherwise it can be overrided in <use>
+        if (id) {
+            var idElem = elem,
+                hasStrokeWidth = false;
+
+            do {
+                if (idElem.hasAttr('stroke-width')) hasStrokeWidth = true;
+            } while (!idElem.hasAttr('id', id) && !hasStrokeWidth && (idElem = idElem.parentNode));
+
+            if (!hasStrokeWidth) return path;
+        }
+
+        scale = +Math.sqrt(matrix.data[0] * matrix.data[0] + matrix.data[1] * matrix.data[1]).toFixed(transformPrecision);
+
+        if (scale !== 1) {
+            var strokeWidth = elem.computedAttr('stroke-width') || defaultStrokeWidth;
+
+            if (elem.hasAttr('stroke-width')) {
+                elem.attrs['stroke-width'].value = elem.attrs['stroke-width'].value.trim()
+                    .replace(regNumericValues, function(num) { return removeLeadingZero(num * scale) });
+            } else {
+                elem.addAttr({
+                    name: 'stroke-width',
+                    prefix: '',
+                    local: 'stroke-width',
+                    value: strokeWidth.replace(regNumericValues, function(num) { return removeLeadingZero(num * scale) })
+                });
+            }
+        }
+    } else if (id) { // Stroke and stroke-width can be redefined with <use>
+        return path;
+    }
+
+    path.forEach(function(pathItem) {
+
+        if (pathItem.data) {
+
+            // h -> l
+            if (pathItem.instruction === 'h') {
+
+                pathItem.instruction = 'l';
+                pathItem.data[1] = 0;
+
+            // v -> l
+            } else if (pathItem.instruction === 'v') {
+
+                pathItem.instruction = 'l';
+                pathItem.data[1] = pathItem.data[0];
+                pathItem.data[0] = 0;
+
+            }
+
+            // if there is a translate() transform
+            if (pathItem.instruction === 'M' &&
+                (matrix.data[4] !== 0 ||
+                matrix.data[5] !== 0)
+            ) {
+
+                // then apply it only to the first absoluted M
+                newPoint = transformPoint(matrix.data, pathItem.data[0], pathItem.data[1]);
+                set(pathItem.data, newPoint);
+                set(pathItem.coords, newPoint);
+
+                // clear translate() data from transform matrix
+                matrix.data[4] = 0;
+                matrix.data[5] = 0;
+
+            } else {
+
+                if (pathItem.instruction == 'a') {
+
+                    transformArc(pathItem.data, matrix.data);
+
+                    // reduce number of digits in rotation angle
+                    if (Math.abs(pathItem.data[2]) > 80) {
+                        var a = pathItem.data[0],
+                            rotation = pathItem.data[2];
+                        pathItem.data[0] = pathItem.data[1];
+                        pathItem.data[1] = a;
+                        pathItem.data[2] = rotation + (rotation > 0 ? -90 : 90);
+                    }
+
+                    newPoint = transformPoint(matrix.data, pathItem.data[5], pathItem.data[6]);
+                    pathItem.data[5] = newPoint[0];
+                    pathItem.data[6] = newPoint[1];
+
+                } else {
+
+                    for (var i = 0; i < pathItem.data.length; i += 2) {
+                        newPoint = transformPoint(matrix.data, pathItem.data[i], pathItem.data[i + 1]);
+                        pathItem.data[i] = newPoint[0];
+                        pathItem.data[i + 1] = newPoint[1];
+                    }
+                }
+
+                pathItem.coords[0] = pathItem.base[0] + pathItem.data[pathItem.data.length - 2];
+                pathItem.coords[1] = pathItem.base[1] + pathItem.data[pathItem.data.length - 1];
+
+            }
+
+        }
+
+    });
+
+    // remove transform attr
+    elem.removeAttr('transform');
+
+    return path;
+};
+
+/**
+ * Apply transform 3x3 matrix to x-y point.
+ *
+ * @param {Array} matrix transform 3x3 matrix
+ * @param {Array} point x-y point
+ * @return {Array} point with new coordinates
+ */
+function transformPoint(matrix, x, y) {
+
+    return [
+        matrix[0] * x + matrix[2] * y + matrix[4],
+        matrix[1] * x + matrix[3] * y + matrix[5]
+    ];
+
+}
+
+/**
+ * Compute Cubic Bézie bounding box.
+ *
+ * @see http://processingjs.nihongoresources.com/bezierinfo/
+ *
+ * @param {Float} xa
+ * @param {Float} ya
+ * @param {Float} xb
+ * @param {Float} yb
+ * @param {Float} xc
+ * @param {Float} yc
+ * @param {Float} xd
+ * @param {Float} yd
+ *
+ * @return {Object}
+ */
+exports.computeCubicBoundingBox = function(xa, ya, xb, yb, xc, yc, xd, yd) {
+
+    var minx = Number.POSITIVE_INFINITY,
+        miny = Number.POSITIVE_INFINITY,
+        maxx = Number.NEGATIVE_INFINITY,
+        maxy = Number.NEGATIVE_INFINITY,
+        ts,
+        t,
+        x,
+        y,
+        i;
+
+    // X
+    if (xa < minx) { minx = xa; }
+    if (xa > maxx) { maxx = xa; }
+    if (xd < minx) { minx= xd; }
+    if (xd > maxx) { maxx = xd; }
+
+    ts = computeCubicFirstDerivativeRoots(xa, xb, xc, xd);
+
+    for (i = 0; i < ts.length; i++) {
+
+        t = ts[i];
+
+        if (t >= 0 && t <= 1) {
+            x = computeCubicBaseValue(t, xa, xb, xc, xd);
+            // y = computeCubicBaseValue(t, ya, yb, yc, yd);
+
+            if (x < minx) { minx = x; }
+            if (x > maxx) { maxx = x; }
+        }
+
+    }
+
+    // Y
+    if (ya < miny) { miny = ya; }
+    if (ya > maxy) { maxy = ya; }
+    if (yd < miny) { miny = yd; }
+    if (yd > maxy) { maxy = yd; }
+
+    ts = computeCubicFirstDerivativeRoots(ya, yb, yc, yd);
+
+    for (i = 0; i < ts.length; i++) {
+
+        t = ts[i];
+
+        if (t >= 0 && t <= 1) {
+            // x = computeCubicBaseValue(t, xa, xb, xc, xd);
+            y = computeCubicBaseValue(t, ya, yb, yc, yd);
+
+            if (y < miny) { miny = y; }
+            if (y > maxy) { maxy = y; }
+        }
+
+    }
+
+    return {
+        minx: minx,
+        miny: miny,
+        maxx: maxx,
+        maxy: maxy
+    };
+
+};
+
+// compute the value for the cubic bezier function at time=t
+function computeCubicBaseValue(t, a, b, c, d) {
+
+    var mt = 1 - t;
+
+    return mt * mt * mt * a + 3 * mt * mt * t * b + 3 * mt * t * t * c + t * t * t * d;
+
+}
+
+// compute the value for the first derivative of the cubic bezier function at time=t
+function computeCubicFirstDerivativeRoots(a, b, c, d) {
+
+    var result = [-1, -1],
+        tl = -a + 2 * b - c,
+        tr = -Math.sqrt(-a * (c - d) + b * b - b * (c + d) + c * c),
+        dn = -a + 3 * b - 3 * c + d;
+
+    if (dn !== 0) {
+        result[0] = (tl + tr) / dn;
+        result[1] = (tl - tr) / dn;
+    }
+
+    return result;
+
+}
+
+/**
+ * Compute Quadratic Bézier bounding box.
+ *
+ * @see http://processingjs.nihongoresources.com/bezierinfo/
+ *
+ * @param {Float} xa
+ * @param {Float} ya
+ * @param {Float} xb
+ * @param {Float} yb
+ * @param {Float} xc
+ * @param {Float} yc
+ *
+ * @return {Object}
+ */
+exports.computeQuadraticBoundingBox = function(xa, ya, xb, yb, xc, yc) {
+
+    var minx = Number.POSITIVE_INFINITY,
+        miny = Number.POSITIVE_INFINITY,
+        maxx = Number.NEGATIVE_INFINITY,
+        maxy = Number.NEGATIVE_INFINITY,
+        t,
+        x,
+        y;
+
+    // X
+    if (xa < minx) { minx = xa; }
+    if (xa > maxx) { maxx = xa; }
+    if (xc < minx) { minx = xc; }
+    if (xc > maxx) { maxx = xc; }
+
+    t = computeQuadraticFirstDerivativeRoot(xa, xb, xc);
+
+    if (t >= 0 && t <= 1) {
+        x = computeQuadraticBaseValue(t, xa, xb, xc);
+        // y = computeQuadraticBaseValue(t, ya, yb, yc);
+
+        if (x < minx) { minx = x; }
+        if (x > maxx) { maxx = x; }
+    }
+
+    // Y
+    if (ya < miny) { miny = ya; }
+    if (ya > maxy) { maxy = ya; }
+    if (yc < miny) { miny = yc; }
+    if (yc > maxy) { maxy = yc; }
+
+    t = computeQuadraticFirstDerivativeRoot(ya, yb, yc);
+
+    if (t >= 0 && t <=1 ) {
+        // x = computeQuadraticBaseValue(t, xa, xb, xc);
+        y = computeQuadraticBaseValue(t, ya, yb, yc);
+
+        if (y < miny) { miny = y; }
+        if (y > maxy) { maxy = y ; }
+
+    }
+
+    return {
+        minx: minx,
+        miny: miny,
+        maxx: maxx,
+        maxy: maxy
+    };
+
+};
+
+// compute the value for the quadratic bezier function at time=t
+function computeQuadraticBaseValue(t, a, b, c) {
+
+    var mt = 1 - t;
+
+    return mt * mt * a + 2 * mt * t * b + t * t * c;
+
+}
+
+// compute the value for the first derivative of the quadratic bezier function at time=t
+function computeQuadraticFirstDerivativeRoot(a, b, c) {
+
+    var t = -1,
+        denominator = a - 2 * b + c;
+
+    if (denominator !== 0) {
+        t = (a - b) / denominator;
+    }
+
+    return t;
+
+}
+
+/**
+ * Convert path array to string.
+ *
+ * @param {Array} path input path data
+ * @param {Object} params plugin params
+ * @return {String} output path string
+ */
+exports.js2path = function(path, data, params) {
+
+    path.pathJS = data;
+
+    if (params.collapseRepeated) {
+        data = collapseRepeated(data);
+    }
+
+    path.attr('d').value = data.reduce(function(pathString, item) {
+        return pathString += item.instruction + (item.data ? cleanupOutData(item.data, params) : '');
+    }, '');
+
+};
+
+/**
+ * Collapse repeated instructions data
+ *
+ * @param {Array} path input path data
+ * @return {Array} output path data
+ */
+function collapseRepeated(data) {
+
+    var prev,
+        prevIndex;
+
+    // copy an array and modifieds item to keep original data untouched
+    data = data.reduce(function(newPath, item) {
+        if (
+            prev && item.data &&
+            item.instruction == prev.instruction
+        ) {
+            // concat previous data with current
+            if (item.instruction != 'M') {
+                prev = newPath[prevIndex] = {
+                    instruction: prev.instruction,
+                    data: prev.data.concat(item.data),
+                    coords: item.coords,
+                    base: prev.base
+                };
+            } else {
+                prev.data = item.data;
+                prev.coords = item.coords;
+            }
+        } else {
+            newPath.push(item);
+            prev = item;
+            prevIndex = newPath.length - 1;
+        }
+
+        return newPath;
+    }, []);
+
+    return data;
+
+}
+
+function set(dest, source) {
+    dest[0] = source[source.length - 2];
+    dest[1] = source[source.length - 1];
+    return dest;
+}
+
+/**
+ * Checks if two paths have an intersection by checking convex hulls
+ * collision using Gilbert-Johnson-Keerthi distance algorithm
+ * http://entropyinteractive.com/2011/04/gjk-algorithm/
+ *
+ * @param {Array} path1 JS path representation
+ * @param {Array} path2 JS path representation
+ * @return {Boolean}
+ */
+exports.intersects = function(path1, path2) {
+    if (path1.length < 3 || path2.length < 3) return false; // nothing to fill
+
+    // Collect points of every subpath.
+    var points1 = relative2absolute(path1).reduce(gatherPoints, []),
+        points2 = relative2absolute(path2).reduce(gatherPoints, []);
+
+    // Axis-aligned bounding box check.
+    if (points1.maxX <= points2.minX || points2.maxX <= points1.minX ||
+        points1.maxY <= points2.minY || points2.maxY <= points1.minY ||
+        points1.every(function (set1) {
+            return points2.every(function (set2) {
+                return set1[set1.maxX][0] <= set2[set2.minX][0] ||
+                    set2[set2.maxX][0] <= set1[set1.minX][0] ||
+                    set1[set1.maxY][1] <= set2[set2.minY][1] ||
+                    set2[set2.maxY][1] <= set1[set1.minY][1];
+            });
+        })
+    ) return false;
+
+    // Get a convex hull from points of each subpath. Has the most complexity O(n·log n).
+    var hullNest1 = points1.map(convexHull),
+        hullNest2 = points2.map(convexHull);
+
+    // Check intersection of every subpath of the first path with every subpath of the second.
+    return hullNest1.some(function(hull1) {
+        if (hull1.length < 3) return false;
+
+        return hullNest2.some(function(hull2) {
+            if (hull2.length < 3) return false;
+
+            var simplex = [getSupport(hull1, hull2, [1, 0])], // create the initial simplex
+                direction = minus(simplex[0]); // set the direction to point towards the origin
+
+            var iterations = 1e4; // infinite loop protection, 10 000 iterations is more than enough
+            while (true) {
+                if (iterations-- == 0) {
+                    console.error('Error: infinite loop while processing mergePaths plugin.');
+                    return true; // true is the safe value that means “do nothing with paths”
+                }
+                // add a new point
+                simplex.push(getSupport(hull1, hull2, direction));
+                // see if the new point was on the correct side of the origin
+                if (dot(direction, simplex[simplex.length - 1]) <= 0) return false;
+                // process the simplex
+                if (processSimplex(simplex, direction)) return true;
+            }
+        });
+    });
+
+    function getSupport(a, b, direction) {
+        return sub(supportPoint(a, direction), supportPoint(b, minus(direction)));
+    }
+
+    // Computes farthest polygon point in particular direction.
+    // Thanks to knowledge of min/max x and y coordinates we can choose a quadrant to search in.
+    // Since we're working on convex hull, the dot product is increasing until we find the farthest point.
+    function supportPoint(polygon, direction) {
+        var index = direction[1] >= 0 ?
+                direction[0] < 0 ? polygon.maxY : polygon.maxX :
+                direction[0] < 0 ? polygon.minX : polygon.minY,
+            max = -Infinity,
+            value;
+        while ((value = dot(polygon[index], direction)) > max) {
+            max = value;
+            index = ++index % polygon.length;
+        }
+        return polygon[(index || polygon.length) - 1];
+    }
+};
+
+function processSimplex(simplex, direction) {
+    /* jshint -W004 */
+
+    // we only need to handle to 1-simplex and 2-simplex
+    if (simplex.length == 2) { // 1-simplex
+        var a = simplex[1],
+            b = simplex[0],
+            AO = minus(simplex[1]),
+            AB = sub(b, a);
+        // AO is in the same direction as AB
+        if (dot(AO, AB) > 0) {
+            // get the vector perpendicular to AB facing O
+            set(direction, orth(AB, a));
+        } else {
+            set(direction, AO);
+            // only A remains in the simplex
+            simplex.shift();
+        }
+    } else { // 2-simplex
+        var a = simplex[2], // [a, b, c] = simplex
+            b = simplex[1],
+            c = simplex[0],
+            AB = sub(b, a),
+            AC = sub(c, a),
+            AO = minus(a),
+            ACB = orth(AB, AC), // the vector perpendicular to AB facing away from C
+            ABC = orth(AC, AB); // the vector perpendicular to AC facing away from B
+
+        if (dot(ACB, AO) > 0) {
+            if (dot(AB, AO) > 0) { // region 4
+                set(direction, ACB);
+                simplex.shift(); // simplex = [b, a]
+            } else { // region 5
+                set(direction, AO);
+                simplex.splice(0, 2); // simplex = [a]
+            }
+        } else if (dot(ABC, AO) > 0) {
+            if (dot(AC, AO) > 0) { // region 6
+                set(direction, ABC);
+                simplex.splice(1, 1); // simplex = [c, a]
+            } else { // region 5 (again)
+                set(direction, AO);
+                simplex.splice(0, 2); // simplex = [a]
+            }
+        } else // region 7
+            return true;
+    }
+    return false;
+}
+
+function minus(v) {
+    return [-v[0], -v[1]];
+}
+
+function sub(v1, v2) {
+    return [v1[0] - v2[0], v1[1] - v2[1]];
+}
+
+function dot(v1, v2) {
+    return v1[0] * v2[0] + v1[1] * v2[1];
+}
+
+function orth(v, from) {
+    var o = [-v[1], v[0]];
+    return dot(o, minus(from)) < 0 ? minus(o) : o;
+}
+
+function gatherPoints(points, item, index, path) {
+
+    var subPath = points.length && points[points.length - 1],
+        prev = index && path[index - 1],
+        basePoint = subPath.length && subPath[subPath.length - 1],
+        data = item.data,
+        ctrlPoint = basePoint;
+
+    switch (item.instruction) {
+        case 'M':
+            points.push(subPath = []);
+            break;
+        case 'H':
+            addPoint(subPath, [data[0], basePoint[1]]);
+            break;
+        case 'V':
+            addPoint(subPath, [basePoint[0], data[0]]);
+            break;
+        case 'Q':
+            addPoint(subPath, data.slice(0, 2));
+            prevCtrlPoint = [data[2] - data[0], data[3] - data[1]]; // Save control point for shorthand
+            break;
+        case 'T':
+            if (prev.instruction == 'Q' && prev.instruction == 'T') {
+                ctrlPoint = [basePoint[0] + prevCtrlPoint[0], basePoint[1] + prevCtrlPoint[1]];
+                addPoint(subPath, ctrlPoint);
+                prevCtrlPoint = [data[0] - ctrlPoint[0], data[1] - ctrlPoint[1]];
+            }
+            break;
+        case 'C':
+            // Approximate quibic Bezier curve with middle points between control points
+            addPoint(subPath, [.5 * (basePoint[0] + data[0]), .5 * (basePoint[1] + data[1])]);
+            addPoint(subPath, [.5 * (data[0] + data[2]), .5 * (data[1] + data[3])]);
+            addPoint(subPath, [.5 * (data[2] + data[4]), .5 * (data[3] + data[5])]);
+            prevCtrlPoint = [data[4] - data[2], data[5] - data[3]]; // Save control point for shorthand
+            break;
+        case 'S':
+            if (prev.instruction == 'C' && prev.instruction == 'S') {
+                addPoint(subPath, [basePoint[0] + .5 * prevCtrlPoint[0], basePoint[1] + .5 * prevCtrlPoint[1]]);
+                ctrlPoint = [basePoint[0] + prevCtrlPoint[0], basePoint[1] + prevCtrlPoint[1]];
+            }
+            addPoint(subPath, [.5 * (ctrlPoint[0] + data[0]), .5 * (ctrlPoint[1]+ data[1])]);
+            addPoint(subPath, [.5 * (data[0] + data[2]), .5 * (data[1] + data[3])]);
+            prevCtrlPoint = [data[2] - data[0], data[3] - data[1]];
+            break;
+        case 'A':
+            // Convert the arc to bezier curves and use the same approximation
+            var curves = a2c.apply(0, basePoint.concat(data));
+            for (var cData; (cData = curves.splice(0,6).map(toAbsolute)).length;) {
+                addPoint(subPath, [.5 * (basePoint[0] + cData[0]), .5 * (basePoint[1] + cData[1])]);
+                addPoint(subPath, [.5 * (cData[0] + cData[2]), .5 * (cData[1] + cData[3])]);
+                addPoint(subPath, [.5 * (cData[2] + cData[4]), .5 * (cData[3] + cData[5])]);
+                if (curves.length) addPoint(subPath, basePoint = cData.slice(-2));
+            }
+            break;
+    }
+    // Save final command coordinates
+    if (data && data.length >= 2) addPoint(subPath, data.slice(-2));
+    return points;
+
+    function toAbsolute(n, i) { return n + basePoint[i % 2] }
+
+    // Writes data about the extreme points on each axle
+    function addPoint(path, point) {
+        if (!path.length || point[1] > path[path.maxY][1]) {
+            path.maxY = path.length;
+            points.maxY = points.length ? Math.max(point[1], points.maxY) : point[1];
+        }
+        if (!path.length || point[0] > path[path.maxX][0]) {
+            path.maxX = path.length;
+            points.maxX = points.length ? Math.max(point[0], points.maxX) : point[0];
+        }
+        if (!path.length || point[1] < path[path.minY][1]) {
+            path.minY = path.length;
+            points.minY = points.length ? Math.min(point[1], points.minY) : point[1];
+        }
+        if (!path.length || point[0] < path[path.minX][0]) {
+            path.minX = path.length;
+            points.minX = points.length ? Math.min(point[0], points.minX) : point[0];
+        }
+        path.push(point);
+    }
+}
+
+/**
+ * Forms a convex hull from set of points of every subpath using monotone chain convex hull algorithm.
+ * http://en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain
+ *
+ * @param points An array of [X, Y] coordinates
+ */
+function convexHull(points) {
+    /* jshint -W004 */
+
+    points.sort(function(a, b) {
+        return a[0] == b[0] ? a[1] - b[1] : a[0] - b[0];
+    });
+
+    var lower = [],
+        minY = 0,
+        bottom = 0;
+    for (var i = 0; i < points.length; i++) {
+        while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], points[i]) <= 0) {
+            lower.pop();
+        }
+        if (points[i][1] < points[minY][1]) {
+            minY = i;
+            bottom = lower.length;
+        }
+        lower.push(points[i]);
+    }
+
+    var upper = [],
+        maxY = points.length - 1,
+        top = 0;
+    for (var i = points.length; i--;) {
+        while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], points[i]) <= 0) {
+            upper.pop();
+        }
+        if (points[i][1] > points[maxY][1]) {
+            maxY = i;
+            top = upper.length;
+        }
+        upper.push(points[i]);
+    }
+
+    // last points are equal to starting points of the other part
+    upper.pop();
+    lower.pop();
+
+    var hull = lower.concat(upper);
+
+    hull.minX = 0; // by sorting
+    hull.maxX = lower.length;
+    hull.minY = bottom;
+    hull.maxY = (lower.length + top) % hull.length;
+
+    return hull;
+}
+
+function cross(o, a, b) {
+    return (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+}
+
+/* Based on code from Snap.svg (Apache 2 license). http://snapsvg.io/
+ * Thanks to Dmitry Baranovskiy for his great work!
+ */
+
+// jshint ignore: start
+function a2c(x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
+    // for more information of where this Math came from visit:
+    // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
+    var _120 = Math.PI * 120 / 180,
+        rad = Math.PI / 180 * (+angle || 0),
+        res = [],
+        rotateX = function(x, y, rad) { return x * Math.cos(rad) - y * Math.sin(rad) },
+        rotateY = function(x, y, rad) { return x * Math.sin(rad) + y * Math.cos(rad) };
+    if (!recursive) {
+        x1 = rotateX(x1, y1, -rad);
+        y1 = rotateY(x1, y1, -rad);
+        x2 = rotateX(x2, y2, -rad);
+        y2 = rotateY(x2, y2, -rad);
+        var x = (x1 - x2) / 2,
+            y = (y1 - y2) / 2;
+        var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
+        if (h > 1) {
+            h = Math.sqrt(h);
+            rx = h * rx;
+            ry = h * ry;
+        }
+        var rx2 = rx * rx,
+            ry2 = ry * ry,
+            k = (large_arc_flag == sweep_flag ? -1 : 1) *
+                Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
+            cx = k * rx * y / ry + (x1 + x2) / 2,
+            cy = k * -ry * x / rx + (y1 + y2) / 2,
+            f1 = Math.asin(((y1 - cy) / ry).toFixed(9)),
+            f2 = Math.asin(((y2 - cy) / ry).toFixed(9));
+
+        f1 = x1 < cx ? Math.PI - f1 : f1;
+        f2 = x2 < cx ? Math.PI - f2 : f2;
+        f1 < 0 && (f1 = Math.PI * 2 + f1);
+        f2 < 0 && (f2 = Math.PI * 2 + f2);
+        if (sweep_flag && f1 > f2) {
+            f1 = f1 - Math.PI * 2;
+        }
+        if (!sweep_flag && f2 > f1) {
+            f2 = f2 - Math.PI * 2;
+        }
+    } else {
+        f1 = recursive[0];
+        f2 = recursive[1];
+        cx = recursive[2];
+        cy = recursive[3];
+    }
+    var df = f2 - f1;
+    if (Math.abs(df) > _120) {
+        var f2old = f2,
+            x2old = x2,
+            y2old = y2;
+        f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
+        x2 = cx + rx * Math.cos(f2);
+        y2 = cy + ry * Math.sin(f2);
+        res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
+    }
+    df = f2 - f1;
+    var c1 = Math.cos(f1),
+        s1 = Math.sin(f1),
+        c2 = Math.cos(f2),
+        s2 = Math.sin(f2),
+        t = Math.tan(df / 4),
+        hx = 4 / 3 * rx * t,
+        hy = 4 / 3 * ry * t,
+        m = [
+            - hx * s1, hy * c1,
+            x2 + hx * s2 - x1, y2 - hy * c2 - y1,
+            x2 - x1, y2 - y1
+        ];
+    if (recursive) {
+        return m.concat(res);
+    } else {
+        res = m.concat(res);
+        var newres = [];
+        for (var i = 0, n = res.length; i < n; i++) {
+            newres[i] = i % 2 ? rotateY(res[i - 1], res[i], rad) : rotateX(res[i], res[i + 1], rad);
+        }
+        return newres;
+    }
+}
+// jshint ignore: end

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/_transforms.js

@@ -0,0 +1,308 @@
+'use strict';
+
+var regTransformTypes = /matrix|translate|scale|rotate|skewX|skewY/,
+    regTransformSplit = /\s*(matrix|translate|scale|rotate|skewX|skewY)\s*\(\s*(.+?)\s*\)[\s,]*/,
+    regNumericValues = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
+
+/**
+ * Convert transform string to JS representation.
+ *
+ * @param {String} transformString input string
+ * @param {Object} params plugin params
+ * @return {Array} output array
+ */
+exports.transform2js = function(transformString) {
+
+        // JS representation of the transform data
+    var transforms = [],
+        // current transform context
+        current;
+
+    // split value into ['', 'translate', '10 50', '', 'scale', '2', '', 'rotate', '-45', '']
+    transformString.split(regTransformSplit).forEach(function(item) {
+        /*jshint -W084 */
+        var num;
+
+        if (item) {
+            // if item is a translate function
+            if (regTransformTypes.test(item)) {
+                // then collect it and change current context
+                transforms.push(current = { name: item });
+            // else if item is data
+            } else {
+                // then split it into [10, 50] and collect as context.data
+                while (num = regNumericValues.exec(item)) {
+                    num = Number(num);
+                    if (current.data)
+                        current.data.push(num);
+                    else
+                        current.data = [num];
+                }
+            }
+        }
+    });
+
+    return transforms;
+
+};
+
+/**
+ * Multiply transforms into one.
+ *
+ * @param {Array} input transforms array
+ * @return {Array} output matrix array
+ */
+exports.transformsMultiply = function(transforms) {
+
+    // convert transforms objects to the matrices
+    transforms = transforms.map(function(transform) {
+        if (transform.name === 'matrix') {
+            return transform.data;
+        }
+        return transformToMatrix(transform);
+    });
+
+    // multiply all matrices into one
+    transforms = {
+        name: 'matrix',
+        data: transforms.reduce(function(a, b) {
+            return multiplyTransformMatrices(a, b);
+        })
+    };
+
+    return transforms;
+
+};
+
+/**
+ * Do math like a schoolgirl.
+ *
+ * @type {Object}
+ */
+var mth = exports.mth = {
+
+    rad: function(deg) {
+        return deg * Math.PI / 180;
+    },
+
+    deg: function(rad) {
+        return rad * 180 / Math.PI;
+    },
+
+    cos: function(deg) {
+        return Math.cos(this.rad(deg));
+    },
+
+    acos: function(val, floatPrecision) {
+        return +(this.deg(Math.acos(val)).toFixed(floatPrecision));
+    },
+
+    sin: function(deg) {
+        return Math.sin(this.rad(deg));
+    },
+
+    asin: function(val, floatPrecision) {
+        return +(this.deg(Math.asin(val)).toFixed(floatPrecision));
+    },
+
+    tan: function(deg) {
+        return Math.tan(this.rad(deg));
+    },
+
+    atan: function(val, floatPrecision) {
+        return +(this.deg(Math.atan(val)).toFixed(floatPrecision));
+    }
+
+};
+
+/**
+ * Decompose matrix into simple transforms. See
+ * http://www.maths-informatique-jeux.com/blog/frederic/?post/2013/12/01/Decomposition-of-2D-transform-matrices
+ *
+ * @param {Object} data matrix transform object
+ * @return {Object|Array} transforms array or original transform object
+ */
+exports.matrixToTransform = function(transform, params) {
+    var floatPrecision = params.floatPrecision,
+        data = transform.data,
+        transforms = [],
+        sx = +Math.sqrt(data[0] * data[0] + data[1] * data[1]).toFixed(params.transformPrecision),
+        sy = +((data[0] * data[3] - data[1] * data[2]) / sx).toFixed(params.transformPrecision),
+        colsSum = data[0] * data[2] + data[1] * data[3],
+        rowsSum = data[0] * data[1] + data[2] * data[3],
+        scaleBefore = rowsSum || +(sx == sy);
+
+    // [..., ..., ..., ..., tx, ty] → translate(tx, ty)
+    if (data[4] || data[5]) {
+        transforms.push({ name: 'translate', data: data.slice(4, data[5] ? 6 : 5) });
+    }
+
+    // [sx, 0, tan(a)·sy, sy, 0, 0] → skewX(a)·scale(sx, sy)
+    if (!data[1] && data[2]) {
+        transforms.push({ name: 'skewX', data: [mth.atan(data[2] / sy, floatPrecision)] });
+
+    // [sx, sx·tan(a), 0, sy, 0, 0] → skewY(a)·scale(sx, sy)
+    } else if (data[1] && !data[2]) {
+        transforms.push({ name: 'skewY', data: [mth.atan(data[1] / data[0], floatPrecision)] });
+        sx = data[0];
+        sy = data[3];
+
+    // [sx·cos(a), sx·sin(a), sy·-sin(a), sy·cos(a), x, y] → rotate(a[, cx, cy])·(scale or skewX) or
+    // [sx·cos(a), sy·sin(a), sx·-sin(a), sy·cos(a), x, y] → scale(sx, sy)·rotate(a[, cx, cy]) (if !scaleBefore)
+    } else if (!colsSum || (sx == 1 && sy == 1) || !scaleBefore) {
+        if (!scaleBefore) {
+            sx = (data[0] < 0 ? -1 : 1) * Math.sqrt(data[0] * data[0] + data[2] * data[2]);
+            sy = (data[3] < 0 ? -1 : 1) * Math.sqrt(data[1] * data[1] + data[3] * data[3]);
+            transforms.push({ name: 'scale', data: [sx, sy] });
+        }
+        var rotate = [mth.acos(data[0] / sx, floatPrecision) * (data[1] * sy < 0 ? -1 : 1)];
+
+        if (rotate[0]) transforms.push({ name: 'rotate', data: rotate });
+
+        if (rowsSum && colsSum) transforms.push({
+            name: 'skewX',
+            data: [mth.atan(colsSum / (sx * sx), floatPrecision)]
+        });
+
+        // rotate(a, cx, cy) can consume translate() within optional arguments cx, cy (rotation point)
+        if (rotate[0] && (data[4] || data[5])) {
+            transforms.shift();
+            var cos = data[0] / sx,
+                sin = data[1] / (scaleBefore ? sx : sy),
+                x = data[4] * (scaleBefore || sy),
+                y = data[5] * (scaleBefore || sx),
+                denom = (Math.pow(1 - cos, 2) + Math.pow(sin, 2)) * (scaleBefore || sx * sy);
+            rotate.push(((1 - cos) * x - sin * y) / denom);
+            rotate.push(((1 - cos) * y + sin * x) / denom);
+        }
+
+    // Too many transformations, return original matrix if it isn't just a scale/translate
+    } else if (data[1] || data[2]) {
+        return transform;
+    }
+
+    if (scaleBefore && (sx != 1 || sy != 1) || !transforms.length) transforms.push({
+        name: 'scale',
+        data: sx == sy ? [sx] : [sx, sy]
+    });
+
+    return transforms;
+};
+
+/**
+ * Convert transform to the matrix data.
+ *
+ * @param {Object} transform transform object
+ * @return {Array} matrix data
+ */
+function transformToMatrix(transform) {
+
+    if (transform.name === 'matrix') return transform.data;
+
+    var matrix;
+
+    switch (transform.name) {
+        case 'translate':
+            // [1, 0, 0, 1, tx, ty]
+            matrix = [1, 0, 0, 1, transform.data[0], transform.data[1] || 0];
+            break;
+        case 'scale':
+            // [sx, 0, 0, sy, 0, 0]
+            matrix = [transform.data[0], 0, 0, transform.data[1] || transform.data[0], 0, 0];
+            break;
+        case 'rotate':
+            // [cos(a), sin(a), -sin(a), cos(a), x, y]
+            var cos = mth.cos(transform.data[0]),
+                sin = mth.sin(transform.data[0]),
+                cx = transform.data[1] || 0,
+                cy = transform.data[2] || 0;
+
+            matrix = [cos, sin, -sin, cos, (1 - cos) * cx + sin * cy, (1 - cos) * cy - sin * cx];
+            break;
+        case 'skewX':
+            // [1, 0, tan(a), 1, 0, 0]
+            matrix = [1, 0, mth.tan(transform.data[0]), 1, 0, 0];
+            break;
+        case 'skewY':
+            // [1, tan(a), 0, 1, 0, 0]
+            matrix = [1, mth.tan(transform.data[0]), 0, 1, 0, 0];
+            break;
+    }
+
+    return matrix;
+
+}
+
+/**
+ * Applies transformation to an arc. To do so, we represent ellipse as a matrix, multiply it
+ * by the transformation matrix and use a singular value decomposition to represent in a form
+ * rotate(θ)·scale(a b)·rotate(φ). This gives us new ellipse params a, b and θ.
+ * SVD is being done with the formulae provided by Wolffram|Alpha (svd {{m0, m2}, {m1, m3}})
+ *
+ * @param {Array} arc [a, b, rotation in deg]
+ * @param {Array} transform transformation matrix
+ * @return {Array} arc transformed input arc
+ */
+exports.transformArc = function(arc, transform) {
+
+    var a = arc[0],
+        b = arc[1],
+        rot = arc[2] * Math.PI / 180,
+        cos = Math.cos(rot),
+        sin = Math.sin(rot),
+        h = Math.pow(arc[5] * cos + arc[6] * sin, 2) / (4 * a * a) +
+            Math.pow(arc[6] * cos - arc[5] * sin, 2) / (4 * b * b);
+    if (h > 1) {
+        h = Math.sqrt(h);
+        a *= h;
+        b *= h;
+    }
+    var ellipse = [a * cos, a * sin, -b * sin, b * cos, 0, 0],
+        m = multiplyTransformMatrices(transform, ellipse),
+        // Decompose the new ellipse matrix
+        lastCol = m[2] * m[2] + m[3] * m[3],
+        squareSum = m[0] * m[0] + m[1] * m[1] + lastCol,
+        root = Math.sqrt(
+            (Math.pow(m[0] - m[3], 2) + Math.pow(m[1] + m[2], 2)) *
+            (Math.pow(m[0] + m[3], 2) + Math.pow(m[1] - m[2], 2))
+        );
+
+    if (!root) { // circle
+        arc[0] = arc[1] = Math.sqrt(squareSum / 2);
+        arc[2] = 0;
+    } else {
+        var majorAxisSqr = (squareSum + root) / 2,
+            minorAxisSqr = (squareSum - root) / 2,
+            major = Math.abs(majorAxisSqr - lastCol) > 1e-6,
+            sub = (major ? majorAxisSqr : minorAxisSqr) - lastCol,
+            rowsSum = m[0] * m[2] + m[1] * m[3],
+            term1 = m[0] * sub + m[2] * rowsSum,
+            term2 = m[1] * sub + m[3] * rowsSum;
+        arc[0] = Math.sqrt(majorAxisSqr);
+        arc[1] = Math.sqrt(minorAxisSqr);
+        arc[2] = ((major ? term2 < 0 : term1 > 0) ? -1 : 1) *
+            Math.acos((major ? term1 : term2) / Math.sqrt(term1 * term1 + term2 * term2)) * 180 / Math.PI;
+    }
+    return arc;
+
+};
+
+/**
+ * Multiply transformation matrices.
+ *
+ * @param {Array} a matrix A data
+ * @param {Array} b matrix B data
+ * @return {Array} result
+ */
+function multiplyTransformMatrices(a, b) {
+
+    return [
+        a[0] * b[0] + a[2] * b[1],
+        a[1] * b[0] + a[3] * b[1],
+        a[0] * b[2] + a[2] * b[3],
+        a[1] * b[2] + a[3] * b[3],
+        a[0] * b[4] + a[2] * b[5] + a[4],
+        a[1] * b[4] + a[3] * b[5] + a[5]
+    ];
+
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/addAttributesToSVGElement.js

@@ -0,0 +1,57 @@
+'use strict';
+
+exports.type = 'full';
+
+exports.active = false;
+
+exports.description = 'adds attributes to an outer <svg> element';
+
+var ENOCLS = 'Error in plugin "addAttributesToSVGElement": absent parameters.\n\
+It should have a list of classes in "attributes" or one "attribute".\n\
+Config example:\n\n\
+\
+plugins:\n\
+- addAttributesToSVGElement:\n\
+    attribute: "mySvg"\n\n\
+\
+plugins:\n\
+- addAttributesToSVGElement:\n\
+    attributes: ["mySvg", "size-big"]\n';
+
+/**
+ * Add attributes to an outer <svg> element. Example config:
+ *
+ * plugins:
+ * - addAttributesToSVGElement:
+ *     attribute: 'data-icon'
+ *
+ * plugins:
+ * - addAttributesToSVGElement:
+ *     attributes: ['data-icon', 'data-disabled']
+ *
+ * @author April Arcus
+ */
+exports.fn = function(data, params) {
+    if (!params || !(Array.isArray(params.attributes) && params.attributes.some(String) || params.attribute)) {
+        console.error(ENOCLS);
+        return data;
+    }
+
+    var attributes = params.attributes || [ params.attribute ],
+        svg = data.content[0];
+
+    if (svg.isElem('svg')) {
+        attributes.forEach(function (attribute) {
+            if (!svg.hasAttr(attribute)) {
+                svg.addAttr({
+                    name: attribute,
+                    prefix: '',
+                    local: attribute
+                });
+            }
+        });
+    }
+
+    return data;
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/addClassesToSVGElement.js

@@ -0,0 +1,64 @@
+'use strict';
+
+exports.type = 'full';
+
+exports.active = false;
+
+exports.description = 'adds classnames to an outer <svg> element';
+
+var ENOCLS = 'Error in plugin "addClassesToSVGElement": absent parameters.\n\
+It should have a list of classes in "classNames" or one "className".\n\
+Config example:\n\n\
+\
+plugins:\n\
+- addClassesToSVGElement:\n\
+    className: "mySvg"\n\n\
+\
+plugins:\n\
+- addClassesToSVGElement:\n\
+    classNames: ["mySvg", "size-big"]\n';
+
+/**
+ * Add classnames to an outer <svg> element. Example config:
+ *
+ * plugins:
+ * - addClassesToSVGElement:
+ *     className: 'mySvg'
+ *
+ * plugins:
+ * - addClassesToSVGElement:
+ *     classNames: ['mySvg', 'size-big']
+ *
+ * @author April Arcus
+ */
+exports.fn = function(data, params) {
+    if (!params || !(Array.isArray(params.classNames) && params.classNames.some(String) || params.className)) {
+        console.error(ENOCLS);
+        return data;
+    }
+
+    var classNames = params.classNames || [ params.className ],
+        svg = data.content[0];
+
+    if (svg.isElem('svg')) {
+        if (svg.hasAttr('class')) {
+            var classes = svg.attr('class').value.split(' ');
+            classNames.forEach(function(className){
+                if (classes.indexOf(className) < 0) {
+                    classes.push(className);
+                }
+            });
+            svg.attr('class').value = classes.join(' ');
+        } else {
+            svg.addAttr({
+                name: 'class',
+                value: classNames.join(' '),
+                prefix: '',
+                local: 'class'
+            });
+        }
+    }
+
+    return data;
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/cleanupAttrs.js

@@ -0,0 +1,56 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'cleanups attributes from newlines, trailing and repeating spaces';
+
+exports.params = {
+    newlines: true,
+    trim: true,
+    spaces: true
+};
+
+var regNewlinesNeedSpace = /(\S)\r?\n(\S)/g,
+    regNewlines = /\r?\n/g,
+    regSpaces = /\s{2,}/g;
+
+/**
+ * Cleanup attributes values from newlines, trailing and repeating spaces.
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.isElem()) {
+
+        item.eachAttr(function(attr) {
+
+            if (params.newlines) {
+                // new line which requires a space instead of themselve
+                attr.value = attr.value.replace(regNewlinesNeedSpace, function(match, p1, p2) {
+                    return p1 + ' ' + p2;
+                });
+
+                // simple new line
+                attr.value = attr.value.replace(regNewlines, '');
+            }
+
+            if (params.trim) {
+                attr.value = attr.value.trim();
+            }
+
+            if (params.spaces) {
+                attr.value = attr.value.replace(regSpaces, ' ');
+            }
+
+        });
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/cleanupEnableBackground.js

@@ -0,0 +1,84 @@
+'use strict';
+
+exports.type = 'full';
+
+exports.active = true;
+
+exports.description = 'remove or cleanup enable-background attribute when possible';
+
+/**
+ * Remove or cleanup enable-background attr which coincides with a width/height box.
+ *
+ * @see http://www.w3.org/TR/SVG/filters.html#EnableBackgroundProperty
+ *
+ * @example
+ * <svg width="100" height="50" enable-background="new 0 0 100 50">
+ *             ⬇
+ * <svg width="100" height="50">
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(data) {
+
+    var regEnableBackground = /^new\s0\s0\s([\-+]?\d*\.?\d+([eE][\-+]?\d+)?)\s([\-+]?\d*\.?\d+([eE][\-+]?\d+)?)$/,
+        hasFilter = false,
+        elems = ['svg', 'mask', 'pattern'];
+
+    function checkEnableBackground(item) {
+        if (
+            item.isElem(elems) &&
+            item.hasAttr('enable-background') &&
+            item.hasAttr('width') &&
+            item.hasAttr('height')
+        ) {
+
+            var match = item.attr('enable-background').value.match(regEnableBackground);
+
+            if (match) {
+                if (
+                    item.attr('width').value === match[1] &&
+                    item.attr('height').value === match[3]
+                ) {
+                    if (item.isElem('svg')) {
+                        item.removeAttr('enable-background');
+                    } else {
+                        item.attr('enable-background').value = 'new';
+                    }
+                }
+            }
+
+        }
+    }
+
+    function checkForFilter(item) {
+        if (item.isElem('filter')) {
+            hasFilter = true;
+        }
+    }
+
+    function monkeys(items, fn) {
+        items.content.forEach(function(item) {
+            fn(item);
+
+            if (item.content) {
+                monkeys(item, fn);
+            }
+        });
+        return items;
+    }
+
+    var firstStep = monkeys(data, function(item) {
+        checkEnableBackground(item);
+        if (!hasFilter) {
+            checkForFilter(item);
+        }
+    });
+
+    return hasFilter ? firstStep : monkeys(firstStep, function(item) {
+            //we don't need 'enable-background' if we have no filters
+            item.removeAttr('enable-background');
+        });
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/cleanupIDs.js

@@ -0,0 +1,208 @@
+'use strict';
+
+exports.type = 'full';
+
+exports.active = true;
+
+exports.description = 'removes unused IDs and minifies used';
+
+exports.params = {
+    remove: true,
+    minify: true,
+    prefix: ''
+};
+
+var referencesProps = require('./_collections').referencesProps,
+    regReferencesUrl = /\burl\(("|')?#(.+?)\1\)/,
+    regReferencesHref = /^#(.+?)$/,
+    regReferencesBegin = /^(\w+?)\./,
+    styleOrScript = ['style', 'script'],
+    generateIDchars = [
+        'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
+    ],
+    maxIDindex = generateIDchars.length - 1;
+
+/**
+ * Remove unused and minify used IDs
+ * (only if there are no any <style> or <script>).
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(data, params) {
+
+    var currentID,
+        currentIDstring,
+        IDs = Object.create(null),
+        referencesIDs = Object.create(null),
+        idPrefix = 'id-', // prefix IDs so that values like '__proto__' don't break the work
+        hasStyleOrScript = false;
+
+    /**
+     * Bananas!
+     *
+     * @param {Array} items input items
+     * @return {Array} output items
+     */
+    function monkeys(items) {
+
+        for (var i = 0; i < items.content.length && !hasStyleOrScript; i++) {
+
+            var item = items.content[i],
+                match;
+
+            // check if <style> of <script> presents
+            if (item.isElem(styleOrScript)) {
+                hasStyleOrScript = true;
+                continue;
+            }
+
+            // …and don't remove any ID if yes
+            if (item.isElem()) {
+
+                item.eachAttr(function(attr) {
+                    var key;
+                    // save IDs
+                    if (attr.name === 'id') {
+                        key = idPrefix + attr.value;
+                        if (key in IDs) {
+                            item.removeAttr('id');
+                        } else {
+                            IDs[key] = item;
+                        }
+                    }
+
+                    // save IDs url() references
+                    else if (referencesProps.indexOf(attr.name) > -1) {
+                        match = attr.value.match(regReferencesUrl);
+
+                        if (match) {
+                            key = idPrefix + match[2];
+                            if (referencesIDs[key]) {
+                                referencesIDs[key].push(attr);
+                            } else {
+                                referencesIDs[key] = [attr];
+                            }
+                        }
+                    }
+
+                    // save IDs href references
+                    else if (
+                        attr.local === 'href' && (match = attr.value.match(regReferencesHref)) ||
+                        attr.name === 'begin' && (match = attr.value.match(regReferencesBegin))
+                    ) {
+                        key = idPrefix + match[1];
+                        if (referencesIDs[key]) {
+                            referencesIDs[key].push(attr);
+                        } else {
+                            referencesIDs[key] = [attr];
+                        }
+                    }
+                });
+
+            }
+
+            // go deeper
+            if (item.content) {
+                monkeys(item);
+            }
+        }
+
+        return items;
+
+    }
+
+    data = monkeys(data);
+
+    if (hasStyleOrScript) {
+        return data;
+    }
+
+    var idKey;
+    for (var k in referencesIDs) {
+        if (IDs[k]) {
+            idKey = k;
+            k = k.replace(idPrefix, '');
+            // replace referenced IDs with the minified ones
+            if (params.minify) {
+                currentIDstring = getIDstring(currentID = generateID(currentID), params);
+                IDs[idKey].attr('id').value = currentIDstring;
+
+                referencesIDs[idKey].forEach(function(attr) {
+                    attr.value = attr.value
+                        .replace('#' + k, '#' + currentIDstring)
+                        .replace(k + '.', currentIDstring + '.');
+                });
+
+                idKey = idPrefix + k;
+            }
+
+            // don't remove referenced IDs
+            delete IDs[idKey];
+        }
+    }
+
+    // remove non-referenced IDs attributes from elements
+    if (params.remove) {
+
+        for(var ID in IDs) {
+            IDs[ID].removeAttr('id');
+        }
+
+    }
+
+    return data;
+
+};
+
+/**
+ * Generate unique minimal ID.
+ *
+ * @param {Array} [currentID] current ID
+ * @return {Array} generated ID array
+ */
+function generateID(currentID) {
+
+    if (!currentID) return [0];
+
+    currentID[currentID.length - 1]++;
+
+    for(var i = currentID.length - 1; i > 0; i--) {
+        if (currentID[i] > maxIDindex) {
+            currentID[i] = 0;
+
+            if (currentID[i - 1] !== undefined) {
+                currentID[i - 1]++;
+            }
+        }
+    }
+
+    if (currentID[0] > maxIDindex) {
+        currentID[0] = 0;
+        currentID.unshift(0);
+    }
+
+    return currentID;
+
+}
+
+/**
+ * Get string from generated ID array.
+ *
+ * @param {Array} arr input ID array
+ * @return {String} output ID string
+ */
+function getIDstring(arr, params) {
+
+    var str = params.prefix;
+
+    arr.forEach(function(i) {
+        str += generateIDchars[i];
+    });
+
+    return str;
+
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/cleanupListOfValues.js

@@ -0,0 +1,141 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'rounds list of values to the fixed precision';
+
+exports.params = {
+    floatPrecision: 3,
+    leadingZero: true,
+    defaultPx: true,
+    convertToPx: true
+};
+
+var regNumericValues = /^([\-+]?\d*\.?\d+([eE][\-+]?\d+)?)(px|pt|pc|mm|cm|m|in|ft|em|ex|%)?$/,
+    regSeparator = /\s+,?\s*|,\s*/,
+    removeLeadingZero = require('../lib/svgo/tools').removeLeadingZero,
+    absoluteLengths = { // relative to px
+        cm: 96/2.54,
+        mm: 96/25.4,
+        in: 96,
+        pt: 4/3,
+        pc: 16
+    };
+
+/**
+ * Round list of values to the fixed precision.
+ *
+ * @example
+ * <svg viewBox="0 0 200.28423 200.28423" enable-background="new 0 0 200.28423 200.28423">
+ *         ⬇
+ * <svg viewBox="0 0 200.284 200.284" enable-background="new 0 0 200.284 200.284">
+ *
+ *
+ * <polygon points="208.250977 77.1308594 223.069336 ... "/>
+ *         ⬇
+ * <polygon points="208.251 77.131 223.069 ... "/>
+ *
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author kiyopikko
+ */
+exports.fn = function(item, params) {
+
+
+    if ( item.hasAttr('points') ) {
+        roundValues(item.attrs.points);
+    }
+
+    if ( item.hasAttr('enable-background') ) {
+        roundValues(item.attrs['enable-background']);
+    }
+
+    if ( item.hasAttr('viewBox') ) {
+        roundValues(item.attrs.viewBox);
+    }
+
+    if ( item.hasAttr('stroke-dasharray') ) {
+        roundValues(item.attrs['stroke-dasharray']);
+    }
+
+    if ( item.hasAttr('dx') ) {
+        roundValues(item.attrs.dx);
+    }
+
+    if ( item.hasAttr('dy') ) {
+        roundValues(item.attrs.dy);
+    }
+
+    if ( item.hasAttr('x') ) {
+        roundValues(item.attrs.x);
+    }
+
+    if ( item.hasAttr('y') ) {
+        roundValues(item.attrs.y);
+    }
+
+
+    function roundValues($prop){
+
+        var num, units,
+            match,
+            matchNew,
+            lists = $prop.value,
+            listsArr = lists.split(regSeparator),
+            roundedListArr = [],
+            roundedList;
+
+        listsArr.forEach(function(elem){
+
+            match = elem.match(regNumericValues);
+            matchNew = elem.match(/new/);
+
+             // if attribute value matches regNumericValues
+            if(match){
+
+                // round it to the fixed precision
+                num = +(+match[1]).toFixed(params.floatPrecision),
+                units = match[3] || '';
+
+                // convert absolute values to pixels
+                if (params.convertToPx && units && (units in absoluteLengths)) {
+                    var pxNum = +(absoluteLengths[units] * match[1]).toFixed(params.floatPrecision);
+
+                    if (String(pxNum).length < match[0].length)
+                        num = pxNum,
+                        units = 'px';
+                }
+
+                 // and remove leading zero
+                if (params.leadingZero) {
+                    num = removeLeadingZero(num);
+                }
+
+                // remove default 'px' units
+                if (params.defaultPx && units === 'px') {
+                    units = '';
+                }
+
+                roundedListArr.push(num+units);
+
+            }
+            // if attribute value is "new"(only enable-background).
+            else if(matchNew){
+
+                roundedListArr.push('new');
+
+            }
+
+        });
+
+        roundedList = roundedListArr.join(' ');
+        $prop.value = roundedList;
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/cleanupNumericValues.js

@@ -0,0 +1,76 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'rounds numeric values to the fixed precision, removes default ‘px’ units';
+
+exports.params = {
+    floatPrecision: 3,
+    leadingZero: true,
+    defaultPx: true,
+    convertToPx: true
+};
+
+var regNumericValues = /^([\-+]?\d*\.?\d+([eE][\-+]?\d+)?)(px|pt|pc|mm|cm|m|in|ft|em|ex|%)?$/,
+    removeLeadingZero = require('../lib/svgo/tools').removeLeadingZero,
+    absoluteLengths = { // relative to px
+        cm: 96/2.54,
+        mm: 96/25.4,
+        in: 96,
+        pt: 4/3,
+        pc: 16
+    };
+
+/**
+ * Round numeric values to the fixed precision,
+ * remove default 'px' units.
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.isElem()) {
+
+        var match;
+
+        item.eachAttr(function(attr) {
+            match = attr.value.match(regNumericValues);
+
+            // if attribute value matches regNumericValues
+            if (match) {
+                // round it to the fixed precision
+                var num = +(+match[1]).toFixed(params.floatPrecision),
+                    units = match[3] || '';
+
+                // convert absolute values to pixels
+                if (params.convertToPx && units && (units in absoluteLengths)) {
+                    var pxNum = +(absoluteLengths[units] * match[1]).toFixed(params.floatPrecision);
+
+                    if (String(pxNum).length < match[0].length)
+                        num = pxNum,
+                        units = 'px';
+                }
+
+                // and remove leading zero
+                if (params.leadingZero) {
+                    num = removeLeadingZero(num);
+                }
+
+                // remove default 'px' units
+                if (params.defaultPx && units === 'px') {
+                    units = '';
+                }
+
+                attr.value = num + units;
+            }
+        });
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/collapseGroups.js

@@ -0,0 +1,91 @@
+'use strict';
+
+exports.type = 'perItemReverse';
+
+exports.active = true;
+
+exports.description = 'collapses useless groups';
+
+var collections = require('./_collections'),
+    attrsInheritable = collections.inheritableAttrs,
+    animationElems = collections.elemsGroups.animation;
+
+function hasAnimatedAttr(item) {
+    /* jshint validthis:true */
+    return item.isElem(animationElems) && item.hasAttr('attributeName', this) ||
+        !item.isEmpty() && item.content.some(hasAnimatedAttr, this);
+}
+
+/*
+ * Collapse useless groups.
+ *
+ * @example
+ * <g>
+ *     <g attr1="val1">
+ *         <path d="..."/>
+ *     </g>
+ * </g>
+ *         ⬇
+ * <g>
+ *     <g>
+ *         <path attr1="val1" d="..."/>
+ *     </g>
+ * </g>
+ *         ⬇
+ * <path attr1="val1" d="..."/>
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    // non-empty elements
+    if (item.isElem() && !item.isElem('switch') && !item.isEmpty()) {
+
+        item.content.forEach(function(g, i) {
+
+            // non-empty groups
+            if (g.isElem('g') && !g.isEmpty()) {
+
+                // move group attibutes to the single content element
+                if (g.hasAttr() && g.content.length === 1) {
+                    var inner = g.content[0];
+
+                    if (inner.isElem() && !inner.hasAttr('id') &&
+                        !(g.hasAttr('class') && inner.hasAttr('class')) && (
+                            !g.hasAttr('clip-path') && !g.hasAttr('mask') ||
+                            inner.isElem('g') && !g.hasAttr('transform') && !inner.hasAttr('transform')
+                        )
+                    ) {
+                        g.eachAttr(function(attr) {
+                            if (g.content.some(hasAnimatedAttr, attr.name)) return;
+
+                            if (!inner.hasAttr(attr.name)) {
+                                inner.addAttr(attr);
+                            } else if (attr.name == 'transform') {
+                                inner.attr(attr.name).value = attr.value + ' ' + inner.attr(attr.name).value;
+                            } else if (
+                                attrsInheritable.indexOf(attr.name) < 0 &&
+                                !inner.hasAttr(attr.name, attr.value)
+                            ) {
+                                return;
+                            }
+
+                            g.removeAttr(attr.name);
+                        });
+                    }
+                }
+
+                // collapse groups without attributes
+                if (!g.hasAttr() && !g.content.some(function(item) { return item.isElem(animationElems) })) {
+                    item.spliceContent(i, 1, g.content);
+                }
+            }
+
+        });
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/convertColors.js

@@ -0,0 +1,127 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'converts colors: rgb() to #rrggbb and #rrggbb to #rgb';
+
+exports.params = {
+    currentColor: false,
+    names2hex: true,
+    rgb2hex: true,
+    shorthex: true,
+    shortname: true
+};
+
+var collections = require('./_collections'),
+    rNumber = '([+-]?(?:\\d*\\.\\d+|\\d+\\.?)%?)',
+    rComma = '\\s*,\\s*',
+    regRGB = new RegExp('^rgb\\(\\s*' + rNumber + rComma + rNumber + rComma + rNumber + '\\s*\\)$'),
+    regHEX = /^\#(([a-fA-F0-9])\2){3}$/,
+    none = /\bnone\b/i;
+
+/**
+ * Convert different colors formats in element attributes to hex.
+ *
+ * @see http://www.w3.org/TR/SVG/types.html#DataTypeColor
+ * @see http://www.w3.org/TR/SVG/single-page.html#types-ColorKeywords
+ *
+ * @example
+ * Convert color name keyword to long hex:
+ * fuchsia ➡ #ff00ff
+ *
+ * Convert rgb() to long hex:
+ * rgb(255, 0, 255) ➡ #ff00ff
+ * rgb(50%, 100, 100%) ➡ #7f64ff
+ *
+ * Convert long hex to short hex:
+ * #aabbcc ➡ #abc
+ *
+ * Convert hex to short name
+ * #000080 ➡ navy
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.elem) {
+
+        item.eachAttr(function(attr) {
+
+            if (collections.colorsProps.indexOf(attr.name) > -1) {
+
+                var val = attr.value,
+                    match;
+
+                // Convert colors to currentColor
+                if (params.currentColor) {
+                    if (typeof params.currentColor === 'string') {
+                        match = val === params.currentColor;
+                    } else if (params.currentColor.exec) {
+                        match = params.currentColor.exec(val);
+                    } else {
+                        match = !val.match(none);
+                    }
+                    if (match) {
+                        val = 'currentColor';
+                    }
+                }
+
+                // Convert color name keyword to long hex
+                if (params.names2hex && val.toLowerCase() in collections.colorsNames) {
+                    val = collections.colorsNames[val.toLowerCase()];
+                }
+
+                // Convert rgb() to long hex
+                if (params.rgb2hex && (match = val.match(regRGB))) {
+                    match = match.slice(1, 4).map(function(m) {
+                        if (m.indexOf('%') > -1)
+                            m = Math.round(parseFloat(m) * 2.55);
+
+                        return Math.max(0, Math.min(m, 255));
+                    });
+
+                    val = rgb2hex(match);
+                }
+
+                // Convert long hex to short hex
+                if (params.shorthex && (match = val.match(regHEX))) {
+                    val = '#' + match[0][1] + match[0][3] + match[0][5];
+                }
+
+                // Convert hex to short name
+                if (params.shortname && val in collections.colorsShortNames) {
+                    val = collections.colorsShortNames[val];
+                }
+
+                attr.value = val;
+
+            }
+
+        });
+
+    }
+
+};
+
+/**
+ * Convert [r, g, b] to #rrggbb.
+ *
+ * @see https://gist.github.com/983535
+ *
+ * @example
+ * rgb2hex([255, 255, 255]) // '#ffffff'
+ *
+ * @param {Array} rgb [r, g, b]
+ * @return {String} #rrggbb
+ *
+ * @author Jed Schmidt
+ */
+function rgb2hex(rgb) {
+    return '#' + ('00000' + (rgb[0] << 16 | rgb[1] << 8 | rgb[2]).toString(16)).slice(-6).toUpperCase();
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/convertPathData.js

@@ -0,0 +1,957 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'optimizes path data: writes in shorter form, applies transformations';
+
+exports.params = {
+    applyTransforms: true,
+    applyTransformsStroked: true,
+    makeArcs: {
+        threshold: 2.5, // coefficient of rounding error
+        tolerance: 0.5  // percentage of radius
+    },
+    straightCurves: true,
+    lineShorthands: true,
+    curveSmoothShorthands: true,
+    floatPrecision: 3,
+    transformPrecision: 5,
+    removeUseless: true,
+    collapseRepeated: true,
+    utilizeAbsolute: true,
+    leadingZero: true,
+    negativeExtraSpace: true
+};
+
+var pathElems = require('./_collections.js').pathElems,
+    path2js = require('./_path.js').path2js,
+    js2path = require('./_path.js').js2path,
+    applyTransforms = require('./_path.js').applyTransforms,
+    cleanupOutData = require('../lib/svgo/tools').cleanupOutData,
+    roundData,
+    precision,
+    error,
+    arcThreshold,
+    arcTolerance,
+    hasMarkerMid;
+
+/**
+ * Convert absolute Path to relative,
+ * collapse repeated instructions,
+ * detect and convert Lineto shorthands,
+ * remove useless instructions like "l0,0",
+ * trim useless delimiters and leading zeros,
+ * decrease accuracy of floating-point numbers.
+ *
+ * @see http://www.w3.org/TR/SVG/paths.html#PathData
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.isElem(pathElems) && item.hasAttr('d')) {
+
+        precision = params.floatPrecision;
+        error = precision !== false ? +Math.pow(.1, precision).toFixed(precision) : 1e-2;
+        roundData = precision > 0 && precision < 20 ? strongRound : round;
+        if (params.makeArcs) {
+            arcThreshold = params.makeArcs.threshold;
+            arcTolerance = params.makeArcs.tolerance;
+        }
+        hasMarkerMid = item.hasAttr('marker-mid');
+
+        var data = path2js(item);
+
+        // TODO: get rid of functions returns
+        if (data.length) {
+            convertToRelative(data);
+
+            if (params.applyTransforms) {
+                data = applyTransforms(item, data, params);
+            }
+
+            data = filters(data, params);
+
+            if (params.utilizeAbsolute) {
+                data = convertToMixed(data, params);
+            }
+
+            js2path(item, data, params);
+        }
+
+    }
+
+};
+
+/**
+ * Convert absolute path data coordinates to relative.
+ *
+ * @param {Array} path input path data
+ * @param {Object} params plugin params
+ * @return {Array} output path data
+ */
+function convertToRelative(path) {
+
+    var point = [0, 0],
+        subpathPoint = [0, 0],
+        baseItem;
+
+    path.forEach(function(item, index) {
+
+        var instruction = item.instruction,
+            data = item.data;
+
+        // data !== !z
+        if (data) {
+
+            // already relative
+            // recalculate current point
+            if ('mcslqta'.indexOf(instruction) > -1) {
+
+                point[0] += data[data.length - 2];
+                point[1] += data[data.length - 1];
+
+                if (instruction === 'm') {
+                    subpathPoint[0] = point[0];
+                    subpathPoint[1] = point[1];
+                    baseItem = item;
+                }
+
+            } else if (instruction === 'h') {
+
+                point[0] += data[0];
+
+            } else if (instruction === 'v') {
+
+                point[1] += data[0];
+
+            }
+
+            // convert absolute path data coordinates to relative
+            // if "M" was not transformed from "m"
+            // M → m
+            if (instruction === 'M') {
+
+                if (index > 0) instruction = 'm';
+
+                data[0] -= point[0];
+                data[1] -= point[1];
+
+                subpathPoint[0] = point[0] += data[0];
+                subpathPoint[1] = point[1] += data[1];
+
+                baseItem = item;
+
+            }
+
+            // L → l
+            // T → t
+            else if ('LT'.indexOf(instruction) > -1) {
+
+                instruction = instruction.toLowerCase();
+
+                // x y
+                // 0 1
+                data[0] -= point[0];
+                data[1] -= point[1];
+
+                point[0] += data[0];
+                point[1] += data[1];
+
+            // C → c
+            } else if (instruction === 'C') {
+
+                instruction = 'c';
+
+                // x1 y1 x2 y2 x y
+                // 0  1  2  3  4 5
+                data[0] -= point[0];
+                data[1] -= point[1];
+                data[2] -= point[0];
+                data[3] -= point[1];
+                data[4] -= point[0];
+                data[5] -= point[1];
+
+                point[0] += data[4];
+                point[1] += data[5];
+
+            // S → s
+            // Q → q
+            } else if ('SQ'.indexOf(instruction) > -1) {
+
+                instruction = instruction.toLowerCase();
+
+                // x1 y1 x y
+                // 0  1  2 3
+                data[0] -= point[0];
+                data[1] -= point[1];
+                data[2] -= point[0];
+                data[3] -= point[1];
+
+                point[0] += data[2];
+                point[1] += data[3];
+
+            // A → a
+            } else if (instruction === 'A') {
+
+                instruction = 'a';
+
+                // rx ry x-axis-rotation large-arc-flag sweep-flag x y
+                // 0  1  2               3              4          5 6
+                data[5] -= point[0];
+                data[6] -= point[1];
+
+                point[0] += data[5];
+                point[1] += data[6];
+
+            // H → h
+            } else if (instruction === 'H') {
+
+                instruction = 'h';
+
+                data[0] -= point[0];
+
+                point[0] += data[0];
+
+            // V → v
+            } else if (instruction === 'V') {
+
+                instruction = 'v';
+
+                data[0] -= point[1];
+
+                point[1] += data[0];
+
+            }
+
+            item.instruction = instruction;
+            item.data = data;
+
+            // store absolute coordinates for later use
+            item.coords = point.slice(-2);
+
+        }
+
+        // !data === z, reset current point
+        else if (instruction == 'z') {
+            if (baseItem) {
+                item.coords = baseItem.coords;
+            }
+            point[0] = subpathPoint[0];
+            point[1] = subpathPoint[1];
+        }
+
+        item.base = index > 0 ? path[index - 1].coords : [0, 0];
+
+    });
+
+    return path;
+
+}
+
+/**
+ * Main filters loop.
+ *
+ * @param {Array} path input path data
+ * @param {Object} params plugin params
+ * @return {Array} output path data
+ */
+function filters(path, params) {
+
+    var stringify = data2Path.bind(null, params),
+        relSubpoint = [0, 0],
+        pathBase = [0, 0],
+        prev = {};
+
+    path = path.filter(function(item, index, path) {
+
+        var instruction = item.instruction,
+            data = item.data,
+            next = path[index + 1];
+
+        if (data) {
+
+            var sdata = data,
+                circle;
+
+            if (instruction === 's') {
+                sdata = [0, 0].concat(data);
+
+                if ('cs'.indexOf(prev.instruction) > -1) {
+                    var pdata = prev.data,
+                        n = pdata.length;
+
+                    // (-x, -y) of the prev tangent point relative to the current point
+                    sdata[0] = pdata[n - 2] - pdata[n - 4];
+                    sdata[1] = pdata[n - 1] - pdata[n - 3];
+                }
+
+            }
+
+            // convert curves to arcs if possible
+            if (
+                params.makeArcs &&
+                (instruction == 'c' || instruction == 's') &&
+                isConvex(sdata) &&
+                (circle = findCircle(sdata))
+            ) {
+                var r = roundData([circle.radius])[0],
+                    angle = findArcAngle(sdata, circle),
+                    sweep = sdata[5] * sdata[0] - sdata[4] * sdata[1] > 0 ? 1 : 0,
+                    arc = {
+                        instruction: 'a',
+                        data: [r, r, 0, 0, sweep, sdata[4], sdata[5]],
+                        coords: item.coords.slice(),
+                        base: item.base
+                    },
+                    output = [arc],
+                    // relative coordinates to adjust the found circle
+                    relCenter = [circle.center[0] - sdata[4], circle.center[1] - sdata[5]],
+                    relCircle = { center: relCenter, radius: circle.radius },
+                    arcCurves = [item],
+                    hasPrev = 0,
+                    suffix = '',
+                    nextLonghand;
+
+                if (
+                    prev.instruction == 'c' && isConvex(prev.data) && isArcPrev(prev.data, circle) ||
+                    prev.instruction == 'a' && prev.sdata && isArcPrev(prev.sdata, circle)
+                ) {
+                    arcCurves.unshift(prev);
+                    arc.base = prev.base;
+                    arc.data[5] = arc.coords[0] - arc.base[0];
+                    arc.data[6] = arc.coords[1] - arc.base[1];
+                    var prevData = prev.instruction == 'a' ? prev.sdata : prev.data;
+                    angle += findArcAngle(prevData,
+                        {
+                            center: [prevData[4] + relCenter[0], prevData[5] + relCenter[1]],
+                            radius: circle.radius
+                        }
+                    );
+                    if (angle > Math.PI) arc.data[3] = 1;
+                    hasPrev = 1;
+                }
+
+                // check if next curves are fitting the arc
+                for (var j = index; (next = path[++j]) && ~'cs'.indexOf(next.instruction);) {
+                    var nextData = next.data;
+                    if (next.instruction == 's') {
+                        nextLonghand = makeLonghand({instruction: 's', data: next.data.slice() },
+                            path[j - 1].data);
+                        nextData = nextLonghand.data;
+                        nextLonghand.data = nextData.slice(0, 2);
+                        suffix = stringify([nextLonghand]);
+                    }
+                    if (isConvex(nextData) && isArc(nextData, relCircle)) {
+                        angle += findArcAngle(nextData, relCircle);
+                        if (angle - 2 * Math.PI > 1e-3) break; // more than 360°
+                        if (angle > Math.PI) arc.data[3] = 1;
+                        arcCurves.push(next);
+                        if (2 * Math.PI - angle > 1e-3) { // less than 360°
+                            arc.coords = next.coords;
+                            arc.data[5] = arc.coords[0] - arc.base[0];
+                            arc.data[6] = arc.coords[1] - arc.base[1];
+                        } else {
+                            // full circle, make a half-circle arc and add a second one
+                            arc.data[5] = 2 * (relCircle.center[0] - nextData[4]);
+                            arc.data[6] = 2 * (relCircle.center[1] - nextData[5]);
+                            arc.coords = [arc.base[0] + arc.data[5], arc.base[1] + arc.data[6]];
+                            arc = {
+                                instruction: 'a',
+                                data: [r, r, 0, 0, sweep,
+                                    next.coords[0] - arc.coords[0], next.coords[1] - arc.coords[1]],
+                                coords: next.coords,
+                                base: arc.coords
+                            };
+                            output.push(arc);
+                            j++;
+                            break;
+                        }
+                        relCenter[0] -= nextData[4];
+                        relCenter[1] -= nextData[5];
+                    } else break;
+                }
+
+                if ((stringify(output) + suffix).length < stringify(arcCurves).length) {
+                    if (path[j] && path[j].instruction == 's') {
+                        makeLonghand(path[j], path[j - 1].data);
+                    }
+                    if (hasPrev) {
+                        var prevArc = output.shift();
+                        roundData(prevArc.data);
+                        relSubpoint[0] += prevArc.data[5] - prev.data[prev.data.length - 2];
+                        relSubpoint[1] += prevArc.data[6] - prev.data[prev.data.length - 1];
+                        prev.instruction = 'a';
+                        prev.data = prevArc.data;
+                        item.base = prev.coords = prevArc.coords;
+                    }
+                    arc = output.shift();
+                    if (arcCurves.length == 1) {
+                        item.sdata = sdata.slice(); // preserve curve data for future checks
+                    } else if (arcCurves.length - 1 - hasPrev > 0) {
+                        // filter out consumed next items
+                        path.splice.apply(path, [index + 1, arcCurves.length - 1 - hasPrev].concat(output));
+                    }
+                    if (!arc) return false;
+                    instruction = 'a';
+                    data = arc.data;
+                    item.coords = arc.coords;
+                }
+            }
+
+            // Rounding relative coordinates, taking in account accummulating error
+            // to get closer to absolute coordinates. Sum of rounded value remains same:
+            // l .25 3 .25 2 .25 3 .25 2 -> l .3 3 .2 2 .3 3 .2 2
+            if (precision !== false) {
+                if ('mltqsc'.indexOf(instruction) > -1) {
+                    for (var i = data.length; i--;) {
+                        data[i] += item.base[i % 2] - relSubpoint[i % 2];
+                    }
+                } else if (instruction == 'h') {
+                    data[0] += item.base[0] - relSubpoint[0];
+                } else if (instruction == 'v') {
+                    data[0] += item.base[1] - relSubpoint[1];
+                } else if (instruction == 'a') {
+                    data[5] += item.base[0] - relSubpoint[0];
+                    data[6] += item.base[1] - relSubpoint[1];
+                }
+                roundData(data);
+
+                if      (instruction == 'h') relSubpoint[0] += data[0];
+                else if (instruction == 'v') relSubpoint[1] += data[0];
+                else {
+                    relSubpoint[0] += data[data.length - 2];
+                    relSubpoint[1] += data[data.length - 1];
+                }
+                roundData(relSubpoint);
+
+                if (instruction.toLowerCase() == 'm') {
+                    pathBase[0] = relSubpoint[0];
+                    pathBase[1] = relSubpoint[1];
+                }
+            }
+
+            // convert straight curves into lines segments
+            if (params.straightCurves) {
+
+                if (
+                    instruction === 'c' &&
+                    isCurveStraightLine(data) ||
+                    instruction === 's' &&
+                    isCurveStraightLine(sdata)
+                ) {
+                    if (next && next.instruction == 's')
+                        makeLonghand(next, data); // fix up next curve
+                    instruction = 'l';
+                    data = data.slice(-2);
+                }
+
+                else if (
+                    instruction === 'q' &&
+                    isCurveStraightLine(data)
+                ) {
+                    if (next && next.instruction == 't')
+                        makeLonghand(next, data); // fix up next curve
+                    instruction = 'l';
+                    data = data.slice(-2);
+                }
+
+                else if (
+                    instruction === 't' &&
+                    prev.instruction !== 'q' &&
+                    prev.instruction !== 't'
+                ) {
+                    instruction = 'l';
+                    data = data.slice(-2);
+                }
+
+                else if (
+                    instruction === 'a' &&
+                    (data[0] === 0 || data[1] === 0)
+                ) {
+                    instruction = 'l';
+                    data = data.slice(-2);
+                }
+            }
+
+            // horizontal and vertical line shorthands
+            // l 50 0 → h 50
+            // l 0 50 → v 50
+            if (
+                params.lineShorthands &&
+                instruction === 'l'
+            ) {
+                if (data[1] === 0) {
+                    instruction = 'h';
+                    data.pop();
+                } else if (data[0] === 0) {
+                    instruction = 'v';
+                    data.shift();
+                }
+            }
+
+            // collapse repeated commands
+            // h 20 h 30 -> h 50
+            if (
+                params.collapseRepeated &&
+                !hasMarkerMid &&
+                ('mhv'.indexOf(instruction) > -1) &&
+                prev.instruction &&
+                instruction == prev.instruction.toLowerCase() &&
+                (
+                    (instruction != 'h' && instruction != 'v') ||
+                    (prev.data[0] >= 0) == (item.data[0] >= 0)
+            )) {
+                prev.data[0] += data[0];
+                if (instruction != 'h' && instruction != 'v') {
+                    prev.data[1] += data[1];
+                }
+                prev.coords = item.coords;
+                path[index] = prev;
+                return false;
+            }
+
+            // convert curves into smooth shorthands
+            if (params.curveSmoothShorthands && prev.instruction) {
+
+                // curveto
+                if (instruction === 'c') {
+
+                    // c + c → c + s
+                    if (
+                        prev.instruction === 'c' &&
+                        data[0] === -(prev.data[2] - prev.data[4]) &&
+                        data[1] === -(prev.data[3] - prev.data[5])
+                    ) {
+                        instruction = 's';
+                        data = data.slice(2);
+                    }
+
+                    // s + c → s + s
+                    else if (
+                        prev.instruction === 's' &&
+                        data[0] === -(prev.data[0] - prev.data[2]) &&
+                        data[1] === -(prev.data[1] - prev.data[3])
+                    ) {
+                        instruction = 's';
+                        data = data.slice(2);
+                    }
+
+                    // [^cs] + c → [^cs] + s
+                    else if (
+                        'cs'.indexOf(prev.instruction) === -1 &&
+                        data[0] === 0 &&
+                        data[1] === 0
+                    ) {
+                        instruction = 's';
+                        data = data.slice(2);
+                    }
+
+                }
+
+                // quadratic Bézier curveto
+                else if (instruction === 'q') {
+
+                    // q + q → q + t
+                    if (
+                        prev.instruction === 'q' &&
+                        data[0] === (prev.data[2] - prev.data[0]) &&
+                        data[1] === (prev.data[3] - prev.data[1])
+                    ) {
+                        instruction = 't';
+                        data = data.slice(2);
+                    }
+
+                    // t + q → t + t
+                    else if (
+                        prev.instruction === 't' &&
+                        data[2] === prev.data[0] &&
+                        data[3] === prev.data[1]
+                    ) {
+                        instruction = 't';
+                        data = data.slice(2);
+                    }
+
+                }
+
+            }
+
+            // remove useless non-first path segments
+            if (params.removeUseless) {
+
+                // l 0,0 / h 0 / v 0 / q 0,0 0,0 / t 0,0 / c 0,0 0,0 0,0 / s 0,0 0,0
+                if (
+                    (
+                     'lhvqtcs'.indexOf(instruction) > -1
+                    ) &&
+                    data.every(function(i) { return i === 0; })
+                ) {
+                    path[index] = prev;
+                    return false;
+                }
+
+                // a 25,25 -30 0,1 0,0
+                if (
+                    instruction === 'a' &&
+                    data[5] === 0 &&
+                    data[6] === 0
+                ) {
+                    path[index] = prev;
+                    return false;
+                }
+
+            }
+
+            item.instruction = instruction;
+            item.data = data;
+
+            prev = item;
+
+        } else {
+
+            // z resets coordinates
+            relSubpoint[0] = pathBase[0];
+            relSubpoint[1] = pathBase[1];
+            if (prev.instruction == 'z') return false;
+            prev = item;
+
+        }
+
+        return true;
+
+    });
+
+    return path;
+
+}
+
+/**
+ * Writes data in shortest form using absolute or relative coordinates.
+ *
+ * @param {Array} data input path data
+ * @return {Boolean} output
+ */
+function convertToMixed(path, params) {
+
+    var prev = path[0];
+
+    path = path.filter(function(item, index) {
+
+        if (index == 0) return true;
+        if (!item.data) {
+            prev = item;
+            return true;
+        }
+
+        var instruction = item.instruction,
+            data = item.data,
+            adata = data && data.slice(0);
+
+        if ('mltqsc'.indexOf(instruction) > -1) {
+            for (var i = adata.length; i--;) {
+                adata[i] += item.base[i % 2];
+            }
+        } else if (instruction == 'h') {
+                adata[0] += item.base[0];
+        } else if (instruction == 'v') {
+                adata[0] += item.base[1];
+        } else if (instruction == 'a') {
+                adata[5] += item.base[0];
+                adata[6] += item.base[1];
+        }
+
+        roundData(adata);
+
+        var absoluteDataStr = cleanupOutData(adata, params),
+            relativeDataStr = cleanupOutData(data, params);
+
+        // Convert to absolute coordinates if it's shorter.
+        // v-20 -> V0
+        // Don't convert if it fits following previous instruction.
+        // l20 30-10-50 instead of l20 30L20 30
+        if (
+            absoluteDataStr.length < relativeDataStr.length &&
+            !(
+                params.negativeExtraSpace &&
+                instruction == prev.instruction &&
+                prev.instruction.charCodeAt(0) > 96 &&
+                absoluteDataStr.length == relativeDataStr.length - 1 &&
+                (data[0] < 0 || /^0\./.test(data[0]) && prev.data[prev.data.length - 1] % 1)
+            )
+        ) {
+            item.instruction = instruction.toUpperCase();
+            item.data = adata;
+        }
+
+        prev = item;
+
+        return true;
+
+    });
+
+    return path;
+
+}
+
+/**
+ * Checks if curve is convex. Control points of such a curve must form
+ * a convex quadrilateral with diagonals crosspoint inside of it.
+ *
+ * @param {Array} data input path data
+ * @return {Boolean} output
+ */
+function isConvex(data) {
+
+    var center = getIntersection([0, 0, data[2], data[3], data[0], data[1], data[4], data[5]]);
+
+    return center &&
+        (data[2] < center[0] == center[0] < 0) &&
+        (data[3] < center[1] == center[1] < 0) &&
+        (data[4] < center[0] == center[0] < data[0]) &&
+        (data[5] < center[1] == center[1] < data[1]);
+
+}
+
+/**
+ * Computes lines equations by two points and returns their intersection point.
+ *
+ * @param {Array} coords 8 numbers for 4 pairs of coordinates (x,y)
+ * @return {Array|undefined} output coordinate of lines' crosspoint
+ */
+function getIntersection(coords) {
+
+        // Prev line equation parameters.
+    var a1 = coords[1] - coords[3], // y1 - y2
+        b1 = coords[2] - coords[0], // x2 - x1
+        c1 = coords[0] * coords[3] - coords[2] * coords[1], // x1 * y2 - x2 * y1
+
+        // Next line equation parameters
+        a2 = coords[5] - coords[7], // y1 - y2
+        b2 = coords[6] - coords[4], // x2 - x1
+        c2 = coords[4] * coords[7] - coords[5] * coords[6], // x1 * y2 - x2 * y1
+        denom = (a1 * b2 - a2 * b1);
+
+    if (!denom) return; // parallel lines havn't an intersection
+
+    var cross = [
+            (b1 * c2 - b2 * c1) / denom,
+            (a1 * c2 - a2 * c1) / -denom
+        ];
+    if (
+        !isNaN(cross[0]) && !isNaN(cross[1]) &&
+        isFinite(cross[0]) && isFinite(cross[1])
+    ) {
+        return cross;
+    }
+
+}
+
+/**
+ * Decrease accuracy of floating-point numbers
+ * in path data keeping a specified number of decimals.
+ * Smart rounds values like 2.3491 to 2.35 instead of 2.349.
+ * Doesn't apply "smartness" if the number precision fits already.
+ *
+ * @param {Array} data input data array
+ * @return {Array} output data array
+ */
+function strongRound(data) {
+    for (var i = data.length; i-- > 0;) {
+        if (data[i].toFixed(precision) != data[i]) {
+            var rounded = +data[i].toFixed(precision - 1);
+            data[i] = +Math.abs(rounded - data[i]).toFixed(precision + 1) >= error ?
+                +data[i].toFixed(precision) :
+                rounded;
+        }
+    }
+    return data;
+}
+
+/**
+ * Simple rounding function if precision is 0.
+ *
+ * @param {Array} data input data array
+ * @return {Array} output data array
+ */
+function round(data) {
+    for (var i = data.length; i-- > 0;) {
+        data[i] = Math.round(data[i]);
+    }
+    return data;
+}
+
+/**
+ * Checks if a curve is a straight line by measuring distance
+ * from middle points to the line formed by end points.
+ *
+ * @param {Array} xs array of curve points x-coordinates
+ * @param {Array} ys array of curve points y-coordinates
+ * @return {Boolean}
+ */
+
+function isCurveStraightLine(data) {
+
+    // Get line equation a·x + b·y + c = 0 coefficients a, b (c = 0) by start and end points.
+    var i = data.length - 2,
+        a = -data[i + 1], // y1 − y2 (y1 = 0)
+        b = data[i],      // x2 − x1 (x1 = 0)
+        d = 1 / (a * a + b * b); // same part for all points
+
+    if (i <= 1 || !isFinite(d)) return false; // curve that ends at start point isn't the case
+
+    // Distance from point (x0, y0) to the line is sqrt((c − a·x0 − b·y0)² / (a² + b²))
+    while ((i -= 2) >= 0) {
+        if (Math.sqrt(Math.pow(a * data[i] + b * data[i + 1], 2) * d) > error)
+            return false;
+    }
+
+    return true;
+
+}
+
+/**
+ * Converts next curve from shorthand to full form using the current curve data.
+ *
+ * @param {Object} item curve to convert
+ * @param {Array} data current curve data
+ */
+
+function makeLonghand(item, data) {
+    switch (item.instruction) {
+        case 's': item.instruction = 'c'; break;
+        case 't': item.instruction = 'q'; break;
+    }
+    item.data.unshift(data[data.length - 2] - data[data.length - 4], data[data.length - 1] - data[data.length - 3]);
+    return item;
+}
+
+/**
+ * Returns distance between two points
+ *
+ * @param {Array} point1 first point coordinates
+ * @param {Array} point2 second point coordinates
+ * @return {Number} distance
+ */
+
+function getDistance(point1, point2) {
+    return Math.sqrt(Math.pow(point1[0] - point2[0], 2) + Math.pow(point1[1] - point2[1], 2));
+}
+
+/**
+ * Returns coordinates of the curve point corresponding to the certain t
+ * a·(1 - t)³·p1 + b·(1 - t)²·t·p2 + c·(1 - t)·t²·p3 + d·t³·p4,
+ * where pN are control points and p1 is zero due to relative coordinates.
+ *
+ * @param {Array} curve array of curve points coordinates
+ * @param {Number} t parametric position from 0 to 1
+ * @return {Array} Point coordinates
+ */
+
+function getCubicBezierPoint(curve, t) {
+    var sqrT = t * t,
+        cubT = sqrT * t,
+        mt = 1 - t,
+        sqrMt = mt * mt;
+
+    return [
+        3 * sqrMt * t * curve[0] + 3 * mt * sqrT * curve[2] + cubT * curve[4],
+        3 * sqrMt * t * curve[1] + 3 * mt * sqrT * curve[3] + cubT * curve[5]
+    ];
+}
+
+/**
+ * Finds circle by 3 points of the curve and checks if the curve fits the found circle.
+ *
+ * @param {Array} curve
+ * @return {Object|undefined} circle
+ */
+
+function findCircle(curve) {
+    var midPoint = getCubicBezierPoint(curve, 1/2),
+        m1 = [midPoint[0] / 2, midPoint[1] / 2],
+        m2 = [(midPoint[0] + curve[4]) / 2, (midPoint[1] + curve[5]) / 2],
+        center = getIntersection([
+            m1[0], m1[1],
+            m1[0] + m1[1], m1[1] - m1[0],
+            m2[0], m2[1],
+            m2[0] + (m2[1] - midPoint[1]), m2[1] - (m2[0] - midPoint[0])
+        ]),
+        radius = center && getDistance([0, 0], center),
+        tolerance = Math.min(arcThreshold * error, arcTolerance * radius / 100);
+
+    if (center && [1/4, 3/4].every(function(point) {
+        return Math.abs(getDistance(getCubicBezierPoint(curve, point), center) - radius) <= tolerance;
+    }))
+        return { center: center, radius: radius};
+}
+
+/**
+ * Checks if a curve fits the given circe.
+ *
+ * @param {Object} circle
+ * @param {Array} curve
+ * @return {Boolean}
+ */
+
+function isArc(curve,  circle) {
+    var tolerance = Math.min(arcThreshold * error, arcTolerance * circle.radius / 100);
+
+    return [0, 1/4, 1/2, 3/4, 1].every(function(point) {
+        return Math.abs(getDistance(getCubicBezierPoint(curve, point), circle.center) - circle.radius) <= tolerance;
+    });
+}
+
+/**
+ * Checks if a previos curve fits the given circe.
+ *
+ * @param {Object} circle
+ * @param {Array} curve
+ * @return {Boolean}
+ */
+
+function isArcPrev(curve,  circle) {
+    return isArc(curve, {
+        center: [circle.center[0] + curve[4], circle.center[1] + curve[5]],
+        radius: circle.radius
+    });
+}
+
+/**
+ * Finds angle of a curve fitting the given arc.
+
+ * @param {Array} curve
+ * @param {Object} relCircle
+ * @return {Number} angle
+ */
+
+function findArcAngle(curve, relCircle) {
+    var x1 = -relCircle.center[0],
+        y1 = -relCircle.center[1],
+        x2 = curve[4] - relCircle.center[0],
+        y2 = curve[5] - relCircle.center[1];
+
+    return Math.acos(
+            (x1 * x2 + y1 * y2) /
+            Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2))
+        );
+}
+
+/**
+ * Converts given path data to string.
+ *
+ * @param {Object} params
+ * @param {Array} pathData
+ * @return {String}
+ */
+
+function data2Path(params, pathData) {
+    return pathData.reduce(function(pathString, item) {
+        return pathString += item.instruction + (item.data ? cleanupOutData(roundData(item.data.slice()), params) : '');
+    }, '');
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/convertShapeToPath.js

@@ -0,0 +1,103 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'converts basic shapes to more compact path form';
+
+var none = { value: 0 },
+    regNumber = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
+
+/**
+ * Converts basic shape to more compact path.
+ * It also allows further optimizations like
+ * combining paths with similar attributes.
+ *
+ * @see http://www.w3.org/TR/SVG/shapes.html
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Lev Solntsev
+ */
+exports.fn = function(item) {
+
+    if (
+        item.isElem('rect') &&
+        item.hasAttr('width') &&
+        item.hasAttr('height') &&
+        !item.hasAttr('rx') &&
+        !item.hasAttr('ry')
+    ) {
+
+        var x = +(item.attr('x') || none).value,
+            y = +(item.attr('y') || none).value,
+            width  = +item.attr('width').value,
+            height = +item.attr('height').value;
+
+            // Values like '100%' compute to NaN, thus running after
+            // cleanupNumericValues when 'px' units has already been removed.
+            // TODO: Calculate sizes from % and non-px units if possible.
+        if (isNaN(x - y + width - height)) return;
+
+        var pathData =
+            'M' + x + ' ' + y +
+            'H' + (x + width) +
+            'V' + (y + height) +
+            'H' + x +
+            'z';
+
+        item.addAttr({
+                name: 'd',
+                value: pathData,
+                prefix: '',
+                local: 'd'
+            });
+
+        item.renameElem('path')
+            .removeAttr(['x', 'y', 'width', 'height']);
+
+    } else if (item.isElem('line')) {
+
+        var x1 = +(item.attr('x1') || none).value,
+            y1 = +(item.attr('y1') || none).value,
+            x2 = +(item.attr('x2') || none).value,
+            y2 = +(item.attr('y2') || none).value;
+        if (isNaN(x1 - y1 + x2 - y2)) return;
+
+        item.addAttr({
+                name: 'd',
+                value: 'M' + x1 + ' ' + y1 + 'L' + x2 + ' ' + y2,
+                prefix: '',
+                local: 'd'
+            });
+
+        item.renameElem('path')
+            .removeAttr(['x1', 'y1', 'x2', 'y2']);
+
+    } else if ((
+            item.isElem('polyline') ||
+            item.isElem('polygon')
+        ) &&
+        item.hasAttr('points')
+    ) {
+
+        var coords = (item.attr('points').value.match(regNumber) || []).map(Number);
+        if (coords.length < 4) return false;
+
+        item.addAttr({
+                name: 'd',
+                value: 'M' + coords.slice(0,2).join(' ') +
+                       'L' + coords.slice(2).join(' ') +
+                       (item.isElem('polygon') ? 'z' : ''),
+                prefix: '',
+                local: 'd'
+            });
+
+        item.renameElem('path')
+            .removeAttr('points');
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/convertStyleToAttrs.js

@@ -0,0 +1,117 @@
+/* jshint quotmark: false */
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'converts style to attributes';
+
+var EXTEND = require('whet.extend'),
+    stylingProps = require('./_collections').attrsGroups.presentation,
+    rEscape = '\\\\(?:[0-9a-f]{1,6}\\s?|\\r\\n|.)',                 // Like \" or \2051. Code points consume one space.
+    rAttr = '\\s*(' + g('[^:;\\\\]', rEscape) + '*?)\\s*',          // attribute name like ‘fill’
+    rSingleQuotes = "'(?:[^'\\n\\r\\\\]|" + rEscape + ")*?(?:'|$)", // string in single quotes: 'smth'
+    rQuotes = '"(?:[^"\\n\\r\\\\]|' + rEscape + ')*?(?:"|$)',       // string in double quotes: "smth"
+    rQuotedString = new RegExp('^' + g(rSingleQuotes, rQuotes) + '$'),
+
+    // Parentheses, E.g.: url(data:image/png;base64,iVBO...).
+    // ':' and ';' inside of it should be threated as is. (Just like in strings.)
+    rParenthesis = '\\(' + g('[^\'"()\\\\]+', rEscape, rSingleQuotes, rQuotes) + '*?' + '\\)',
+
+    // The value. It can have strings and parentheses (see above). Fallbacks to anything in case of unexpected input.
+    rValue = '\\s*(' + g('[^\'"();\\\\]+?', rEscape, rSingleQuotes, rQuotes, rParenthesis, '[^;]*?') + '*?' + ')',
+
+    // End of declaration. Spaces outside of capturing groups help to do natural trimming.
+    rDeclEnd = '\\s*(?:;\\s*|$)',
+
+    // Final RegExp to parse CSS declarations.
+    regDeclarationBlock = new RegExp(rAttr + ':' + rValue + rDeclEnd, 'ig'),
+
+    // Comments expression. Honors escape sequences and strings.
+    regStripComments = new RegExp(g(rEscape, rSingleQuotes, rQuotes, '/\\*[^]*?\\*/'), 'ig');
+
+/**
+ * Convert style in attributes. Cleanups comments and illegal declarations (without colon) as a side effect.
+ *
+ * @example
+ * <g style="fill:#000; color: #fff;">
+ *             ⬇
+ * <g fill="#000" color="#fff">
+ *
+ * @example
+ * <g style="fill:#000; color: #fff; -webkit-blah: blah">
+ *             ⬇
+ * <g fill="#000" color="#fff" style="-webkit-blah: blah">
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+    /* jshint boss: true */
+
+    if (item.elem && item.hasAttr('style')) {
+            // ['opacity: 1', 'color: #000']
+        var styleValue = item.attr('style').value,
+            styles = [],
+            attrs = {};
+
+        // Strip CSS comments preserving escape sequences and strings.
+        styleValue = styleValue.replace(regStripComments, function(match) {
+            return match[0] == '/' ? '' :
+                match[0] == '\\' && /[-g-z]/i.test(match[1]) ? match[1] : match;
+        });
+
+        regDeclarationBlock.lastIndex = 0;
+        for (var rule; rule = regDeclarationBlock.exec(styleValue);) {
+            styles.push([rule[1], rule[2]]);
+        }
+
+        if (styles.length) {
+
+            styles = styles.filter(function(style) {
+                if (style[0]) {
+                    var prop = style[0].toLowerCase(),
+                        val = style[1];
+
+                    if (rQuotedString.test(val)) {
+                        val = val.slice(1, -1);
+                    }
+
+                    if (stylingProps.indexOf(prop) > -1) {
+
+                        attrs[prop] = {
+                            name: prop,
+                            value: val,
+                            local: prop,
+                            prefix: ''
+                        };
+
+                        return false;
+                    }
+                }
+
+                return true;
+            });
+
+            EXTEND(item.attrs, attrs);
+
+            if (styles.length) {
+                item.attr('style').value = styles
+                    .map(function(declaration) { return declaration.join(':') })
+                    .join(';');
+            } else {
+                item.removeAttr('style');
+            }
+
+        }
+
+    }
+
+};
+
+function g() {
+    return '(?:' + Array.prototype.join.call(arguments, '|') + ')';
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/convertTransform.js

@@ -0,0 +1,364 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'collapses multiple transformations and optimizes it';
+
+exports.params = {
+    convertToShorts: true,
+    // degPrecision: 3, // transformPrecision (or matrix precision) - 2 by default
+    floatPrecision: 3,
+    transformPrecision: 5,
+    matrixToTransform: true,
+    shortTranslate: true,
+    shortScale: true,
+    shortRotate: true,
+    removeUseless: true,
+    collapseIntoOne: true,
+    leadingZero: true,
+    negativeExtraSpace: false
+};
+
+var cleanupOutData = require('../lib/svgo/tools').cleanupOutData,
+    EXTEND = require('whet.extend'),
+    transform2js = require('./_transforms.js').transform2js,
+    transformsMultiply = require('./_transforms.js').transformsMultiply,
+    matrixToTransform = require('./_transforms.js').matrixToTransform,
+    degRound,
+    floatRound,
+    transformRound;
+
+/**
+ * Convert matrices to the short aliases,
+ * convert long translate, scale or rotate transform notations to the shorts ones,
+ * convert transforms to the matrices and multiply them all into one,
+ * remove useless transforms.
+ *
+ * @see http://www.w3.org/TR/SVG/coords.html#TransformMatrixDefined
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.elem) {
+
+        // transform
+        if (item.hasAttr('transform')) {
+            convertTransform(item, 'transform', params);
+        }
+
+        // gradientTransform
+        if (item.hasAttr('gradientTransform')) {
+            convertTransform(item, 'gradientTransform', params);
+        }
+
+        // patternTransform
+        if (item.hasAttr('patternTransform')) {
+            convertTransform(item, 'patternTransform', params);
+        }
+
+    }
+
+};
+
+/**
+ * Main function.
+ *
+ * @param {Object} item input item
+ * @param {String} attrName attribute name
+ * @param {Object} params plugin params
+ */
+function convertTransform(item, attrName, params) {
+    var data = transform2js(item.attr(attrName).value);
+    params = definePrecision(data, params);
+
+    if (params.collapseIntoOne && data.length > 1) {
+        data = [transformsMultiply(data)];
+    }
+
+    if (params.convertToShorts) {
+        data = convertToShorts(data, params);
+    } else {
+        data.forEach(roundTransform);
+    }
+
+    if (params.removeUseless) {
+        data = removeUseless(data);
+    }
+
+    if (data.length) {
+        item.attr(attrName).value = js2transform(data, params);
+    } else {
+        item.removeAttr(attrName);
+    }
+}
+
+/**
+ * Defines precision to work with certain parts.
+ * transformPrecision - for scale and four first matrix parameters (needs a better precision due to multiplying),
+ * floatPrecision - for translate including two last matrix and rotate parameters,
+ * degPrecision - for rotate and skew. By default it's equal to (rougly)
+ * transformPrecision - 2 or floatPrecision whichever is lower. Can be set in params.
+ *
+ * @param {Array} transforms input array
+ * @param {Object} params plugin params
+ * @return {Array} output array
+ */
+function definePrecision(data, params) {
+    /* jshint validthis: true */
+    var matrixData = data.reduce(getMatrixData, []),
+        significantDigits = params.transformPrecision;
+
+    // Clone params so it don't affect other elements transformations.
+    params = EXTEND({}, params);
+
+    // Limit transform precision with matrix one. Calculating with larger precision doesn't add any value.
+    if (matrixData.length) {
+        params.transformPrecision = Math.min(params.transformPrecision,
+            Math.max.apply(Math, matrixData.map(floatDigits)) || params.transformPrecision);
+
+        significantDigits = Math.max.apply(Math, matrixData.map(function(n) {
+            return String(n).replace(/\D+/g, '').length; // Number of digits in a number. 123.45 → 5
+        }));
+    }
+    // No sense in angle precision more then number of significant digits in matrix.
+    if (!('degPrecision' in params)) {
+        params.degPrecision = Math.max(0, Math.min(params.floatPrecision, significantDigits - 2));
+    }
+
+    floatRound = params.floatPrecision >= 1 && params.floatPrecision < 20 ?
+        smartRound.bind(this, params.floatPrecision) :
+        round;
+    degRound = params.degPrecision >= 1 && params.floatPrecision < 20 ?
+        smartRound.bind(this, params.degPrecision) :
+        round;
+    transformRound = params.transformPrecision >= 1 && params.floatPrecision < 20 ?
+        smartRound.bind(this, params.transformPrecision) :
+        round;
+
+    return params;
+}
+
+/**
+ * Gathers four first matrix parameters.
+ *
+ * @param {Array} a array of data
+ * @param {Object} transform
+ * @return {Array} output array
+ */
+function getMatrixData(a, b) {
+    return b.name == 'matrix' ? a.concat(b.data.slice(0, 4)) : a;
+}
+
+/**
+ * Returns number of digits after the point. 0.125 → 3
+ */
+function floatDigits(n) {
+    return (n = String(n)).slice(n.indexOf('.')).length - 1;
+}
+
+/**
+ * Convert transforms to the shorthand alternatives.
+ *
+ * @param {Array} transforms input array
+ * @param {Object} params plugin params
+ * @return {Array} output array
+ */
+function convertToShorts(transforms, params) {
+
+    for(var i = 0; i < transforms.length; i++) {
+
+        var transform = transforms[i];
+
+        // convert matrix to the short aliases
+        if (
+            params.matrixToTransform &&
+            transform.name === 'matrix'
+        ) {
+            var decomposed = matrixToTransform(transform, params);
+            if (decomposed != transform &&
+                js2transform(decomposed, params).length <= js2transform([transform], params).length) {
+
+                transforms.splice.apply(transforms, [i, 1].concat(decomposed));
+            }
+            transform = transforms[i];
+        }
+
+        // fixed-point numbers
+        // 12.754997 → 12.755
+        roundTransform(transform);
+
+        // convert long translate transform notation to the shorts one
+        // translate(10 0) → translate(10)
+        if (
+            params.shortTranslate &&
+            transform.name === 'translate' &&
+            transform.data.length === 2 &&
+            !transform.data[1]
+        ) {
+            transform.data.pop();
+        }
+
+        // convert long scale transform notation to the shorts one
+        // scale(2 2) → scale(2)
+        if (
+            params.shortScale &&
+            transform.name === 'scale' &&
+            transform.data.length === 2 &&
+            transform.data[0] === transform.data[1]
+        ) {
+            transform.data.pop();
+        }
+
+        // convert long rotate transform notation to the short one
+        // translate(cx cy) rotate(a) translate(-cx -cy) → rotate(a cx cy)
+        if (
+            params.shortRotate &&
+            transforms[i - 2] &&
+            transforms[i - 2].name === 'translate' &&
+            transforms[i - 1].name === 'rotate' &&
+            transforms[i].name === 'translate' &&
+            transforms[i - 2].data[0] === -transforms[i].data[0] &&
+            transforms[i - 2].data[1] === -transforms[i].data[1]
+        ) {
+            transforms.splice(i - 2, 3, {
+                name: 'rotate',
+                data: [
+                    transforms[i - 1].data[0],
+                    transforms[i - 2].data[0],
+                    transforms[i - 2].data[1]
+                ]
+            });
+
+            // splice compensation
+            i -= 2;
+
+            transform = transforms[i];
+        }
+
+    }
+
+    return transforms;
+
+}
+
+/**
+ * Remove useless transforms.
+ *
+ * @param {Array} transforms input array
+ * @return {Array} output array
+ */
+function removeUseless(transforms) {
+
+    return transforms.filter(function(transform) {
+
+        // translate(0), rotate(0[, cx, cy]), skewX(0), skewY(0)
+        if (
+            ['translate', 'rotate', 'skewX', 'skewY'].indexOf(transform.name) > -1 &&
+            (transform.data.length == 1 || transform.name == 'rotate') &&
+            !transform.data[0] ||
+
+            // translate(0, 0)
+            transform.name == 'translate' &&
+            !transform.data[0] &&
+            !transform.data[1] ||
+
+            // scale(1)
+            transform.name == 'scale' &&
+            transform.data[0] == 1 &&
+            (transform.data.length < 2 || transform.data[1] == 1) ||
+
+            // matrix(1 0 0 1 0 0)
+            transform.name == 'matrix' &&
+            transform.data[0] == 1 &&
+            transform.data[3] == 1 &&
+            !(transform.data[1] || transform.data[2] || transform.data[4] || transform.data[5])
+        ) {
+            return false;
+        }
+
+        return true;
+
+    });
+
+}
+
+/**
+ * Convert transforms JS representation to string.
+ *
+ * @param {Array} transformJS JS representation array
+ * @param {Object} params plugin params
+ * @return {String} output string
+ */
+function js2transform(transformJS, params) {
+
+    var transformString = '';
+
+    // collect output value string
+    transformJS.forEach(function(transform) {
+        roundTransform(transform);
+        transformString += (transformString && ' ') + transform.name + '(' + cleanupOutData(transform.data, params) + ')';
+    });
+
+    return transformString;
+
+}
+
+function roundTransform(transform) {
+    switch (transform.name) {
+        case 'translate':
+            transform.data = floatRound(transform.data);
+            break;
+        case 'rotate':
+            transform.data = degRound(transform.data.slice(0, 1)).concat(floatRound(transform.data.slice(1)));
+            break;
+        case 'skewX':
+        case 'skewY':
+            transform.data = degRound(transform.data);
+            break;
+        case 'scale':
+            transform.data = transformRound(transform.data);
+            break;
+        case 'matrix':
+            transform.data = transformRound(transform.data.slice(0, 4)).concat(floatRound(transform.data.slice(4)));
+            break;
+    }
+    return transform;
+}
+
+/**
+ * Rounds numbers in array.
+ *
+ * @param {Array} data input data array
+ * @return {Array} output data array
+ */
+function round(data) {
+    return data.map(Math.round);
+}
+
+/**
+ * Decrease accuracy of floating-point numbers
+ * in transforms keeping a specified number of decimals.
+ * Smart rounds values like 2.349 to 2.35.
+ *
+ * @param {Number} fixed number of decimals
+ * @param {Array} data input data array
+ * @return {Array} output data array
+ */
+function smartRound(precision, data) {
+    for (var i = data.length, tolerance = +Math.pow(.1, precision).toFixed(precision); i--;) {
+        if (data[i].toFixed(precision) != data[i]) {
+            var rounded = +data[i].toFixed(precision - 1);
+            data[i] = +Math.abs(rounded - data[i]).toFixed(precision + 1) >= tolerance ?
+                +data[i].toFixed(precision) :
+                rounded;
+        }
+    }
+    return data;
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/mergePaths.js

@@ -0,0 +1,71 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'merges multiple paths in one if possible';
+
+exports.params = {
+    collapseRepeated: true,
+    leadingZero: true,
+    negativeExtraSpace: true
+};
+
+var path2js = require('./_path.js').path2js,
+    js2path = require('./_path.js').js2path,
+    intersects = require('./_path.js').intersects;
+
+/**
+ * Merge multiple Paths into one.
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich, Lev Solntsev
+ */
+exports.fn = function(item, params) {
+
+    if (!item.isElem() || item.isEmpty()) return;
+
+    var prevContentItem = null,
+        prevContentItemKeys = null;
+
+    item.content = item.content.filter(function(contentItem) {
+
+        if (prevContentItem &&
+            prevContentItem.isElem('path') &&
+            prevContentItem.isEmpty() &&
+            prevContentItem.hasAttr('d') &&
+            contentItem.isElem('path') &&
+            contentItem.isEmpty() &&
+            contentItem.hasAttr('d')
+        ) {
+
+            if (!prevContentItemKeys) {
+                prevContentItemKeys = Object.keys(prevContentItem.attrs);
+            }
+
+            var contentItemAttrs = Object.keys(contentItem.attrs),
+                equalData = prevContentItemKeys.length == contentItemAttrs.length &&
+                    contentItemAttrs.every(function(key) {
+                        return key == 'd' ||
+                            prevContentItem.hasAttr(key) &&
+                            prevContentItem.attr(key).value == contentItem.attr(key).value;
+                    }),
+                prevPathJS = path2js(prevContentItem),
+                curPathJS = path2js(contentItem);
+
+            if (equalData && !intersects(prevPathJS, curPathJS)) {
+                js2path(prevContentItem, prevPathJS.concat(curPathJS), params);
+                return false;
+            }
+        }
+
+        prevContentItem = contentItem;
+        prevContentItemKeys = null;
+        return true;
+
+    });
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/minifyStyles.js

@@ -0,0 +1,45 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.params = {
+    svgo: {}
+};
+
+exports.description = 'minifies existing styles in svg';
+
+var csso = require('csso');
+
+/**
+ * Minifies styles (<style> element + style attribute) using svgo
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author strarsis <strarsis@gmail.com>
+ */
+exports.fn = function(item, svgoOptions) {
+
+    if(item.elem) {
+        if(item.isElem('style') && !item.isEmpty()) {
+            var styleCss = item.content[0].text || item.content[0].cdata || [],
+                DATA = styleCss.indexOf('>') >= 0 || styleCss.indexOf('<') >= 0 ? 'cdata' : 'text';
+            if(styleCss.length > 0) {
+                var styleCssMinified = csso.minify(styleCss, svgoOptions);
+                item.content[0][DATA] = styleCssMinified.css;
+            }
+      }
+
+      if(item.hasAttr('style')) {
+          var itemCss = item.attr('style').value;
+          if(itemCss.length > 0) {
+              var itemCssMinified = csso.minifyBlock(itemCss, svgoOptions);
+              item.attr('style').value = itemCssMinified.css;
+          }
+      }
+    }
+
+    return item;
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/moveElemsAttrsToGroup.js

@@ -0,0 +1,126 @@
+'use strict';
+
+exports.type = 'perItemReverse';
+
+exports.active = true;
+
+exports.description = 'moves elements attributes to the existing group wrapper';
+
+var inheritableAttrs = require('./_collections').inheritableAttrs,
+    pathElems = require('./_collections.js').pathElems;
+
+/**
+ * Collapse content's intersected and inheritable
+ * attributes to the existing group wrapper.
+ *
+ * @example
+ * <g attr1="val1">
+ *     <g attr2="val2">
+ *         text
+ *     </g>
+ *     <circle attr2="val2" attr3="val3"/>
+ * </g>
+ *              ⬇
+ * <g attr1="val1" attr2="val2">
+ *     <g>
+ *         text
+ *     </g>
+ *    <circle attr3="val3"/>
+ * </g>
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (item.isElem('g') && !item.isEmpty() && item.content.length > 1) {
+
+        var intersection = {},
+            hasTransform = false,
+            hasClip = item.hasAttr('clip-path') || item.hasAttr('mask'),
+            intersected = item.content.every(function(inner) {
+                if (inner.isElem() && inner.hasAttr()) {
+                    // don't mess with possible styles (hack until CSS parsing is implemented)
+                    if (inner.hasAttr('class')) return false;
+                    if (!Object.keys(intersection).length) {
+                        intersection = inner.attrs;
+                    } else {
+                        intersection = intersectInheritableAttrs(intersection, inner.attrs);
+
+                        if (!intersection) return false;
+                    }
+
+                    return true;
+                }
+            }),
+            allPath = item.content.every(function(inner) {
+                return inner.isElem(pathElems);
+            });
+
+        if (intersected) {
+
+            item.content.forEach(function(g) {
+
+                for (var name in intersection) {
+
+                    if (!allPath && !hasClip || name !== 'transform') {
+
+                        g.removeAttr(name);
+
+                        if (name === 'transform') {
+                            if (!hasTransform) {
+                                if (item.hasAttr('transform')) {
+                                    item.attr('transform').value += ' ' + intersection[name].value;
+                                } else {
+                                    item.addAttr(intersection[name]);
+                                }
+
+                                hasTransform = true;
+                            }
+                        } else {
+                            item.addAttr(intersection[name]);
+                        }
+
+                    }
+                }
+
+            });
+
+        }
+
+    }
+
+};
+
+/**
+ * Intersect inheritable attributes.
+ *
+ * @param {Object} a first attrs object
+ * @param {Object} b second attrs object
+ *
+ * @return {Object} intersected attrs object
+ */
+function intersectInheritableAttrs(a, b) {
+
+    var c = {};
+
+    for (var n in a) {
+        if (
+            b.hasOwnProperty(n) &&
+            inheritableAttrs.indexOf(n) > -1 &&
+            a[n].name === b[n].name &&
+            a[n].value === b[n].value &&
+            a[n].prefix === b[n].prefix &&
+            a[n].local === b[n].local
+        ) {
+            c[n] = a[n];
+        }
+    }
+
+    if (!Object.keys(c).length) return false;
+
+    return c;
+
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/moveGroupAttrsToElems.js

@@ -0,0 +1,63 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'moves some group attributes to the content elements';
+
+var collections = require('./_collections.js'),
+    pathElems = collections.pathElems.concat(['g', 'text']),
+    referencesProps = collections.referencesProps;
+
+/**
+ * Move group attrs to the content elements.
+ *
+ * @example
+ * <g transform="scale(2)">
+ *     <path transform="rotate(45)" d="M0,0 L10,20"/>
+ *     <path transform="translate(10, 20)" d="M0,10 L20,30"/>
+ * </g>
+ *                          ⬇
+ * <g>
+ *     <path transform="scale(2) rotate(45)" d="M0,0 L10,20"/>
+ *     <path transform="scale(2) translate(10, 20)" d="M0,10 L20,30"/>
+ * </g>
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    // move group transform attr to content's pathElems
+    if (
+        item.isElem('g') &&
+        item.hasAttr('transform') &&
+        !item.isEmpty() &&
+        !item.someAttr(function(attr) {
+            return ~referencesProps.indexOf(attr.name) && ~attr.value.indexOf('url(');
+        }) &&
+        item.content.every(function(inner) {
+            return inner.isElem(pathElems) && !inner.hasAttr('id');
+        })
+    ) {
+        item.content.forEach(function(inner) {
+            var attr = item.attr('transform');
+            if (inner.hasAttr('transform')) {
+                inner.attr('transform').value = attr.value + ' ' + inner.attr('transform').value;
+            } else {
+                inner.addAttr({
+                    'name': attr.name,
+                    'local': attr.local,
+                    'prefix': attr.prefix,
+                    'value': attr.value
+                });
+            }
+        });
+
+        item.removeAttr('transform');
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeAttrs.js

@@ -0,0 +1,119 @@
+'use strict';
+
+var ELEM_SEP = ':';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes specified attributes';
+
+exports.params = {
+    attrs: []
+};
+
+/**
+ * Remove attributes
+ *
+ * @param attrs:
+ *
+ *   format: [ element* : attribute* ]
+ *
+ *   element   : regexp (wrapped into ^...$), single * or omitted > all elements
+ *   attribute : regexp (wrapped into ^...$)
+ *
+ *   examples:
+ *
+ *     > basic: remove fill attribute
+ *     ---
+ *     removeAttrs:
+ *       attrs: 'fill'
+ *
+ *     > remove fill attribute on path element
+ *     ---
+ *       attrs: 'path:fill'
+ *
+ *
+ *     > remove all fill and stroke attribute
+ *     ---
+ *       attrs:
+ *         - 'fill'
+ *         - 'stroke'
+ *
+ *     [is same as]
+ *
+ *       attrs: '(fill|stroke)'
+ *
+ *     [is same as]
+ *
+ *       attrs: '*:(fill|stroke)'
+ *
+ *     [is same as]
+ *
+ *       attrs: '.*:(fill|stroke)'
+ *
+ *
+ *     > remove all stroke related attributes
+ *     ----
+ *     attrs: 'stroke.*'
+ *
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Benny Schudel
+ */
+exports.fn = function(item, params) {
+
+        // wrap into an array if params is not
+    if (!Array.isArray(params.attrs)) {
+        params.attrs = [params.attrs];
+    }
+
+    if (item.isElem()) {
+
+            // prepare patterns
+        var patterns = params.attrs.map(function(pattern) {
+
+                // apply to all elements if specifc element is omitted
+            if (pattern.indexOf(ELEM_SEP) === -1) {
+                pattern = ['.*', ELEM_SEP, pattern].join('');
+            }
+
+                // create regexps for element and attribute name
+            return pattern.split(ELEM_SEP)
+                .map(function(value) {
+
+                        // adjust single * to match anything
+                    if (value === '*') { value = '.*'; }
+
+                    return new RegExp(['^', value, '$'].join(''), 'i');
+                });
+
+        });
+
+            // loop patterns
+        patterns.forEach(function(pattern) {
+
+                // matches element
+            if (pattern[0].test(item.elem)) {
+
+                    // loop attributes
+                item.eachAttr(function(attr) {
+                    var name = attr.name;
+
+                        // matches attribute name
+                    if (pattern[1].test(name)) {
+                        item.removeAttr(name);
+                    }
+
+                });
+
+            }
+
+        });
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeComments.js

@@ -0,0 +1,27 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes comments';
+
+/**
+ * Remove comments.
+ *
+ * @example
+ * <!-- Generator: Adobe Illustrator 15.0.0, SVG Export
+ * Plug-In . SVG Version: 6.00 Build 0)  -->
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (item.comment && item.comment.charAt(0) !== '!') {
+        return false;
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeDesc.js

@@ -0,0 +1,32 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.params = {
+    removeAny: false
+};
+
+exports.description = 'removes <desc> (only non-meaningful by default)';
+
+var standardDescs = /^Created with/;
+
+/**
+ * Removes <desc>.
+ * Removes only standard editors content or empty elements 'cause it can be used for accessibility.
+ * Enable parameter 'removeAny' to remove any description.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/SVG/Element/desc
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Daniel Wabyick
+ */
+exports.fn = function(item, params) {
+
+    return !item.isElem('desc') || !(params.removeAny || item.isEmpty() ||
+            standardDescs.test(item.content[0].text));
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeDimensions.js

@@ -0,0 +1,32 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes width and height in presence of viewBox';
+
+/**
+ * Remove width/height attributes when a viewBox attribute is present.
+ *
+ * @example
+ * <svg width="100" height="50" viewBox="0 0 100 50">
+ *   ↓
+ * <svg viewBox="0 0 100 50">
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if true, with and height will be filtered out
+ *
+ * @author Benny Schudel
+ */
+exports.fn = function(item) {
+
+    if (
+        item.isElem('svg') &&
+        item.hasAttr('viewBox')
+    ) {
+        item.removeAttr('width');
+        item.removeAttr('height');
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeDoctype.js

@@ -0,0 +1,40 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes doctype declaration';
+
+/**
+ * Remove DOCTYPE declaration.
+ *
+ * "Unfortunately the SVG DTDs are a source of so many
+ * issues that the SVG WG has decided not to write one
+ * for the upcoming SVG 1.2 standard. In fact SVG WG
+ * members are even telling people not to use a DOCTYPE
+ * declaration in SVG 1.0 and 1.1 documents"
+ * https://jwatt.org/svg/authoring/#doctype-declaration
+ *
+ * @example
+ * <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ * q"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+ *
+ * @example
+ * <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ * "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" [
+ *     <!-- an internal subset can be embedded here -->
+ * ]>
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (item.doctype) {
+        return false;
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeEditorsNSData.js

@@ -0,0 +1,65 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes editors namespaces, elements and attributes';
+
+var editorNamespaces = require('./_collections').editorNamespaces,
+    prefixes = [];
+
+exports.params = {
+    additionalNamespaces: []
+};
+
+/**
+ * Remove editors namespaces, elements and attributes.
+ *
+ * @example
+ * <svg xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd">
+ * <sodipodi:namedview/>
+ * <path sodipodi:nodetypes="cccc"/>
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (Array.isArray(params.additionalNamespaces)) {
+        editorNamespaces = editorNamespaces.concat(params.additionalNamespaces);
+    }
+
+    if (item.elem) {
+
+        if (item.isElem('svg')) {
+
+            item.eachAttr(function(attr) {
+                if (attr.prefix === 'xmlns' && editorNamespaces.indexOf(attr.value) > -1) {
+                    prefixes.push(attr.local);
+
+                    // <svg xmlns:sodipodi="">
+                    item.removeAttr(attr.name);
+                }
+            });
+
+        }
+
+        // <* sodipodi:*="">
+        item.eachAttr(function(attr) {
+            if (prefixes.indexOf(attr.prefix) > -1) {
+                item.removeAttr(attr.name);
+            }
+        });
+
+        // <sodipodi:*>
+        if (prefixes.indexOf(item.prefix) > -1) {
+            return false;
+        }
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeElementsByAttr.js

@@ -0,0 +1,80 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes arbitrary elements by ID or className (disabled by default)';
+
+exports.params = {
+    id: [],
+    class: []
+};
+
+/**
+ * Remove arbitrary SVG elements by ID or className.
+ *
+ * @param id
+ *   examples:
+ *
+ *     > single: remove element with ID of `elementID`
+ *     ---
+ *     removeElementsByAttr:
+ *       id: 'elementID'
+ *
+ *     > list: remove multiple elements by ID
+ *     ---
+ *     removeElementsByAttr:
+ *       id:
+ *         - 'elementID'
+ *         - 'anotherID'
+ *
+ * @param class
+ *   examples:
+ *
+ *     > single: remove all elements with class of `elementClass`
+ *     ---
+ *     removeElementsByAttr:
+ *       class: 'elementClass'
+ *
+ *     > list: remove all elements with class of `elementClass` or `anotherClass`
+ *     ---
+ *     removeElementsByAttr:
+ *       class:
+ *         - 'elementClass'
+ *         - 'anotherClass'
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Eli Dupuis (@elidupuis)
+ */
+exports.fn = function(item, params) {
+    var elemId, elemClass;
+
+    // wrap params in an array if not already
+    ['id', 'class'].forEach(function(key) {
+        if (!Array.isArray(params[key])) {
+            params[key] = [ params[key] ];
+        }
+    });
+
+    // abort if current item is no an element
+    if (!item.isElem()) {
+        return;
+    }
+
+    // remove element if it's `id` matches configured `id` params
+    elemId = item.attr('id');
+    if (elemId) {
+        return params.id.indexOf(elemId.value) === -1;
+    }
+
+    // remove element if it's `class` contains any of the configured `class` params
+    elemClass = item.attr('class');
+    if (elemClass) {
+        var hasClassRegex = new RegExp(params.class.join('|'));
+        return !hasClassRegex.test(elemClass.value);
+    }
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeEmptyAttrs.js

@@ -0,0 +1,29 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes empty attributes';
+
+/**
+ * Remove attributes with empty values.
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (item.elem) {
+
+        item.eachAttr(function(attr) {
+            if (attr.value === '') {
+                item.removeAttr(attr.name);
+            }
+        });
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeEmptyContainers.js

@@ -0,0 +1,32 @@
+'use strict';
+
+exports.type = 'perItemReverse';
+
+exports.active = true;
+
+exports.description = 'removes empty container elements';
+
+var container = require('./_collections').elemsGroups.container;
+
+/**
+ * Remove empty containers.
+ *
+ * @see http://www.w3.org/TR/SVG/intro.html#TermContainerElement
+ *
+ * @example
+ * <defs/>
+ *
+ * @example
+ * <g><marker><a/></marker></g>
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    return !(item.isElem(container) && !item.isElem('svg') && item.isEmpty() &&
+        (!item.isElem('pattern') || !item.hasAttrLocal('href')));
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeEmptyText.js

@@ -0,0 +1,59 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes empty <text> elements';
+
+exports.params = {
+    text: true,
+    tspan: true,
+    tref: true
+};
+
+/**
+ * Remove empty Text elements.
+ *
+ * @see http://www.w3.org/TR/SVG/text.html
+ *
+ * @example
+ * Remove empty text element:
+ * <text/>
+ *
+ * Remove empty tspan element:
+ * <tspan/>
+ *
+ * Remove tref with empty xlink:href attribute:
+ * <tref xlink:href=""/>
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    // Remove empty text element
+    if (
+        params.text &&
+        item.isElem('text') &&
+        item.isEmpty()
+    ) return false;
+
+    // Remove empty tspan element
+    if (
+        params.tspan &&
+        item.isElem('tspan') &&
+        item.isEmpty()
+    ) return false;
+
+    // Remove tref with empty xlink:href attribute
+    if (
+        params.tref &&
+        item.isElem('tref') &&
+        !item.hasAttrLocal('href')
+    ) return false;
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeHiddenElems.js

@@ -0,0 +1,218 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes hidden elements (zero sized, with absent attributes)';
+
+exports.params = {
+    displayNone: true,
+    opacity0: true,
+    circleR0: true,
+    ellipseRX0: true,
+    ellipseRY0: true,
+    rectWidth0: true,
+    rectHeight0: true,
+    patternWidth0: true,
+    patternHeight0: true,
+    imageWidth0: true,
+    imageHeight0: true,
+    pathEmptyD: true,
+    polylineEmptyPoints: true,
+    polygonEmptyPoints: true
+};
+
+var regValidPath = /M\s*(?:[-+]?(?:\d*\.\d+|\d+(?:\.|(?!\.)))([eE][-+]?\d+)?(?!\d)\s*,?\s*){2}\D*\d/i;
+
+/**
+ * Remove hidden elements with disabled rendering:
+ * - display="none"
+ * - opacity="0"
+ * - circle with zero radius
+ * - ellipse with zero x-axis or y-axis radius
+ * - rectangle with zero width or height
+ * - pattern with zero width or height
+ * - image with zero width or height
+ * - path with empty data
+ * - polyline with empty points
+ * - polygon with empty points
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.elem) {
+
+        // display="none"
+        //
+        // http://www.w3.org/TR/SVG/painting.html#DisplayProperty
+        // "A value of display: none indicates that the given element
+        // and its children shall not be rendered directly"
+        if (
+            params.displayNone &&
+            item.hasAttr('display', 'none')
+        ) return false;
+
+        // opacity="0"
+        //
+        // http://www.w3.org/TR/SVG/masking.html#ObjectAndGroupOpacityProperties
+        if (
+            params.opacity0 &&
+            item.hasAttr('opacity', '0')
+        ) return false;
+
+        // Circles with zero radius
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#CircleElementRAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <circle r="0">
+        if (
+            params.circleR0 &&
+            item.isElem('circle') &&
+            item.isEmpty() &&
+            item.hasAttr('r', '0')
+        ) return false;
+
+        // Ellipse with zero x-axis radius
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#EllipseElementRXAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <ellipse rx="0">
+        if (
+            params.ellipseRX0 &&
+            item.isElem('ellipse') &&
+            item.isEmpty() &&
+            item.hasAttr('rx', '0')
+        ) return false;
+
+        // Ellipse with zero y-axis radius
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#EllipseElementRYAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <ellipse ry="0">
+        if (
+            params.ellipseRY0 &&
+            item.isElem('ellipse') &&
+            item.isEmpty() &&
+            item.hasAttr('ry', '0')
+        ) return false;
+
+        // Rectangle with zero width
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#RectElementWidthAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <rect width="0">
+        if (
+            params.rectWidth0 &&
+            item.isElem('rect') &&
+            item.isEmpty() &&
+            item.hasAttr('width', '0')
+        ) return false;
+
+        // Rectangle with zero height
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#RectElementHeightAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <rect height="0">
+        if (
+            params.rectHeight0 &&
+            params.rectWidth0 &&
+            item.isElem('rect') &&
+            item.isEmpty() &&
+            item.hasAttr('height', '0')
+        ) return false;
+
+        // Pattern with zero width
+        //
+        // http://www.w3.org/TR/SVG/pservers.html#PatternElementWidthAttribute
+        // "A value of zero disables rendering of the element (i.e., no paint is applied)"
+        //
+        // <pattern width="0">
+        if (
+            params.patternWidth0 &&
+            item.isElem('pattern') &&
+            item.hasAttr('width', '0')
+        ) return false;
+
+        // Pattern with zero height
+        //
+        // http://www.w3.org/TR/SVG/pservers.html#PatternElementHeightAttribute
+        // "A value of zero disables rendering of the element (i.e., no paint is applied)"
+        //
+        // <pattern height="0">
+        if (
+            params.patternHeight0 &&
+            item.isElem('pattern') &&
+            item.hasAttr('height', '0')
+        ) return false;
+
+        // Image with zero width
+        //
+        // http://www.w3.org/TR/SVG/struct.html#ImageElementWidthAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <image width="0">
+        if (
+            params.imageWidth0 &&
+            item.isElem('image') &&
+            item.hasAttr('width', '0')
+        ) return false;
+
+        // Image with zero height
+        //
+        // http://www.w3.org/TR/SVG/struct.html#ImageElementHeightAttribute
+        // "A value of zero disables rendering of the element"
+        //
+        // <image height="0">
+        if (
+            params.imageHeight0 &&
+            item.isElem('image') &&
+            item.hasAttr('height', '0')
+        ) return false;
+
+        // Path with empty data
+        //
+        // http://www.w3.org/TR/SVG/paths.html#DAttribute
+        //
+        // <path d=""/>
+        if (
+            params.pathEmptyD &&
+            item.isElem('path') &&
+            (!item.hasAttr('d') || !regValidPath.test(item.attr('d').value))
+        ) return false;
+
+        // Polyline with empty points
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#PolylineElementPointsAttribute
+        //
+        // <polyline points="">
+        if (
+            params.polylineEmptyPoints &&
+            item.isElem('polyline') &&
+            !item.hasAttr('points')
+        ) return false;
+
+        // Polygon with empty points
+        //
+        // http://www.w3.org/TR/SVG/shapes.html#PolygonElementPointsAttribute
+        //
+        // <polygon points="">
+        if (
+            params.polygonEmptyPoints &&
+            item.isElem('polygon') &&
+            !item.hasAttr('points')
+        ) return false;
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeMetadata.js

@@ -0,0 +1,23 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes <metadata>';
+
+/**
+ * Remove <metadata>.
+ *
+ * http://www.w3.org/TR/SVG/metadata.html
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    return !item.isElem('metadata');
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeNonInheritableGroupAttrs.js

@@ -0,0 +1,40 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes non-inheritable group’s presentational attributes';
+
+var inheritableAttrs = require('./_collections').inheritableAttrs,
+    attrsGroups = require('./_collections').attrsGroups,
+    excludedAttrs = ['display', 'opacity'];
+
+/**
+ * Remove non-inheritable group's "presentation" attributes.
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (item.isElem('g')) {
+
+        item.eachAttr(function(attr) {
+            if (
+                ~attrsGroups.presentation.indexOf(attr.name) &&
+                ~attrsGroups.graphicalEvent.indexOf(attr.name) &&
+                ~attrsGroups.core.indexOf(attr.name) &&
+                ~attrsGroups.conditionalProcessing.indexOf(attr.name) &&
+                !~excludedAttrs.indexOf(attr.name) &&
+                !~inheritableAttrs.indexOf(attr.name)
+            ) {
+                item.removeAttr(attr.name);
+            }
+        });
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeRasterImages.js

@@ -0,0 +1,28 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes raster images (disabled by default)';
+
+/**
+ * Remove raster images references in <image>.
+ *
+ * @see https://bugs.webkit.org/show_bug.cgi?id=63548
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (
+        item.isElem('image') &&
+        item.hasAttrLocal('href', /(\.|image\/)(jpg|png|gif)/)
+    ) {
+        return false;
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeStyleElement.js

@@ -0,0 +1,23 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes <style> element (disabled by default)';
+
+/**
+ * Remove <style>.
+ *
+ * http://www.w3.org/TR/SVG/styling.html#StyleElement
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Betsy Dupuis
+ */
+exports.fn = function(item) {
+
+    return !item.isElem('style');
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeTitle.js

@@ -0,0 +1,24 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes <title> (disabled by default)';
+
+/**
+ * Remove <title>.
+ * Disabled by default cause it may be used for accessibility.
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/SVG/Element/title
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Igor Kalashnikov
+ */
+exports.fn = function(item) {
+
+    return !item.isElem('title');
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeUnknownsAndDefaults.js

@@ -0,0 +1,143 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes unknown elements content and attributes, removes attrs with default values';
+
+exports.params = {
+    unknownContent: true,
+    unknownAttrs: true,
+    defaultAttrs: true,
+    uselessOverrides: true,
+    keepDataAttrs: true
+};
+
+var collections = require('./_collections'),
+    elems = collections.elems,
+    attrsGroups = collections.attrsGroups,
+    elemsGroups = collections.elemsGroups,
+    attrsGroupsDefaults = collections.attrsGroupsDefaults,
+    attrsInheritable = collections.inheritableAttrs;
+
+// collect and extend all references
+for (var elem in elems) {
+    elem = elems[elem];
+
+    if (elem.attrsGroups) {
+        elem.attrs = elem.attrs || [];
+
+        elem.attrsGroups.forEach(function(attrsGroupName) {
+            elem.attrs = elem.attrs.concat(attrsGroups[attrsGroupName]);
+
+            var groupDefaults = attrsGroupsDefaults[attrsGroupName];
+
+            if (groupDefaults) {
+                elem.defaults = elem.defaults || {};
+
+                for (var attrName in groupDefaults) {
+                    elem.defaults[attrName] = groupDefaults[attrName];
+                }
+            }
+        });
+
+    }
+
+    if (elem.contentGroups) {
+        elem.content = elem.content || [];
+
+        elem.contentGroups.forEach(function(contentGroupName) {
+            elem.content = elem.content.concat(elemsGroups[contentGroupName]);
+        });
+    }
+}
+
+/**
+ * Remove unknown elements content and attributes,
+ * remove attributes with default values.
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    // elems w/o namespace prefix
+    if (item.isElem() && !item.prefix) {
+
+        var elem = item.elem;
+
+        // remove unknown element's content
+        if (
+            params.unknownContent &&
+            !item.isEmpty() &&
+            elems[elem] && // make sure we know of this element before checking its children
+            elem !== 'foreignObject' // Don't check foreignObject
+        ) {
+            item.content.forEach(function(content, i) {
+                if (
+                    content.isElem() &&
+                    !content.prefix &&
+                    (
+                        (
+                            elems[elem].content && // Do we have a record of its permitted content?
+                            elems[elem].content.indexOf(content.elem) === -1
+                        ) ||
+                        (
+                            !elems[elem].content && // we dont know about its permitted content
+                            !elems[content.elem] // check that we know about the element at all
+                        )
+                    )
+                ) {
+                    item.content.splice(i, 1);
+                }
+            });
+        }
+
+        // remove element's unknown attrs and attrs with default values
+        if (elems[elem] && elems[elem].attrs) {
+
+            item.eachAttr(function(attr) {
+
+                if (
+                    attr.name !== 'xmlns' &&
+                    (attr.prefix === 'xml' || !attr.prefix) &&
+                    (!params.keepDataAttrs || attr.name.indexOf('data-') != 0)
+                ) {
+                    if (
+                        // unknown attrs
+                        (
+                            params.unknownAttrs &&
+                            elems[elem].attrs.indexOf(attr.name) === -1
+                        ) ||
+                        // attrs with default values
+                        (
+                            params.defaultAttrs &&
+                            elems[elem].defaults &&
+                            elems[elem].defaults[attr.name] === attr.value && (
+                                attrsInheritable.indexOf(attr.name) < 0 ||
+                                !item.parentNode.computedAttr(attr.name)
+                            )
+                        ) ||
+                        // useless overrides
+                        (
+                            params.uselessOverrides &&
+                            attr.name !== 'transform' &&
+                            attrsInheritable.indexOf(attr.name) > -1 &&
+                            item.parentNode.computedAttr(attr.name, attr.value)
+                        )
+                    ) {
+                        item.removeAttr(attr.name);
+                    }
+                }
+
+            });
+
+        }
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeUnusedNS.js

@@ -0,0 +1,107 @@
+'use strict';
+
+exports.type = 'full';
+
+exports.active = true;
+
+exports.description = 'removes unused namespaces declaration';
+
+/**
+ * Remove unused namespaces declaration.
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(data) {
+
+    var svgElem,
+        xmlnsCollection = [];
+
+    /**
+     * Remove namespace from collection.
+     *
+     * @param {String} ns namescape name
+     */
+    function removeNSfromCollection(ns) {
+
+        var pos = xmlnsCollection.indexOf(ns);
+
+        // if found - remove ns from the namespaces collection
+        if (pos > -1) {
+            xmlnsCollection.splice(pos, 1);
+        }
+
+    }
+
+    /**
+     * Bananas!
+     *
+     * @param {Array} items input items
+     *
+     * @return {Array} output items
+     */
+    function monkeys(items) {
+
+        var i = 0,
+            length = items.content.length;
+
+        while(i < length) {
+
+            var item = items.content[i];
+
+            if (item.isElem('svg')) {
+
+                item.eachAttr(function(attr) {
+                    // collect namespaces
+                    if (attr.prefix === 'xmlns' && attr.local) {
+                        xmlnsCollection.push(attr.local);
+                    }
+                });
+
+                // if svg element has ns-attr
+                if (xmlnsCollection.length) {
+                    // save svg element
+                    svgElem = item;
+                }
+
+            } else if (xmlnsCollection.length) {
+
+                // check item for the ns-attrs
+                if (item.prefix) {
+                    removeNSfromCollection(item.prefix);
+                }
+
+                // check each attr for the ns-attrs
+                item.eachAttr(function(attr) {
+                    removeNSfromCollection(attr.prefix);
+                });
+
+            }
+
+            // if nothing is found - go deeper
+            if (xmlnsCollection.length && item.content) {
+                monkeys(item);
+            }
+
+            i++;
+
+        }
+
+        return items;
+
+    }
+
+    data = monkeys(data);
+
+    // remove svg element ns-attributes if they are not used even once
+    if (xmlnsCollection.length) {
+        xmlnsCollection.forEach(function(name) {
+            svgElem.removeAttr('xmlns:' + name);
+        });
+    }
+
+    return data;
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeUselessDefs.js

@@ -0,0 +1,51 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes elements in <defs> without id';
+
+var nonRendering = require('./_collections').elemsGroups.nonRendering,
+    defs;
+
+/**
+ * Removes content of defs and properties that aren't rendered directly without ids.
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Lev Solntsev
+ */
+exports.fn = function(item) {
+
+    if (item.isElem('defs')) {
+
+        defs = item;
+        item.content = (item.content || []).reduce(getUsefulItems, []);
+
+        if (item.isEmpty()) return false;
+
+    } else if (item.isElem(nonRendering) && !item.hasAttr('id')) {
+
+        return false;
+
+    }
+
+};
+
+function getUsefulItems(usefulItems, item) {
+
+    if (item.hasAttr('id') || item.isElem('style')) {
+
+        usefulItems.push(item);
+        item.parentNode = defs;
+
+    } else if (!item.isEmpty()) {
+
+        item.content.reduce(getUsefulItems, usefulItems);
+
+    }
+
+    return usefulItems;
+}

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeUselessStrokeAndFill.js

@@ -0,0 +1,92 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes useless stroke and fill attributes';
+
+exports.params = {
+    stroke: true,
+    fill: true
+};
+
+var shape = require('./_collections').elemsGroups.shape,
+    regStrokeProps = /^stroke/,
+    regFillProps = /^fill-/,
+    styleOrScript = ['style', 'script'],
+    hasStyleOrScript = false;
+
+/**
+ * Remove useless stroke and fill attrs.
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item, params) {
+
+    if (item.isElem(styleOrScript)) {
+        hasStyleOrScript = true;
+    }
+
+    if (!hasStyleOrScript && item.isElem(shape) && !item.computedAttr('id')) {
+
+        var stroke = params.stroke && item.computedAttr('stroke'),
+            fill = params.fill && !item.computedAttr('fill', 'none');
+
+        // remove stroke*
+        if (
+            params.stroke &&
+            (!stroke ||
+                stroke == 'none' ||
+                item.computedAttr('stroke-opacity', '0') ||
+                item.computedAttr('stroke-width', '0')
+            )
+        ) {
+            var parentStroke = item.parentNode.computedAttr('stroke'),
+                declineStroke = parentStroke && parentStroke != 'none';
+
+            item.eachAttr(function(attr) {
+                if (regStrokeProps.test(attr.name)) {
+                    item.removeAttr(attr.name);
+                }
+            });
+
+            if (declineStroke) item.addAttr({
+                name: 'stroke',
+                value: 'none',
+                prefix: '',
+                local: 'stroke'
+            });
+        }
+
+        // remove fill*
+        if (
+            params.fill &&
+            (!fill || item.computedAttr('fill-opacity', '0'))
+        ) {
+            item.eachAttr(function(attr) {
+                if (regFillProps.test(attr.name)) {
+                    item.removeAttr(attr.name);
+                }
+            });
+
+            if (fill) {
+                if (item.hasAttr('fill'))
+                    item.attr('fill').value = 'none';
+                else
+                    item.addAttr({
+                        name: 'fill',
+                        value: 'none',
+                        prefix: '',
+                        local: 'fill'
+                    });
+            }
+        }
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeViewBox.js

@@ -0,0 +1,49 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes viewBox attribute when possible (disabled by default)';
+
+var regViewBox = /^0\s0\s([\-+]?\d*\.?\d+([eE][\-+]?\d+)?)\s([\-+]?\d*\.?\d+([eE][\-+]?\d+)?)$/,
+    viewBoxElems = ['svg', 'pattern'];
+
+/**
+ * Remove viewBox attr which coincides with a width/height box.
+ *
+ * @see http://www.w3.org/TR/SVG/coords.html#ViewBoxAttribute
+ *
+ * @example
+ * <svg width="100" height="50" viewBox="0 0 100 50">
+ *             ⬇
+ * <svg width="100" height="50">
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    if (
+        item.isElem(viewBoxElems) &&
+        item.hasAttr('viewBox') &&
+        item.hasAttr('width') &&
+        item.hasAttr('height')
+    ) {
+
+        var match = item.attr('viewBox').value.match(regViewBox);
+
+        if (match) {
+            if (
+                item.attr('width').value === match[1] &&
+                item.attr('height').value === match[3]
+            ) {
+                item.removeAttr('viewBox');
+            }
+        }
+
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeXMLNS.js

@@ -0,0 +1,28 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'removes xmlns attribute (for inline svg, disabled by default)';
+
+/**
+ * Remove the xmlns attribute when present.
+ *
+ * @example
+ * <svg viewBox="0 0 100 50" xmlns="http://www.w3.org/2000/svg">
+ *   ↓
+ * <svg viewBox="0 0 100 50">
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if true, xmlns will be filtered out
+ *
+ * @author Ricardo Tomasi
+ */
+exports.fn = function(item) {
+
+    if (item.isElem('svg') && item.hasAttr('xmlns')) {
+        item.removeAttr('xmlns');
+    }
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/removeXMLProcInst.js

@@ -0,0 +1,24 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = true;
+
+exports.description = 'removes XML processing instructions';
+
+/**
+ * Remove XML Processing Instruction.
+ *
+ * @example
+ * <?xml version="1.0" encoding="utf-8"?>
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function(item) {
+
+    return !(item.processinginstruction && item.processinginstruction.name === 'xml');
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/sortAttrs.js

@@ -0,0 +1,81 @@
+'use strict';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'sorts element attributes (disabled by default)';
+
+exports.params = {
+	order: [
+		'id',
+		'width', 'height',
+		'x', 'x1', 'x2',
+		'y', 'y1', 'y2',
+		'cx', 'cy', 'r',
+		'fill', 'stroke', 'marker',
+		'd', 'points'
+	]
+};
+
+/**
+ * Sort element attributes for epic readability.
+ *
+ * @param {Object} item current iteration item
+ * @param {Object} params plugin params
+ *
+ * @author Nikolay Frantsev
+ */
+exports.fn = function(item, params) {
+
+	var attrs = [],
+		sorted = {},
+		orderlen = params.order.length + 1;
+
+	if (item.elem) {
+
+		item.eachAttr(function(attr) {
+			attrs.push(attr);
+		});
+
+		attrs.sort(function(a, b) {
+			if (a.prefix != b.prefix) {
+				// xmlns attributes implicitly have the prefix xmlns
+				if (a.prefix == 'xmlns')
+					return -1;
+				if (b.prefix == 'xmlns')
+					return 1;
+				return a.prefix < b.prefix ? -1 : 1;
+			}
+
+			var aindex = orderlen;
+			var bindex = orderlen;
+
+			for (var i = 0; i < params.order.length; i++) {
+				if (a.name == params.order[i]) {
+					aindex = i;
+				} else if (a.name.indexOf(params.order[i] + '-') === 0) {
+					aindex = i + .5;
+				}
+				if (b.name == params.order[i]) {
+					bindex = i;
+				} else if (b.name.indexOf(params.order[i] + '-') === 0) {
+					bindex = i + .5;
+				}
+			}
+
+			if (aindex != bindex) {
+				return aindex - bindex;
+			}
+			return a.name < b.name ? -1 : 1;
+		});
+
+		attrs.forEach(function (attr) {
+			sorted[attr.name] = attr;
+		});
+
+		item.attrs = sorted;
+
+	}
+
+};

goTorrentWebUI/node_modules/css-loader/node_modules/svgo/plugins/transformsWithOnePath.js

@@ -0,0 +1,327 @@
+'use strict';
+
+/*
+ * Thanks to http://fontello.com project for sponsoring this plugin
+ */
+
+exports.type = 'full';
+
+exports.active = false;
+
+exports.description = 'performs a set of operations on SVG with one path inside (disabled by default)';
+
+exports.params = {
+    // width and height to resize SVG and rescale inner Path
+    width: false,
+    height: false,
+
+    // scale inner Path without resizing SVG
+    scale: false,
+
+    // shiftX/Y inner Path
+    shiftX: false,
+    shiftY: false,
+
+    // crop SVG width along the real width of inner Path
+    hcrop: false,
+
+    // vertical center inner Path inside SVG height
+    vcenter: false,
+
+    // stringify params
+    floatPrecision: 3,
+    leadingZero: true,
+    negativeExtraSpace: true
+};
+
+var _path = require('./_path.js'),
+    relative2absolute = _path.relative2absolute,
+    computeCubicBoundingBox = _path.computeCubicBoundingBox,
+    computeQuadraticBoundingBox = _path.computeQuadraticBoundingBox,
+    applyTransforms = _path.applyTransforms,
+    js2path = _path.js2path,
+    path2js = _path.path2js,
+    EXTEND = require('whet.extend');
+
+exports.fn = function(data, params) {
+
+    data.content.forEach(function(item) {
+
+        // only for SVG with one Path inside
+        if (item.isElem('svg') &&
+            item.content.length === 1 &&
+            item.content[0].isElem('path')
+        ) {
+
+            var svgElem = item,
+                pathElem = svgElem.content[0],
+                // get absoluted Path data
+                path = relative2absolute(EXTEND(true, [], path2js(pathElem))),
+                xs = [],
+                ys = [],
+                cubicСontrolPoint = [0, 0],
+                quadraticСontrolPoint = [0, 0],
+                lastPoint = [0, 0],
+                cubicBoundingBox,
+                quadraticBoundingBox,
+                i,
+                segment;
+
+            path.forEach(function(pathItem) {
+
+                // ML
+                if ('ML'.indexOf(pathItem.instruction) > -1) {
+
+                    for (i = 0; i < pathItem.data.length; i++) {
+                        if (i % 2 === 0) {
+                            xs.push(pathItem.data[i]);
+                        } else {
+                            ys.push(pathItem.data[i]);
+                        }
+                    }
+
+                    lastPoint = cubicСontrolPoint = quadraticСontrolPoint = pathItem.data.slice(-2);
+
+                // H
+                } else if (pathItem.instruction === 'H') {
+
+                    pathItem.data.forEach(function(d) {
+                        xs.push(d);
+                    });
+
+                    lastPoint[0] = cubicСontrolPoint[0] = quadraticСontrolPoint[0] = pathItem.data[pathItem.data.length - 2];
+
+                // V
+                } else if (pathItem.instruction === 'V') {
+
+                    pathItem.data.forEach(function(d) {
+                        ys.push(d);
+                    });
+
+                    lastPoint[1] = cubicСontrolPoint[1] = quadraticСontrolPoint[1] = pathItem.data[pathItem.data.length - 1];
+
+                // C
+                } else if (pathItem.instruction === 'C') {
+
+                    for (i = 0; i < pathItem.data.length; i += 6) {
+
+                        segment = pathItem.data.slice(i, i + 6);
+
+                        cubicBoundingBox = computeCubicBoundingBox.apply(this, lastPoint.concat(segment));
+
+                        xs.push(cubicBoundingBox.minx);
+                        xs.push(cubicBoundingBox.maxx);
+
+                        ys.push(cubicBoundingBox.miny);
+                        ys.push(cubicBoundingBox.maxy);
+
+                        // reflected control point for the next possible S
+                        cubicСontrolPoint = [
+                            2 * segment[4] - segment[2],
+                            2 * segment[5] - segment[3]
+                        ];
+
+                        lastPoint = segment.slice(-2);
+
+                    }
+
+                // S
+                } else if (pathItem.instruction === 'S') {
+
+                    for (i = 0; i < pathItem.data.length; i += 4) {
+
+                        segment = pathItem.data.slice(i, i + 4);
+
+                        cubicBoundingBox = computeCubicBoundingBox.apply(this, lastPoint.concat(cubicСontrolPoint).concat(segment));
+
+                        xs.push(cubicBoundingBox.minx);
+                        xs.push(cubicBoundingBox.maxx);
+
+                        ys.push(cubicBoundingBox.miny);
+                        ys.push(cubicBoundingBox.maxy);
+
+                        // reflected control point for the next possible S
+                        cubicСontrolPoint = [
+                            2 * segment[2] - cubicСontrolPoint[0],
+                            2 * segment[3] - cubicСontrolPoint[1],
+                        ];
+
+                        lastPoint = segment.slice(-2);
+
+                    }
+
+                // Q
+                } else if (pathItem.instruction === 'Q') {
+
+                    for (i = 0; i < pathItem.data.length; i += 4) {
+
+                        segment = pathItem.data.slice(i, i + 4);
+
+                        quadraticBoundingBox = computeQuadraticBoundingBox.apply(this, lastPoint.concat(segment));
+
+                        xs.push(quadraticBoundingBox.minx);
+                        xs.push(quadraticBoundingBox.maxx);
+
+                        ys.push(quadraticBoundingBox.miny);
+                        ys.push(quadraticBoundingBox.maxy);
+
+                        // reflected control point for the next possible T
+                        quadraticСontrolPoint = [
+                            2 * segment[2] - segment[0],
+                            2 * segment[3] - segment[1]
+                        ];
+
+                        lastPoint = segment.slice(-2);
+
+                    }
+
+                // S
+                } else if (pathItem.instruction === 'T') {
+
+                    for (i = 0; i < pathItem.data.length; i += 2) {
+
+                        segment = pathItem.data.slice(i, i + 2);
+
+                        quadraticBoundingBox = computeQuadraticBoundingBox.apply(this, lastPoint.concat(quadraticСontrolPoint).concat(segment));
+
+                        xs.push(quadraticBoundingBox.minx);
+                        xs.push(quadraticBoundingBox.maxx);
+
+                        ys.push(quadraticBoundingBox.miny);
+                        ys.push(quadraticBoundingBox.maxy);
+
+                        // reflected control point for the next possible T
+                        quadraticСontrolPoint = [
+                            2 * segment[0] - quadraticСontrolPoint[0],
+                            2 * segment[1] - quadraticСontrolPoint[1]
+                        ];
+
+                        lastPoint = segment.slice(-2);
+
+                    }
+
+                }
+
+            });
+
+            var xmin = Math.min.apply(this, xs).toFixed(params.floatPrecision),
+                xmax = Math.max.apply(this, xs).toFixed(params.floatPrecision),
+                ymin = Math.min.apply(this, ys).toFixed(params.floatPrecision),
+                ymax = Math.max.apply(this, ys).toFixed(params.floatPrecision),
+                svgWidth = +svgElem.attr('width').value,
+                svgHeight = +svgElem.attr('height').value,
+                realWidth = Math.round(xmax - xmin),
+                realHeight = Math.round(ymax - ymin),
+                transform = '',
+                scale;
+
+            // width & height
+            if (params.width && params.height) {
+
+                scale = Math.min(params.width / svgWidth, params.height / svgHeight);
+
+                realWidth = realWidth * scale;
+                realHeight = realHeight * scale;
+
+                svgWidth = svgElem.attr('width').value = params.width;
+                svgHeight = svgElem.attr('height').value = params.height;
+
+                transform += ' scale(' + scale + ')';
+
+            // width
+            } else if (params.width && !params.height) {
+
+                scale = params.width / svgWidth;
+
+                realWidth = realWidth * scale;
+                realHeight = realHeight * scale;
+
+                svgWidth = svgElem.attr('width').value = params.width;
+                svgHeight = svgElem.attr('height').value = svgHeight * scale;
+
+                transform += ' scale(' + scale + ')';
+
+            // height
+            } else if (params.height && !params.width) {
+
+                scale = params.height / svgHeight;
+
+                realWidth = realWidth * scale;
+                realHeight = realHeight * scale;
+
+                svgWidth = svgElem.attr('width').value = svgWidth * scale;
+                svgHeight = svgElem.attr('height').value = params.height;
+
+                transform += ' scale(' + scale + ')';
+
+            }
+
+            // shiftX
+            if (params.shiftX) {
+                transform += ' translate(' + realWidth * params.shiftX + ', 0)';
+            }
+
+            // shiftY
+            if (params.shiftY) {
+                transform += ' translate(0, ' + realHeight * params.shiftY + ')';
+            }
+
+            // scale
+            if (params.scale) {
+                scale = params.scale;
+
+                var shiftX = svgWidth / 2,
+                    shiftY = svgHeight / 2;
+
+                realWidth = realWidth * scale;
+                realHeight = realHeight * scale;
+
+                if (params.shiftX || params.shiftY) {
+                    transform += ' scale(' + scale + ')';
+                } else {
+                    transform += ' translate(' + shiftX + ' ' + shiftY + ') scale(' + scale + ') translate(-' + shiftX + ' -' + shiftY + ')';
+                }
+            }
+
+            // hcrop
+            if (params.hcrop) {
+                transform += ' translate(' + (-xmin) + ' 0)';
+
+                svgElem.attr('width').value = realWidth;
+            }
+
+            // vcenter
+            if (params.vcenter) {
+                transform += ' translate(0 ' + (((svgHeight - realHeight) / 2) - ymin) + ')';
+            }
+
+            if (transform) {
+                pathElem.addAttr({
+                    name: 'transform',
+                    prefix: '',
+                    local: 'transform',
+                    value: transform
+                });
+
+                path = applyTransforms(pathElem, pathElem.pathJS, true, params.floatPrecision);
+
+                // transformed data rounding
+                path.forEach(function(pathItem) {
+                    if (pathItem.data) {
+                        pathItem.data = pathItem.data.map(function(num) {
+                            return +num.toFixed(params.floatPrecision);
+                        });
+                    }
+                });
+
+                // save new
+                js2path(pathElem, path, params);
+            }
+
+        }
+
+    });
+
+    return data;
+
+};