Last commit july 5th

spa/node_modules/node-sass/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013-2016 Andrew Nesbitt
+
+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.

spa/node_modules/node-sass/README.md

@@ -0,0 +1,653 @@
+# node-sass
+
+**Warning:** [LibSass and Node Sass are deprecated](https://sass-lang.com/blog/libsass-is-deprecated).
+While they will continue to receive maintenance releases indefinitely, there are no
+plans to add additional features or compatibility with any new CSS or Sass features.
+Projects that still use it should move onto
+[Dart Sass](https://sass-lang.com/dart-sass).
+
+## Node version support policy
+
+1. Supported Node.js versions vary by release, please consult the [releases page](https://github.com/sass/node-sass/releases).
+1. Node versions that hit end of life <https://github.com/nodejs/Release>, will be dropped from support at each node-sass release (major, minor).
+1. We will stop building binaries for unsupported releases, testing for breakages in dependency compatibility, but we will not block installations for those that want to support themselves.
+1. New node release require minor internal changes along with support from CI providers (AppVeyor, GitHub Actions). We will open a single issue for interested parties to subscribe to, and close additional issues.
+
+Below is a quick guide for minimum and maximum supported versions of node-sass:
+
+NodeJS  | Supported node-sass version | Node Module
+--------|-----------------------------|------------
+Node 20 | 9.0+                        | 115
+Node 19 | 8.0+                        | 111
+Node 18 | 8.0+                        | 108
+Node 17 | 7.0+, <8.0                  | 102
+Node 16 | 6.0+                        | 93
+Node 15 | 5.0+, <7.0                  | 88
+Node 14 | 4.14+, <9.0                 | 83
+Node 13 | 4.13+, <5.0                 | 79
+Node 12 | 4.12+, <8.0                 | 72
+Node 11 | 4.10+, <5.0                 | 67
+Node 10 | 4.9+, <6.0                  | 64
+Node 8  | 4.5.3+, <5.0                | 57
+Node <8 | <5.0                        | <57
+
+<table>
+  <tr>
+    <td>
+      <img width="77px" alt="Sass logo" src="https://rawgit.com/sass/node-sass/master/media/logo.svg" />
+    </td>
+    <td valign="bottom" align="right">
+      <a href="https://www.npmjs.com/package/node-sass">
+        <img width="100%" src="https://nodei.co/npm/node-sass.png?downloads=true&downloadRank=true&stars=true">
+      </a>
+    </td>
+  </tr>
+</table>
+
+![Alpine](https://github.com/sass/node-sass/workflows/Build%20bindings%20for%20Alpine%20releases/badge.svg)
+![Linux](https://github.com/sass/node-sass/workflows/Build%20bindings%20for%20Linux%20releases/badge.svg)
+![macOS](https://github.com/sass/node-sass/workflows/Build%20bindings%20for%20macOS%20releases/badge.svg)
+![Windows x64](https://github.com/sass/node-sass/workflows/Build%20bindings%20for%20Windows%20releases/badge.svg)
+![Linting](https://github.com/sass/node-sass/workflows/Lint%20JS/badge.svg)
+[![Windows x86](https://ci.appveyor.com/api/projects/status/22mjbk59kvd55m9y/branch/master?svg=true)](https://ci.appveyor.com/project/sass/node-sass/branch/master)
+[![Coverage Status](https://coveralls.io/repos/sass/node-sass/badge.svg?branch=master)](https://coveralls.io/r/sass/node-sass?branch=master)
+
+Node-sass is a library that provides binding for Node.js to [LibSass], the C version of the popular stylesheet preprocessor, Sass.
+
+It allows you to natively compile .scss files to css at incredible speed and automatically via a connect middleware.
+
+Find it on npm: <https://www.npmjs.com/package/node-sass>
+
+Follow @nodesass on twitter for release updates: <https://twitter.com/nodesass>
+
+## Install
+
+```shell
+npm install node-sass
+```
+
+Some users have reported issues installing on Ubuntu due to `node` being registered to another package. [Follow the official NodeJS docs](https://github.com/nodesource/distributions/blob/master/README.md#debinstall) to install NodeJS so that `#!/usr/bin/env node` correctly resolves.
+
+Compiling on Windows machines requires the [node-gyp prerequisites](https://github.com/nodejs/node-gyp#on-windows).
+
+Are you seeing the following error? Check out our [Troubleshooting guide](https://github.com/sass/node-sass/blob/master/TROUBLESHOOTING.md#installing-node-sass-4x-with-node--4).**
+
+```
+SyntaxError: Use of const in strict mode.
+```
+
+**Having installation troubles? Check out our [Troubleshooting guide](https://github.com/sass/node-sass/blob/master/TROUBLESHOOTING.md).**
+
+### Install from mirror in China
+
+```shell
+npm install -g mirror-config-china --registry=https://registry.npmmirror.com
+npm install node-sass
+```
+
+## Usage
+
+```javascript
+var sass = require('node-sass');
+sass.render({
+  file: scss_filename,
+  [, options..]
+}, function(err, result) { /*...*/ });
+// OR
+var result = sass.renderSync({
+  data: scss_content
+  [, options..]
+});
+```
+
+## Options
+
+### file
+
+* Type: `String`
+* Default: `null`
+
+**Special**: `file` or `data` must be specified
+
+Path to a file for [LibSass] to compile.
+
+### data
+
+* Type: `String`
+* Default: `null`
+
+**Special**: `file` or `data` must be specified
+
+A string to pass to [LibSass] to compile. It is recommended that you use `includePaths` in conjunction with this so that [LibSass] can find files when using the `@import` directive.
+
+### importer (>= v2.0.0) - _experimental_
+
+**This is an experimental LibSass feature. Use with caution.**
+
+* Type: `Function | Function[]` signature `function(url, prev, done)`
+* Default: `undefined`
+
+Function Parameters and Information:
+
+* `url (String)` - the path in import **as-is**, which [LibSass] encountered
+* `prev (String)` - the previously resolved path
+* `done (Function)` - a callback function to invoke on async completion, takes an object literal containing
+  * `file (String)` - an alternate path for [LibSass] to use **OR**
+  * `contents (String)` - the imported contents (for example, read from memory or the file system)
+
+Handles when [LibSass] encounters the `@import` directive. A custom importer allows extension of the [LibSass] engine in both a synchronous and asynchronous manner. In both cases, the goal is to either `return` or call `done()` with an object literal. Depending on the value of the object literal, one of two things will happen.
+
+When returning or calling `done()` with `{ file: "String" }`, the new file path will be assumed for the `@import`. It's recommended to be mindful of the value of `prev` in instances where relative path resolution may be required.
+
+When returning or calling `done()` with `{ contents: "String" }`, the string value will be used as if the file was read in through an external source.
+
+Starting from v3.0.0:
+
+* `this` refers to a contextual scope for the immediate run of `sass.render` or `sass.renderSync`
+
+* importers can return error and LibSass will emit that error in response. For instance:
+
+  ```javascript
+  done(new Error('doesn\'t exist!'));
+  // or return synchronously
+  return new Error('nothing to do here');
+  ```
+
+* importer can be an array of functions, which will be called by LibSass in the order of their occurrence in array. This helps user specify special importer for particular kind of path (filesystem, http). If an importer does not want to handle a particular path, it should return `null`. See [functions section](#functions--v300---experimental) for more details on Sass types.
+
+### functions (>= v3.0.0) - _experimental_
+
+**This is an experimental LibSass feature. Use with caution.**
+
+`functions` is an `Object` that holds a collection of custom functions that may be invoked by the sass files being compiled. They may take zero or more input parameters and must return a value either synchronously (`return ...;`) or asynchronously (`done();`). Those parameters will be instances of one of the constructors contained in the `require('node-sass').types` hash. The return value must be of one of these types as well. See the list of available types below:
+
+#### types.Number(value [, unit = ""])
+
+* `getValue()`/ `setValue(value)` : gets / sets the numerical portion of the number
+* `getUnit()` / `setUnit(unit)` : gets / sets the unit portion of the number
+
+#### types.String(value)
+
+* `getValue()` / `setValue(value)` : gets / sets the enclosed string
+
+#### types.Color(r, g, b [, a = 1.0]) or types.Color(argb)
+
+* `getR()` / `setR(value)` : red component (integer from `0` to `255`)
+* `getG()` / `setG(value)` : green component (integer from `0` to `255`)
+* `getB()` / `setB(value)` : blue component (integer from `0` to `255`)
+* `getA()` / `setA(value)` : alpha component (number from `0` to `1.0`)
+
+Example:
+
+```javascript
+var Color = require('node-sass').types.Color,
+  c1 = new Color(255, 0, 0),
+  c2 = new Color(0xff0088cc);
+```
+
+#### types.Boolean(value)
+
+* `getValue()` : gets the enclosed boolean
+* `types.Boolean.TRUE` : Singleton instance of `types.Boolean` that holds "true"
+* `types.Boolean.FALSE` : Singleton instance of `types.Boolean` that holds "false"
+
+#### types.List(length [, commaSeparator = true])
+
+* `getValue(index)` / `setValue(index, value)` : `value` must itself be an instance of one of the constructors in `sass.types`.
+* `getSeparator()` / `setSeparator(isComma)` : whether to use commas as a separator
+* `getLength()`
+
+#### types.Map(length)
+
+* `getKey(index)` / `setKey(index, value)`
+* `getValue(index)` / `setValue(index, value)`
+* `getLength()`
+
+#### types.Null()
+
+* `types.Null.NULL` : Singleton instance of `types.Null`.
+
+#### Example
+
+```javascript
+sass.renderSync({
+  data: '#{headings(2,5)} { color: #08c; }',
+  functions: {
+    'headings($from: 0, $to: 6)': function(from, to) {
+      var i, f = from.getValue(), t = to.getValue(),
+          list = new sass.types.List(t - f + 1);
+
+      for (i = f; i <= t; i++) {
+        list.setValue(i - f, new sass.types.String('h' + i));
+      }
+
+      return list;
+    }
+  }
+});
+```
+
+### includePaths
+
+* Type: `Array<String>`
+* Default: `[]`
+
+An array of paths that [LibSass] can look in to attempt to resolve your `@import` declarations. When using `data`, it is recommended that you use this.
+
+### indentedSyntax
+
+* Type: `Boolean`
+* Default: `false`
+
+`true` values enable [Sass Indented Syntax](https://sass-lang.com/documentation/file.INDENTED_SYNTAX.html) for parsing the data string or file.
+
+__Note:__ node-sass/libsass will compile a mixed library of scss and indented syntax (.sass) files with the Default setting (false) as long as .sass and .scss extensions are used in filenames.
+
+### indentType (>= v3.0.0)
+
+* Type: `String`
+* Default: `space`
+
+Used to determine whether to use space or tab character for indentation.
+
+### indentWidth (>= v3.0.0)
+
+* Type: `Number`
+* Default: `2`
+* Maximum: `10`
+
+Used to determine the number of spaces or tabs to be used for indentation.
+
+### linefeed (>= v3.0.0)
+
+* Type: `String`
+* Default: `lf`
+
+Used to determine whether to use `cr`, `crlf`, `lf` or `lfcr` sequence for line break.
+
+### omitSourceMapUrl
+
+* Type: `Boolean`
+* Default: `false`
+
+**Special:** When using this, you should also specify `outFile` to avoid unexpected behavior.
+
+`true` values disable the inclusion of source map information in the output file.
+
+### outFile
+
+* Type: `String | null`
+* Default: `null`
+
+**Special:** Required when `sourceMap` is a truthy value
+
+Specify the intended location of the output file. Strongly recommended when outputting source maps so that they can properly refer back to their intended files.
+
+**Attention** enabling this option will **not** write the file on disk for you, it's for internal reference purpose only (to generate the map for example).
+
+Example on how to write it on the disk
+
+```javascript
+sass.render({
+    ...
+    outFile: yourPathTotheFile,
+  }, function(error, result) { // node-style callback from v3.0.0 onwards
+    if(!error){
+      // No errors during the compilation, write this result on the disk
+      fs.writeFile(yourPathTotheFile, result.css, function(err){
+        if(!err){
+          //file written on disk
+        }
+      });
+    }
+  });
+});
+```
+
+### outputStyle
+
+* Type: `String`
+* Default: `nested`
+* Values: `nested`, `expanded`, `compact`, `compressed`
+
+Determines the output format of the final CSS style.
+
+### precision
+
+* Type: `Integer`
+* Default: `5`
+
+Used to determine how many digits after the decimal will be allowed. For instance, if you had a decimal number of `1.23456789` and a precision of `5`, the result will be `1.23457` in the final CSS.
+
+### sourceComments
+
+* Type: `Boolean`
+* Default: `false`
+
+`true` Enables the line number and file where a selector is defined to be emitted into the compiled CSS as a comment. Useful for debugging, especially when using imports and mixins.
+
+### sourceMap
+
+* Type: `Boolean | String | undefined`
+* Default: `undefined`
+
+Enables source map generation during `render` and `renderSync`.
+
+When `sourceMap === true`, the value of `outFile` is used as the target output location for the source map with the suffix `.map` appended. If no `outFile` is set, `sourceMap` parameter is ignored.
+
+When `typeof sourceMap === "string"`, the value of `sourceMap` will be used as the writing location for the file.
+
+### sourceMapContents
+
+* Type: `Boolean`
+* Default: `false`
+
+`true` includes the `contents` in the source map information
+
+### sourceMapEmbed
+
+* Type: `Boolean`
+* Default: `false`
+
+`true` embeds the source map as a data URI
+
+### sourceMapRoot
+
+* Type: `String`
+* Default: `undefined`
+
+the value will be emitted as `sourceRoot` in the source map information
+
+## `render` Callback (>= v3.0.0)
+
+node-sass supports standard node style asynchronous callbacks with the signature of `function(err, result)`. In error conditions, the `error` argument is populated with the error object. In success conditions, the `result` object is populated with an object describing the result of the render call.
+
+### Error Object
+
+* `message` (String) - The error message.
+* `line` (Number) - The line number of error.
+* `column` (Number) - The column number of error.
+* `status` (Number) - The status code.
+* `file` (String) - The filename of error. In case `file` option was not set (in favour of `data`), this will reflect the value `stdin`.
+
+### Result Object
+
+* `css` (Buffer) - The compiled CSS. Write this to a file, or serve it out as needed.
+* `map` (Buffer) - The source map
+* `stats` (Object) - An object containing information about the compile. It contains the following keys:
+  * `entry` (String) - The path to the scss file, or `data` if the source was not a file
+  * `start` (Number) - Date.now() before the compilation
+  * `end` (Number) - Date.now() after the compilation
+  * `duration` (Number) - *end* - *start*
+  * `includedFiles` (Array) - Absolute paths to all related scss files in no particular order.
+
+### Examples
+
+```javascript
+var sass = require('node-sass');
+sass.render({
+  file: '/path/to/myFile.scss',
+  data: 'body{background:blue; a{color:black;}}',
+  importer: function(url, prev, done) {
+    // url is the path in import as is, which LibSass encountered.
+    // prev is the previously resolved path.
+    // done is an optional callback, either consume it or return value synchronously.
+    // this.options contains this options hash, this.callback contains the node-style callback
+    someAsyncFunction(url, prev, function(result){
+      done({
+        file: result.path, // only one of them is required, see section Special Behaviours.
+        contents: result.data
+      });
+    });
+    // OR
+    var result = someSyncFunction(url, prev);
+    return {file: result.path, contents: result.data};
+  },
+  includePaths: [ 'lib/', 'mod/' ],
+  outputStyle: 'compressed'
+}, function(error, result) { // node-style callback from v3.0.0 onwards
+  if (error) {
+    console.log(error.status); // used to be "code" in v2x and below
+    console.log(error.column);
+    console.log(error.message);
+    console.log(error.line);
+  }
+  else {
+    console.log(result.css.toString());
+
+    console.log(result.stats);
+
+    console.log(result.map.toString());
+    // or better
+    console.log(JSON.stringify(result.map)); // note, JSON.stringify accepts Buffer too
+  }
+});
+// OR
+var result = sass.renderSync({
+  file: '/path/to/file.scss',
+  data: 'body{background:blue; a{color:black;}}',
+  outputStyle: 'compressed',
+  outFile: '/to/my/output.css',
+  sourceMap: true, // or an absolute or relative (to outFile) path
+  importer: function(url, prev, done) {
+    // url is the path in import as is, which LibSass encountered.
+    // prev is the previously resolved path.
+    // done is an optional callback, either consume it or return value synchronously.
+    // this.options contains this options hash
+    someAsyncFunction(url, prev, function(result){
+      done({
+        file: result.path, // only one of them is required, see section Special Behaviours.
+        contents: result.data
+      });
+    });
+    // OR
+    var result = someSyncFunction(url, prev);
+    return {file: result.path, contents: result.data};
+  }
+});
+
+console.log(result.css);
+console.log(result.map);
+console.log(result.stats);
+```
+
+### Special behaviours
+
+* In the case that both `file` and `data` options are set, node-sass will give precedence to `data` and use `file` to calculate paths in sourcemaps.
+
+### Version information (>= v2.0.0)
+
+Both `node-sass` and `libsass` version info is now exposed via the `info` method:
+
+```javascript
+var sass = require('node-sass');
+
+console.log(sass.info);
+
+/*
+  it will output something like:
+
+  node-sass       2.0.1   (Wrapper)       [JavaScript]
+  libsass         3.1.0   (Sass Compiler) [C/C++]
+*/
+```
+
+Since node-sass >=v3.0.0 LibSass version is determined at run time.
+
+## Integrations
+
+Listing of community uses of node-sass in build tools and frameworks.
+
+### Brackets extension
+
+[@jasonsanjose](https://github.com/jasonsanjose) has created a [Brackets](http://brackets.io) extension based on node-sass: <https://github.com/jasonsanjose/brackets-sass>. When editing Sass files, the extension compiles changes on save. The extension also integrates with Live Preview to show Sass changes in the browser without saving or compiling.
+
+### Brunch plugin
+
+[Brunch](http://brunch.io)'s official sass plugin uses node-sass by default, and automatically falls back to ruby if use of Compass is detected: <https://github.com/brunch/sass-brunch>
+
+### Connect/Express middleware
+
+Recompile `.scss` files automatically for connect and express based http servers.
+
+This functionality has been moved to [`node-sass-middleware`](https://github.com/sass/node-sass-middleware) in node-sass v1.0.0
+
+### DocPad Plugin
+
+[@10xLaCroixDrinker](https://github.com/10xLaCroixDrinker) wrote a [DocPad](http://docpad.org/) plugin that compiles `.scss` files using node-sass: <https://github.com/docpad/docpad-plugin-nodesass>
+
+### Duo.js extension
+
+[@stephenway](https://github.com/stephenway) has created an extension that transpiles Sass to CSS using node-sass with [duo.js](http://duojs.org/)
+<https://github.com/duojs/sass>
+
+### Grunt extension
+
+[@sindresorhus](https://github.com/sindresorhus/) has created a set of grunt tasks based on node-sass: <https://github.com/sindresorhus/grunt-sass>
+
+### Gulp extension
+
+[@dlmanning](https://github.com/dlmanning/) has created a gulp sass plugin based on node-sass: <https://github.com/dlmanning/gulp-sass>
+
+### Harp
+
+[@sintaxi](https://github.com/sintaxi)’s Harp web server implicitly compiles `.scss` files using node-sass: <https://github.com/sintaxi/harp>
+
+### Metalsmith plugin
+
+[@stevenschobert](https://github.com/stevenschobert/) has created a metalsmith plugin based on node-sass: <https://github.com/stevenschobert/metalsmith-sass>
+
+### Meteor plugin
+
+[@fourseven](https://github.com/fourseven) has created a meteor plugin based on node-sass: <https://github.com/fourseven/meteor-scss>
+
+### Mimosa module
+
+[@dbashford](https://github.com/dbashford) has created a Mimosa module for sass which includes node-sass: <https://github.com/dbashford/mimosa-sass>
+
+## Example App
+
+There is also an example connect app here: <https://github.com/andrew/node-sass-example>
+
+## Rebuilding binaries
+
+Node-sass includes pre-compiled binaries for popular platforms, to add a binary for your platform follow these steps:
+
+Check out the project:
+
+```bash
+git clone --recursive https://github.com/sass/node-sass.git
+cd node-sass
+npm install
+node scripts/build -f  # use -d switch for debug release
+# if succeeded, it will generate and move
+# the binary in vendor directory.
+```
+
+## Command Line Interface
+
+The interface for command-line usage is fairly simplistic at this stage, as seen in the following usage section.
+
+Output will be sent to stdout if the `--output` flag is omitted.
+
+### Usage
+
+ `node-sass [options] <input> [output]`
+ Or:
+ `cat <input> | node-sass > output`
+
+Example:
+
+`node-sass src/style.scss dest/style.css`
+
+ **Options:**
+
+```bash
+    -w, --watch                Watch a directory or file
+    -r, --recursive            Recursively watch directories or files
+    -o, --output               Output directory
+    -x, --omit-source-map-url  Omit source map URL comment from output
+    -i, --indented-syntax      Treat data from stdin as sass code (versus scss)
+    -q, --quiet                Suppress log output except on error
+    -v, --version              Prints version info
+    --output-style             CSS output style (nested | expanded | compact | compressed)
+    --indent-type              Indent type for output CSS (space | tab)
+    --indent-width             Indent width; number of spaces or tabs (maximum value: 10)
+    --linefeed                 Linefeed style (cr | crlf | lf | lfcr)
+    --source-comments          Include debug info in output
+    --source-map               Emit source map
+    --source-map-contents      Embed include contents in map
+    --source-map-embed         Embed sourceMappingUrl as data URI
+    --source-map-root          Base path, will be emitted in source-map as is
+    --include-path             Path to look for imported files
+    --follow                   Follow symlinked directories
+    --precision                The amount of precision allowed in decimal numbers
+    --error-bell               Output a bell character on errors
+    --importer                 Path to .js file containing custom importer
+    --functions                Path to .js file containing custom functions
+    --help                     Print usage info
+```
+
+The `input` can be either a single `.scss` or `.sass`, or a directory. If the input is a directory the `--output` flag must also be supplied.
+
+Also, note `--importer` takes the (absolute or relative to pwd) path to a js file, which needs to have a default `module.exports` set to the importer function. See our test [fixtures](https://github.com/sass/node-sass/tree/974f93e76ddd08ea850e3e663cfe64bb6a059dd3/test/fixtures/extras) for example.
+
+The `--source-map` option accepts a boolean value, in which case it replaces destination extension with `.css.map`. It also accepts path to `.map` file and even path to the desired directory.
+When compiling a directory `--source-map` can either be a boolean value or a directory.
+
+## Binary configuration parameters
+
+node-sass supports different configuration parameters to change settings related to the sass binary such as binary name, binary path or alternative download path. Following parameters are supported by node-sass:
+
+Variable name            | .npmrc parameter         | Process argument           | Value
+-------------------------|--------------------------|----------------------------|------
+SASS_BINARY_NAME         | sass_binary_name         | --sass-binary-name         | path
+SASS_BINARY_SITE         | sass_binary_site         | --sass-binary-site         | URL
+SASS_BINARY_PATH         | sass_binary_path         | --sass-binary-path         | path
+SASS_BINARY_DIR          | sass_binary_dir          | --sass-binary-dir          | path
+SASS_REJECT_UNAUTHORIZED | sass_reject_unauthorized | --sass-reject-unauthorized | value
+
+These parameters can be used as environment variable:
+
+* E.g. `export SASS_BINARY_SITE=http://example.com/`
+
+As local or global [.npmrc](https://docs.npmjs.com/misc/config) configuration file:
+
+* E.g. `sass_binary_site=http://example.com/`
+
+As a process argument:
+
+* E.g. `npm install node-sass --sass-binary-site=http://example.com/`
+
+If you are using self-signed certificates for your binary then `SASS_REJECT_UNAUTHORIZED` will override (rejectUnauthorized)[https://nodejs.org/docs/latest/api/tls.html#tls_tls_createserver_options_secureconnectionlistener].
+
+## Post-install Build
+
+Install runs only two Mocha tests to see if your machine can use the pre-built [LibSass] which will save some time during install. If any tests fail it will build from source.
+
+## Maintainers
+
+This module is brought to you and maintained by the following people:
+
+* Michael Mifsud - Project Lead ([Github](https://github.com/xzyfer) / [Twitter](https://twitter.com/xzyfer))
+* Andrew Nesbitt ([Github](https://github.com/andrew) / [Twitter](https://twitter.com/teabass))
+* Dean Mao ([Github](https://github.com/deanmao) / [Twitter](https://twitter.com/deanmao))
+* Brett Wilkins ([Github](https://github.com/bwilkins) / [Twitter](https://twitter.com/bjmaz))
+* Keith Cirkel ([Github](https://github.com/keithamus) / [Twitter](https://twitter.com/Keithamus))
+* Laurent Goderre ([Github](https://github.com/laurentgoderre) / [Twitter](https://twitter.com/laurentgoderre))
+* Nick Schonning ([Github](https://github.com/nschonni) / [Twitter](https://twitter.com/nschonni))
+* Adeel Mujahid ([Github](https://github.com/am11) / [Twitter](https://twitter.com/adeelbm))
+
+## Contributors
+
+We <3 our contributors! A special thanks to all those who have clocked in some dev time on this project, we really appreciate your hard work. You can find [a full list of those people here.](https://github.com/sass/node-sass/graphs/contributors)
+
+### Note on Patches/Pull Requests
+
+Check out our [Contributing guide](/.github/CONTRIBUTING.md)
+
+## Copyright
+
+Copyright (c) 2015 Andrew Nesbitt. See [LICENSE](https://github.com/sass/node-sass/blob/master/LICENSE) for details.
+
+[LibSass]: https://github.com/sass/libsass

spa/node_modules/node-sass/bin/node-sass

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+
+var Emitter = require('events').EventEmitter,
+  forEach = require('async-foreach').forEach,
+  Gaze = require('gaze'),
+  meow = require('meow'),
+  util = require('util'),
+  path = require('path'),
+  glob = require('glob'),
+  sass = require('../lib'),
+  render = require('../lib/render'),
+  watcher = require('../lib/watcher'),
+  stdout = require('stdout-stream'),
+  stdin = require('get-stdin'),
+  fs = require('fs');
+
+/**
+ * Initialize CLI
+ */
+
+var cli = meow(`
+    Usage:
+      node-sass [options] <input.scss>
+      cat <input.scss> | node-sass [options] > output.css
+
+    Example: Compile foobar.scss to foobar.css
+      node-sass --output-style compressed foobar.scss > foobar.css
+      cat foobar.scss | node-sass --output-style compressed > foobar.css
+
+    Example: Watch the sass directory for changes, compile with sourcemaps to the css directory
+      node-sass --watch --recursive --output css
+        --source-map true --source-map-contents sass
+
+    Options
+      -w, --watch                Watch a directory or file
+      -r, --recursive            Recursively watch directories or files
+      -o, --output               Output directory
+      -x, --omit-source-map-url  Omit source map URL comment from output
+      -i, --indented-syntax      Treat data from stdin as sass code (versus scss)
+      -q, --quiet                Suppress log output except on error
+      -v, --version              Prints version info
+      --output-style             CSS output style (nested | expanded | compact | compressed)
+      --indent-type              Indent type for output CSS (space | tab)
+      --indent-width             Indent width; number of spaces or tabs (maximum value: 10)
+      --linefeed                 Linefeed style (cr | crlf | lf | lfcr)
+      --source-comments          Include debug info in output
+      --source-map               Emit source map (boolean, or path to output .map file)
+      --source-map-contents      Embed include contents in map
+      --source-map-embed         Embed sourceMappingUrl as data URI
+      --source-map-root          Base path, will be emitted in source-map as is
+      --include-path             Path to look for imported files
+      --follow                   Follow symlinked directories
+      --precision                The amount of precision allowed in decimal numbers
+      --error-bell               Output a bell character on errors
+      --importer                 Path to .js file containing custom importer
+      --functions                Path to .js file containing custom functions
+      --help                     Print usage info
+`, {
+  version: sass.info,
+  flags: {
+    errorBell: {
+      type: 'boolean',
+    },
+    functions: {
+      type: 'string',
+    },
+    follow: {
+      type: 'boolean',
+    },
+    importer: {
+      type: 'string',
+    },
+    includePath: {
+      type: 'string',
+      default: [process.cwd()],
+      isMultiple: true,
+    },
+    indentType: {
+      type: 'string',
+      default: 'space',
+    },
+    indentWidth: {
+      type: 'number',
+      default: 2,
+    },
+    indentedSyntax: {
+      type: 'boolean',
+      alias: 'i',
+    },
+    linefeed: {
+      type: 'string',
+      default: 'lf',
+    },
+    omitSourceMapUrl: {
+      type: 'boolean',
+      alias: 'x',
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+    },
+    outputStyle: {
+      type: 'string',
+      default: 'nested',
+    },
+    precision: {
+      type: 'number',
+      default: 5,
+    },
+    quiet: {
+      type: 'boolean',
+      default: false,
+      alias: 'q',
+    },
+    recursive: {
+      type: 'boolean',
+      default: true,
+      alias: 'r',
+    },
+    sourceMapContents: {
+      type: 'boolean',
+    },
+    sourceMapEmbed: {
+      type: 'boolean',
+    },
+    sourceMapRoot: {
+      type: 'string',
+    },
+    sourceComments: {
+      type: 'boolean',
+      alias: 'c',
+    },
+    version: {
+      type: 'boolean',
+      alias: 'v',
+    },
+    watch: {
+      type: 'boolean',
+      alias: 'w',
+    },
+  },
+});
+
+/**
+ * Is a Directory
+ *
+ * @param {String} filePath
+ * @returns {Boolean}
+ * @api private
+ */
+
+function isDirectory(filePath) {
+  var isDir = false;
+  try {
+    var absolutePath = path.resolve(filePath);
+    isDir = fs.statSync(absolutePath).isDirectory();
+  } catch (e) {
+    isDir = e.code === 'ENOENT';
+  }
+  return isDir;
+}
+
+/**
+ * Get correct glob pattern
+ *
+ * @param {Object} options
+ * @returns {String}
+ * @api private
+ */
+
+function globPattern(options) {
+  return options.recursive ? '**/*.{sass,scss}' : '*.{sass,scss}';
+}
+
+/**
+ * Create emitter
+ *
+ * @api private
+ */
+
+function getEmitter() {
+  var emitter = new Emitter();
+
+  emitter.on('error', function(err) {
+    if (options.errorBell) {
+      err += '\x07';
+    }
+    console.error(err);
+    if (!options.watch) {
+      process.exit(1);
+    }
+  });
+
+  emitter.on('warn', function(data) {
+    if (!options.quiet) {
+      console.warn(data);
+    }
+  });
+
+  emitter.on('info', function(data) {
+    if (!options.quiet) {
+      console.info(data);
+    }
+  });
+
+  emitter.on('log', stdout.write.bind(stdout));
+
+  return emitter;
+}
+
+/**
+ * Construct options
+ *
+ * @param {Array} arguments
+ * @param {Object} options
+ * @api private
+ */
+
+function getOptions(args, options) {
+  var cssDir, sassDir, file, mapDir;
+  options.src = args[0];
+
+  if (args[1]) {
+    options.dest = path.resolve(args[1]);
+  } else if (options.output) {
+    options.dest = path.join(
+      path.resolve(options.output),
+      [path.basename(options.src, path.extname(options.src)), '.css'].join(''));  // replace ext.
+  }
+
+  if (options.directory) {
+    sassDir = path.resolve(options.directory);
+    file = path.relative(sassDir, args[0]);
+    cssDir = path.resolve(options.output);
+    options.dest = path.join(cssDir, file).replace(path.extname(file), '.css');
+  }
+
+  if (options.sourceMap) {
+    if(!options.sourceMapOriginal) {
+      options.sourceMapOriginal = options.sourceMap;
+    }
+
+    if (options.sourceMapOriginal === 'true') {
+      options.sourceMap = options.dest + '.map';
+    } else {
+      // check if sourceMap path ends with .map to avoid isDirectory false-positive
+      var sourceMapIsDirectory = options.sourceMapOriginal.indexOf('.map', options.sourceMapOriginal.length - 4) === -1 && isDirectory(options.sourceMapOriginal);
+
+      if (!sourceMapIsDirectory) {
+        options.sourceMap = path.resolve(options.sourceMapOriginal);
+      } else if (!options.directory) {
+        options.sourceMap = path.resolve(options.sourceMapOriginal, path.basename(options.dest) + '.map');
+      } else {
+        sassDir = path.resolve(options.directory);
+        file = path.relative(sassDir, args[0]);
+        mapDir = path.resolve(options.sourceMapOriginal);
+        options.sourceMap = path.join(mapDir, file).replace(path.extname(file), '.css.map');
+      }
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Watch
+ *
+ * @param {Object} options
+ * @param {Object} emitter
+ * @api private
+ */
+
+function watch(options, emitter) {
+  var handler = function(files) {
+    files.added.forEach(function(file) {
+      var watch = gaze.watched();
+      Object.keys(watch).forEach(function (dir) {
+        if (watch[dir].indexOf(file) !== -1) {
+          gaze.add(file);
+        }
+      });
+    });
+
+    files.changed.forEach(function(file) {
+      if (path.basename(file)[0] !== '_') {
+        renderFile(file, options, emitter);
+      }
+    });
+
+    files.removed.forEach(function(file) {
+      gaze.remove(file);
+    });
+  };
+
+  var gaze = new Gaze();
+  gaze.add(watcher.reset(options));
+  gaze.on('error', emitter.emit.bind(emitter, 'error'));
+
+  gaze.on('changed', function(file) {
+    handler(watcher.changed(file));
+  });
+
+  gaze.on('added', function(file) {
+    handler(watcher.added(file));
+  });
+
+  gaze.on('deleted', function(file) {
+    handler(watcher.removed(file));
+  });
+}
+
+/**
+ * Run
+ *
+ * @param {Object} options
+ * @param {Object} emitter
+ * @api private
+ */
+
+function run(options, emitter) {
+  if (options.directory) {
+    if (!options.output) {
+      emitter.emit('error', 'An output directory must be specified when compiling a directory');
+    }
+    if (!isDirectory(options.output)) {
+      emitter.emit('error', 'An output directory must be specified when compiling a directory');
+    }
+  }
+
+  if (options.sourceMapOriginal && options.directory && !isDirectory(options.sourceMapOriginal) && options.sourceMapOriginal !== 'true') {
+    emitter.emit('error', 'The --source-map option must be either a boolean or directory when compiling a directory');
+  }
+
+  if (options.importer) {
+    if ((path.resolve(options.importer) === path.normalize(options.importer).replace(/(.+)([/|\\])$/, '$1'))) {
+      options.importer = require(options.importer);
+    } else {
+      options.importer = require(path.resolve(options.importer));
+    }
+  }
+
+  if (options.functions) {
+    if ((path.resolve(options.functions) === path.normalize(options.functions).replace(/(.+)([/|\\])$/, '$1'))) {
+      options.functions = require(options.functions);
+    } else {
+      options.functions = require(path.resolve(options.functions));
+    }
+  }
+
+  if (options.watch) {
+    watch(options, emitter);
+  } else if (options.directory) {
+    renderDir(options, emitter);
+  } else {
+    render(options, emitter);
+  }
+}
+
+/**
+ * Render a file
+ *
+ * @param {String} file
+ * @param {Object} options
+ * @param {Object} emitter
+ * @api private
+ */
+function renderFile(file, options, emitter) {
+  options = getOptions([path.resolve(file)], options);
+  if (options.watch && !options.quiet) {
+    emitter.emit('info', util.format('=> changed: %s', file));
+  }
+  render(options, emitter);
+}
+
+/**
+ * Render all sass files in a directory
+ *
+ * @param {Object} options
+ * @param {Object} emitter
+ * @api private
+ */
+function renderDir(options, emitter) {
+  var globPath = path.resolve(options.directory, globPattern(options));
+  glob(globPath, { ignore: '**/_*', follow: options.follow }, function(err, files) {
+    if (err) {
+      return emitter.emit('error', util.format('You do not have permission to access this path: %s.', err.path));
+    } else if (!files.length) {
+      return emitter.emit('error', 'No input file was found.');
+    }
+
+    forEach(files, function(subject) {
+      emitter.once('done', this.async());
+      renderFile(subject, options, emitter);
+    }, function(successful, arr) {
+      var outputDir = path.join(process.cwd(), options.output);
+      if (!options.quiet) {
+        emitter.emit('info', util.format('Wrote %s CSS files to %s', arr.length, outputDir));
+      }
+      process.exit();
+    });
+  });
+}
+
+/**
+ * Arguments and options
+ */
+
+var options = getOptions(cli.input, cli.flags);
+var emitter = getEmitter();
+
+/**
+ * Show usage if no arguments are supplied
+ */
+
+if (!options.src && process.stdin.isTTY) {
+  emitter.emit('error', [
+    'Provide a Sass file to render',
+    '',
+    'Example: Compile foobar.scss to foobar.css',
+    '  node-sass --output-style compressed foobar.scss > foobar.css',
+    '  cat foobar.scss | node-sass --output-style compressed > foobar.css',
+    '',
+    'Example: Watch the sass directory for changes, compile with sourcemaps to the css directory',
+    '  node-sass --watch --recursive --output css',
+    '    --source-map true --source-map-contents sass',
+  ].join('\n'));
+}
+
+/**
+ * Apply arguments
+ */
+
+if (options.src) {
+  if (isDirectory(options.src)) {
+    options.directory = options.src;
+  }
+  run(options, emitter);
+} else if (!process.stdin.isTTY) {
+  stdin(function(data) {
+    options.data = data;
+    options.stdin = true;
+    run(options, emitter);
+  });
+}

spa/node_modules/node-sass/binding.gyp

@@ -0,0 +1,74 @@
+{
+  'variables': {
+      'libsass_ext%': '',
+  },
+  'targets': [
+    {
+      'target_name': 'binding',
+      'win_delay_load_hook': 'true',
+      'sources': [
+        'src/binding.cpp',
+        'src/create_string.cpp',
+        'src/custom_function_bridge.cpp',
+        'src/custom_importer_bridge.cpp',
+        'src/sass_context_wrapper.cpp',
+        'src/sass_types/boolean.cpp',
+        'src/sass_types/color.cpp',
+        'src/sass_types/error.cpp',
+        'src/sass_types/factory.cpp',
+        'src/sass_types/list.cpp',
+        'src/sass_types/map.cpp',
+        'src/sass_types/null.cpp',
+        'src/sass_types/number.cpp',
+        'src/sass_types/string.cpp'
+      ],
+      'msvs_settings': {
+        'VCLinkerTool': {
+           'SetChecksum': 'true'
+        }
+      },
+      'xcode_settings': {
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'OTHER_LDFLAGS': [],
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'NO',
+        'MACOSX_DEPLOYMENT_TARGET': '10.11'
+      },
+      'include_dirs': [
+        '<!(node -e "require(\'nan\')")',
+      ],
+      'conditions': [
+        ['libsass_ext == "" or libsass_ext == "no"', {
+          'dependencies': [
+            'src/libsass.gyp:libsass',
+          ]
+        }],
+        ['libsass_ext == "auto"', {
+          'cflags_cc': [
+            '<!(pkg-config --cflags libsass)',
+          ],
+          'link_settings': {
+            'ldflags': [
+              '<!(pkg-config --libs-only-other --libs-only-L libsass)',
+            ],
+            'libraries': [
+              '<!(pkg-config --libs-only-l libsass)',
+            ],
+          }
+        }],
+        ['libsass_ext == "yes"', {
+          'cflags_cc': [
+            '<(libsass_cflags)',
+          ],
+          'link_settings': {
+            'ldflags': [
+              '<(libsass_ldflags)',
+            ],
+            'libraries': [
+              '<(libsass_library)',
+            ],
+          }
+        }]
+      ]
+    }
+  ]
+}

spa/node_modules/node-sass/lib/binding.js

@@ -0,0 +1,20 @@
+/*!
+ * node-sass: lib/binding.js
+ */
+
+var errors = require('./errors');
+
+/**
+ * Require binding
+ */
+module.exports = function(ext) {
+  if (!ext.hasBinary(ext.getBinaryPath())) {
+    if (!ext.isSupportedEnvironment()) {
+      throw new Error(errors.unsupportedEnvironment());
+    } else {
+      throw new Error(errors.missingBinary());
+    }
+  }
+
+  return require(ext.getBinaryPath());
+};

spa/node_modules/node-sass/lib/errors.js

@@ -0,0 +1,49 @@
+/*!
+ * node-sass: lib/errors.js
+ */
+
+var sass = require('./extensions'),
+  pkg = require('../package.json');
+
+function humanEnvironment() {
+  return sass.getHumanEnvironment(sass.getBinaryName());
+}
+
+function foundBinaries() {
+  return [
+    'Found bindings for the following environments:',
+    foundBinariesList(),
+  ].join('\n');
+}
+
+function foundBinariesList() {
+  return sass.getInstalledBinaries().map(function(env) {
+    return '  - ' + sass.getHumanEnvironment(env);
+  }).join('\n');
+}
+
+function missingBinaryFooter() {
+  return [
+    'This usually happens because your environment has changed since running `npm install`.',
+    'Run `npm rebuild node-sass` to download the binding for your current environment.',
+  ].join('\n');
+}
+
+module.exports.unsupportedEnvironment = function() {
+  return [
+    'Node Sass does not yet support your current environment: ' + humanEnvironment(),
+    'For more information on which environments are supported please see:',
+    'https://github.com/sass/node-sass/releases/tag/v' + pkg.version
+  ].join('\n');
+};
+
+module.exports.missingBinary = function() {
+  return [
+    'Missing binding ' + sass.getBinaryPath(),
+    'Node Sass could not find a binding for your current environment: ' + humanEnvironment(),
+    '',
+    foundBinaries(),
+    '',
+    missingBinaryFooter(),
+  ].join('\n');
+};

spa/node_modules/node-sass/lib/extensions.js

@@ -0,0 +1,457 @@
+/*!
+ * node-sass: lib/extensions.js
+ */
+
+var eol = require('os').EOL,
+  fs = require('fs'),
+  path = require('path'),
+  trueCasePathSync = require('true-case-path').trueCasePathSync,
+  pkg = require('../package.json'),
+  defaultBinaryDir = path.join(__dirname, '..', 'vendor');
+
+/**
+ * Get the human readable name of the Platform that is running
+ *
+ * @param  {string} platform - An OS platform to match, or null to fallback to
+ * the current process platform
+ * @return {Object} The name of the platform if matched, false otherwise
+ *
+ * @api public
+ */
+function getHumanPlatform(platform) {
+  switch (platform || process.platform) {
+    case 'darwin': return 'OS X';
+    case 'freebsd': return 'FreeBSD';
+    case 'linux': return 'Linux';
+    case 'linux_musl': return 'Linux/musl';
+    case 'win32': return 'Windows';
+    default: return false;
+  }
+}
+
+/**
+ * Provides a more readable version of the architecture
+ *
+ * @param  {string} arch - An instruction architecture name to match, or null to
+ * lookup the current process architecture
+ * @return {Object} The value of the process architecture, or false if unknown
+ *
+ * @api public
+ */
+function getHumanArchitecture(arch) {
+  switch (arch || process.arch) {
+    case 'ia32': return '32-bit';
+    case 'x86': return '32-bit';
+    case 'x64': return '64-bit';
+    default: return false;
+  }
+}
+
+/**
+ * Get the friendly name of the Node environment being run
+ *
+ * @param  {Object} abi - A Node Application Binary Interface value, or null to
+ * fallback to the current Node ABI
+ * @return {Object} Returns a string name of the Node environment or false if
+ * unmatched
+ *
+ * @api public
+ */
+function getHumanNodeVersion(abi) {
+  switch (parseInt(abi || process.versions.modules, 10)) {
+    case 11: return 'Node 0.10.x';
+    case 14: return 'Node 0.12.x';
+    case 42: return 'io.js 1.x';
+    case 43: return 'io.js 1.1.x';
+    case 44: return 'io.js 2.x';
+    case 45: return 'io.js 3.x';
+    case 46: return 'Node.js 4.x';
+    case 47: return 'Node.js 5.x';
+    case 48: return 'Node.js 6.x';
+    case 49: return 'Electron 1.3.x';
+    case 50: return 'Electron 1.4.x';
+    case 51: return 'Node.js 7.x';
+    case 53: return 'Electron 1.6.x';
+    case 57: return 'Node.js 8.x';
+    case 59: return 'Node.js 9.x';
+    case 64: return 'Node.js 10.x';
+    case 67: return 'Node.js 11.x';
+    case 72: return 'Node.js 12.x';
+    case 79: return 'Node.js 13.x';
+    case 83: return 'Node.js 14.x';
+    case 88: return 'Node.js 15.x';
+    case 93: return 'Node.js 16.x';
+    case 102: return 'Node.js 17.x';
+    case 108: return 'Node.js 18.x';
+    case 111: return 'Node.js 19.x';
+    case 115: return 'Node.js 20.x';
+    default: return false;
+  }
+}
+
+/**
+ * Get a human readable description of where node-sass is running to support
+ * user error reporting when something goes wrong
+ *
+ * @param  {string} env - The name of the native bindings that is to be parsed
+ * @return {string} A description of what os, architecture, and Node version
+ * that is being run
+ *
+ * @api public
+ */
+function getHumanEnvironment(env) {
+  var binding = env.replace(/_binding\.node$/, ''),
+    parts = binding.split('-'),
+    platform = getHumanPlatform(parts[0]),
+    arch = getHumanArchitecture(parts[1]),
+    runtime = getHumanNodeVersion(parts[2]);
+
+  if (parts.length !== 3) {
+    return 'Unknown environment (' + binding + ')';
+  }
+
+  if (!platform) {
+    platform = 'Unsupported platform (' + parts[0] + ')';
+  }
+
+  if (!arch) {
+    arch = 'Unsupported architecture (' + parts[1] + ')';
+  }
+
+  if (!runtime) {
+    runtime = 'Unsupported runtime (' + parts[2] + ')';
+  }
+
+  return [
+    platform, arch, 'with', runtime,
+  ].join(' ');
+}
+
+/**
+ * Get the value of the binaries under the default path
+ *
+ * @return {Array} The currently installed node-sass bindings
+ *
+ * @api public
+ */
+function getInstalledBinaries() {
+  return fs.readdirSync(getBinaryDir());
+}
+
+/**
+ * Check that an environment matches the allowlisted values or the current
+ * environment if no parameters are passed
+ *
+ * @param  {string} platform - The name of the OS platform(darwin, win32, etc...)
+ * @param  {string} arch - The instruction set architecture of the Node environment
+ * @param  {string} abi - The Node Application Binary Interface
+ * @return {Boolean} True, if node-sass supports the current platform, false otherwise
+ *
+ * @api public
+ */
+function isSupportedEnvironment(platform, arch, abi) {
+  return (
+    false !== getHumanPlatform(platform) &&
+    false !== getHumanArchitecture(arch) &&
+    false !== getHumanNodeVersion(abi)
+  );
+}
+
+/**
+ * Get the value of a CLI argument
+ *
+ * @param {String} name
+ * @param {Array} args
+ * @api private
+ */
+
+function getArgument(name, args) {
+  var flags = args || process.argv.slice(2),
+    index = flags.lastIndexOf(name);
+
+  if (index === -1 || index + 1 >= flags.length) {
+    return null;
+  }
+
+  return flags[index + 1];
+}
+
+/**
+ * Get binary name.
+ * If environment variable SASS_BINARY_NAME,
+ * .npmrc variable sass_binary_name or
+ * process argument --binary-name is provided,
+ * return it as is, otherwise make default binary
+ * name: {platform}-{arch}-{v8 version}.node
+ *
+ * @api public
+ */
+
+function getBinaryName() {
+  var binaryName,
+    variant,
+    platform = process.platform;
+
+  if (getArgument('--sass-binary-name')) {
+    binaryName = getArgument('--sass-binary-name');
+  } else if (process.env.SASS_BINARY_NAME) {
+    binaryName = process.env.SASS_BINARY_NAME;
+  } else if (process.env.npm_config_sass_binary_name) {
+    binaryName = process.env.npm_config_sass_binary_name;
+  } else if (pkg.nodeSassConfig && pkg.nodeSassConfig.binaryName) {
+    binaryName = pkg.nodeSassConfig.binaryName;
+  } else {
+    variant = getPlatformVariant();
+    if (variant) {
+      platform += '_' + variant;
+    }
+
+    binaryName = [
+      platform, '-',
+      process.arch, '-',
+      process.versions.modules
+    ].join('');
+  }
+
+  return [binaryName, 'binding.node'].join('_');
+}
+
+/**
+ * Determine the URL to fetch binary file from.
+ * By default fetch from the node-sass distribution
+ * site on GitHub.
+ *
+ * The default URL can be overridden using
+ * the environment variable SASS_BINARY_SITE,
+ * .npmrc variable sass_binary_site or
+ * or a command line option --sass-binary-site:
+ *
+ *   node scripts/install.js --sass-binary-site http://example.com/
+ *
+ * The URL should to the mirror of the repository
+ * laid out as follows:
+ *
+ * SASS_BINARY_SITE/
+ *
+ *  v3.0.0
+ *  v3.0.0/freebsd-x64-14_binding.node
+ *  ....
+ *  v3.0.0
+ *  v3.0.0/freebsd-ia32-11_binding.node
+ *  v3.0.0/freebsd-x64-42_binding.node
+ *  ... etc. for all supported versions and platforms
+ *
+ * @api public
+ */
+
+function getBinaryUrl() {
+  var site = getArgument('--sass-binary-site') ||
+             process.env.SASS_BINARY_SITE  ||
+             process.env.npm_config_sass_binary_site ||
+             (pkg.nodeSassConfig && pkg.nodeSassConfig.binarySite) ||
+             'https://github.com/sass/node-sass/releases/download';
+
+  return [site, 'v' + pkg.version, getBinaryName()].join('/');
+}
+
+/**
+ * Get binary dir.
+ * If environment variable SASS_BINARY_DIR,
+ * .npmrc variable sass_binary_dir or
+ * process argument --sass-binary-dir is provided,
+ * select it by appending binary name, otherwise
+ * use default binary dir.
+ * Once the primary selection is made, check if
+ * callers wants to throw if file not exists before
+ * returning.
+ *
+ * @api public
+ */
+
+function getBinaryDir() {
+  var binaryDir;
+
+  if (getArgument('--sass-binary-dir')) {
+    binaryDir = getArgument('--sass-binary-dir');
+  } else if (process.env.SASS_BINARY_DIR) {
+    binaryDir = process.env.SASS_BINARY_DIR;
+  } else if (process.env.npm_config_sass_binary_dir) {
+    binaryDir = process.env.npm_config_sass_binary_dir;
+  } else if (pkg.nodeSassConfig && pkg.nodeSassConfig.binaryDir) {
+    binaryDir = pkg.nodeSassConfig.binaryDir;
+  } else {
+    binaryDir = defaultBinaryDir;
+  }
+
+  return binaryDir;
+}
+
+/**
+ * Get binary path.
+ * If environment variable SASS_BINARY_PATH,
+ * .npmrc variable sass_binary_path or
+ * process argument --sass-binary-path is provided,
+ * select it by appending binary name, otherwise
+ * make default binary path using binary name.
+ * Once the primary selection is made, check if
+ * callers wants to throw if file not exists before
+ * returning.
+ *
+ * @api public
+ */
+
+function getBinaryPath() {
+  var binaryPath;
+
+  if (getArgument('--sass-binary-path')) {
+    binaryPath = getArgument('--sass-binary-path');
+  } else if (process.env.SASS_BINARY_PATH) {
+    binaryPath = process.env.SASS_BINARY_PATH;
+  } else if (process.env.npm_config_sass_binary_path) {
+    binaryPath = process.env.npm_config_sass_binary_path;
+  } else if (pkg.nodeSassConfig && pkg.nodeSassConfig.binaryPath) {
+    binaryPath = pkg.nodeSassConfig.binaryPath;
+  } else {
+    binaryPath = path.join(getBinaryDir(), getBinaryName().replace(/_(?=binding\.node)/, '/'));
+  }
+
+  try {
+    return trueCasePathSync(binaryPath) || binaryPath;
+  } catch (e) {
+    return binaryPath;
+  }
+}
+
+/**
+ * An array of paths suitable for use as a local disk cache of the binding.
+ *
+ * @return {[]String} an array of paths
+ * @api public
+ */
+function getCachePathCandidates() {
+  return [
+    process.env.npm_config_sass_binary_cache,
+    process.env.npm_config_cache,
+  ].filter(function(_) { return _; });
+}
+
+/**
+ * The most suitable location for caching the binding on disk.
+ *
+ * Given the candidates directories provided by `getCachePathCandidates()` this
+ * returns the first writable directory. By treating the candidate directories
+ * as a prioritised list this method is deterministic, assuming no change to the
+ * local environment.
+ *
+ * @return {String} directory to cache binding
+ * @api public
+ */
+function getBinaryCachePath() {
+  var i,
+    cachePath,
+    cachePathCandidates = getCachePathCandidates();
+
+  for (i = 0; i < cachePathCandidates.length; i++) {
+    cachePath = path.join(cachePathCandidates[i], pkg.name, pkg.version);
+
+    try {
+      fs.mkdirSync(cachePath, {recursive: true});
+      return cachePath;
+    } catch (e) {
+      // Directory is not writable, try another
+    }
+  }
+
+  return '';
+}
+
+/**
+ * The cached binding
+ *
+ * Check the candidates directories provided by `getCachePathCandidates()` for
+ * the binding file, if it exists. By treating the candidate directories
+ * as a prioritised list this method is deterministic, assuming no change to the
+ * local environment.
+ *
+ * @return {String} path to cached binary
+ * @api public
+ */
+function getCachedBinary() {
+  var i,
+    cachePath,
+    cacheBinary,
+    cachePathCandidates = getCachePathCandidates(),
+    binaryName = getBinaryName();
+
+  for (i = 0; i < cachePathCandidates.length; i++) {
+    cachePath = path.join(cachePathCandidates[i], pkg.name, pkg.version);
+    cacheBinary = path.join(cachePath, binaryName);
+
+    if (fs.existsSync(cacheBinary)) {
+      return cacheBinary;
+    }
+  }
+
+  return '';
+}
+
+/**
+ * Does the supplied binary path exist
+ *
+ * @param {String} binaryPath
+ * @api public
+ */
+
+function hasBinary(binaryPath) {
+  return fs.existsSync(binaryPath);
+}
+
+/**
+ * Get Sass version information
+ *
+ * @api public
+ */
+
+function getVersionInfo(binding) {
+  return [
+    ['node-sass', pkg.version, '(Wrapper)', '[JavaScript]'].join('\t'),
+    ['libsass  ', binding.libsassVersion(), '(Sass Compiler)', '[C/C++]'].join('\t'),
+  ].join(eol);
+}
+
+/**
+ * Gets the platform variant, currently either an empty string or 'musl' for Linux/musl platforms.
+ *
+ * @api public
+ */
+
+function getPlatformVariant() {
+  var contents = '';
+
+  if (process.platform !== 'linux') {
+    return '';
+  }
+
+  try {
+    contents = fs.readFileSync(process.execPath);
+
+    if (contents.indexOf('libc.musl-x86_64.so.1') !== -1) {
+      return 'musl';
+    }
+  } catch (err) { } // eslint-disable-line no-empty
+
+  return '';
+}
+
+module.exports.hasBinary = hasBinary;
+module.exports.getBinaryUrl = getBinaryUrl;
+module.exports.getBinaryName = getBinaryName;
+module.exports.getBinaryDir = getBinaryDir;
+module.exports.getBinaryPath = getBinaryPath;
+module.exports.getBinaryCachePath = getBinaryCachePath;
+module.exports.getCachedBinary = getCachedBinary;
+module.exports.getCachePathCandidates = getCachePathCandidates;
+module.exports.getVersionInfo = getVersionInfo;
+module.exports.getHumanEnvironment = getHumanEnvironment;
+module.exports.getInstalledBinaries = getInstalledBinaries;
+module.exports.isSupportedEnvironment = isSupportedEnvironment;

spa/node_modules/node-sass/lib/index.js

@@ -0,0 +1,458 @@
+/*!
+ * node-sass: lib/index.js
+ */
+
+var path = require('path'),
+  clonedeep = require('lodash/cloneDeep'),
+  sass = require('./extensions');
+
+/**
+ * Require binding
+ */
+
+var binding = require('./binding')(sass);
+
+/**
+ * Get input file
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getInputFile(options) {
+  return options.file ? path.resolve(options.file) : null;
+}
+
+/**
+ * Get output file
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getOutputFile(options) {
+  var outFile = options.outFile;
+
+  if (!outFile || typeof outFile !== 'string' || (!options.data && !options.file)) {
+    return null;
+  }
+
+  return path.resolve(outFile);
+}
+
+/**
+ * Get source map
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getSourceMap(options) {
+  var sourceMap = options.sourceMap;
+
+  if (sourceMap && typeof sourceMap !== 'string' && options.outFile) {
+    sourceMap = options.outFile + '.map';
+  }
+
+  return sourceMap && typeof sourceMap === 'string' ? path.resolve(sourceMap) : null;
+}
+
+/**
+ * Get stats
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getStats(options) {
+  var stats = {};
+
+  stats.entry = options.file || 'data';
+  stats.start = Date.now();
+
+  return stats;
+}
+
+/**
+ * End stats
+ *
+ * @param {Object} stats
+ * @param {Object} sourceMap
+ * @api private
+ */
+
+function endStats(stats) {
+  stats.end = Date.now();
+  stats.duration = stats.end - stats.start;
+
+  return stats;
+}
+
+/**
+ * Get style
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getStyle(options) {
+  var styles = {
+    nested: 0,
+    expanded: 1,
+    compact: 2,
+    compressed: 3
+  };
+
+  return styles[options.outputStyle] || 0;
+}
+
+/**
+ * Get indent width
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getIndentWidth(options) {
+  var width = parseInt(options.indentWidth) || 2;
+
+  return width > 10 ? 2 : width;
+}
+
+/**
+ * Get indent type
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getIndentType(options) {
+  var types = {
+    space: 0,
+    tab: 1
+  };
+
+  return types[options.indentType] || 0;
+}
+
+/**
+ * Get linefeed
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getLinefeed(options) {
+  var feeds = {
+    cr: '\r',
+    crlf: '\r\n',
+    lf: '\n',
+    lfcr: '\n\r'
+  };
+
+  return feeds[options.linefeed] || '\n';
+}
+
+/**
+ * Build an includePaths string
+ * from the options.includePaths array and the SASS_PATH environment variable
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function buildIncludePaths(options) {
+  options.includePaths = options.includePaths || [];
+
+  if (Object.prototype.hasOwnProperty.call(process.env, 'SASS_PATH')) {
+    options.includePaths = options.includePaths.concat(
+      process.env.SASS_PATH.split(path.delimiter)
+    );
+  }
+
+  // Preserve the behaviour people have come to expect.
+  // This behaviour was removed from Sass in 3.4 and
+  // LibSass in 3.5.
+  options.includePaths.unshift(process.cwd());
+
+  return options.includePaths.join(path.delimiter);
+}
+
+/**
+ * Get options
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function getOptions(opts, cb) {
+  if (typeof opts !== 'object') {
+    throw new Error('Invalid: options is not an object.');
+  }
+  var options = clonedeep(opts || {});
+
+  options.sourceComments = options.sourceComments || false;
+  if (Object.prototype.hasOwnProperty.call(options, 'file')) {
+    options.file = getInputFile(options);
+  }
+  options.outFile = getOutputFile(options);
+  options.includePaths = buildIncludePaths(options);
+  options.precision = parseInt(options.precision) || 5;
+  options.sourceMap = getSourceMap(options);
+  options.style = getStyle(options);
+  options.indentWidth = getIndentWidth(options);
+  options.indentType = getIndentType(options);
+  options.linefeed = getLinefeed(options);
+
+  // context object represents node-sass environment
+  options.context = { options: options, callback: cb };
+
+  options.result = {
+    stats: getStats(options)
+  };
+
+  return options;
+}
+
+/**
+ * Executes a callback and transforms any exception raised into a sass error
+ *
+ * @param {Function} callback
+ * @param {Array} arguments
+ * @api private
+ */
+
+function tryCallback(callback, args) {
+  try {
+    return callback.apply(this, args);
+  } catch (e) {
+    if (typeof e === 'string') {
+      return new binding.types.Error(e);
+    } else if (e instanceof Error) {
+      return new binding.types.Error(e.message);
+    } else {
+      return new binding.types.Error('An unexpected error occurred');
+    }
+  }
+}
+
+/**
+ * Normalizes the signature of custom functions to make it possible to just supply the
+ * function name and have the signature default to `fn(...)`. The callback is adjusted
+ * to transform the input sass list into discrete arguments.
+ *
+ * @param {String} signature
+ * @param {Function} callback
+ * @return {Object}
+ * @api private
+ */
+
+function normalizeFunctionSignature(signature, callback) {
+  if (!/^\*|@warn|@error|@debug|\w+\(.*\)$/.test(signature)) {
+    if (!/\w+/.test(signature)) {
+      throw new Error('Invalid function signature format "' + signature + '"');
+    }
+
+    return {
+      signature: signature + '(...)',
+      callback: function() {
+        var args = Array.prototype.slice.call(arguments),
+          list = args.shift(),
+          i;
+
+        for (i = list.getLength() - 1; i >= 0; i--) {
+          args.unshift(list.getValue(i));
+        }
+
+        return callback.apply(this, args);
+      }
+    };
+  }
+
+  return {
+    signature: signature,
+    callback: callback
+  };
+}
+
+/**
+ * Render
+ *
+ * @param {Object} options
+ * @api public
+ */
+
+module.exports.render = function(opts, cb) {
+  var options = getOptions(opts, cb);
+
+  // options.error and options.success are for libsass binding
+  options.error = function(err) {
+    var payload = Object.assign(new Error(), JSON.parse(err));
+
+    if (cb) {
+      options.context.callback.call(options.context, payload, null);
+    }
+  };
+
+  options.success = function() {
+    var result = options.result;
+    var stats = endStats(result.stats);
+    var payload = {
+      css: result.css,
+      stats: stats
+    };
+    if (result.map) {
+      payload.map = result.map;
+    }
+
+    if (cb) {
+      options.context.callback.call(options.context, null, payload);
+    }
+  };
+
+  var importer = options.importer;
+
+  if (importer) {
+    if (Array.isArray(importer)) {
+      options.importer = [];
+      importer.forEach(function(subject, index) {
+        options.importer[index] = function(file, prev, bridge) {
+          function done(result) {
+            bridge.success(result === module.exports.NULL ? null : result);
+          }
+
+          var result = subject.call(options.context, file, prev, done);
+
+          if (result !== undefined) {
+            done(result);
+          }
+        };
+      });
+    } else {
+      options.importer = function(file, prev, bridge) {
+        function done(result) {
+          bridge.success(result === module.exports.NULL ? null : result);
+        }
+
+        var result = importer.call(options.context, file, prev, done);
+
+        if (result !== undefined) {
+          done(result);
+        }
+      };
+    }
+  }
+
+  var functions = clonedeep(options.functions);
+
+  if (functions) {
+    options.functions = {};
+
+    Object.keys(functions).forEach(function(subject) {
+      var cb = normalizeFunctionSignature(subject, functions[subject]);
+
+      options.functions[cb.signature] = function() {
+        var args = Array.prototype.slice.call(arguments),
+          bridge = args.pop();
+
+        function done(data) {
+          bridge.success(data);
+        }
+
+        var result = tryCallback(cb.callback.bind(options.context), args.concat(done));
+
+        if (result) {
+          done(result);
+        }
+      };
+    });
+  }
+
+  if (options.data) {
+    binding.render(options);
+  } else if (options.file) {
+    binding.renderFile(options);
+  } else {
+    cb({status: 3, message: 'No input specified: provide a file name or a source string to process' });
+  }
+};
+
+/**
+ * Render sync
+ *
+ * @param {Object} options
+ * @api public
+ */
+
+module.exports.renderSync = function(opts) {
+  var options = getOptions(opts);
+  var importer = options.importer;
+
+  if (importer) {
+    if (Array.isArray(importer)) {
+      options.importer = [];
+      importer.forEach(function(subject, index) {
+        options.importer[index] = function(file, prev) {
+          var result = subject.call(options.context, file, prev);
+
+          return result === module.exports.NULL ? null : result;
+        };
+      });
+    } else {
+      options.importer = function(file, prev) {
+        var result = importer.call(options.context, file, prev);
+
+        return result === module.exports.NULL ? null : result;
+      };
+    }
+  }
+
+  var functions = clonedeep(options.functions);
+
+  if (options.functions) {
+    options.functions = {};
+
+    Object.keys(functions).forEach(function(signature) {
+      var cb = normalizeFunctionSignature(signature, functions[signature]);
+
+      options.functions[cb.signature] = function() {
+        return tryCallback(cb.callback.bind(options.context), arguments);
+      };
+    });
+  }
+
+  var status;
+  if (options.data) {
+    status = binding.renderSync(options);
+  } else if (options.file) {
+    status = binding.renderFileSync(options);
+  } else {
+    throw new Error('No input specified: provide a file name or a source string to process');
+  }
+
+  var result = options.result;
+
+  if (status) {
+    result.stats = endStats(result.stats);
+    return result;
+  }
+
+  throw Object.assign(new Error(), JSON.parse(result.error));
+};
+
+/**
+ * API Info
+ *
+ * @api public
+ */
+
+module.exports.info = sass.getVersionInfo(binding);
+
+/**
+ * Expose sass types
+ */
+
+module.exports.types = binding.types;
+module.exports.TRUE = binding.types.Boolean.TRUE;
+module.exports.FALSE = binding.types.Boolean.FALSE;
+module.exports.NULL = binding.types.Null.NULL;

spa/node_modules/node-sass/lib/render.js

@@ -0,0 +1,120 @@
+/*!
+ * node-sass: lib/render.js
+ */
+
+var chalk = require('chalk'),
+  fs = require('fs'),
+  path = require('path'),
+  sass = require('./');
+
+/**
+ * Render
+ *
+ * @param {Object} options
+ * @param {Object} emitter
+ * @api public
+ */
+
+module.exports = function(options, emitter) {
+  var renderOptions = {
+    includePaths: options.includePath,
+    omitSourceMapUrl: options.omitSourceMapUrl,
+    indentedSyntax: options.indentedSyntax,
+    outFile: options.dest,
+    outputStyle: options.outputStyle,
+    precision: options.precision,
+    sourceComments: options.sourceComments,
+    sourceMapEmbed: options.sourceMapEmbed,
+    sourceMapContents: options.sourceMapContents,
+    sourceMap: options.sourceMap,
+    sourceMapRoot: options.sourceMapRoot,
+    importer: options.importer,
+    functions: options.functions,
+    indentWidth: options.indentWidth,
+    indentType: options.indentType,
+    linefeed: options.linefeed
+  };
+
+  if (options.data) {
+    renderOptions.data = options.data;
+  } else if (options.src) {
+    renderOptions.file = options.src;
+  }
+
+  var sourceMap = options.sourceMap;
+  var destination = options.dest;
+  var stdin = options.stdin;
+
+  var success = function(result) {
+    var todo = 1;
+    var done = function() {
+      if (--todo <= 0) {
+        emitter.emit('done');
+      }
+    };
+
+    if (!destination || stdin) {
+      emitter.emit('log', result.css.toString());
+
+      if (sourceMap && !options.sourceMapEmbed) {
+        emitter.emit('log', result.map.toString());
+      }
+
+      return done();
+    }
+
+    emitter.emit('info', chalk.green('Rendering Complete, saving .css file...'));
+
+    fs.mkdir(path.dirname(destination), {recursive: true}, function(err) {
+      if (err) {
+        return emitter.emit('error', chalk.red(err));
+      }
+
+      fs.writeFile(destination, result.css.toString(), function(err) {
+        if (err) {
+          return emitter.emit('error', chalk.red(err));
+        }
+
+        emitter.emit('info', chalk.green('Wrote CSS to ' + destination));
+        emitter.emit('write', err, destination, result.css.toString());
+        done();
+      });
+    });
+
+    if (sourceMap) {
+      todo++;
+
+      fs.mkdir(path.dirname(sourceMap), {recursive: true}, function(err) {
+        if (err) {
+          return emitter.emit('error', chalk.red(err));
+        }
+        fs.writeFile(sourceMap, result.map, function(err) {
+          if (err) {
+            return emitter.emit('error', chalk.red('Error' + err));
+          }
+
+          emitter.emit('info', chalk.green('Wrote Source Map to ' + sourceMap));
+          emitter.emit('write-source-map', err, sourceMap, result.map);
+          done();
+        });
+      });
+    }
+
+    emitter.emit('render', result.css.toString());
+  };
+
+  var error = function(error) {
+    emitter.emit('error', chalk.red(JSON.stringify(error, null, 2)));
+  };
+
+  var renderCallback = function(err, result) {
+    if (err) {
+      error(err);
+    }
+    else {
+      success(result);
+    }
+  };
+
+  sass.render(renderOptions, renderCallback);
+};

spa/node_modules/node-sass/lib/watcher.js

@@ -0,0 +1,93 @@
+var grapher = require('sass-graph'),
+  clonedeep = require('lodash/cloneDeep'),
+  path = require('path'),
+  config = {},
+  watcher = {},
+  graph = null;
+
+watcher.reset = function(opts) {
+  config = clonedeep(opts || config || {});
+  var options = {
+    loadPaths: config.includePath,
+    extensions: ['scss', 'sass', 'css'],
+    follow: config.follow,
+  };
+
+  if (config.directory) {
+    graph = grapher.parseDir(config.directory, options);
+  } else {
+    graph = grapher.parseFile(config.src, options);
+  }
+
+  return Object.keys(graph.index);
+};
+
+watcher.changed = function(absolutePath) {
+  var files = {
+    added: [],
+    changed: [],
+    removed: [],
+  };
+
+  this.reset();
+
+  if (absolutePath && path.basename(absolutePath)[0] !== '_') {
+    files.changed.push(absolutePath);
+  }
+
+  graph.visitAncestors(absolutePath, function(parent) {
+    if (path.basename(parent)[0] !== '_') {
+      files.changed.push(parent);
+    }
+  });
+
+  graph.visitDescendents(absolutePath, function(child) {
+    files.added.push(child);
+  });
+
+  return files;
+};
+
+watcher.added = function(absolutePath) {
+  var files = {
+    added: [],
+    changed: [],
+    removed: [],
+  };
+
+  this.reset();
+
+  if (Object.keys(graph.index).indexOf(absolutePath) === -1) {
+    files.added.push(absolutePath);
+  }
+
+  graph.visitDescendents(absolutePath, function(child) {
+    files.added.push(child);
+  });
+
+  return files;
+};
+
+watcher.removed = function(absolutePath) {
+  var files = {
+    added: [],
+    changed: [],
+    removed: [],
+  };
+
+  graph.visitAncestors(absolutePath, function(parent) {
+    if (path.basename(parent)[0] !== '_') {
+      files.changed.push(parent);
+    }
+  });
+
+  if (Object.keys(graph.index).indexOf(absolutePath) !== -1) {
+    files.removed.push(absolutePath);
+  }
+
+  this.reset();
+
+  return files;
+};
+
+module.exports = watcher;

spa/node_modules/node-sass/node_modules/ansi-styles/index.d.ts

@@ -0,0 +1,345 @@
+declare type CSSColor =
+	| 'aliceblue'
+	| 'antiquewhite'
+	| 'aqua'
+	| 'aquamarine'
+	| 'azure'
+	| 'beige'
+	| 'bisque'
+	| 'black'
+	| 'blanchedalmond'
+	| 'blue'
+	| 'blueviolet'
+	| 'brown'
+	| 'burlywood'
+	| 'cadetblue'
+	| 'chartreuse'
+	| 'chocolate'
+	| 'coral'
+	| 'cornflowerblue'
+	| 'cornsilk'
+	| 'crimson'
+	| 'cyan'
+	| 'darkblue'
+	| 'darkcyan'
+	| 'darkgoldenrod'
+	| 'darkgray'
+	| 'darkgreen'
+	| 'darkgrey'
+	| 'darkkhaki'
+	| 'darkmagenta'
+	| 'darkolivegreen'
+	| 'darkorange'
+	| 'darkorchid'
+	| 'darkred'
+	| 'darksalmon'
+	| 'darkseagreen'
+	| 'darkslateblue'
+	| 'darkslategray'
+	| 'darkslategrey'
+	| 'darkturquoise'
+	| 'darkviolet'
+	| 'deeppink'
+	| 'deepskyblue'
+	| 'dimgray'
+	| 'dimgrey'
+	| 'dodgerblue'
+	| 'firebrick'
+	| 'floralwhite'
+	| 'forestgreen'
+	| 'fuchsia'
+	| 'gainsboro'
+	| 'ghostwhite'
+	| 'gold'
+	| 'goldenrod'
+	| 'gray'
+	| 'green'
+	| 'greenyellow'
+	| 'grey'
+	| 'honeydew'
+	| 'hotpink'
+	| 'indianred'
+	| 'indigo'
+	| 'ivory'
+	| 'khaki'
+	| 'lavender'
+	| 'lavenderblush'
+	| 'lawngreen'
+	| 'lemonchiffon'
+	| 'lightblue'
+	| 'lightcoral'
+	| 'lightcyan'
+	| 'lightgoldenrodyellow'
+	| 'lightgray'
+	| 'lightgreen'
+	| 'lightgrey'
+	| 'lightpink'
+	| 'lightsalmon'
+	| 'lightseagreen'
+	| 'lightskyblue'
+	| 'lightslategray'
+	| 'lightslategrey'
+	| 'lightsteelblue'
+	| 'lightyellow'
+	| 'lime'
+	| 'limegreen'
+	| 'linen'
+	| 'magenta'
+	| 'maroon'
+	| 'mediumaquamarine'
+	| 'mediumblue'
+	| 'mediumorchid'
+	| 'mediumpurple'
+	| 'mediumseagreen'
+	| 'mediumslateblue'
+	| 'mediumspringgreen'
+	| 'mediumturquoise'
+	| 'mediumvioletred'
+	| 'midnightblue'
+	| 'mintcream'
+	| 'mistyrose'
+	| 'moccasin'
+	| 'navajowhite'
+	| 'navy'
+	| 'oldlace'
+	| 'olive'
+	| 'olivedrab'
+	| 'orange'
+	| 'orangered'
+	| 'orchid'
+	| 'palegoldenrod'
+	| 'palegreen'
+	| 'paleturquoise'
+	| 'palevioletred'
+	| 'papayawhip'
+	| 'peachpuff'
+	| 'peru'
+	| 'pink'
+	| 'plum'
+	| 'powderblue'
+	| 'purple'
+	| 'rebeccapurple'
+	| 'red'
+	| 'rosybrown'
+	| 'royalblue'
+	| 'saddlebrown'
+	| 'salmon'
+	| 'sandybrown'
+	| 'seagreen'
+	| 'seashell'
+	| 'sienna'
+	| 'silver'
+	| 'skyblue'
+	| 'slateblue'
+	| 'slategray'
+	| 'slategrey'
+	| 'snow'
+	| 'springgreen'
+	| 'steelblue'
+	| 'tan'
+	| 'teal'
+	| 'thistle'
+	| 'tomato'
+	| 'turquoise'
+	| 'violet'
+	| 'wheat'
+	| 'white'
+	| 'whitesmoke'
+	| 'yellow'
+	| 'yellowgreen';
+
+declare namespace ansiStyles {
+	interface ColorConvert {
+		/**
+		The RGB color space.
+
+		@param red - (`0`-`255`)
+		@param green - (`0`-`255`)
+		@param blue - (`0`-`255`)
+		*/
+		rgb(red: number, green: number, blue: number): string;
+
+		/**
+		The RGB HEX color space.
+
+		@param hex - A hexadecimal string containing RGB data.
+		*/
+		hex(hex: string): string;
+
+		/**
+		@param keyword - A CSS color name.
+		*/
+		keyword(keyword: CSSColor): string;
+
+		/**
+		The HSL color space.
+
+		@param hue - (`0`-`360`)
+		@param saturation - (`0`-`100`)
+		@param lightness - (`0`-`100`)
+		*/
+		hsl(hue: number, saturation: number, lightness: number): string;
+
+		/**
+		The HSV color space.
+
+		@param hue - (`0`-`360`)
+		@param saturation - (`0`-`100`)
+		@param value - (`0`-`100`)
+		*/
+		hsv(hue: number, saturation: number, value: number): string;
+
+		/**
+		The HSV color space.
+
+		@param hue - (`0`-`360`)
+		@param whiteness - (`0`-`100`)
+		@param blackness - (`0`-`100`)
+		*/
+		hwb(hue: number, whiteness: number, blackness: number): string;
+
+		/**
+		Use a [4-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4-bit) to set text color.
+		*/
+		ansi(ansi: number): string;
+
+		/**
+		Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+		*/
+		ansi256(ansi: number): string;
+	}
+
+	interface CSPair {
+		/**
+		The ANSI terminal control sequence for starting this style.
+		*/
+		readonly open: string;
+
+		/**
+		The ANSI terminal control sequence for ending this style.
+		*/
+		readonly close: string;
+	}
+
+	interface ColorBase {
+		readonly ansi: ColorConvert;
+		readonly ansi256: ColorConvert;
+		readonly ansi16m: ColorConvert;
+
+		/**
+		The ANSI terminal control sequence for ending this color.
+		*/
+		readonly close: string;
+	}
+
+	interface Modifier {
+		/**
+		Resets the current color chain.
+		*/
+		readonly reset: CSPair;
+
+		/**
+		Make text bold.
+		*/
+		readonly bold: CSPair;
+
+		/**
+		Emitting only a small amount of light.
+		*/
+		readonly dim: CSPair;
+
+		/**
+		Make text italic. (Not widely supported)
+		*/
+		readonly italic: CSPair;
+
+		/**
+		Make text underline. (Not widely supported)
+		*/
+		readonly underline: CSPair;
+
+		/**
+		Inverse background and foreground colors.
+		*/
+		readonly inverse: CSPair;
+
+		/**
+		Prints the text, but makes it invisible.
+		*/
+		readonly hidden: CSPair;
+
+		/**
+		Puts a horizontal line through the center of the text. (Not widely supported)
+		*/
+		readonly strikethrough: CSPair;
+	}
+
+	interface ForegroundColor {
+		readonly black: CSPair;
+		readonly red: CSPair;
+		readonly green: CSPair;
+		readonly yellow: CSPair;
+		readonly blue: CSPair;
+		readonly cyan: CSPair;
+		readonly magenta: CSPair;
+		readonly white: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly gray: CSPair;
+
+		/**
+		Alias for `blackBright`.
+		*/
+		readonly grey: CSPair;
+
+		readonly blackBright: CSPair;
+		readonly redBright: CSPair;
+		readonly greenBright: CSPair;
+		readonly yellowBright: CSPair;
+		readonly blueBright: CSPair;
+		readonly cyanBright: CSPair;
+		readonly magentaBright: CSPair;
+		readonly whiteBright: CSPair;
+	}
+
+	interface BackgroundColor {
+		readonly bgBlack: CSPair;
+		readonly bgRed: CSPair;
+		readonly bgGreen: CSPair;
+		readonly bgYellow: CSPair;
+		readonly bgBlue: CSPair;
+		readonly bgCyan: CSPair;
+		readonly bgMagenta: CSPair;
+		readonly bgWhite: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGray: CSPair;
+
+		/**
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGrey: CSPair;
+
+		readonly bgBlackBright: CSPair;
+		readonly bgRedBright: CSPair;
+		readonly bgGreenBright: CSPair;
+		readonly bgYellowBright: CSPair;
+		readonly bgBlueBright: CSPair;
+		readonly bgCyanBright: CSPair;
+		readonly bgMagentaBright: CSPair;
+		readonly bgWhiteBright: CSPair;
+	}
+}
+
+declare const ansiStyles: {
+	readonly modifier: ansiStyles.Modifier;
+	readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase;
+	readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase;
+	readonly codes: ReadonlyMap<number, number>;
+} & ansiStyles.BackgroundColor & ansiStyles.ForegroundColor & ansiStyles.Modifier;
+
+export = ansiStyles;

spa/node_modules/node-sass/node_modules/ansi-styles/index.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const wrapAnsi16 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${code + offset}m`;
+};
+
+const wrapAnsi256 = (fn, offset) => (...args) => {
+	const code = fn(...args);
+	return `\u001B[${38 + offset};5;${code}m`;
+};
+
+const wrapAnsi16m = (fn, offset) => (...args) => {
+	const rgb = fn(...args);
+	return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+};
+
+const ansi2ansi = n => n;
+const rgb2rgb = (r, g, b) => [r, g, b];
+
+const setLazyProperty = (object, property, get) => {
+	Object.defineProperty(object, property, {
+		get: () => {
+			const value = get();
+
+			Object.defineProperty(object, property, {
+				value,
+				enumerable: true,
+				configurable: true
+			});
+
+			return value;
+		},
+		enumerable: true,
+		configurable: true
+	});
+};
+
+/** @type {typeof import('color-convert')} */
+let colorConvert;
+const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+	if (colorConvert === undefined) {
+		colorConvert = require('color-convert');
+	}
+
+	const offset = isBackground ? 10 : 0;
+	const styles = {};
+
+	for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+		const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace;
+		if (sourceSpace === targetSpace) {
+			styles[name] = wrap(identity, offset);
+		} else if (typeof suite === 'object') {
+			styles[name] = wrap(suite[targetSpace], offset);
+		}
+	}
+
+	return styles;
+};
+
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+
+			// Bright color
+			blackBright: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+
+	// Alias bright black as gray (and grey)
+	styles.color.gray = styles.color.blackBright;
+	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+	styles.color.grey = styles.color.blackBright;
+	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+
+			group[styleName] = styles[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false
+	});
+
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
+
+	setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false));
+	setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false));
+	setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true));
+	setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true));
+
+	return styles;
+}
+
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});

spa/node_modules/node-sass/node_modules/ansi-styles/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

spa/node_modules/node-sass/node_modules/ansi-styles/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "ansi-styles",
+	"version": "4.3.0",
+	"description": "ANSI escape codes for styling strings in the terminal",
+	"license": "MIT",
+	"repository": "chalk/ansi-styles",
+	"funding": "https://github.com/chalk/ansi-styles?sponsor=1",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd",
+		"screenshot": "svg-term --command='node screenshot' --out=screenshot.svg --padding=3 --width=55 --height=3 --at=1000 --no-cursor"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"dependencies": {
+		"color-convert": "^2.0.1"
+	},
+	"devDependencies": {
+		"@types/color-convert": "^1.9.0",
+		"ava": "^2.3.0",
+		"svg-term-cli": "^2.1.1",
+		"tsd": "^0.11.0",
+		"xo": "^0.25.3"
+	}
+}

spa/node_modules/node-sass/node_modules/ansi-styles/readme.md

@@ -0,0 +1,152 @@
+# ansi-styles [![Build Status](https://travis-ci.org/chalk/ansi-styles.svg?branch=master)](https://travis-ci.org/chalk/ansi-styles)
+
+> [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal
+
+You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings.
+
+<img src="screenshot.svg" width="900">
+
+## Install
+
+```
+$ npm install ansi-styles
+```
+
+## Usage
+
+```js
+const style = require('ansi-styles');
+
+console.log(`${style.green.open}Hello world!${style.green.close}`);
+
+
+// Color conversion between 16/256/truecolor
+// NOTE: If conversion goes to 16 colors or 256 colors, the original color
+//       may be degraded to fit that color palette. This means terminals
+//       that do not support 16 million colors will best-match the
+//       original color.
+console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close);
+console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close);
+console.log(style.color.ansi16m.hex('#abcdef') + 'Hello world!' + style.color.close);
+```
+
+## API
+
+Each style has an `open` and `close` property.
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(Not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(Not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Advanced usage
+
+By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `style.modifier`
+- `style.color`
+- `style.bgColor`
+
+###### Example
+
+```js
+console.log(style.color.green.open);
+```
+
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+
+###### Example
+
+```js
+console.log(style.codes.get(36));
+//=> 39
+```
+
+## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
+
+`ansi-styles` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `keyword`
+- `hsl`
+- `hsv`
+- `hwb`
+- `ansi`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code
+style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code
+
+style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+
+style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code
+style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background code
+```
+
+## Related
+
+- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

spa/node_modules/node-sass/node_modules/chalk/index.d.ts

@@ -0,0 +1,415 @@
+/**
+Basic foreground colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type ForegroundColor =
+	| 'black'
+	| 'red'
+	| 'green'
+	| 'yellow'
+	| 'blue'
+	| 'magenta'
+	| 'cyan'
+	| 'white'
+	| 'gray'
+	| 'grey'
+	| 'blackBright'
+	| 'redBright'
+	| 'greenBright'
+	| 'yellowBright'
+	| 'blueBright'
+	| 'magentaBright'
+	| 'cyanBright'
+	| 'whiteBright';
+
+/**
+Basic background colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type BackgroundColor =
+	| 'bgBlack'
+	| 'bgRed'
+	| 'bgGreen'
+	| 'bgYellow'
+	| 'bgBlue'
+	| 'bgMagenta'
+	| 'bgCyan'
+	| 'bgWhite'
+	| 'bgGray'
+	| 'bgGrey'
+	| 'bgBlackBright'
+	| 'bgRedBright'
+	| 'bgGreenBright'
+	| 'bgYellowBright'
+	| 'bgBlueBright'
+	| 'bgMagentaBright'
+	| 'bgCyanBright'
+	| 'bgWhiteBright';
+
+/**
+Basic colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type Color = ForegroundColor | BackgroundColor;
+
+declare type Modifiers =
+	| 'reset'
+	| 'bold'
+	| 'dim'
+	| 'italic'
+	| 'underline'
+	| 'inverse'
+	| 'hidden'
+	| 'strikethrough'
+	| 'visible';
+
+declare namespace chalk {
+	/**
+	Levels:
+	- `0` - All colors disabled.
+	- `1` - Basic 16 colors support.
+	- `2` - ANSI 256 colors support.
+	- `3` - Truecolor 16 million colors support.
+	*/
+	type Level = 0 | 1 | 2 | 3;
+
+	interface Options {
+		/**
+		Specify the color support for Chalk.
+
+		By default, color support is automatically detected based on the environment.
+
+		Levels:
+		- `0` - All colors disabled.
+		- `1` - Basic 16 colors support.
+		- `2` - ANSI 256 colors support.
+		- `3` - Truecolor 16 million colors support.
+		*/
+		level?: Level;
+	}
+
+	/**
+	Return a new Chalk instance.
+	*/
+	type Instance = new (options?: Options) => Chalk;
+
+	/**
+	Detect whether the terminal supports color.
+	*/
+	interface ColorSupport {
+		/**
+		The color level used by Chalk.
+		*/
+		level: Level;
+
+		/**
+		Return whether Chalk supports basic 16 colors.
+		*/
+		hasBasic: boolean;
+
+		/**
+		Return whether Chalk supports ANSI 256 colors.
+		*/
+		has256: boolean;
+
+		/**
+		Return whether Chalk supports Truecolor 16 million colors.
+		*/
+		has16m: boolean;
+	}
+
+	interface ChalkFunction {
+		/**
+		Use a template string.
+
+		@remarks Template literals are unsupported for nested calls (see [issue #341](https://github.com/chalk/chalk/issues/341))
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		log(chalk`
+		CPU: {red ${cpu.totalPercent}%}
+		RAM: {green ${ram.used / ram.total * 100}%}
+		DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%}
+		`);
+		```
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		log(chalk.red.bgBlack`2 + 3 = {bold ${2 + 3}}`)
+		```
+		*/
+		(text: TemplateStringsArray, ...placeholders: unknown[]): string;
+
+		(...text: unknown[]): string;
+	}
+
+	interface Chalk extends ChalkFunction {
+		/**
+		Return a new Chalk instance.
+		*/
+		Instance: Instance;
+
+		/**
+		The color support for Chalk.
+
+		By default, color support is automatically detected based on the environment.
+
+		Levels:
+		- `0` - All colors disabled.
+		- `1` - Basic 16 colors support.
+		- `2` - ANSI 256 colors support.
+		- `3` - Truecolor 16 million colors support.
+		*/
+		level: Level;
+
+		/**
+		Use HEX value to set text color.
+
+		@param color - Hexadecimal value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.hex('#DEADED');
+		```
+		*/
+		hex(color: string): Chalk;
+
+		/**
+		Use keyword color value to set text color.
+
+		@param color - Keyword value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.keyword('orange');
+		```
+		*/
+		keyword(color: string): Chalk;
+
+		/**
+		Use RGB values to set text color.
+		*/
+		rgb(red: number, green: number, blue: number): Chalk;
+
+		/**
+		Use HSL values to set text color.
+		*/
+		hsl(hue: number, saturation: number, lightness: number): Chalk;
+
+		/**
+		Use HSV values to set text color.
+		*/
+		hsv(hue: number, saturation: number, value: number): Chalk;
+
+		/**
+		Use HWB values to set text color.
+		*/
+		hwb(hue: number, whiteness: number, blackness: number): Chalk;
+
+		/**
+		Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set text color.
+
+		30 <= code && code < 38 || 90 <= code && code < 98
+		For example, 31 for red, 91 for redBright.
+		*/
+		ansi(code: number): Chalk;
+
+		/**
+		Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+		*/
+		ansi256(index: number): Chalk;
+
+		/**
+		Use HEX value to set background color.
+
+		@param color - Hexadecimal value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.bgHex('#DEADED');
+		```
+		*/
+		bgHex(color: string): Chalk;
+
+		/**
+		Use keyword color value to set background color.
+
+		@param color - Keyword value representing the desired color.
+
+		@example
+		```
+		import chalk = require('chalk');
+
+		chalk.bgKeyword('orange');
+		```
+		*/
+		bgKeyword(color: string): Chalk;
+
+		/**
+		Use RGB values to set background color.
+		*/
+		bgRgb(red: number, green: number, blue: number): Chalk;
+
+		/**
+		Use HSL values to set background color.
+		*/
+		bgHsl(hue: number, saturation: number, lightness: number): Chalk;
+
+		/**
+		Use HSV values to set background color.
+		*/
+		bgHsv(hue: number, saturation: number, value: number): Chalk;
+
+		/**
+		Use HWB values to set background color.
+		*/
+		bgHwb(hue: number, whiteness: number, blackness: number): Chalk;
+
+		/**
+		Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set background color.
+
+		30 <= code && code < 38 || 90 <= code && code < 98
+		For example, 31 for red, 91 for redBright.
+		Use the foreground code, not the background code (for example, not 41, nor 101).
+		*/
+		bgAnsi(code: number): Chalk;
+
+		/**
+		Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color.
+		*/
+		bgAnsi256(index: number): Chalk;
+
+		/**
+		Modifier: Resets the current color chain.
+		*/
+		readonly reset: Chalk;
+
+		/**
+		Modifier: Make text bold.
+		*/
+		readonly bold: Chalk;
+
+		/**
+		Modifier: Emitting only a small amount of light.
+		*/
+		readonly dim: Chalk;
+
+		/**
+		Modifier: Make text italic. (Not widely supported)
+		*/
+		readonly italic: Chalk;
+
+		/**
+		Modifier: Make text underline. (Not widely supported)
+		*/
+		readonly underline: Chalk;
+
+		/**
+		Modifier: Inverse background and foreground colors.
+		*/
+		readonly inverse: Chalk;
+
+		/**
+		Modifier: Prints the text, but makes it invisible.
+		*/
+		readonly hidden: Chalk;
+
+		/**
+		Modifier: Puts a horizontal line through the center of the text. (Not widely supported)
+		*/
+		readonly strikethrough: Chalk;
+
+		/**
+		Modifier: Prints the text only when Chalk has a color support level > 0.
+		Can be useful for things that are purely cosmetic.
+		*/
+		readonly visible: Chalk;
+
+		readonly black: Chalk;
+		readonly red: Chalk;
+		readonly green: Chalk;
+		readonly yellow: Chalk;
+		readonly blue: Chalk;
+		readonly magenta: Chalk;
+		readonly cyan: Chalk;
+		readonly white: Chalk;
+
+		/*
+		Alias for `blackBright`.
+		*/
+		readonly gray: Chalk;
+
+		/*
+		Alias for `blackBright`.
+		*/
+		readonly grey: Chalk;
+
+		readonly blackBright: Chalk;
+		readonly redBright: Chalk;
+		readonly greenBright: Chalk;
+		readonly yellowBright: Chalk;
+		readonly blueBright: Chalk;
+		readonly magentaBright: Chalk;
+		readonly cyanBright: Chalk;
+		readonly whiteBright: Chalk;
+
+		readonly bgBlack: Chalk;
+		readonly bgRed: Chalk;
+		readonly bgGreen: Chalk;
+		readonly bgYellow: Chalk;
+		readonly bgBlue: Chalk;
+		readonly bgMagenta: Chalk;
+		readonly bgCyan: Chalk;
+		readonly bgWhite: Chalk;
+
+		/*
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGray: Chalk;
+
+		/*
+		Alias for `bgBlackBright`.
+		*/
+		readonly bgGrey: Chalk;
+
+		readonly bgBlackBright: Chalk;
+		readonly bgRedBright: Chalk;
+		readonly bgGreenBright: Chalk;
+		readonly bgYellowBright: Chalk;
+		readonly bgBlueBright: Chalk;
+		readonly bgMagentaBright: Chalk;
+		readonly bgCyanBright: Chalk;
+		readonly bgWhiteBright: Chalk;
+	}
+}
+
+/**
+Main Chalk object that allows to chain styles together.
+Call the last one as a method with a string argument.
+Order doesn't matter, and later styles take precedent in case of a conflict.
+This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
+*/
+declare const chalk: chalk.Chalk & chalk.ChalkFunction & {
+	supportsColor: chalk.ColorSupport | false;
+	Level: chalk.Level;
+	Color: Color;
+	ForegroundColor: ForegroundColor;
+	BackgroundColor: BackgroundColor;
+	Modifiers: Modifiers;
+	stderr: chalk.Chalk & {supportsColor: chalk.ColorSupport | false};
+};
+
+export = chalk;

spa/node_modules/node-sass/node_modules/chalk/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

spa/node_modules/node-sass/node_modules/chalk/package.json

@@ -0,0 +1,68 @@
+{
+	"name": "chalk",
+	"version": "4.1.2",
+	"description": "Terminal string styling done right",
+	"license": "MIT",
+	"repository": "chalk/chalk",
+	"funding": "https://github.com/chalk/chalk?sponsor=1",
+	"main": "source",
+	"engines": {
+		"node": ">=10"
+	},
+	"scripts": {
+		"test": "xo && nyc ava && tsd",
+		"bench": "matcha benchmark.js"
+	},
+	"files": [
+		"source",
+		"index.d.ts"
+	],
+	"keywords": [
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"str",
+		"ansi",
+		"style",
+		"styles",
+		"tty",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text"
+	],
+	"dependencies": {
+		"ansi-styles": "^4.1.0",
+		"supports-color": "^7.1.0"
+	},
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"coveralls": "^3.0.7",
+		"execa": "^4.0.0",
+		"import-fresh": "^3.1.0",
+		"matcha": "^0.7.0",
+		"nyc": "^15.0.0",
+		"resolve-from": "^5.0.0",
+		"tsd": "^0.7.4",
+		"xo": "^0.28.2"
+	},
+	"xo": {
+		"rules": {
+			"unicorn/prefer-string-slice": "off",
+			"unicorn/prefer-includes": "off",
+			"@typescript-eslint/member-ordering": "off",
+			"no-redeclare": "off",
+			"unicorn/string-content": "off",
+			"unicorn/better-regex": "off"
+		}
+	}
+}

spa/node_modules/node-sass/node_modules/chalk/readme.md

@@ -0,0 +1,341 @@
+<h1 align="center">
+	<br>
+	<br>
+	<img width="320" src="media/logo.svg" alt="Chalk">
+	<br>
+	<br>
+	<br>
+</h1>
+
+> Terminal string styling done right
+
+[![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk) [![Coverage Status](https://coveralls.io/repos/github/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/github/chalk/chalk?branch=master) [![npm dependents](https://badgen.net/npm/dependents/chalk)](https://www.npmjs.com/package/chalk?activeTab=dependents) [![Downloads](https://badgen.net/npm/dt/chalk)](https://www.npmjs.com/package/chalk) [![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/xojs/xo) ![TypeScript-ready](https://img.shields.io/npm/types/chalk.svg) [![run on repl.it](https://repl.it/badge/github/chalk/chalk)](https://repl.it/github/chalk/chalk)
+
+<img src="https://cdn.jsdelivr.net/gh/chalk/ansi-styles@8261697c95bf34b6c7767e2cbe9941a851d59385/screenshot.svg" width="900">
+
+<br>
+
+---
+
+<div align="center">
+	<p>
+		<p>
+			<sup>
+				Sindre Sorhus' open source work is supported by the community on <a href="https://github.com/sponsors/sindresorhus">GitHub Sponsors</a> and <a href="https://stakes.social/0x44d871aebF0126Bf646753E2C976Aa7e68A66c15">Dev</a>
+			</sup>
+		</p>
+		<sup>Special thanks to:</sup>
+		<br>
+		<br>
+		<a href="https://standardresume.co/tech">
+			<img src="https://sindresorhus.com/assets/thanks/standard-resume-logo.svg" width="160"/>
+		</a>
+		<br>
+		<br>
+		<a href="https://retool.com/?utm_campaign=sindresorhus">
+			<img src="https://sindresorhus.com/assets/thanks/retool-logo.svg" width="230"/>
+		</a>
+		<br>
+		<br>
+		<a href="https://doppler.com/?utm_campaign=github_repo&utm_medium=referral&utm_content=chalk&utm_source=github">
+			<div>
+				<img src="https://dashboard.doppler.com/imgs/logo-long.svg" width="240" alt="Doppler">
+			</div>
+			<b>All your environment variables, in one place</b>
+			<div>
+				<span>Stop struggling with scattered API keys, hacking together home-brewed tools,</span>
+				<br>
+				<span>and avoiding access controls. Keep your team and servers in sync with Doppler.</span>
+			</div>
+		</a>
+		<br>
+		<a href="https://uibakery.io/?utm_source=chalk&utm_medium=sponsor&utm_campaign=github">
+			<div>
+				<img src="https://sindresorhus.com/assets/thanks/uibakery-logo.jpg" width="270" alt="UI Bakery">
+			</div>
+		</a>
+	</p>
+</div>
+
+---
+
+<br>
+
+## Highlights
+
+- Expressive API
+- Highly performant
+- Ability to nest styles
+- [256/Truecolor color support](#256-and-truecolor-color-support)
+- Auto-detects color support
+- Doesn't extend `String.prototype`
+- Clean and focused
+- Actively maintained
+- [Used by ~50,000 packages](https://www.npmjs.com/browse/depended/chalk) as of January 1, 2020
+
+## Install
+
+```console
+$ npm install chalk
+```
+
+## Usage
+
+```js
+const chalk = require('chalk');
+
+console.log(chalk.blue('Hello world!'));
+```
+
+Chalk comes with an easy to use composable API where you just chain and nest the styles you want.
+
+```js
+const chalk = require('chalk');
+const log = console.log;
+
+// Combine styled and normal strings
+log(chalk.blue('Hello') + ' World' + chalk.red('!'));
+
+// Compose multiple styles using the chainable API
+log(chalk.blue.bgRed.bold('Hello world!'));
+
+// Pass in multiple arguments
+log(chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz'));
+
+// Nest styles
+log(chalk.red('Hello', chalk.underline.bgBlue('world') + '!'));
+
+// Nest styles of the same type even (color, underline, background)
+log(chalk.green(
+	'I am a green line ' +
+	chalk.blue.underline.bold('with a blue substring') +
+	' that becomes green again!'
+));
+
+// ES2015 template literal
+log(`
+CPU: ${chalk.red('90%')}
+RAM: ${chalk.green('40%')}
+DISK: ${chalk.yellow('70%')}
+`);
+
+// ES2015 tagged template literal
+log(chalk`
+CPU: {red ${cpu.totalPercent}%}
+RAM: {green ${ram.used / ram.total * 100}%}
+DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%}
+`);
+
+// Use RGB colors in terminal emulators that support it.
+log(chalk.keyword('orange')('Yay for orange colored text!'));
+log(chalk.rgb(123, 45, 67).underline('Underlined reddish color'));
+log(chalk.hex('#DEADED').bold('Bold gray!'));
+```
+
+Easily define your own themes:
+
+```js
+const chalk = require('chalk');
+
+const error = chalk.bold.red;
+const warning = chalk.keyword('orange');
+
+console.log(error('Error!'));
+console.log(warning('Warning!'));
+```
+
+Take advantage of console.log [string substitution](https://nodejs.org/docs/latest/api/console.html#console_console_log_data_args):
+
+```js
+const name = 'Sindre';
+console.log(chalk.green('Hello %s'), name);
+//=> 'Hello Sindre'
+```
+
+## API
+
+### chalk.`<style>[.<style>...](string, [string...])`
+
+Example: `chalk.red.bold.underline('Hello', 'world');`
+
+Chain [styles](#styles) and call the last one as a method with a string argument. Order doesn't matter, and later styles take precedent in case of a conflict. This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
+
+Multiple arguments will be separated by space.
+
+### chalk.level
+
+Specifies the level of color support.
+
+Color support is automatically detected, but you can override it by setting the `level` property. You should however only do this in your own code as it applies globally to all Chalk consumers.
+
+If you need to change this in a reusable module, create a new instance:
+
+```js
+const ctx = new chalk.Instance({level: 0});
+```
+
+| Level | Description |
+| :---: | :--- |
+| `0` | All colors disabled |
+| `1` | Basic color support (16 colors) |
+| `2` | 256 color support |
+| `3` | Truecolor support (16 million colors) |
+
+### chalk.supportsColor
+
+Detect whether the terminal [supports color](https://github.com/chalk/supports-color). Used internally and handled for you, but exposed for convenience.
+
+Can be overridden by the user with the flags `--color` and `--no-color`. For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks.
+
+Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively.
+
+### chalk.stderr and chalk.stderr.supportsColor
+
+`chalk.stderr` contains a separate instance configured with color support detected for `stderr` stream instead of `stdout`. Override rules from `chalk.supportsColor` apply to this too. `chalk.stderr.supportsColor` is exposed for convenience.
+
+## Styles
+
+### Modifiers
+
+- `reset` - Resets the current color chain.
+- `bold` - Make text bold.
+- `dim` - Emitting only a small amount of light.
+- `italic` - Make text italic. *(Not widely supported)*
+- `underline` - Make text underline. *(Not widely supported)*
+- `inverse`- Inverse background and foreground colors.
+- `hidden` - Prints the text, but makes it invisible.
+- `strikethrough` - Puts a horizontal line through the center of the text. *(Not widely supported)*
+- `visible`- Prints the text only when Chalk has a color level > 0. Can be useful for things that are purely cosmetic.
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Tagged template literal
+
+Chalk can be used as a [tagged template literal](https://exploringjs.com/es6/ch_template-literals.html#_tagged-template-literals).
+
+```js
+const chalk = require('chalk');
+
+const miles = 18;
+const calculateFeet = miles => miles * 5280;
+
+console.log(chalk`
+	There are {bold 5280 feet} in a mile.
+	In {bold ${miles} miles}, there are {green.bold ${calculateFeet(miles)} feet}.
+`);
+```
+
+Blocks are delimited by an opening curly brace (`{`), a style, some content, and a closing curly brace (`}`).
+
+Template styles are chained exactly like normal Chalk styles. The following three statements are equivalent:
+
+```js
+console.log(chalk.bold.rgb(10, 100, 200)('Hello!'));
+console.log(chalk.bold.rgb(10, 100, 200)`Hello!`);
+console.log(chalk`{bold.rgb(10,100,200) Hello!}`);
+```
+
+Note that function styles (`rgb()`, `hsl()`, `keyword()`, etc.) may not contain spaces between parameters.
+
+All interpolated values (`` chalk`${foo}` ``) are converted to strings via the `.toString()` method. All curly braces (`{` and `}`) in interpolated value strings are escaped.
+
+## 256 and Truecolor color support
+
+Chalk supports 256 colors and [Truecolor](https://gist.github.com/XVilka/8346728) (16 million colors) on supported terminal apps.
+
+Colors are downsampled from 16 million RGB values to an ANSI color format that is supported by the terminal emulator (or by specifying `{level: n}` as a Chalk option). For example, Chalk configured to run at level 1 (basic color support) will downsample an RGB value of #FF0000 (red) to 31 (ANSI escape for red).
+
+Examples:
+
+- `chalk.hex('#DEADED').underline('Hello, world!')`
+- `chalk.keyword('orange')('Some orange text')`
+- `chalk.rgb(15, 100, 204).inverse('Hello!')`
+
+Background versions of these models are prefixed with `bg` and the first level of the module capitalized (e.g. `keyword` for foreground colors and `bgKeyword` for background colors).
+
+- `chalk.bgHex('#DEADED').underline('Hello, world!')`
+- `chalk.bgKeyword('orange')('Some orange text')`
+- `chalk.bgRgb(15, 100, 204).inverse('Hello!')`
+
+The following color models can be used:
+
+- [`rgb`](https://en.wikipedia.org/wiki/RGB_color_model) - Example: `chalk.rgb(255, 136, 0).bold('Orange!')`
+- [`hex`](https://en.wikipedia.org/wiki/Web_colors#Hex_triplet) - Example: `chalk.hex('#FF8800').bold('Orange!')`
+- [`keyword`](https://www.w3.org/wiki/CSS/Properties/color/keywords) (CSS keywords) - Example: `chalk.keyword('orange').bold('Orange!')`
+- [`hsl`](https://en.wikipedia.org/wiki/HSL_and_HSV) - Example: `chalk.hsl(32, 100, 50).bold('Orange!')`
+- [`hsv`](https://en.wikipedia.org/wiki/HSL_and_HSV) - Example: `chalk.hsv(32, 100, 100).bold('Orange!')`
+- [`hwb`](https://en.wikipedia.org/wiki/HWB_color_model) - Example: `chalk.hwb(32, 0, 50).bold('Orange!')`
+- [`ansi`](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) - Example: `chalk.ansi(31).bgAnsi(93)('red on yellowBright')`
+- [`ansi256`](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) - Example: `chalk.bgAnsi256(194)('Honeydew, more or less')`
+
+## Windows
+
+If you're on Windows, do yourself a favor and use [Windows Terminal](https://github.com/microsoft/terminal) instead of `cmd.exe`.
+
+## Origin story
+
+[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68) and the package is unmaintained. Although there are other packages, they either do too much or not enough. Chalk is a clean and focused alternative.
+
+## chalk for enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of chalk and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-chalk?utm_source=npm-chalk&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
+
+## Related
+
+- [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module
+- [ansi-styles](https://github.com/chalk/ansi-styles) - ANSI escape codes for styling strings in the terminal
+- [supports-color](https://github.com/chalk/supports-color) - Detect whether a terminal supports color
+- [strip-ansi](https://github.com/chalk/strip-ansi) - Strip ANSI escape codes
+- [strip-ansi-stream](https://github.com/chalk/strip-ansi-stream) - Strip ANSI escape codes from a stream
+- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes
+- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes
+- [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes
+- [slice-ansi](https://github.com/chalk/slice-ansi) - Slice a string with ANSI escape codes
+- [color-convert](https://github.com/qix-/color-convert) - Converts colors between different models
+- [chalk-animation](https://github.com/bokub/chalk-animation) - Animate strings in the terminal
+- [gradient-string](https://github.com/bokub/gradient-string) - Apply color gradients to strings
+- [chalk-pipe](https://github.com/LitoMore/chalk-pipe) - Create chalk style schemes with simpler style strings
+- [terminal-link](https://github.com/sindresorhus/terminal-link) - Create clickable links in the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)

spa/node_modules/node-sass/node_modules/chalk/source/index.js

@@ -0,0 +1,229 @@
+'use strict';
+const ansiStyles = require('ansi-styles');
+const {stdout: stdoutColor, stderr: stderrColor} = require('supports-color');
+const {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+} = require('./util');
+
+const {isArray} = Array;
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = [
+	'ansi',
+	'ansi',
+	'ansi256',
+	'ansi16m'
+];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+		throw new Error('The `level` option should be an integer from 0 to 3');
+	}
+
+	// Detect level if not set manually
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+class ChalkClass {
+	constructor(options) {
+		// eslint-disable-next-line no-constructor-return
+		return chalkFactory(options);
+	}
+}
+
+const chalkFactory = options => {
+	const chalk = {};
+	applyOptions(chalk, options);
+
+	chalk.template = (...arguments_) => chalkTag(chalk.template, ...arguments_);
+
+	Object.setPrototypeOf(chalk, Chalk.prototype);
+	Object.setPrototypeOf(chalk.template, chalk);
+
+	chalk.template.constructor = () => {
+		throw new Error('`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.');
+	};
+
+	chalk.template.Instance = ChalkClass;
+
+	return chalk.template;
+};
+
+function Chalk(options) {
+	return chalkFactory(options);
+}
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+	styles[styleName] = {
+		get() {
+			const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+			Object.defineProperty(this, styleName, {value: builder});
+			return builder;
+		}
+	};
+}
+
+styles.visible = {
+	get() {
+		const builder = createBuilder(this, this._styler, true);
+		Object.defineProperty(this, 'visible', {value: builder});
+		return builder;
+	}
+};
+
+const usedModels = ['rgb', 'hex', 'keyword', 'hsl', 'hsv', 'hwb', 'ansi', 'ansi256'];
+
+for (const model of usedModels) {
+	styles[model] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		}
+	};
+}
+
+for (const model of usedModels) {
+	const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = {
+		get() {
+			const {level} = this;
+			return function (...arguments_) {
+				const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+				return createBuilder(this, styler, this._isEmpty);
+			};
+		}
+	};
+}
+
+const proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this._generator.level;
+		},
+		set(level) {
+			this._generator.level = level;
+		}
+	}
+});
+
+const createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === undefined) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => {
+		if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+			// Called as a template literal, for example: chalk.red`2 + 3 = {bold ${2+3}}`
+			return applyStyle(builder, chalkTag(builder, ...arguments_));
+		}
+
+		// Single argument is hot path, implicit coercion is faster than anything
+		// eslint-disable-next-line no-implicit-coercion
+		return applyStyle(builder, (arguments_.length === 1) ? ('' + arguments_[0]) : arguments_.join(' '));
+	};
+
+	// We alter the prototype because we must return a function, but there is
+	// no way to create a function with a different prototype
+	Object.setPrototypeOf(builder, proto);
+
+	builder._generator = self;
+	builder._styler = _styler;
+	builder._isEmpty = _isEmpty;
+
+	return builder;
+};
+
+const applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) {
+		return self._isEmpty ? '' : string;
+	}
+
+	let styler = self._styler;
+
+	if (styler === undefined) {
+		return string;
+	}
+
+	const {openAll, closeAll} = styler;
+	if (string.indexOf('\u001B') !== -1) {
+		while (styler !== undefined) {
+			// Replace any instances already present with a re-opening code
+			// otherwise only the part of the string until said closing code
+			// will be colored, and the rest will simply be 'plain'.
+			string = stringReplaceAll(string, styler.close, styler.open);
+
+			styler = styler.parent;
+		}
+	}
+
+	// We can move both next actions out of loop, because remaining actions in loop won't have
+	// any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+	// after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+	const lfIndex = string.indexOf('\n');
+	if (lfIndex !== -1) {
+		string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	}
+
+	return openAll + string + closeAll;
+};
+
+let template;
+const chalkTag = (chalk, ...strings) => {
+	const [firstString] = strings;
+
+	if (!isArray(firstString) || !isArray(firstString.raw)) {
+		// If chalk() was called by itself or with a string,
+		// return the string itself as a string.
+		return strings.join(' ');
+	}
+
+	const arguments_ = strings.slice(1);
+	const parts = [firstString.raw[0]];
+
+	for (let i = 1; i < firstString.length; i++) {
+		parts.push(
+			String(arguments_[i - 1]).replace(/[{}\\]/g, '\\$&'),
+			String(firstString.raw[i])
+		);
+	}
+
+	if (template === undefined) {
+		template = require('./templates');
+	}
+
+	return template(chalk, parts.join(''));
+};
+
+Object.defineProperties(Chalk.prototype, styles);
+
+const chalk = Chalk(); // eslint-disable-line new-cap
+chalk.supportsColor = stdoutColor;
+chalk.stderr = Chalk({level: stderrColor ? stderrColor.level : 0}); // eslint-disable-line new-cap
+chalk.stderr.supportsColor = stderrColor;
+
+module.exports = chalk;

spa/node_modules/node-sass/node_modules/chalk/source/templates.js

@@ -0,0 +1,134 @@
+'use strict';
+const TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+const STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+const STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+const ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+
+const ESCAPES = new Map([
+	['n', '\n'],
+	['r', '\r'],
+	['t', '\t'],
+	['b', '\b'],
+	['f', '\f'],
+	['v', '\v'],
+	['0', '\0'],
+	['\\', '\\'],
+	['e', '\u001B'],
+	['a', '\u0007']
+]);
+
+function unescape(c) {
+	const u = c[0] === 'u';
+	const bracket = c[1] === '{';
+
+	if ((u && !bracket && c.length === 5) || (c[0] === 'x' && c.length === 3)) {
+		return String.fromCharCode(parseInt(c.slice(1), 16));
+	}
+
+	if (u && bracket) {
+		return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+	}
+
+	return ESCAPES.get(c) || c;
+}
+
+function parseArguments(name, arguments_) {
+	const results = [];
+	const chunks = arguments_.trim().split(/\s*,\s*/g);
+	let matches;
+
+	for (const chunk of chunks) {
+		const number = Number(chunk);
+		if (!Number.isNaN(number)) {
+			results.push(number);
+		} else if ((matches = chunk.match(STRING_REGEX))) {
+			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+		} else {
+			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+		}
+	}
+
+	return results;
+}
+
+function parseStyle(style) {
+	STYLE_REGEX.lastIndex = 0;
+
+	const results = [];
+	let matches;
+
+	while ((matches = STYLE_REGEX.exec(style)) !== null) {
+		const name = matches[1];
+
+		if (matches[2]) {
+			const args = parseArguments(name, matches[2]);
+			results.push([name].concat(args));
+		} else {
+			results.push([name]);
+		}
+	}
+
+	return results;
+}
+
+function buildStyle(chalk, styles) {
+	const enabled = {};
+
+	for (const layer of styles) {
+		for (const style of layer.styles) {
+			enabled[style[0]] = layer.inverse ? null : style.slice(1);
+		}
+	}
+
+	let current = chalk;
+	for (const [styleName, styles] of Object.entries(enabled)) {
+		if (!Array.isArray(styles)) {
+			continue;
+		}
+
+		if (!(styleName in current)) {
+			throw new Error(`Unknown Chalk style: ${styleName}`);
+		}
+
+		current = styles.length > 0 ? current[styleName](...styles) : current[styleName];
+	}
+
+	return current;
+}
+
+module.exports = (chalk, temporary) => {
+	const styles = [];
+	const chunks = [];
+	let chunk = [];
+
+	// eslint-disable-next-line max-params
+	temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+		if (escapeCharacter) {
+			chunk.push(unescape(escapeCharacter));
+		} else if (style) {
+			const string = chunk.join('');
+			chunk = [];
+			chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
+			styles.push({inverse, styles: parseStyle(style)});
+		} else if (close) {
+			if (styles.length === 0) {
+				throw new Error('Found extraneous } in Chalk template literal');
+			}
+
+			chunks.push(buildStyle(chalk, styles)(chunk.join('')));
+			chunk = [];
+			styles.pop();
+		} else {
+			chunk.push(character);
+		}
+	});
+
+	chunks.push(chunk.join(''));
+
+	if (styles.length > 0) {
+		const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? '' : 's'} (\`}\`)`;
+		throw new Error(errMessage);
+	}
+
+	return chunks.join('');
+};

spa/node_modules/node-sass/node_modules/chalk/source/util.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const stringReplaceAll = (string, substring, replacer) => {
+	let index = string.indexOf(substring);
+	if (index === -1) {
+		return string;
+	}
+
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+const stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+	let endIndex = 0;
+	let returnValue = '';
+	do {
+		const gotCR = string[index - 1] === '\r';
+		returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+		endIndex = index + 1;
+		index = string.indexOf('\n', endIndex);
+	} while (index !== -1);
+
+	returnValue += string.substr(endIndex);
+	return returnValue;
+};
+
+module.exports = {
+	stringReplaceAll,
+	stringEncaseCRLFWithFirstIndex
+};

spa/node_modules/node-sass/node_modules/color-convert/CHANGELOG.md

@@ -0,0 +1,54 @@
+# 1.0.0 - 2016-01-07
+
+- Removed: unused speed test
+- Added: Automatic routing between previously unsupported conversions
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Removed: `xxx2xxx()` and `xxx2xxxRaw()` functions
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Removed: `convert()` class
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Changed: all functions to lookup dictionary
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Changed: `ansi` to `ansi256`
+([#27](https://github.com/Qix-/color-convert/pull/27))
+- Fixed: argument grouping for functions requiring only one argument
+([#27](https://github.com/Qix-/color-convert/pull/27))
+
+# 0.6.0 - 2015-07-23
+
+- Added: methods to handle
+[ANSI](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors) 16/256 colors:
+  - rgb2ansi16
+  - rgb2ansi
+  - hsl2ansi16
+  - hsl2ansi
+  - hsv2ansi16
+  - hsv2ansi
+  - hwb2ansi16
+  - hwb2ansi
+  - cmyk2ansi16
+  - cmyk2ansi
+  - keyword2ansi16
+  - keyword2ansi
+  - ansi162rgb
+  - ansi162hsl
+  - ansi162hsv
+  - ansi162hwb
+  - ansi162cmyk
+  - ansi162keyword
+  - ansi2rgb
+  - ansi2hsl
+  - ansi2hsv
+  - ansi2hwb
+  - ansi2cmyk
+  - ansi2keyword
+([#18](https://github.com/harthur/color-convert/pull/18))
+
+# 0.5.3 - 2015-06-02
+
+- Fixed: hsl2hsv does not return `NaN` anymore when using `[0,0,0]`
+([#15](https://github.com/harthur/color-convert/issues/15))
+
+---
+
+Check out commit logs for older releases

spa/node_modules/node-sass/node_modules/color-convert/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011-2016 Heather Arthur <fayearthur@gmail.com>
+
+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.
+

spa/node_modules/node-sass/node_modules/color-convert/README.md

@@ -0,0 +1,68 @@
+# color-convert
+
+[![Build Status](https://travis-ci.org/Qix-/color-convert.svg?branch=master)](https://travis-ci.org/Qix-/color-convert)
+
+Color-convert is a color conversion library for JavaScript and node.
+It converts all ways between `rgb`, `hsl`, `hsv`, `hwb`, `cmyk`, `ansi`, `ansi16`, `hex` strings, and CSS `keyword`s (will round to closest):
+
+```js
+var convert = require('color-convert');
+
+convert.rgb.hsl(140, 200, 100);             // [96, 48, 59]
+convert.keyword.rgb('blue');                // [0, 0, 255]
+
+var rgbChannels = convert.rgb.channels;     // 3
+var cmykChannels = convert.cmyk.channels;   // 4
+var ansiChannels = convert.ansi16.channels; // 1
+```
+
+# Install
+
+```console
+$ npm install color-convert
+```
+
+# API
+
+Simply get the property of the _from_ and _to_ conversion that you're looking for.
+
+All functions have a rounded and unrounded variant. By default, return values are rounded. To get the unrounded (raw) results, simply tack on `.raw` to the function.
+
+All 'from' functions have a hidden property called `.channels` that indicates the number of channels the function expects (not including alpha).
+
+```js
+var convert = require('color-convert');
+
+// Hex to LAB
+convert.hex.lab('DEADBF');         // [ 76, 21, -2 ]
+convert.hex.lab.raw('DEADBF');     // [ 75.56213190997677, 20.653827952644754, -2.290532499330533 ]
+
+// RGB to CMYK
+convert.rgb.cmyk(167, 255, 4);     // [ 35, 0, 98, 0 ]
+convert.rgb.cmyk.raw(167, 255, 4); // [ 34.509803921568626, 0, 98.43137254901961, 0 ]
+```
+
+### Arrays
+All functions that accept multiple arguments also support passing an array.
+
+Note that this does **not** apply to functions that convert from a color that only requires one value (e.g. `keyword`, `ansi256`, `hex`, etc.)
+
+```js
+var convert = require('color-convert');
+
+convert.rgb.hex(123, 45, 67);      // '7B2D43'
+convert.rgb.hex([123, 45, 67]);    // '7B2D43'
+```
+
+## Routing
+
+Conversions that don't have an _explicitly_ defined conversion (in [conversions.js](conversions.js)), but can be converted by means of sub-conversions (e.g. XYZ -> **RGB** -> CMYK), are automatically routed together. This allows just about any color model supported by `color-convert` to be converted to any other model, so long as a sub-conversion path exists. This is also true for conversions requiring more than one step in between (e.g. LCH -> **LAB** -> **XYZ** -> **RGB** -> Hex).
+
+Keep in mind that extensive conversions _may_ result in a loss of precision, and exist only to be complete. For a list of "direct" (single-step) conversions, see [conversions.js](conversions.js).
+
+# Contribute
+
+If there is a new model you would like to support, or want to add a direct conversion between two existing models, please send us a pull request.
+
+# License
+Copyright © 2011-2016, Heather Arthur and Josh Junon. Licensed under the [MIT License](LICENSE).

spa/node_modules/node-sass/node_modules/color-convert/conversions.js

@@ -0,0 +1,839 @@
+/* MIT license */
+/* eslint-disable no-mixed-operators */
+const cssKeywords = require('color-name');
+
+// NOTE: conversions should only return primitive values (i.e. arrays, or
+//       values that give correct `typeof` results).
+//       do not use box values types (i.e. Number(), String(), etc.)
+
+const reverseKeywords = {};
+for (const key of Object.keys(cssKeywords)) {
+	reverseKeywords[cssKeywords[key]] = key;
+}
+
+const convert = {
+	rgb: {channels: 3, labels: 'rgb'},
+	hsl: {channels: 3, labels: 'hsl'},
+	hsv: {channels: 3, labels: 'hsv'},
+	hwb: {channels: 3, labels: 'hwb'},
+	cmyk: {channels: 4, labels: 'cmyk'},
+	xyz: {channels: 3, labels: 'xyz'},
+	lab: {channels: 3, labels: 'lab'},
+	lch: {channels: 3, labels: 'lch'},
+	hex: {channels: 1, labels: ['hex']},
+	keyword: {channels: 1, labels: ['keyword']},
+	ansi16: {channels: 1, labels: ['ansi16']},
+	ansi256: {channels: 1, labels: ['ansi256']},
+	hcg: {channels: 3, labels: ['h', 'c', 'g']},
+	apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
+	gray: {channels: 1, labels: ['gray']}
+};
+
+module.exports = convert;
+
+// Hide .channels and .labels properties
+for (const model of Object.keys(convert)) {
+	if (!('channels' in convert[model])) {
+		throw new Error('missing channels property: ' + model);
+	}
+
+	if (!('labels' in convert[model])) {
+		throw new Error('missing channel labels property: ' + model);
+	}
+
+	if (convert[model].labels.length !== convert[model].channels) {
+		throw new Error('channel and label counts mismatch: ' + model);
+	}
+
+	const {channels, labels} = convert[model];
+	delete convert[model].channels;
+	delete convert[model].labels;
+	Object.defineProperty(convert[model], 'channels', {value: channels});
+	Object.defineProperty(convert[model], 'labels', {value: labels});
+}
+
+convert.rgb.hsl = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const min = Math.min(r, g, b);
+	const max = Math.max(r, g, b);
+	const delta = max - min;
+	let h;
+	let s;
+
+	if (max === min) {
+		h = 0;
+	} else if (r === max) {
+		h = (g - b) / delta;
+	} else if (g === max) {
+		h = 2 + (b - r) / delta;
+	} else if (b === max) {
+		h = 4 + (r - g) / delta;
+	}
+
+	h = Math.min(h * 60, 360);
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	const l = (min + max) / 2;
+
+	if (max === min) {
+		s = 0;
+	} else if (l <= 0.5) {
+		s = delta / (max + min);
+	} else {
+		s = delta / (2 - max - min);
+	}
+
+	return [h, s * 100, l * 100];
+};
+
+convert.rgb.hsv = function (rgb) {
+	let rdif;
+	let gdif;
+	let bdif;
+	let h;
+	let s;
+
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const v = Math.max(r, g, b);
+	const diff = v - Math.min(r, g, b);
+	const diffc = function (c) {
+		return (v - c) / 6 / diff + 1 / 2;
+	};
+
+	if (diff === 0) {
+		h = 0;
+		s = 0;
+	} else {
+		s = diff / v;
+		rdif = diffc(r);
+		gdif = diffc(g);
+		bdif = diffc(b);
+
+		if (r === v) {
+			h = bdif - gdif;
+		} else if (g === v) {
+			h = (1 / 3) + rdif - bdif;
+		} else if (b === v) {
+			h = (2 / 3) + gdif - rdif;
+		}
+
+		if (h < 0) {
+			h += 1;
+		} else if (h > 1) {
+			h -= 1;
+		}
+	}
+
+	return [
+		h * 360,
+		s * 100,
+		v * 100
+	];
+};
+
+convert.rgb.hwb = function (rgb) {
+	const r = rgb[0];
+	const g = rgb[1];
+	let b = rgb[2];
+	const h = convert.rgb.hsl(rgb)[0];
+	const w = 1 / 255 * Math.min(r, Math.min(g, b));
+
+	b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+
+	return [h, w * 100, b * 100];
+};
+
+convert.rgb.cmyk = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+
+	const k = Math.min(1 - r, 1 - g, 1 - b);
+	const c = (1 - r - k) / (1 - k) || 0;
+	const m = (1 - g - k) / (1 - k) || 0;
+	const y = (1 - b - k) / (1 - k) || 0;
+
+	return [c * 100, m * 100, y * 100, k * 100];
+};
+
+function comparativeDistance(x, y) {
+	/*
+		See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
+	*/
+	return (
+		((x[0] - y[0]) ** 2) +
+		((x[1] - y[1]) ** 2) +
+		((x[2] - y[2]) ** 2)
+	);
+}
+
+convert.rgb.keyword = function (rgb) {
+	const reversed = reverseKeywords[rgb];
+	if (reversed) {
+		return reversed;
+	}
+
+	let currentClosestDistance = Infinity;
+	let currentClosestKeyword;
+
+	for (const keyword of Object.keys(cssKeywords)) {
+		const value = cssKeywords[keyword];
+
+		// Compute comparative distance
+		const distance = comparativeDistance(rgb, value);
+
+		// Check if its less, if so set as closest
+		if (distance < currentClosestDistance) {
+			currentClosestDistance = distance;
+			currentClosestKeyword = keyword;
+		}
+	}
+
+	return currentClosestKeyword;
+};
+
+convert.keyword.rgb = function (keyword) {
+	return cssKeywords[keyword];
+};
+
+convert.rgb.xyz = function (rgb) {
+	let r = rgb[0] / 255;
+	let g = rgb[1] / 255;
+	let b = rgb[2] / 255;
+
+	// Assume sRGB
+	r = r > 0.04045 ? (((r + 0.055) / 1.055) ** 2.4) : (r / 12.92);
+	g = g > 0.04045 ? (((g + 0.055) / 1.055) ** 2.4) : (g / 12.92);
+	b = b > 0.04045 ? (((b + 0.055) / 1.055) ** 2.4) : (b / 12.92);
+
+	const x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
+	const y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
+	const z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);
+
+	return [x * 100, y * 100, z * 100];
+};
+
+convert.rgb.lab = function (rgb) {
+	const xyz = convert.rgb.xyz(rgb);
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert.hsl.rgb = function (hsl) {
+	const h = hsl[0] / 360;
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+	let t2;
+	let t3;
+	let val;
+
+	if (s === 0) {
+		val = l * 255;
+		return [val, val, val];
+	}
+
+	if (l < 0.5) {
+		t2 = l * (1 + s);
+	} else {
+		t2 = l + s - l * s;
+	}
+
+	const t1 = 2 * l - t2;
+
+	const rgb = [0, 0, 0];
+	for (let i = 0; i < 3; i++) {
+		t3 = h + 1 / 3 * -(i - 1);
+		if (t3 < 0) {
+			t3++;
+		}
+
+		if (t3 > 1) {
+			t3--;
+		}
+
+		if (6 * t3 < 1) {
+			val = t1 + (t2 - t1) * 6 * t3;
+		} else if (2 * t3 < 1) {
+			val = t2;
+		} else if (3 * t3 < 2) {
+			val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+		} else {
+			val = t1;
+		}
+
+		rgb[i] = val * 255;
+	}
+
+	return rgb;
+};
+
+convert.hsl.hsv = function (hsl) {
+	const h = hsl[0];
+	let s = hsl[1] / 100;
+	let l = hsl[2] / 100;
+	let smin = s;
+	const lmin = Math.max(l, 0.01);
+
+	l *= 2;
+	s *= (l <= 1) ? l : 2 - l;
+	smin *= lmin <= 1 ? lmin : 2 - lmin;
+	const v = (l + s) / 2;
+	const sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);
+
+	return [h, sv * 100, v * 100];
+};
+
+convert.hsv.rgb = function (hsv) {
+	const h = hsv[0] / 60;
+	const s = hsv[1] / 100;
+	let v = hsv[2] / 100;
+	const hi = Math.floor(h) % 6;
+
+	const f = h - Math.floor(h);
+	const p = 255 * v * (1 - s);
+	const q = 255 * v * (1 - (s * f));
+	const t = 255 * v * (1 - (s * (1 - f)));
+	v *= 255;
+
+	switch (hi) {
+		case 0:
+			return [v, t, p];
+		case 1:
+			return [q, v, p];
+		case 2:
+			return [p, v, t];
+		case 3:
+			return [p, q, v];
+		case 4:
+			return [t, p, v];
+		case 5:
+			return [v, p, q];
+	}
+};
+
+convert.hsv.hsl = function (hsv) {
+	const h = hsv[0];
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+	const vmin = Math.max(v, 0.01);
+	let sl;
+	let l;
+
+	l = (2 - s) * v;
+	const lmin = (2 - s) * vmin;
+	sl = s * vmin;
+	sl /= (lmin <= 1) ? lmin : 2 - lmin;
+	sl = sl || 0;
+	l /= 2;
+
+	return [h, sl * 100, l * 100];
+};
+
+// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
+convert.hwb.rgb = function (hwb) {
+	const h = hwb[0] / 360;
+	let wh = hwb[1] / 100;
+	let bl = hwb[2] / 100;
+	const ratio = wh + bl;
+	let f;
+
+	// Wh + bl cant be > 1
+	if (ratio > 1) {
+		wh /= ratio;
+		bl /= ratio;
+	}
+
+	const i = Math.floor(6 * h);
+	const v = 1 - bl;
+	f = 6 * h - i;
+
+	if ((i & 0x01) !== 0) {
+		f = 1 - f;
+	}
+
+	const n = wh + f * (v - wh); // Linear interpolation
+
+	let r;
+	let g;
+	let b;
+	/* eslint-disable max-statements-per-line,no-multi-spaces */
+	switch (i) {
+		default:
+		case 6:
+		case 0: r = v;  g = n;  b = wh; break;
+		case 1: r = n;  g = v;  b = wh; break;
+		case 2: r = wh; g = v;  b = n; break;
+		case 3: r = wh; g = n;  b = v; break;
+		case 4: r = n;  g = wh; b = v; break;
+		case 5: r = v;  g = wh; b = n; break;
+	}
+	/* eslint-enable max-statements-per-line,no-multi-spaces */
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.cmyk.rgb = function (cmyk) {
+	const c = cmyk[0] / 100;
+	const m = cmyk[1] / 100;
+	const y = cmyk[2] / 100;
+	const k = cmyk[3] / 100;
+
+	const r = 1 - Math.min(1, c * (1 - k) + k);
+	const g = 1 - Math.min(1, m * (1 - k) + k);
+	const b = 1 - Math.min(1, y * (1 - k) + k);
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.rgb = function (xyz) {
+	const x = xyz[0] / 100;
+	const y = xyz[1] / 100;
+	const z = xyz[2] / 100;
+	let r;
+	let g;
+	let b;
+
+	r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
+	g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
+	b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);
+
+	// Assume sRGB
+	r = r > 0.0031308
+		? ((1.055 * (r ** (1.0 / 2.4))) - 0.055)
+		: r * 12.92;
+
+	g = g > 0.0031308
+		? ((1.055 * (g ** (1.0 / 2.4))) - 0.055)
+		: g * 12.92;
+
+	b = b > 0.0031308
+		? ((1.055 * (b ** (1.0 / 2.4))) - 0.055)
+		: b * 12.92;
+
+	r = Math.min(Math.max(0, r), 1);
+	g = Math.min(Math.max(0, g), 1);
+	b = Math.min(Math.max(0, b), 1);
+
+	return [r * 255, g * 255, b * 255];
+};
+
+convert.xyz.lab = function (xyz) {
+	let x = xyz[0];
+	let y = xyz[1];
+	let z = xyz[2];
+
+	x /= 95.047;
+	y /= 100;
+	z /= 108.883;
+
+	x = x > 0.008856 ? (x ** (1 / 3)) : (7.787 * x) + (16 / 116);
+	y = y > 0.008856 ? (y ** (1 / 3)) : (7.787 * y) + (16 / 116);
+	z = z > 0.008856 ? (z ** (1 / 3)) : (7.787 * z) + (16 / 116);
+
+	const l = (116 * y) - 16;
+	const a = 500 * (x - y);
+	const b = 200 * (y - z);
+
+	return [l, a, b];
+};
+
+convert.lab.xyz = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let x;
+	let y;
+	let z;
+
+	y = (l + 16) / 116;
+	x = a / 500 + y;
+	z = y - b / 200;
+
+	const y2 = y ** 3;
+	const x2 = x ** 3;
+	const z2 = z ** 3;
+	y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+	x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+	z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+
+	x *= 95.047;
+	y *= 100;
+	z *= 108.883;
+
+	return [x, y, z];
+};
+
+convert.lab.lch = function (lab) {
+	const l = lab[0];
+	const a = lab[1];
+	const b = lab[2];
+	let h;
+
+	const hr = Math.atan2(b, a);
+	h = hr * 360 / 2 / Math.PI;
+
+	if (h < 0) {
+		h += 360;
+	}
+
+	const c = Math.sqrt(a * a + b * b);
+
+	return [l, c, h];
+};
+
+convert.lch.lab = function (lch) {
+	const l = lch[0];
+	const c = lch[1];
+	const h = lch[2];
+
+	const hr = h / 360 * 2 * Math.PI;
+	const a = c * Math.cos(hr);
+	const b = c * Math.sin(hr);
+
+	return [l, a, b];
+};
+
+convert.rgb.ansi16 = function (args, saturation = null) {
+	const [r, g, b] = args;
+	let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation; // Hsv -> ansi16 optimization
+
+	value = Math.round(value / 50);
+
+	if (value === 0) {
+		return 30;
+	}
+
+	let ansi = 30
+		+ ((Math.round(b / 255) << 2)
+		| (Math.round(g / 255) << 1)
+		| Math.round(r / 255));
+
+	if (value === 2) {
+		ansi += 60;
+	}
+
+	return ansi;
+};
+
+convert.hsv.ansi16 = function (args) {
+	// Optimization here; we already know the value and don't need to get
+	// it converted for us.
+	return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+};
+
+convert.rgb.ansi256 = function (args) {
+	const r = args[0];
+	const g = args[1];
+	const b = args[2];
+
+	// We use the extended greyscale palette here, with the exception of
+	// black and white. normal palette only has 4 greyscale shades.
+	if (r === g && g === b) {
+		if (r < 8) {
+			return 16;
+		}
+
+		if (r > 248) {
+			return 231;
+		}
+
+		return Math.round(((r - 8) / 247) * 24) + 232;
+	}
+
+	const ansi = 16
+		+ (36 * Math.round(r / 255 * 5))
+		+ (6 * Math.round(g / 255 * 5))
+		+ Math.round(b / 255 * 5);
+
+	return ansi;
+};
+
+convert.ansi16.rgb = function (args) {
+	let color = args % 10;
+
+	// Handle greyscale
+	if (color === 0 || color === 7) {
+		if (args > 50) {
+			color += 3.5;
+		}
+
+		color = color / 10.5 * 255;
+
+		return [color, color, color];
+	}
+
+	const mult = (~~(args > 50) + 1) * 0.5;
+	const r = ((color & 1) * mult) * 255;
+	const g = (((color >> 1) & 1) * mult) * 255;
+	const b = (((color >> 2) & 1) * mult) * 255;
+
+	return [r, g, b];
+};
+
+convert.ansi256.rgb = function (args) {
+	// Handle greyscale
+	if (args >= 232) {
+		const c = (args - 232) * 10 + 8;
+		return [c, c, c];
+	}
+
+	args -= 16;
+
+	let rem;
+	const r = Math.floor(args / 36) / 5 * 255;
+	const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+	const b = (rem % 6) / 5 * 255;
+
+	return [r, g, b];
+};
+
+convert.rgb.hex = function (args) {
+	const integer = ((Math.round(args[0]) & 0xFF) << 16)
+		+ ((Math.round(args[1]) & 0xFF) << 8)
+		+ (Math.round(args[2]) & 0xFF);
+
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
+
+convert.hex.rgb = function (args) {
+	const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+	if (!match) {
+		return [0, 0, 0];
+	}
+
+	let colorString = match[0];
+
+	if (match[0].length === 3) {
+		colorString = colorString.split('').map(char => {
+			return char + char;
+		}).join('');
+	}
+
+	const integer = parseInt(colorString, 16);
+	const r = (integer >> 16) & 0xFF;
+	const g = (integer >> 8) & 0xFF;
+	const b = integer & 0xFF;
+
+	return [r, g, b];
+};
+
+convert.rgb.hcg = function (rgb) {
+	const r = rgb[0] / 255;
+	const g = rgb[1] / 255;
+	const b = rgb[2] / 255;
+	const max = Math.max(Math.max(r, g), b);
+	const min = Math.min(Math.min(r, g), b);
+	const chroma = (max - min);
+	let grayscale;
+	let hue;
+
+	if (chroma < 1) {
+		grayscale = min / (1 - chroma);
+	} else {
+		grayscale = 0;
+	}
+
+	if (chroma <= 0) {
+		hue = 0;
+	} else
+	if (max === r) {
+		hue = ((g - b) / chroma) % 6;
+	} else
+	if (max === g) {
+		hue = 2 + (b - r) / chroma;
+	} else {
+		hue = 4 + (r - g) / chroma;
+	}
+
+	hue /= 6;
+	hue %= 1;
+
+	return [hue * 360, chroma * 100, grayscale * 100];
+};
+
+convert.hsl.hcg = function (hsl) {
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+
+	const c = l < 0.5 ? (2.0 * s * l) : (2.0 * s * (1.0 - l));
+
+	let f = 0;
+	if (c < 1.0) {
+		f = (l - 0.5 * c) / (1.0 - c);
+	}
+
+	return [hsl[0], c * 100, f * 100];
+};
+
+convert.hsv.hcg = function (hsv) {
+	const s = hsv[1] / 100;
+	const v = hsv[2] / 100;
+
+	const c = s * v;
+	let f = 0;
+
+	if (c < 1.0) {
+		f = (v - c) / (1 - c);
+	}
+
+	return [hsv[0], c * 100, f * 100];
+};
+
+convert.hcg.rgb = function (hcg) {
+	const h = hcg[0] / 360;
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	if (c === 0.0) {
+		return [g * 255, g * 255, g * 255];
+	}
+
+	const pure = [0, 0, 0];
+	const hi = (h % 1) * 6;
+	const v = hi % 1;
+	const w = 1 - v;
+	let mg = 0;
+
+	/* eslint-disable max-statements-per-line */
+	switch (Math.floor(hi)) {
+		case 0:
+			pure[0] = 1; pure[1] = v; pure[2] = 0; break;
+		case 1:
+			pure[0] = w; pure[1] = 1; pure[2] = 0; break;
+		case 2:
+			pure[0] = 0; pure[1] = 1; pure[2] = v; break;
+		case 3:
+			pure[0] = 0; pure[1] = w; pure[2] = 1; break;
+		case 4:
+			pure[0] = v; pure[1] = 0; pure[2] = 1; break;
+		default:
+			pure[0] = 1; pure[1] = 0; pure[2] = w;
+	}
+	/* eslint-enable max-statements-per-line */
+
+	mg = (1.0 - c) * g;
+
+	return [
+		(c * pure[0] + mg) * 255,
+		(c * pure[1] + mg) * 255,
+		(c * pure[2] + mg) * 255
+	];
+};
+
+convert.hcg.hsv = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	const v = c + g * (1.0 - c);
+	let f = 0;
+
+	if (v > 0.0) {
+		f = c / v;
+	}
+
+	return [hcg[0], f * 100, v * 100];
+};
+
+convert.hcg.hsl = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+
+	const l = g * (1.0 - c) + 0.5 * c;
+	let s = 0;
+
+	if (l > 0.0 && l < 0.5) {
+		s = c / (2 * l);
+	} else
+	if (l >= 0.5 && l < 1.0) {
+		s = c / (2 * (1 - l));
+	}
+
+	return [hcg[0], s * 100, l * 100];
+};
+
+convert.hcg.hwb = function (hcg) {
+	const c = hcg[1] / 100;
+	const g = hcg[2] / 100;
+	const v = c + g * (1.0 - c);
+	return [hcg[0], (v - c) * 100, (1 - v) * 100];
+};
+
+convert.hwb.hcg = function (hwb) {
+	const w = hwb[1] / 100;
+	const b = hwb[2] / 100;
+	const v = 1 - b;
+	const c = v - w;
+	let g = 0;
+
+	if (c < 1) {
+		g = (v - c) / (1 - c);
+	}
+
+	return [hwb[0], c * 100, g * 100];
+};
+
+convert.apple.rgb = function (apple) {
+	return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
+};
+
+convert.rgb.apple = function (rgb) {
+	return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
+};
+
+convert.gray.rgb = function (args) {
+	return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+};
+
+convert.gray.hsl = function (args) {
+	return [0, 0, args[0]];
+};
+
+convert.gray.hsv = convert.gray.hsl;
+
+convert.gray.hwb = function (gray) {
+	return [0, 100, gray[0]];
+};
+
+convert.gray.cmyk = function (gray) {
+	return [0, 0, 0, gray[0]];
+};
+
+convert.gray.lab = function (gray) {
+	return [gray[0], 0, 0];
+};
+
+convert.gray.hex = function (gray) {
+	const val = Math.round(gray[0] / 100 * 255) & 0xFF;
+	const integer = (val << 16) + (val << 8) + val;
+
+	const string = integer.toString(16).toUpperCase();
+	return '000000'.substring(string.length) + string;
+};
+
+convert.rgb.gray = function (rgb) {
+	const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+	return [val / 255 * 100];
+};

spa/node_modules/node-sass/node_modules/color-convert/index.js

@@ -0,0 +1,81 @@
+const conversions = require('./conversions');
+const route = require('./route');
+
+const convert = {};
+
+const models = Object.keys(conversions);
+
+function wrapRaw(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
+
+		if (arg0.length > 1) {
+			args = arg0;
+		}
+
+		return fn(args);
+	};
+
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
+}
+
+function wrapRounded(fn) {
+	const wrappedFn = function (...args) {
+		const arg0 = args[0];
+
+		if (arg0 === undefined || arg0 === null) {
+			return arg0;
+		}
+
+		if (arg0.length > 1) {
+			args = arg0;
+		}
+
+		const result = fn(args);
+
+		// We're assuming the result is an array here.
+		// see notice in conversions.js; don't use box types
+		// in conversion functions.
+		if (typeof result === 'object') {
+			for (let len = result.length, i = 0; i < len; i++) {
+				result[i] = Math.round(result[i]);
+			}
+		}
+
+		return result;
+	};
+
+	// Preserve .conversion property if there is one
+	if ('conversion' in fn) {
+		wrappedFn.conversion = fn.conversion;
+	}
+
+	return wrappedFn;
+}
+
+models.forEach(fromModel => {
+	convert[fromModel] = {};
+
+	Object.defineProperty(convert[fromModel], 'channels', {value: conversions[fromModel].channels});
+	Object.defineProperty(convert[fromModel], 'labels', {value: conversions[fromModel].labels});
+
+	const routes = route(fromModel);
+	const routeModels = Object.keys(routes);
+
+	routeModels.forEach(toModel => {
+		const fn = routes[toModel];
+
+		convert[fromModel][toModel] = wrapRounded(fn);
+		convert[fromModel][toModel].raw = wrapRaw(fn);
+	});
+});
+
+module.exports = convert;

spa/node_modules/node-sass/node_modules/color-convert/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "color-convert",
+  "description": "Plain color conversion functions",
+  "version": "2.0.1",
+  "author": "Heather Arthur <fayearthur@gmail.com>",
+  "license": "MIT",
+  "repository": "Qix-/color-convert",
+  "scripts": {
+    "pretest": "xo",
+    "test": "node test/basic.js"
+  },
+  "engines": {
+    "node": ">=7.0.0"
+  },
+  "keywords": [
+    "color",
+    "colour",
+    "convert",
+    "converter",
+    "conversion",
+    "rgb",
+    "hsl",
+    "hsv",
+    "hwb",
+    "cmyk",
+    "ansi",
+    "ansi16"
+  ],
+  "files": [
+    "index.js",
+    "conversions.js",
+    "route.js"
+  ],
+  "xo": {
+    "rules": {
+      "default-case": 0,
+      "no-inline-comments": 0,
+      "operator-linebreak": 0
+    }
+  },
+  "devDependencies": {
+    "chalk": "^2.4.2",
+    "xo": "^0.24.0"
+  },
+  "dependencies": {
+    "color-name": "~1.1.4"
+  }
+}

spa/node_modules/node-sass/node_modules/color-convert/route.js

@@ -0,0 +1,97 @@
+const conversions = require('./conversions');
+
+/*
+	This function routes a model to all other models.
+
+	all functions that are routed have a property `.conversion` attached
+	to the returned synthetic function. This property is an array
+	of strings, each with the steps in between the 'from' and 'to'
+	color models (inclusive).
+
+	conversions that are not possible simply are not included.
+*/
+
+function buildGraph() {
+	const graph = {};
+	// https://jsperf.com/object-keys-vs-for-in-with-closure/3
+	const models = Object.keys(conversions);
+
+	for (let len = models.length, i = 0; i < len; i++) {
+		graph[models[i]] = {
+			// http://jsperf.com/1-vs-infinity
+			// micro-opt, but this is simple.
+			distance: -1,
+			parent: null
+		};
+	}
+
+	return graph;
+}
+
+// https://en.wikipedia.org/wiki/Breadth-first_search
+function deriveBFS(fromModel) {
+	const graph = buildGraph();
+	const queue = [fromModel]; // Unshift -> queue -> pop
+
+	graph[fromModel].distance = 0;
+
+	while (queue.length) {
+		const current = queue.pop();
+		const adjacents = Object.keys(conversions[current]);
+
+		for (let len = adjacents.length, i = 0; i < len; i++) {
+			const adjacent = adjacents[i];
+			const node = graph[adjacent];
+
+			if (node.distance === -1) {
+				node.distance = graph[current].distance + 1;
+				node.parent = current;
+				queue.unshift(adjacent);
+			}
+		}
+	}
+
+	return graph;
+}
+
+function link(from, to) {
+	return function (args) {
+		return to(from(args));
+	};
+}
+
+function wrapConversion(toModel, graph) {
+	const path = [graph[toModel].parent, toModel];
+	let fn = conversions[graph[toModel].parent][toModel];
+
+	let cur = graph[toModel].parent;
+	while (graph[cur].parent) {
+		path.unshift(graph[cur].parent);
+		fn = link(conversions[graph[cur].parent][cur], fn);
+		cur = graph[cur].parent;
+	}
+
+	fn.conversion = path;
+	return fn;
+}
+
+module.exports = function (fromModel) {
+	const graph = deriveBFS(fromModel);
+	const conversion = {};
+
+	const models = Object.keys(graph);
+	for (let len = models.length, i = 0; i < len; i++) {
+		const toModel = models[i];
+		const node = graph[toModel];
+
+		if (node.parent === null) {
+			// No possible conversion, or this node is the source model.
+			continue;
+		}
+
+		conversion[toModel] = wrapConversion(toModel, graph);
+	}
+
+	return conversion;
+};
+

spa/node_modules/node-sass/node_modules/color-name/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2015 Dmitry Ivanov
+
+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.

spa/node_modules/node-sass/node_modules/color-name/README.md

@@ -0,0 +1,11 @@
+A JSON with color names and its values. Based on http://dev.w3.org/csswg/css-color/#named-colors.
+
+[![NPM](https://nodei.co/npm/color-name.png?mini=true)](https://nodei.co/npm/color-name/)
+
+
+```js
+var colors = require('color-name');
+colors.red //[255,0,0]
+```
+
+<a href="LICENSE"><img src="https://upload.wikimedia.org/wikipedia/commons/0/0c/MIT_logo.svg" width="120"/></a>

spa/node_modules/node-sass/node_modules/color-name/index.js

@@ -0,0 +1,152 @@
+'use strict'
+
+module.exports = {
+	"aliceblue": [240, 248, 255],
+	"antiquewhite": [250, 235, 215],
+	"aqua": [0, 255, 255],
+	"aquamarine": [127, 255, 212],
+	"azure": [240, 255, 255],
+	"beige": [245, 245, 220],
+	"bisque": [255, 228, 196],
+	"black": [0, 0, 0],
+	"blanchedalmond": [255, 235, 205],
+	"blue": [0, 0, 255],
+	"blueviolet": [138, 43, 226],
+	"brown": [165, 42, 42],
+	"burlywood": [222, 184, 135],
+	"cadetblue": [95, 158, 160],
+	"chartreuse": [127, 255, 0],
+	"chocolate": [210, 105, 30],
+	"coral": [255, 127, 80],
+	"cornflowerblue": [100, 149, 237],
+	"cornsilk": [255, 248, 220],
+	"crimson": [220, 20, 60],
+	"cyan": [0, 255, 255],
+	"darkblue": [0, 0, 139],
+	"darkcyan": [0, 139, 139],
+	"darkgoldenrod": [184, 134, 11],
+	"darkgray": [169, 169, 169],
+	"darkgreen": [0, 100, 0],
+	"darkgrey": [169, 169, 169],
+	"darkkhaki": [189, 183, 107],
+	"darkmagenta": [139, 0, 139],
+	"darkolivegreen": [85, 107, 47],
+	"darkorange": [255, 140, 0],
+	"darkorchid": [153, 50, 204],
+	"darkred": [139, 0, 0],
+	"darksalmon": [233, 150, 122],
+	"darkseagreen": [143, 188, 143],
+	"darkslateblue": [72, 61, 139],
+	"darkslategray": [47, 79, 79],
+	"darkslategrey": [47, 79, 79],
+	"darkturquoise": [0, 206, 209],
+	"darkviolet": [148, 0, 211],
+	"deeppink": [255, 20, 147],
+	"deepskyblue": [0, 191, 255],
+	"dimgray": [105, 105, 105],
+	"dimgrey": [105, 105, 105],
+	"dodgerblue": [30, 144, 255],
+	"firebrick": [178, 34, 34],
+	"floralwhite": [255, 250, 240],
+	"forestgreen": [34, 139, 34],
+	"fuchsia": [255, 0, 255],
+	"gainsboro": [220, 220, 220],
+	"ghostwhite": [248, 248, 255],
+	"gold": [255, 215, 0],
+	"goldenrod": [218, 165, 32],
+	"gray": [128, 128, 128],
+	"green": [0, 128, 0],
+	"greenyellow": [173, 255, 47],
+	"grey": [128, 128, 128],
+	"honeydew": [240, 255, 240],
+	"hotpink": [255, 105, 180],
+	"indianred": [205, 92, 92],
+	"indigo": [75, 0, 130],
+	"ivory": [255, 255, 240],
+	"khaki": [240, 230, 140],
+	"lavender": [230, 230, 250],
+	"lavenderblush": [255, 240, 245],
+	"lawngreen": [124, 252, 0],
+	"lemonchiffon": [255, 250, 205],
+	"lightblue": [173, 216, 230],
+	"lightcoral": [240, 128, 128],
+	"lightcyan": [224, 255, 255],
+	"lightgoldenrodyellow": [250, 250, 210],
+	"lightgray": [211, 211, 211],
+	"lightgreen": [144, 238, 144],
+	"lightgrey": [211, 211, 211],
+	"lightpink": [255, 182, 193],
+	"lightsalmon": [255, 160, 122],
+	"lightseagreen": [32, 178, 170],
+	"lightskyblue": [135, 206, 250],
+	"lightslategray": [119, 136, 153],
+	"lightslategrey": [119, 136, 153],
+	"lightsteelblue": [176, 196, 222],
+	"lightyellow": [255, 255, 224],
+	"lime": [0, 255, 0],
+	"limegreen": [50, 205, 50],
+	"linen": [250, 240, 230],
+	"magenta": [255, 0, 255],
+	"maroon": [128, 0, 0],
+	"mediumaquamarine": [102, 205, 170],
+	"mediumblue": [0, 0, 205],
+	"mediumorchid": [186, 85, 211],
+	"mediumpurple": [147, 112, 219],
+	"mediumseagreen": [60, 179, 113],
+	"mediumslateblue": [123, 104, 238],
+	"mediumspringgreen": [0, 250, 154],
+	"mediumturquoise": [72, 209, 204],
+	"mediumvioletred": [199, 21, 133],
+	"midnightblue": [25, 25, 112],
+	"mintcream": [245, 255, 250],
+	"mistyrose": [255, 228, 225],
+	"moccasin": [255, 228, 181],
+	"navajowhite": [255, 222, 173],
+	"navy": [0, 0, 128],
+	"oldlace": [253, 245, 230],
+	"olive": [128, 128, 0],
+	"olivedrab": [107, 142, 35],
+	"orange": [255, 165, 0],
+	"orangered": [255, 69, 0],
+	"orchid": [218, 112, 214],
+	"palegoldenrod": [238, 232, 170],
+	"palegreen": [152, 251, 152],
+	"paleturquoise": [175, 238, 238],
+	"palevioletred": [219, 112, 147],
+	"papayawhip": [255, 239, 213],
+	"peachpuff": [255, 218, 185],
+	"peru": [205, 133, 63],
+	"pink": [255, 192, 203],
+	"plum": [221, 160, 221],
+	"powderblue": [176, 224, 230],
+	"purple": [128, 0, 128],
+	"rebeccapurple": [102, 51, 153],
+	"red": [255, 0, 0],
+	"rosybrown": [188, 143, 143],
+	"royalblue": [65, 105, 225],
+	"saddlebrown": [139, 69, 19],
+	"salmon": [250, 128, 114],
+	"sandybrown": [244, 164, 96],
+	"seagreen": [46, 139, 87],
+	"seashell": [255, 245, 238],
+	"sienna": [160, 82, 45],
+	"silver": [192, 192, 192],
+	"skyblue": [135, 206, 235],
+	"slateblue": [106, 90, 205],
+	"slategray": [112, 128, 144],
+	"slategrey": [112, 128, 144],
+	"snow": [255, 250, 250],
+	"springgreen": [0, 255, 127],
+	"steelblue": [70, 130, 180],
+	"tan": [210, 180, 140],
+	"teal": [0, 128, 128],
+	"thistle": [216, 191, 216],
+	"tomato": [255, 99, 71],
+	"turquoise": [64, 224, 208],
+	"violet": [238, 130, 238],
+	"wheat": [245, 222, 179],
+	"white": [255, 255, 255],
+	"whitesmoke": [245, 245, 245],
+	"yellow": [255, 255, 0],
+	"yellowgreen": [154, 205, 50]
+};

spa/node_modules/node-sass/node_modules/color-name/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "color-name",
+  "version": "1.1.4",
+  "description": "A list of color names and its values",
+  "main": "index.js",
+  "files": [
+    "index.js"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:colorjs/color-name.git"
+  },
+  "keywords": [
+    "color-name",
+    "color",
+    "color-keyword",
+    "keyword"
+  ],
+  "author": "DY <dfcreative@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/colorjs/color-name/issues"
+  },
+  "homepage": "https://github.com/colorjs/color-name"
+}

spa/node_modules/node-sass/node_modules/has-flag/index.d.ts

@@ -0,0 +1,39 @@
+/**
+Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag.
+
+@param flag - CLI flag to look for. The `--` prefix is optional.
+@param argv - CLI arguments. Default: `process.argv`.
+@returns Whether the flag exists.
+
+@example
+```
+// $ ts-node foo.ts -f --unicorn --foo=bar -- --rainbow
+
+// foo.ts
+import hasFlag = require('has-flag');
+
+hasFlag('unicorn');
+//=> true
+
+hasFlag('--unicorn');
+//=> true
+
+hasFlag('f');
+//=> true
+
+hasFlag('-f');
+//=> true
+
+hasFlag('foo=bar');
+//=> true
+
+hasFlag('foo');
+//=> false
+
+hasFlag('rainbow');
+//=> false
+```
+*/
+declare function hasFlag(flag: string, argv?: string[]): boolean;
+
+export = hasFlag;

spa/node_modules/node-sass/node_modules/has-flag/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = (flag, argv = process.argv) => {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};

spa/node_modules/node-sass/node_modules/has-flag/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

spa/node_modules/node-sass/node_modules/has-flag/package.json

@@ -0,0 +1,46 @@
+{
+	"name": "has-flag",
+	"version": "4.0.0",
+	"description": "Check if argv has a specific flag",
+	"license": "MIT",
+	"repository": "sindresorhus/has-flag",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"has",
+		"check",
+		"detect",
+		"contains",
+		"find",
+		"flag",
+		"cli",
+		"command-line",
+		"argv",
+		"process",
+		"arg",
+		"args",
+		"argument",
+		"arguments",
+		"getopt",
+		"minimist",
+		"optimist"
+	],
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
+	}
+}

spa/node_modules/node-sass/node_modules/has-flag/readme.md

@@ -0,0 +1,89 @@
+# has-flag [![Build Status](https://travis-ci.org/sindresorhus/has-flag.svg?branch=master)](https://travis-ci.org/sindresorhus/has-flag)
+
+> Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag
+
+Correctly stops looking after an `--` argument terminator.
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-has-flag?utm_source=npm-has-flag&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>
+
+---
+
+
+## Install
+
+```
+$ npm install has-flag
+```
+
+
+## Usage
+
+```js
+// foo.js
+const hasFlag = require('has-flag');
+
+hasFlag('unicorn');
+//=> true
+
+hasFlag('--unicorn');
+//=> true
+
+hasFlag('f');
+//=> true
+
+hasFlag('-f');
+//=> true
+
+hasFlag('foo=bar');
+//=> true
+
+hasFlag('foo');
+//=> false
+
+hasFlag('rainbow');
+//=> false
+```
+
+```
+$ node foo.js -f --unicorn --foo=bar -- --rainbow
+```
+
+
+## API
+
+### hasFlag(flag, [argv])
+
+Returns a boolean for whether the flag exists.
+
+#### flag
+
+Type: `string`
+
+CLI flag to look for. The `--` prefix is optional.
+
+#### argv
+
+Type: `string[]`<br>
+Default: `process.argv`
+
+CLI arguments.
+
+
+## Security
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

spa/node_modules/node-sass/node_modules/supports-color/browser.js

@@ -0,0 +1,5 @@
+'use strict';
+module.exports = {
+	stdout: false,
+	stderr: false
+};

spa/node_modules/node-sass/node_modules/supports-color/index.js

@@ -0,0 +1,135 @@
+'use strict';
+const os = require('os');
+const tty = require('tty');
+const hasFlag = require('has-flag');
+
+const {env} = process;
+
+let forceColor;
+if (hasFlag('no-color') ||
+	hasFlag('no-colors') ||
+	hasFlag('color=false') ||
+	hasFlag('color=never')) {
+	forceColor = 0;
+} else if (hasFlag('color') ||
+	hasFlag('colors') ||
+	hasFlag('color=true') ||
+	hasFlag('color=always')) {
+	forceColor = 1;
+}
+
+if ('FORCE_COLOR' in env) {
+	if (env.FORCE_COLOR === 'true') {
+		forceColor = 1;
+	} else if (env.FORCE_COLOR === 'false') {
+		forceColor = 0;
+	} else {
+		forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+
+function translateLevel(level) {
+	if (level === 0) {
+		return false;
+	}
+
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+
+function supportsColor(haveStream, streamIsTTY) {
+	if (forceColor === 0) {
+		return 0;
+	}
+
+	if (hasFlag('color=16m') ||
+		hasFlag('color=full') ||
+		hasFlag('color=truecolor')) {
+		return 3;
+	}
+
+	if (hasFlag('color=256')) {
+		return 2;
+	}
+
+	if (haveStream && !streamIsTTY && forceColor === undefined) {
+		return 0;
+	}
+
+	const min = forceColor || 0;
+
+	if (env.TERM === 'dumb') {
+		return min;
+	}
+
+	if (process.platform === 'win32') {
+		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+		const osRelease = os.release().split('.');
+		if (
+			Number(osRelease[0]) >= 10 &&
+			Number(osRelease[2]) >= 10586
+		) {
+			return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		}
+
+		return 1;
+	}
+
+	if ('CI' in env) {
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			return 1;
+		}
+
+		return min;
+	}
+
+	if ('TEAMCITY_VERSION' in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	}
+
+	if (env.COLORTERM === 'truecolor') {
+		return 3;
+	}
+
+	if ('TERM_PROGRAM' in env) {
+		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+		switch (env.TERM_PROGRAM) {
+			case 'iTerm.app':
+				return version >= 3 ? 3 : 2;
+			case 'Apple_Terminal':
+				return 2;
+			// No default
+		}
+	}
+
+	if (/-256(color)?$/i.test(env.TERM)) {
+		return 2;
+	}
+
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+		return 1;
+	}
+
+	if ('COLORTERM' in env) {
+		return 1;
+	}
+
+	return min;
+}
+
+function getSupportLevel(stream) {
+	const level = supportsColor(stream, stream && stream.isTTY);
+	return translateLevel(level);
+}
+
+module.exports = {
+	supportsColor: getSupportLevel,
+	stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+	stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+};

spa/node_modules/node-sass/node_modules/supports-color/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

spa/node_modules/node-sass/node_modules/supports-color/package.json

@@ -0,0 +1,53 @@
+{
+	"name": "supports-color",
+	"version": "7.2.0",
+	"description": "Detect whether a terminal supports color",
+	"license": "MIT",
+	"repository": "chalk/supports-color",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava"
+	},
+	"files": [
+		"index.js",
+		"browser.js"
+	],
+	"keywords": [
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"ansi",
+		"styles",
+		"tty",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"command-line",
+		"support",
+		"supports",
+		"capability",
+		"detect",
+		"truecolor",
+		"16m"
+	],
+	"dependencies": {
+		"has-flag": "^4.0.0"
+	},
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"import-fresh": "^3.0.0",
+		"xo": "^0.24.0"
+	},
+	"browser": "browser.js"
+}

spa/node_modules/node-sass/node_modules/supports-color/readme.md

@@ -0,0 +1,76 @@
+# supports-color [![Build Status](https://travis-ci.org/chalk/supports-color.svg?branch=master)](https://travis-ci.org/chalk/supports-color)
+
+> Detect whether a terminal supports color
+
+
+## Install
+
+```
+$ npm install supports-color
+```
+
+
+## Usage
+
+```js
+const supportsColor = require('supports-color');
+
+if (supportsColor.stdout) {
+	console.log('Terminal stdout supports color');
+}
+
+if (supportsColor.stdout.has256) {
+	console.log('Terminal stdout supports 256 colors');
+}
+
+if (supportsColor.stderr.has16m) {
+	console.log('Terminal stderr supports 16 million colors (truecolor)');
+}
+```
+
+
+## API
+
+Returns an `Object` with a `stdout` and `stderr` property for testing either streams. Each property is an `Object`, or `false` if color is not supported.
+
+The `stdout`/`stderr` objects specifies a level of support for color through a `.level` property and a corresponding flag:
+
+- `.level = 1` and `.hasBasic = true`: Basic color support (16 colors)
+- `.level = 2` and `.has256 = true`: 256 color support
+- `.level = 3` and `.has16m = true`: Truecolor support (16 million colors)
+
+
+## Info
+
+It obeys the `--color` and `--no-color` CLI flags.
+
+For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks.
+
+Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively.
+
+
+## Related
+
+- [supports-color-cli](https://github.com/chalk/supports-color-cli) - CLI for this module
+- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
+
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-supports-color?utm_source=npm-supports-color&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>
+
+---

spa/node_modules/node-sass/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "node-sass",
+  "version": "9.0.0",
+  "libsass": "3.5.5",
+  "description": "Wrapper around libsass",
+  "license": "MIT",
+  "bugs": "https://github.com/sass/node-sass/issues",
+  "homepage": "https://github.com/sass/node-sass",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sass/node-sass"
+  },
+  "author": {
+    "name": "Andrew Nesbitt",
+    "email": "andrewnez@gmail.com",
+    "url": "http://andrew.github.com"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "main": "lib/index.js",
+  "nodeSassConfig": {
+    "binarySite": "https://github.com/sass/node-sass/releases/download"
+  },
+  "bin": {
+    "node-sass": "bin/node-sass"
+  },
+  "gypfile": true,
+  "scripts": {
+    "coverage": "nyc npm run test",
+    "install": "node scripts/install.js",
+    "postinstall": "node scripts/build.js",
+    "lint": "eslint bin/node-sass lib scripts test",
+    "test": "mocha test/{*,**/**}.js",
+    "build": "node scripts/build.js --force",
+    "prepublishOnly ": "scripts/prepublish.js"
+  },
+  "files": [
+    "bin",
+    "binding.gyp",
+    "lib",
+    "scripts",
+    "src",
+    "test",
+    "vendor"
+  ],
+  "keywords": [
+    "css",
+    "libsass",
+    "preprocessor",
+    "sass",
+    "scss",
+    "style"
+  ],
+  "dependencies": {
+    "async-foreach": "^0.1.3",
+    "chalk": "^4.1.2",
+    "cross-spawn": "^7.0.3",
+    "gaze": "^1.0.0",
+    "get-stdin": "^4.0.1",
+    "glob": "^7.0.3",
+    "lodash": "^4.17.15",
+    "make-fetch-happen": "^10.0.4",
+    "meow": "^9.0.0",
+    "nan": "^2.17.0",
+    "node-gyp": "^8.4.1",
+    "sass-graph": "^4.0.1",
+    "stdout-stream": "^1.4.0",
+    "true-case-path": "^2.2.1"
+  },
+  "devDependencies": {
+    "eslint": "^8.0.0",
+    "fs-extra": "^10.0.0",
+    "mocha": "^9.0.1",
+    "nyc": "^15.1.0",
+    "rimraf": "^3.0.2",
+    "unique-temp-dir": "^1.0.0"
+  }
+}

spa/node_modules/node-sass/scripts/build.js

@@ -0,0 +1,154 @@
+/*!
+ * node-sass: scripts/build.js
+ */
+
+var fs = require('fs'),
+  path = require('path'),
+  spawn = require('cross-spawn'),
+  sass = require('../lib/extensions');
+
+/**
+ * After build
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function afterBuild(options) {
+  var install = sass.getBinaryPath();
+  var target = path.join(__dirname, '..', 'build',
+    options.debug ? 'Debug' :
+      process.config.target_defaults
+        ?  process.config.target_defaults.default_configuration
+        : 'Release',
+    'binding.node');
+
+  fs.mkdir(path.dirname(install), {recursive: true}, function(err) {
+    if (err && err.code !== 'EEXIST') {
+      console.error(err.message);
+      return;
+    }
+
+    fs.stat(target, function(err) {
+      if (err) {
+        console.error('Build succeeded but target not found');
+        return;
+      }
+
+      fs.rename(target, install, function(err) {
+        if (err) {
+          console.error(err.message);
+          return;
+        }
+
+        console.log('Installed to', install);
+      });
+    });
+  });
+}
+
+/**
+ * Build
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function build(options) {
+  var args = [require.resolve(path.join('node-gyp', 'bin', 'node-gyp.js')), 'rebuild', '--verbose'].concat(
+    ['libsass_ext', 'libsass_cflags', 'libsass_ldflags', 'libsass_library'].map(function(subject) {
+      return ['--', subject, '=', process.env[subject.toUpperCase()] || ''].join('');
+    })).concat(options.args);
+
+  console.log('Building:', [process.execPath].concat(args).join(' '));
+
+  var proc = spawn(process.execPath, args, {
+    stdio: [0, 1, 2]
+  });
+
+  proc.on('exit', function(errorCode) {
+    if (!errorCode) {
+      afterBuild(options);
+      return;
+    }
+
+    if (errorCode === 127 ) {
+      console.error('node-gyp not found!');
+    } else {
+      console.error('Build failed with error code:', errorCode);
+    }
+
+    process.exit(1);
+  });
+}
+
+/**
+ * Parse arguments
+ *
+ * @param {Array} args
+ * @api private
+ */
+
+function parseArgs(args) {
+  var options = {
+    arch: process.arch,
+    platform: process.platform,
+    force: process.env.npm_config_force === 'true',
+  };
+
+  options.args = args.filter(function(arg) {
+    if (arg === '-f' || arg === '--force') {
+      options.force = true;
+      return false;
+    } else if (arg.substring(0, 13) === '--target_arch') {
+      options.arch = arg.substring(14);
+    } else if (arg === '-d' || arg === '--debug') {
+      options.debug = true;
+    } else if (arg.substring(0, 13) === '--libsass_ext' && arg.substring(14) !== 'no') {
+      options.libsassExt = true;
+    }
+
+    return true;
+  });
+
+  return options;
+}
+
+/**
+ * Test for pre-built library
+ *
+ * @param {Object} options
+ * @api private
+ */
+
+function testBinary(options) {
+  if (options.force || process.env.SASS_FORCE_BUILD) {
+    return build(options);
+  }
+
+  if (!sass.hasBinary(sass.getBinaryPath())) {
+    return build(options);
+  }
+
+  console.log('Binary found at', sass.getBinaryPath());
+  console.log('Testing binary');
+
+  try {
+    require('../').renderSync({
+      data: 's { a: ss }'
+    });
+
+    console.log('Binary is fine');
+  } catch (e) {
+    console.log('Binary has a problem:', e);
+    console.log('Building the binary locally');
+
+    return build(options);
+  }
+}
+
+/**
+ * Apply arguments and run
+ */
+
+testBinary(parseArgs(process.argv.slice(2)));

spa/node_modules/node-sass/scripts/install.js

@@ -0,0 +1,121 @@
+/*!
+ * node-sass: scripts/install.js
+ */
+
+var fs = require('fs'),
+  eol = require('os').EOL,
+  path = require('path'),
+  fetch = require('make-fetch-happen'),
+  sass = require('../lib/extensions'),
+  downloadOptions = require('./util/downloadoptions');
+
+/**
+ * Download file, if succeeds save, if not delete
+ *
+ * @param {String} url
+ * @param {String} dest
+ * @param {Function} cb
+ * @api private
+ */
+
+function download(url, dest, cb) {
+  var reportError = function(err) {
+    cb(['Cannot download "', url, '": ', eol, eol,
+      typeof err.message === 'string' ? err.message : err, eol, eol,
+      'Hint: If github.com is not accessible in your location', eol,
+      '      try setting a proxy via HTTP_PROXY, e.g. ', eol, eol,
+      '      export HTTP_PROXY=http://example.com:1234',eol, eol,
+      'or configure npm proxy via', eol, eol,
+      '      npm config set proxy http://example.com:8080'].join(''));
+  };
+
+  var successful = function(response) {
+    return response.status >= 200 && response.status < 300;
+  };
+
+  console.log('Downloading binary from', url);
+
+  try {
+    fetch(url, downloadOptions()).then(function (response) {
+      return response.buffer();
+    }).then(function (buffer) {
+      fs.createWriteStream(dest).on('error', cb).end(buffer, cb);
+      console.log('Download complete');
+    }).catch(function(err) {
+      if(!successful(err)) {
+        reportError(['HTTP error', err.code, err.message].join(' '));
+      } else {
+        reportError(err);
+      }
+    });
+  } catch (err) {
+    cb(err);
+  }
+}
+
+/**
+ * Check and download binary
+ *
+ * @api private
+ */
+
+function checkAndDownloadBinary() {
+  if (process.env.SKIP_SASS_BINARY_DOWNLOAD_FOR_CI) {
+    console.log('Skipping downloading binaries on CI builds');
+    return;
+  }
+
+  var cachedBinary = sass.getCachedBinary(),
+    cachePath = sass.getBinaryCachePath(),
+    binaryPath = sass.getBinaryPath();
+
+  if (sass.hasBinary(binaryPath)) {
+    console.log('node-sass build', 'Binary found at', binaryPath);
+    return;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(binaryPath), {recursive: true});
+  } catch (err) {
+    console.error('Unable to save binary', path.dirname(binaryPath), ':', err);
+    return;
+  }
+
+  if (cachedBinary) {
+    console.log('Cached binary found at', cachedBinary);
+    fs.createReadStream(cachedBinary).pipe(fs.createWriteStream(binaryPath));
+    return;
+  }
+
+  download(sass.getBinaryUrl(), binaryPath, function(err) {
+    if (err) {
+      console.error(err);
+      return;
+    }
+
+    console.log('Binary saved to', binaryPath);
+
+    cachedBinary = path.join(cachePath, sass.getBinaryName());
+
+    if (cachePath) {
+      console.log('Caching binary to', cachedBinary);
+
+      try {
+        fs.mkdirSync(path.dirname(cachedBinary), {recursive: true});
+        fs.createReadStream(binaryPath)
+          .pipe(fs.createWriteStream(cachedBinary))
+          .on('error', function (err) {
+            console.log('Failed to cache binary:', err);
+          });
+      } catch (err) {
+        console.log('Failed to cache binary:', err);
+      }
+    }
+  });
+}
+
+/**
+ * If binary does not exist, download it
+ */
+
+checkAndDownloadBinary();

spa/node_modules/node-sass/scripts/prepublish.js

@@ -0,0 +1,17 @@
+/*!
+ * node-sass: scripts/install.js
+ */
+
+var path = require('path'),
+  rimraf = require('rimraf');
+
+function prepublish() {
+  var vendorPath = path.resolve(__dirname, '..', 'vendor');
+  rimraf.sync(vendorPath);
+}
+
+/**
+ * Run
+ */
+
+prepublish();

spa/node_modules/node-sass/scripts/util/downloadoptions.js

@@ -0,0 +1,26 @@
+var proxy = require('./proxy'),
+  userAgent = require('./useragent'),
+  rejectUnauthorized = require('./rejectUnauthorized');
+
+/**
+ * The options passed to make-fetch-happen when downloading the binary
+ *
+ * @return {Object} an options object for make-fetch-happen
+ * @api private
+ */
+module.exports = function() {
+  var options = {
+    strictSSL: rejectUnauthorized(),
+    timeout: 60000,
+    headers: {
+      'User-Agent': userAgent(),
+    },
+  };
+
+  var proxyConfig = proxy();
+  if (proxyConfig) {
+    options.proxy = proxyConfig;
+  }
+
+  return options;
+};

spa/node_modules/node-sass/scripts/util/proxy.js

@@ -0,0 +1,22 @@
+
+/**
+ * Determine the proxy settings configured by npm
+ *
+ * It's possible to configure npm to use a proxy different
+ * from the system defined proxy. This can be done via the
+ * `npm config` CLI or the `.npmrc` config file.
+ *
+ * If a proxy has been configured in this way we must
+ * tell request explicitly to use it.
+ *
+ * Otherwise we can trust request to the right thing.
+ *
+ * @return {String} the proxy configured by npm or an empty string
+ * @api private
+ */
+module.exports = function() {
+  return process.env.npm_config_https_proxy ||
+    process.env.npm_config_proxy ||
+    process.env.npm_config_http_proxy ||
+    '';
+};

spa/node_modules/node-sass/scripts/util/rejectUnauthorized.js

@@ -0,0 +1,46 @@
+var pkg = require('../../package.json');
+
+/**
+ * Get the value of a CLI argument
+ *
+ * @param {String} name
+ * @param {Array} args
+ * @api private
+ */
+function getArgument(name, args) {
+  var flags = args || process.argv.slice(2),
+    index = flags.lastIndexOf(name);
+
+  if (index === -1 || index + 1 >= flags.length) {
+    return null;
+  }
+
+  return flags[index + 1];
+}
+
+/**
+ * Get the value of reject-unauthorized
+ * If environment variable SASS_REJECT_UNAUTHORIZED is non-zero,
+ * .npmrc variable sass_reject_unauthorized or
+ * process argument --sass-reject_unauthorized is provided,
+ * set rejectUnauthorized to true
+ * Else set to false by default
+ *
+ * @return {Boolean} The value of rejectUnauthorized
+ * @api private
+ */
+module.exports = function() {
+  var rejectUnauthorized = false;
+
+  if (getArgument('--sass-reject-unauthorized')) {
+    rejectUnauthorized = getArgument('--sass-reject-unauthorized');
+  } else if (process.env.SASS_REJECT_UNAUTHORIZED !== '0') {
+    rejectUnauthorized = true;
+  } else if (process.env.npm_config_sass_reject_unauthorized) {
+    rejectUnauthorized = process.env.npm_config_sass_reject_unauthorized;
+  } else if (pkg.nodeSassConfig && pkg.nodeSassConfig.rejectUnauthorized) {
+    rejectUnauthorized = pkg.nodeSassConfig.rejectUnauthorized;
+  } 
+
+  return rejectUnauthorized;
+};

spa/node_modules/node-sass/scripts/util/useragent.js

@@ -0,0 +1,13 @@
+var pkg = require('../../package.json');
+
+/**
+ * A custom user agent use for binary downloads.
+ *
+ * @api private
+ */
+module.exports = function() {
+  return [
+    'node/', process.version, ' ',
+    'node-sass-installer/', pkg.version
+  ].join('');
+};

spa/node_modules/node-sass/src/binding.cpp

@@ -0,0 +1,358 @@
+#include <nan.h>
+#include <vector>
+#include "sass_context_wrapper.h"
+#include "custom_function_bridge.h"
+#include "create_string.h"
+#include "sass_types/factory.h"
+
+Sass_Import_List sass_importer(const char* cur_path, Sass_Importer_Entry cb, struct Sass_Compiler* comp)
+{
+  void* cookie = sass_importer_get_cookie(cb);
+  struct Sass_Import* previous = sass_compiler_get_last_import(comp);
+  const char* prev_path = sass_import_get_abs_path(previous);
+  CustomImporterBridge& bridge = *(static_cast<CustomImporterBridge*>(cookie));
+
+  std::vector<void*> argv;
+  argv.push_back((void*)cur_path);
+  argv.push_back((void*)prev_path);
+
+  return bridge(argv);
+}
+
+union Sass_Value* sass_custom_function(const union Sass_Value* s_args, Sass_Function_Entry cb, struct Sass_Compiler* comp)
+{
+  void* cookie = sass_function_get_cookie(cb);
+  CustomFunctionBridge& bridge = *(static_cast<CustomFunctionBridge*>(cookie));
+
+  std::vector<void*> argv;
+  for (unsigned l = sass_list_get_length(s_args), i = 0; i < l; i++) {
+    argv.push_back((void*)sass_list_get_value(s_args, i));
+  }
+
+  return bridge(argv);
+}
+
+int ExtractOptions(v8::Local<v8::Object> options, void* cptr, sass_context_wrapper* ctx_w, bool is_file, bool is_sync) {
+  Nan::HandleScope scope;
+
+  struct Sass_Context* ctx;
+
+  v8::Local<v8::Value> result_ = Nan::Get(
+    options,
+    Nan::New("result").ToLocalChecked()
+  ).ToLocalChecked();
+  if (!result_->IsObject()) {
+    Nan::ThrowTypeError("\"result\" element is not an object");
+    return -1;
+  }
+
+  ctx_w->result.Reset(result_.As<v8::Object>());
+
+  if (is_file) {
+    ctx_w->fctx = (struct Sass_File_Context*) cptr;
+    ctx = sass_file_context_get_context(ctx_w->fctx);
+  }
+  else {
+    ctx_w->dctx = (struct Sass_Data_Context*) cptr;
+    ctx = sass_data_context_get_context(ctx_w->dctx);
+  }
+
+  struct Sass_Options* sass_options = sass_context_get_options(ctx);
+
+  ctx_w->is_sync = is_sync;
+
+  if (!is_sync) {
+    ctx_w->request.data = ctx_w;
+
+    // async (callback) style
+    v8::Local<v8::Function> success_callback = v8::Local<v8::Function>::Cast(Nan::Get(options, Nan::New("success").ToLocalChecked()).ToLocalChecked());
+    v8::Local<v8::Function> error_callback = v8::Local<v8::Function>::Cast(Nan::Get(options, Nan::New("error").ToLocalChecked()).ToLocalChecked());
+
+    ctx_w->success_callback = new Nan::Callback(success_callback);
+    ctx_w->error_callback = new Nan::Callback(error_callback);
+  }
+
+  if (!is_file) {
+    ctx_w->file = create_string(Nan::Get(options, Nan::New("file").ToLocalChecked()));
+    sass_option_set_input_path(sass_options, ctx_w->file);
+  }
+
+  int indent_len = Nan::To<int32_t>(
+    Nan::Get(
+        options,
+        Nan::New("indentWidth").ToLocalChecked()
+    ).ToLocalChecked()).FromJust();
+
+  ctx_w->indent = (char*)malloc(indent_len + 1);
+
+  strcpy(ctx_w->indent, std::string(
+    indent_len,
+    Nan::To<int32_t>(
+        Nan::Get(
+            options,
+            Nan::New("indentType").ToLocalChecked()
+        ).ToLocalChecked()).FromJust() == 1 ? '\t' : ' '
+    ).c_str());
+
+  ctx_w->linefeed = create_string(Nan::Get(options, Nan::New("linefeed").ToLocalChecked()));
+  ctx_w->include_path = create_string(Nan::Get(options, Nan::New("includePaths").ToLocalChecked()));
+  ctx_w->out_file = create_string(Nan::Get(options, Nan::New("outFile").ToLocalChecked()));
+  ctx_w->source_map = create_string(Nan::Get(options, Nan::New("sourceMap").ToLocalChecked()));
+  ctx_w->source_map_root = create_string(Nan::Get(options, Nan::New("sourceMapRoot").ToLocalChecked()));
+
+  sass_option_set_output_path(sass_options, ctx_w->out_file);
+  sass_option_set_output_style(sass_options, (Sass_Output_Style)Nan::To<int32_t>(Nan::Get(options, Nan::New("style").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_is_indented_syntax_src(sass_options, Nan::To<bool>(Nan::Get(options, Nan::New("indentedSyntax").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_source_comments(sass_options, Nan::To<bool>(Nan::Get(options, Nan::New("sourceComments").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_omit_source_map_url(sass_options, Nan::To<bool>(Nan::Get(options, Nan::New("omitSourceMapUrl").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_source_map_embed(sass_options, Nan::To<bool>(Nan::Get(options, Nan::New("sourceMapEmbed").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_source_map_contents(sass_options, Nan::To<bool>(Nan::Get(options, Nan::New("sourceMapContents").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_source_map_file(sass_options, ctx_w->source_map);
+  sass_option_set_source_map_root(sass_options, ctx_w->source_map_root);
+  sass_option_set_include_path(sass_options, ctx_w->include_path);
+  sass_option_set_precision(sass_options, Nan::To<int32_t>(Nan::Get(options, Nan::New("precision").ToLocalChecked()).ToLocalChecked()).FromJust());
+  sass_option_set_indent(sass_options, ctx_w->indent);
+  sass_option_set_linefeed(sass_options, ctx_w->linefeed);
+
+  v8::Local<v8::Value> importer_callback = Nan::Get(options, Nan::New("importer").ToLocalChecked()).ToLocalChecked();
+
+  if (importer_callback->IsFunction()) {
+    v8::Local<v8::Function> importer = importer_callback.As<v8::Function>();
+
+    CustomImporterBridge *bridge = new CustomImporterBridge(importer, ctx_w->is_sync);
+    ctx_w->importer_bridges.push_back(bridge);
+
+    Sass_Importer_List c_importers = sass_make_importer_list(1);
+    c_importers[0] = sass_make_importer(sass_importer, 0, bridge);
+
+    sass_option_set_c_importers(sass_options, c_importers);
+  }
+  else if (importer_callback->IsArray()) {
+    v8::Local<v8::Array> importers = importer_callback.As<v8::Array>();
+    Sass_Importer_List c_importers = sass_make_importer_list(importers->Length());
+
+    for (size_t i = 0; i < importers->Length(); ++i) {
+      v8::Local<v8::Function> callback = v8::Local<v8::Function>::Cast(Nan::Get(importers, static_cast<uint32_t>(i)).ToLocalChecked());
+
+      CustomImporterBridge *bridge = new CustomImporterBridge(callback, ctx_w->is_sync);
+      ctx_w->importer_bridges.push_back(bridge);
+
+      c_importers[i] = sass_make_importer(sass_importer, importers->Length() - i - 1, bridge);
+    }
+
+    sass_option_set_c_importers(sass_options, c_importers);
+  }
+
+  v8::Local<v8::Value> custom_functions = Nan::Get(options, Nan::New("functions").ToLocalChecked()).ToLocalChecked();
+
+  if (custom_functions->IsObject()) {
+    v8::Local<v8::Object> functions = custom_functions.As<v8::Object>();
+    v8::Local<v8::Array> signatures = Nan::GetOwnPropertyNames(functions).ToLocalChecked();
+    unsigned num_signatures = signatures->Length();
+    Sass_Function_List fn_list = sass_make_function_list(num_signatures);
+
+    for (unsigned i = 0; i < num_signatures; i++) {
+      v8::Local<v8::String> signature = v8::Local<v8::String>::Cast(Nan::Get(signatures, Nan::New(i)).ToLocalChecked());
+      v8::Local<v8::Function> callback = v8::Local<v8::Function>::Cast(Nan::Get(functions, signature).ToLocalChecked());
+
+      CustomFunctionBridge *bridge = new CustomFunctionBridge(callback, ctx_w->is_sync);
+      ctx_w->function_bridges.push_back(bridge);
+
+      char* sig = create_string(signature);
+      Sass_Function_Entry fn = sass_make_function(sig, sass_custom_function, bridge);
+      free(sig);
+      sass_function_set_list_entry(fn_list, i, fn);
+    }
+
+    sass_option_set_c_functions(sass_options, fn_list);
+  }
+  return 0;
+}
+
+void GetStats(sass_context_wrapper* ctx_w, Sass_Context* ctx) {
+  Nan::HandleScope scope;
+
+  char** included_files = sass_context_get_included_files(ctx);
+  v8::Local<v8::Array> arr = Nan::New<v8::Array>();
+
+  if (included_files) {
+    for (int i = 0; included_files[i] != nullptr; ++i) {
+      Nan::Set(arr, i, Nan::New<v8::String>(included_files[i]).ToLocalChecked());
+    }
+  }
+
+  v8::Local<v8::Object> result = Nan::New(ctx_w->result);
+  assert(result->IsObject());
+
+  v8::Local<v8::Value> stats = Nan::Get(
+    result,
+    Nan::New("stats").ToLocalChecked()
+  ).ToLocalChecked();
+  if (stats->IsObject()) {
+    Nan::Set(
+      stats.As<v8::Object>(),
+      Nan::New("includedFiles").ToLocalChecked(),
+      arr
+    );
+  } else {
+    Nan::ThrowTypeError("\"result.stats\" element is not an object");
+  }
+}
+
+int GetResult(sass_context_wrapper* ctx_w, Sass_Context* ctx, bool is_sync = false) {
+  Nan::HandleScope scope;
+  v8::Local<v8::Object> result;
+
+  int status = sass_context_get_error_status(ctx);
+
+  result = Nan::New(ctx_w->result);
+  assert(result->IsObject());
+
+  if (status == 0) {
+    const char* css = sass_context_get_output_string(ctx);
+    const char* map = sass_context_get_source_map_string(ctx);
+
+    Nan::Set(result, Nan::New("css").ToLocalChecked(), Nan::CopyBuffer(css, static_cast<uint32_t>(strlen(css))).ToLocalChecked());
+
+    GetStats(ctx_w, ctx);
+
+    if (map) {
+      Nan::Set(result, Nan::New("map").ToLocalChecked(), Nan::CopyBuffer(map, static_cast<uint32_t>(strlen(map))).ToLocalChecked());
+    }
+  }
+  else if (is_sync) {
+    Nan::Set(result, Nan::New("error").ToLocalChecked(), Nan::New<v8::String>(sass_context_get_error_json(ctx)).ToLocalChecked());
+  }
+
+  return status;
+}
+
+void PerformCall(sass_context_wrapper* ctx_w, Nan::Callback* callback, int argc, v8::Local<v8::Value> argv[]) {
+  if (ctx_w->is_sync) {
+    Nan::Call(*callback, argc, argv);
+  } else {
+    callback->Call(argc, argv, ctx_w->async_resource);
+  }
+}
+
+void MakeCallback(uv_work_t* req) {
+  Nan::HandleScope scope;
+
+  Nan::TryCatch try_catch;
+  sass_context_wrapper* ctx_w = static_cast<sass_context_wrapper*>(req->data);
+  struct Sass_Context* ctx;
+
+  if (ctx_w->dctx) {
+    ctx = sass_data_context_get_context(ctx_w->dctx);
+  }
+  else {
+    ctx = sass_file_context_get_context(ctx_w->fctx);
+  }
+
+  int status = GetResult(ctx_w, ctx);
+
+  if (status == 0 && ctx_w->success_callback) {
+    // if no error, do callback(null, result)
+    PerformCall(ctx_w, ctx_w->success_callback, 0, 0);
+  }
+  else if (ctx_w->error_callback) {
+    // if error, do callback(error)
+    const char* err = sass_context_get_error_json(ctx);
+    v8::Local<v8::Value> argv[] = {
+      Nan::New<v8::String>(err).ToLocalChecked()
+    };
+    PerformCall(ctx_w, ctx_w->error_callback, 1, argv);
+  }
+  if (try_catch.HasCaught()) {
+    Nan::FatalException(try_catch);
+  }
+
+  sass_free_context_wrapper(ctx_w);
+}
+
+NAN_METHOD(render) {
+
+  v8::Local<v8::Object> options = Nan::To<v8::Object>(info[0]).ToLocalChecked();
+  char* source_string = create_string(Nan::Get(options, Nan::New("data").ToLocalChecked()));
+  struct Sass_Data_Context* dctx = sass_make_data_context(source_string);
+  sass_context_wrapper* ctx_w = sass_make_context_wrapper();
+
+  ctx_w->async_resource = new Nan::AsyncResource("node-sass:sass_context_wrapper:render");
+
+  if (ExtractOptions(options, dctx, ctx_w, false, false) >= 0) {
+
+    int status = uv_queue_work(uv_default_loop(), &ctx_w->request, compile_it, (uv_after_work_cb)MakeCallback);
+
+    assert(status == 0);
+  }
+}
+
+NAN_METHOD(render_sync) {
+
+  v8::Local<v8::Object> options = Nan::To<v8::Object>(info[0]).ToLocalChecked();
+  char* source_string = create_string(Nan::Get(options, Nan::New("data").ToLocalChecked()));
+  struct Sass_Data_Context* dctx = sass_make_data_context(source_string);
+  struct Sass_Context* ctx = sass_data_context_get_context(dctx);
+  sass_context_wrapper* ctx_w = sass_make_context_wrapper();
+  int result = -1;
+
+  if ((result = ExtractOptions(options, dctx, ctx_w, false, true)) >= 0) {
+    compile_data(dctx);
+    result = GetResult(ctx_w, ctx, true);
+  }
+
+  sass_free_context_wrapper(ctx_w);
+
+  info.GetReturnValue().Set(result == 0);
+}
+
+NAN_METHOD(render_file) {
+
+  v8::Local<v8::Object> options = Nan::To<v8::Object>(info[0]).ToLocalChecked();
+  char* input_path = create_string(Nan::Get(options, Nan::New("file").ToLocalChecked()));
+  struct Sass_File_Context* fctx = sass_make_file_context(input_path);
+  sass_context_wrapper* ctx_w = sass_make_context_wrapper();
+
+  ctx_w->async_resource = new Nan::AsyncResource("node-sass:sass_context_wrapper:render_file");
+
+  if (ExtractOptions(options, fctx, ctx_w, true, false) >= 0) {
+
+    int status = uv_queue_work(uv_default_loop(), &ctx_w->request, compile_it, (uv_after_work_cb)MakeCallback);
+    assert(status == 0);
+  }
+}
+
+NAN_METHOD(render_file_sync) {
+
+  v8::Local<v8::Object> options = Nan::To<v8::Object>(info[0]).ToLocalChecked();
+  char* input_path = create_string(Nan::Get(options, Nan::New("file").ToLocalChecked()));
+  struct Sass_File_Context* fctx = sass_make_file_context(input_path);
+  struct Sass_Context* ctx = sass_file_context_get_context(fctx);
+  sass_context_wrapper* ctx_w = sass_make_context_wrapper();
+  int result = -1;
+
+  if ((result = ExtractOptions(options, fctx, ctx_w, true, true)) >= 0) {
+    compile_file(fctx);
+    result = GetResult(ctx_w, ctx, true);
+  };
+
+  free(input_path);
+  sass_free_context_wrapper(ctx_w);
+
+  info.GetReturnValue().Set(result == 0);
+}
+
+NAN_METHOD(libsass_version) {
+  info.GetReturnValue().Set(Nan::New<v8::String>(libsass_version()).ToLocalChecked());
+}
+
+NAN_MODULE_INIT(RegisterModule) {
+  Nan::SetMethod(target, "render", render);
+  Nan::SetMethod(target, "renderSync", render_sync);
+  Nan::SetMethod(target, "renderFile", render_file);
+  Nan::SetMethod(target, "renderFileSync", render_file_sync);
+  Nan::SetMethod(target, "libsassVersion", libsass_version);
+  SassTypes::Factory::initExports(target);
+}
+
+NODE_MODULE(binding, RegisterModule);

spa/node_modules/node-sass/src/callback_bridge.h

@@ -0,0 +1,228 @@
+#ifndef CALLBACK_BRIDGE_H
+#define CALLBACK_BRIDGE_H
+
+#include <vector>
+#include <nan.h>
+#include <algorithm>
+#include <uv.h>
+
+#define COMMA ,
+
+template <typename T, typename L = void*>
+class CallbackBridge {
+  public:
+    CallbackBridge(v8::Local<v8::Function>, bool);
+    virtual ~CallbackBridge();
+
+    // Executes the callback
+    T operator()(std::vector<void*>);
+
+  protected:
+    // We will expose a bridge object to the JS callback that wraps this instance so we don't loose context.
+    // This is the V8 constructor for such objects.
+    static Nan::MaybeLocal<v8::Function> get_wrapper_constructor();
+    static void async_gone(uv_handle_t *handle);
+    static NAN_METHOD(New);
+    static NAN_METHOD(ReturnCallback);
+    static Nan::Persistent<v8::Function> wrapper_constructor;
+    Nan::Persistent<v8::Object> wrapper;
+
+    // The callback that will get called in the main thread after the worker thread used for the sass
+    // compilation step makes a call to uv_async_send()
+    static void dispatched_async_uv_callback(uv_async_t*);
+
+    // The V8 values sent to our ReturnCallback must be read on the main thread not the sass worker thread.
+    // This gives a chance to specialized subclasses to transform those values into whatever makes sense to
+    // sass before we resume the worker thread.
+    virtual T post_process_return_value(v8::Local<v8::Value>) const =0;
+
+
+    virtual std::vector<v8::Local<v8::Value>> pre_process_args(std::vector<L>) const =0;
+
+    Nan::Callback* callback;
+    Nan::AsyncResource* async_resource;
+    bool is_sync;
+
+    uv_mutex_t cv_mutex;
+    uv_cond_t condition_variable;
+    uv_async_t *async;
+    std::vector<L> argv;
+    bool has_returned;
+    T return_value;
+};
+
+template <typename T, typename L>
+Nan::Persistent<v8::Function> CallbackBridge<T, L>::wrapper_constructor;
+
+template <typename T, typename L>
+CallbackBridge<T, L>::CallbackBridge(v8::Local<v8::Function> callback, bool is_sync) : callback(new Nan::Callback(callback)), is_sync(is_sync) {
+  /*
+   * This is invoked from the main JavaScript thread.
+   * V8 context is available.
+   */
+  Nan::HandleScope scope;
+  uv_mutex_init(&this->cv_mutex);
+  uv_cond_init(&this->condition_variable);
+  if (!is_sync) {
+    this->async = new uv_async_t;
+    this->async->data = (void*) this;
+    uv_async_init(uv_default_loop(), this->async, (uv_async_cb) dispatched_async_uv_callback);
+    this->async_resource = new Nan::AsyncResource("node-sass:CallbackBridge");
+  }
+
+  v8::Local<v8::Function> func = CallbackBridge<T, L>::get_wrapper_constructor().ToLocalChecked();
+  wrapper.Reset(Nan::NewInstance(func).ToLocalChecked());
+  Nan::SetInternalFieldPointer(Nan::New(wrapper), 0, this);
+}
+
+template <typename T, typename L>
+CallbackBridge<T, L>::~CallbackBridge() {
+  delete this->callback;
+  this->wrapper.Reset();
+  uv_cond_destroy(&this->condition_variable);
+  uv_mutex_destroy(&this->cv_mutex);
+
+  if (!is_sync) {
+    uv_close((uv_handle_t*)this->async, &async_gone);
+    delete this->async_resource;
+  }
+}
+
+template <typename T, typename L>
+T CallbackBridge<T, L>::operator()(std::vector<void*> argv) {
+  // argv.push_back(wrapper);
+  if (this->is_sync) {
+    /*
+     * This is invoked from the main JavaScript thread.
+     * V8 context is available.
+     *
+     * Establish Local<> scope for all functions
+     * from types invoked by pre_process_args() and
+     * post_process_args().
+     */
+    Nan::HandleScope scope;
+    Nan::TryCatch try_catch;
+    std::vector<v8::Local<v8::Value>> argv_v8 = pre_process_args(argv);
+    if (try_catch.HasCaught()) {
+      Nan::FatalException(try_catch);
+    }
+
+    argv_v8.push_back(Nan::New(wrapper));
+
+    return this->post_process_return_value(
+      Nan::Call(*this->callback, argv_v8.size(), &argv_v8[0]).ToLocalChecked()
+    );
+  } else {
+    /*
+     * This is invoked from the worker thread.
+     * No V8 context and functions available.
+     * Just wait for response from asynchronously
+     * scheduled JavaScript code
+     *
+     * XXX Issue #1048: We block here even if the
+     *     event loop stops and the callback
+     *     would never be executed.
+     * XXX Issue #857: By waiting here we occupy
+     *     one of the threads taken from the
+     *     uv threadpool. Might deadlock if
+     *     async I/O executed from JavaScript callbacks.
+     */
+    this->argv = argv;
+
+    uv_mutex_lock(&this->cv_mutex);
+    this->has_returned = false;
+    uv_async_send(this->async);
+    while (!this->has_returned) {
+      uv_cond_wait(&this->condition_variable, &this->cv_mutex);
+    }
+    uv_mutex_unlock(&this->cv_mutex);
+    return this->return_value;
+  }
+}
+
+template <typename T, typename L>
+void CallbackBridge<T, L>::dispatched_async_uv_callback(uv_async_t *req) {
+  CallbackBridge* bridge = static_cast<CallbackBridge*>(req->data);
+
+  /*
+   * Function scheduled via uv_async mechanism, therefore
+   * it is invoked from the main JavaScript thread.
+   * V8 context is available.
+   *
+   * Establish Local<> scope for all functions
+   * from types invoked by pre_process_args() and
+   * post_process_args().
+   */
+  Nan::HandleScope scope;
+  Nan::TryCatch try_catch;
+
+  std::vector<v8::Local<v8::Value>> argv_v8 = bridge->pre_process_args(bridge->argv);
+  if (try_catch.HasCaught()) {
+    Nan::FatalException(try_catch);
+  }
+  argv_v8.push_back(Nan::New(bridge->wrapper));
+
+  bridge->callback->Call(argv_v8.size(), &argv_v8[0], bridge->async_resource);
+
+  if (try_catch.HasCaught()) {
+    Nan::FatalException(try_catch);
+  }
+}
+
+template <typename T, typename L>
+NAN_METHOD(CallbackBridge<T COMMA L>::ReturnCallback) {
+
+  /*
+   * Callback function invoked by the user code.
+   * It is invoked from the main JavaScript thread.
+   * V8 context is available.
+   *
+   * Implicit Local<> handle scope created by NAN_METHOD(.)
+   */
+  CallbackBridge<T, L>* bridge = static_cast<CallbackBridge<T, L>*>(Nan::GetInternalFieldPointer(info.This(), 0));
+  Nan::TryCatch try_catch;
+
+  bridge->return_value = bridge->post_process_return_value(info[0]);
+
+  {
+    uv_mutex_lock(&bridge->cv_mutex);
+    bridge->has_returned = true;
+    uv_mutex_unlock(&bridge->cv_mutex);
+  }
+
+  uv_cond_broadcast(&bridge->condition_variable);
+
+  if (try_catch.HasCaught()) {
+    Nan::FatalException(try_catch);
+  }
+}
+
+template <typename T, typename L>
+Nan::MaybeLocal<v8::Function> CallbackBridge<T, L>::get_wrapper_constructor() {
+  /* Uses handle scope created in the CallbackBridge<T, L> constructor */
+  if (wrapper_constructor.IsEmpty()) {
+    v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
+    tpl->SetClassName(Nan::New("CallbackBridge").ToLocalChecked());
+    tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+    Nan::SetPrototypeTemplate(tpl, "success",
+      Nan::New<v8::FunctionTemplate>(ReturnCallback)
+    );
+
+    wrapper_constructor.Reset(Nan::GetFunction(tpl).ToLocalChecked());
+  }
+
+  return Nan::New(wrapper_constructor);
+}
+
+template <typename T, typename L>
+NAN_METHOD(CallbackBridge<T COMMA L>::New) {
+  info.GetReturnValue().Set(info.This());
+}
+
+template <typename T, typename L>
+void CallbackBridge<T, L>::async_gone(uv_handle_t *handle) {
+  delete (uv_async_t *)handle;
+}
+
+#endif

spa/node_modules/node-sass/src/create_string.cpp

@@ -0,0 +1,21 @@
+#include <nan.h>
+#include <stdlib.h>
+#include <string.h>
+#include "create_string.h"
+
+char* create_string(Nan::MaybeLocal<v8::Value> maybevalue) {
+  v8::Local<v8::Value> value;
+
+  if (maybevalue.ToLocal(&value)) {
+    if (value->IsNull() || !value->IsString()) {
+      return 0;
+    }
+  } else {
+    return 0;
+  }
+
+  Nan::Utf8String string(value);
+  char *str = (char *)malloc(string.length() + 1);
+  strcpy(str, *string);
+  return str;
+}

spa/node_modules/node-sass/src/create_string.h

@@ -0,0 +1,8 @@
+#ifndef CREATE_STRING_H
+#define CREATE_STRING_H
+
+#include <nan.h>
+
+char* create_string(Nan::MaybeLocal<v8::Value>);
+
+#endif

spa/node_modules/node-sass/src/custom_function_bridge.cpp

@@ -0,0 +1,27 @@
+#include <nan.h>
+#include <stdexcept>
+#include "custom_function_bridge.h"
+#include "sass_types/factory.h"
+#include "sass_types/value.h"
+
+Sass_Value* CustomFunctionBridge::post_process_return_value(v8::Local<v8::Value> _val) const {
+  SassTypes::Value *value = SassTypes::Factory::unwrap(_val);
+  if (value) {
+    return value->get_sass_value();
+  } else {
+    return sass_make_error("A SassValue object was expected.");
+  }
+}
+
+std::vector<v8::Local<v8::Value>> CustomFunctionBridge::pre_process_args(std::vector<void*> in) const {
+  std::vector<v8::Local<v8::Value>> argv = std::vector<v8::Local<v8::Value>>();
+
+  for (void* value : in) {
+    Sass_Value* x = static_cast<Sass_Value*>(value);
+    SassTypes::Value* y = SassTypes::Factory::create(x);
+
+    argv.push_back(y->get_js_object());
+  }
+
+  return argv;
+}

spa/node_modules/node-sass/src/custom_function_bridge.h

@@ -0,0 +1,18 @@
+#ifndef CUSTOM_FUNCTION_BRIDGE_H
+#define CUSTOM_FUNCTION_BRIDGE_H
+
+#include <nan.h>
+#include <sass/values.h>
+#include <sass/functions.h>
+#include "callback_bridge.h"
+
+class CustomFunctionBridge : public CallbackBridge<Sass_Value*> {
+  public:
+    CustomFunctionBridge(v8::Local<v8::Function> cb, bool is_sync) : CallbackBridge<Sass_Value*>(cb, is_sync) {}
+
+  private:
+    Sass_Value* post_process_return_value(v8::Local<v8::Value>) const;
+    std::vector<v8::Local<v8::Value>> pre_process_args(std::vector<void*>) const;
+};
+
+#endif

spa/node_modules/node-sass/src/custom_importer_bridge.cpp

@@ -0,0 +1,104 @@
+#include <nan.h>
+#include <stdexcept>
+#include "custom_importer_bridge.h"
+#include "create_string.h"
+
+SassImportList CustomImporterBridge::post_process_return_value(v8::Local<v8::Value> returned_value) const {
+  SassImportList imports = 0;
+  Nan::HandleScope scope;
+
+  if (returned_value->IsArray()) {
+    v8::Local<v8::Array> array = returned_value.As<v8::Array>();
+
+    imports = sass_make_import_list(array->Length());
+
+    for (size_t i = 0; i < array->Length(); ++i) {
+      v8::Local<v8::Value> value;
+      Nan::MaybeLocal<v8::Value> unchecked = Nan::Get(array, static_cast<uint32_t>(i));
+
+      if (!unchecked.ToLocal(&value) || !value->IsObject()) {
+        imports[i] = sass_make_import_entry(0, 0, 0);
+        sass_import_set_error(imports[i], "returned array must only contain object literals", -1, -1);
+        continue;
+      }
+
+      v8::Local<v8::Object> object = value.As<v8::Object>();
+
+      if (value->IsNativeError()) {
+        char* message = create_string(Nan::Get(object, Nan::New<v8::String>("message").ToLocalChecked()));
+
+        imports[i] = sass_make_import_entry(0, 0, 0);
+
+        sass_import_set_error(imports[i], message, -1, -1);
+        free(message);
+      }
+      else {
+        imports[i] = get_importer_entry(object);
+      }
+    }
+  }
+  else if (returned_value->IsNativeError()) {
+    imports = sass_make_import_list(1);
+    v8::Local<v8::Object> object = returned_value.As<v8::Object>();
+    char* message = create_string(Nan::Get(object, Nan::New<v8::String>("message").ToLocalChecked()));
+
+    imports[0] = sass_make_import_entry(0, 0, 0);
+
+    sass_import_set_error(imports[0], message, -1, -1);
+    free(message);
+  }
+  else if (returned_value->IsObject()) {
+    imports = sass_make_import_list(1);
+    imports[0] = get_importer_entry(returned_value.As<v8::Object>());
+  }
+
+  return imports;
+}
+
+Sass_Import* CustomImporterBridge::check_returned_string(Nan::MaybeLocal<v8::Value> value, const char *msg) const
+{
+    v8::Local<v8::Value> checked;
+    if (value.ToLocal(&checked)) {
+      if (!checked->IsUndefined() && !checked->IsString()) {
+        goto err;
+      } else {
+        return nullptr;
+      }
+    }
+err:
+    auto entry = sass_make_import_entry(0, 0, 0);
+    sass_import_set_error(entry, msg, -1, -1);
+    return entry;
+}
+
+Sass_Import* CustomImporterBridge::get_importer_entry(const v8::Local<v8::Object>& object) const {
+  Nan::MaybeLocal<v8::Value> returned_file = Nan::Get(object, Nan::New<v8::String>("file").ToLocalChecked());
+  Nan::MaybeLocal<v8::Value> returned_contents = Nan::Get(object, Nan::New<v8::String>("contents").ToLocalChecked());
+  Nan::MaybeLocal<v8::Value> returned_map = Nan::Get(object, Nan::New<v8::String>("map").ToLocalChecked());
+  Sass_Import *err;
+
+  if ((err = check_returned_string(returned_file, "returned value of `file` must be a string")))
+    return err;
+
+  if ((err = check_returned_string(returned_contents, "returned value of `contents` must be a string")))
+    return err;
+
+  if ((err = check_returned_string(returned_map, "returned value of `returned_map` must be a string")))
+    return err;
+
+  char* path = create_string(returned_file);
+  char* contents = create_string(returned_contents);
+  char* srcmap = create_string(returned_map);
+
+  return sass_make_import_entry(path, contents, srcmap);
+}
+
+std::vector<v8::Local<v8::Value>> CustomImporterBridge::pre_process_args(std::vector<void*> in) const {
+  std::vector<v8::Local<v8::Value>> out;
+
+  for (void* ptr : in) {
+    out.push_back(Nan::New<v8::String>((char const*)ptr).ToLocalChecked());
+  }
+
+  return out;
+}

spa/node_modules/node-sass/src/custom_importer_bridge.h

@@ -0,0 +1,22 @@
+#ifndef CUSTOM_IMPORTER_BRIDGE_H
+#define CUSTOM_IMPORTER_BRIDGE_H
+
+#include <nan.h>
+#include <sass/functions.h>
+#include <sass/values.h>
+#include "callback_bridge.h"
+
+typedef Sass_Import_List SassImportList;
+
+class CustomImporterBridge : public CallbackBridge<SassImportList> {
+  public:
+    CustomImporterBridge(v8::Local<v8::Function> cb, bool is_sync) : CallbackBridge<SassImportList>(cb, is_sync) {}
+
+  private:
+    SassImportList post_process_return_value(v8::Local<v8::Value>) const;
+    Sass_Import* check_returned_string(Nan::MaybeLocal<v8::Value> value, const char *msg) const;
+    Sass_Import* get_importer_entry(const v8::Local<v8::Object>&) const;
+    std::vector<v8::Local<v8::Value>> pre_process_args(std::vector<void*>) const;
+};
+
+#endif

spa/node_modules/node-sass/src/libsass.gyp

@@ -0,0 +1,114 @@
+{
+  'targets': [
+    {
+      'target_name': 'libsass',
+      'win_delay_load_hook': 'false',
+      'type': 'static_library',
+      'defines': [
+         'LIBSASS_VERSION="<!(node -e "process.stdout.write(require(\'../package.json\').libsass)")"'
+      ],
+      'defines!': [
+         'DEBUG'
+      ],
+      'sources': [
+        'libsass/src/ast.cpp',
+        'libsass/src/ast_fwd_decl.cpp',
+        'libsass/src/backtrace.cpp',
+        'libsass/src/base64vlq.cpp',
+        'libsass/src/bind.cpp',
+        'libsass/src/cencode.c',
+        'libsass/src/check_nesting.cpp',
+        'libsass/src/color_maps.cpp',
+        'libsass/src/constants.cpp',
+        'libsass/src/context.cpp',
+        'libsass/src/cssize.cpp',
+        'libsass/src/emitter.cpp',
+        'libsass/src/environment.cpp',
+        'libsass/src/error_handling.cpp',
+        'libsass/src/eval.cpp',
+        'libsass/src/expand.cpp',
+        'libsass/src/extend.cpp',
+        'libsass/src/file.cpp',
+        'libsass/src/functions.cpp',
+        'libsass/src/inspect.cpp',
+        'libsass/src/json.cpp',
+        'libsass/src/lexer.cpp',
+        'libsass/src/listize.cpp',
+        'libsass/src/memory/SharedPtr.cpp',
+        'libsass/src/node.cpp',
+        'libsass/src/operators.cpp',
+        'libsass/src/operators.hpp',
+        'libsass/src/output.cpp',
+        'libsass/src/parser.cpp',
+        'libsass/src/plugins.cpp',
+        'libsass/src/position.cpp',
+        'libsass/src/prelexer.cpp',
+        'libsass/src/remove_placeholders.cpp',
+        'libsass/src/sass.cpp',
+        'libsass/src/sass2scss.cpp',
+        'libsass/src/sass_context.cpp',
+        'libsass/src/sass_functions.cpp',
+        'libsass/src/sass_util.cpp',
+        'libsass/src/sass_values.cpp',
+        'libsass/src/source_map.cpp',
+        'libsass/src/subset_map.cpp',
+        'libsass/src/to_c.cpp',
+        'libsass/src/to_value.cpp',
+        'libsass/src/units.cpp',
+        'libsass/src/utf8_string.cpp',
+        'libsass/src/util.cpp',
+        'libsass/src/values.cpp'
+      ],
+      'cflags!': [
+        '-fno-rtti',
+        '-fno-exceptions'
+      ],
+      'cflags_cc!': [
+        '-fno-rtti',
+        '-fno-exceptions'
+      ],
+      'cflags_cc': [
+        '-fexceptions',
+        '-frtti',
+      ],
+      'include_dirs': [ 'libsass/include' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ 'libsass/include' ],
+      },
+      'conditions': [
+        ['OS=="mac"', {
+          'xcode_settings': {
+            'CLANG_CXX_LANGUAGE_STANDARD': 'c++11',
+            'CLANG_CXX_LIBRARY': 'libc++',
+            'OTHER_LDFLAGS': [],
+            'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+            'GCC_ENABLE_CPP_RTTI': 'YES',
+            'MACOSX_DEPLOYMENT_TARGET': '10.7'
+          }
+        }],
+        ['OS=="win"', {
+          'msvs_settings': {
+            'VCCLCompilerTool': {
+              'AdditionalOptions': [
+                '/GR',
+                '/EHsc'
+              ]
+            }
+          },
+          'conditions': [
+             ['MSVS_VERSION < "2015"', {
+               'sources': [
+                 'libsass/src/c99func.c'
+               ]
+             }]
+          ]
+        }],
+        ['OS!="win"', {
+          'cflags_cc+': [
+            '-std=c++0x'
+          ]
+        }]
+      ]
+    }
+  ]
+}

spa/node_modules/node-sass/src/libsass/.editorconfig

@@ -0,0 +1,15 @@
+# This file is for unifying the coding style for different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+[{Makefile, GNUmakefile.am}]
+indent_style = tab
+indent_size = 4

spa/node_modules/node-sass/src/libsass/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

spa/node_modules/node-sass/src/libsass/.github/CONTRIBUTING.md

@@ -0,0 +1,65 @@
+# Contributing to LibSass
+
+:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:
+
+The following is a set of guidelines for contributing to LibSass, which is hosted in the [Sass Organization](https://github.com/sass) on GitHub.
+These are just guidelines, not rules, use your best judgment and feel free to propose changes to this document in a pull request.
+
+LibSass is a library that implements a [sass language][8] compiler. As such it does not directly interface with end users (frontend developers).
+For direct contributions to the LibSass code base you will need to have at least a rough idea of C++, we will not lie about that.
+But there are other ways to contribute to the progress of LibSass. All contributions are done via github pull requests.
+
+You can also contribute to the LibSass [documentation][9] or provide additional [spec tests][10] (and we will gladly point you in the
+direction for corners that lack test coverage). Foremost we rely on good and concise bug reports for issues the spec tests do not yet catch.
+
+## Precheck: My Sass isn't compiling
+- [ ] Check if you can reproduce the issue via [SourceMap Inspector][5] (updated regularly).
+- [ ] Validate official ruby sass compiler via [SassMeister][6] produces your expected result.
+- [ ] Search for similar issue in [LibSass][1] and [node-sass][2] (include closed tickets)
+- [ ] Optionally test your code directly with [sass][7] or [sassc][3] ([installer][4])
+
+## Precheck: My build/install fails
+- [ ] Problems with building or installing libsass should be directed to implementors first!
+- [ ] Except for issues directly verified via sassc or LibSass own build (make/autotools9
+
+## Craft a meaningfull error report
+- [ ] Include the version of libsass and the implementor (i.e. node-sass or sassc)
+- [ ] Include information about your operating system and environment (i.e. io.js)
+- [ ] Either create a self contained sample that shows your issue ...
+- [ ] ... or provide it as a fetchable (github preferred) archive/repo
+- [ ] ... and include a step by step list of command to get all dependencies
+- [ ] Make it clear if you use indented or/and scss syntax
+
+## My error is hiding in a big code base
+1. we do not have time to support your code base!
+2. to fix occuring issues we need precise bug reports
+3. the more precise you are, the faster we can help you
+4. lazy reports get overlooked even when exposing serious bugs
+5. it's not hard to do, it only takes time
+- [ ] Make sure you saved the current state (i.e. commit to git)
+- [ ] Start by uncommenting blocks in the initial source file
+- [ ] Check if the problem is still there after each edit
+- [ ] Repeat until the problem goes away
+- [ ] Inline imported files as you go along
+- [ ] Finished once you cannot remove more
+- [ ] The emphasis is on the word "repeat" ...
+
+## What makes a code test case
+
+Important is that someone else can get the test case up and running to reproduce it locally. For this
+we urge you to verify that your sample yields the expected result by testing it via [SassMeister][6]
+or directly via ruby sass or node-sass (or any other libsass implementor) before submitting your bug
+report. Once you verified all of the above, you may use the template below to file your bug report.
+
+
+[1]: https://github.com/sass/libsass/issues?utf8=%E2%9C%93&q=is%3Aissue
+[2]: https://github.com/sass/node-sass/issues?utf8=%E2%9C%93&q=is%3Aissue
+[3]: https://github.com/sass/sassc
+[4]: http://libsass.ocbnet.ch/installer/
+[5]: http://libsass.ocbnet.ch/srcmap/
+[6]: http://www.sassmeister.com/
+[7]: https://rubygems.org/gems/sass
+
+[8]: http://sass-lang.com/
+[9]: https://github.com/sass/libsass/tree/master/docs
+[10]: https://github.com/sass/sass-spec

spa/node_modules/node-sass/src/libsass/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,54 @@
+[todo]: # (Title: Be as meaningful as possible)
+[todo]: # (Title: Try to use 60 or less chars)
+
+[todo]: # (This is only a template!)
+[todo]: # (remove unneeded bits)
+[todo]: # (use github preview!)
+
+## input.scss
+
+[todo]: # (always test and report with scss syntax)
+[todo]: # (use sass only when results differ from scss)
+
+```scss
+test {
+  content: bar
+}
+```
+
+## Actual results
+
+[todo]: # (update version info!)
+
+[libsass 3.X.y][1]
+```css
+test {
+  content: bar; }
+```
+
+## Expected result
+
+[todo]: # (update version info!)
+
+ruby sass 3.X.y
+```css
+test {
+  content: bar; }
+```
+
+[todo]: # (update version info!)
+[todo]: # (example for node-sass!)
+
+version info:
+```cmd
+$ node-sass --version
+node-sass       3.X.y   (Wrapper)       [JavaScript]
+libsass         3.X.y   (Sass Compiler) [C/C++]
+```
+
+[todo]: # (Go to http://libsass.ocbnet.ch/srcmap)
+[todo]: # (Enter your SCSS code and hit compile)
+[todo]: # (Click `bookmark` and replace the url)
+[todo]: # (link is used in actual results above)
+
+[1]: http://libsass.ocbnet.ch/srcmap/#dGVzdCB7CiAgY29udGVudDogYmFyOyB9Cg==

spa/node_modules/node-sass/src/libsass/.travis.yml

@@ -0,0 +1,64 @@
+language: cpp
+sudo: false
+
+
+# don't create redundant code coverage reports
+# - AUTOTOOLS=yes COVERAGE=yes BUILD=static
+# - AUTOTOOLS=no COVERAGE=yes BUILD=shared
+# - AUTOTOOLS=no COVERAGE=no BUILD=static
+
+# further speed up day by day travis-ci builds
+# re-enable this if you change the makefiles
+# this will still catch all coding errors!
+# - AUTOTOOLS=yes COVERAGE=no BUILD=static
+
+# currenty there are various issues when
+# built with coverage, clang and autotools
+# - AUTOTOOLS=yes COVERAGE=yes BUILD=shared
+
+matrix:
+  include :
+    - os: linux
+      compiler: gcc
+      env: AUTOTOOLS=no COVERAGE=yes BUILD=static
+    - os: linux
+      compiler: g++-5
+      env: AUTOTOOLS=yes COVERAGE=no BUILD=shared
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-5
+    - os: linux
+      compiler: clang++-3.7
+      env: AUTOTOOLS=no COVERAGE=yes BUILD=static
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+          packages:
+            - clang-3.7
+    - os: linux
+      compiler: clang
+      env: AUTOTOOLS=yes COVERAGE=no BUILD=shared
+    - os: osx
+      compiler: clang
+      env: AUTOTOOLS=no COVERAGE=no BUILD=shared
+    - os: osx
+      compiler: clang
+      env: AUTOTOOLS=no COVERAGE=yes BUILD=static
+    - os: osx
+      compiler: clang
+      env: AUTOTOOLS=yes COVERAGE=no BUILD=shared
+
+script:
+  - ./script/ci-build-libsass
+  - ./script/ci-build-plugin math
+  - ./script/ci-build-plugin glob
+  - ./script/ci-build-plugin digest
+  - ./script/ci-build-plugin tests
+before_install: ./script/ci-install-deps
+install: ./script/ci-install-compiler
+after_success: ./script/ci-report-coverage

spa/node_modules/node-sass/src/libsass/COPYING

@@ -0,0 +1,25 @@
+
+Copyright (C) 2012 by Hampton Catlin
+
+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.
+
+
+The following files in the spec were taken from the original Ruby Sass project which
+is copyright Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein and under
+the same license.

spa/node_modules/node-sass/src/libsass/GNUmakefile.am

@@ -0,0 +1,74 @@
+ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS} -I m4 -I script
+
+AM_COPT = -Wall -O2
+AM_COVLDFLAGS =
+
+if ENABLE_COVERAGE
+	AM_COPT = -Wall -O1 -fno-omit-frame-pointer --coverage
+	AM_COVLDFLAGS += -lgcov
+endif
+
+AM_CPPFLAGS = -I$(top_srcdir)/include
+AM_CFLAGS   = $(AM_COPT)
+AM_CXXFLAGS = $(AM_COPT)
+AM_LDFLAGS  = $(AM_COPT) $(AM_COVLDFLAGS)
+
+# only needed to support old source tree
+# we have moved the files to src folder
+AM_CPPFLAGS += -I$(top_srcdir)
+
+RESOURCES =
+if COMPILER_IS_MINGW32
+  RESOURCES += res/libsass.rc
+  AM_CXXFLAGS += -std=gnu++0x
+else
+  AM_CXXFLAGS += -std=c++0x
+endif
+
+TEST_EXTENSIONS = .rb
+
+if ENABLE_TESTS
+
+SASS_SASSC_PATH ?= $(top_srcdir)/sassc
+SASS_SPEC_PATH ?= $(top_srcdir)/sass-spec
+
+noinst_PROGRAMS = tester
+tester_LDADD = src/libsass.la
+tester_LDFLAGS = $(AM_LDFLAGS)
+nodist_tester_SOURCES = $(SASS_SASSC_PATH)/sassc.c
+SASS_SASSC_VERSION ?= `cd "$(SASS_SASSC_PATH)" && ./version.sh`
+tester_CFLAGS = $(AM_CFLAGS) -DSASSC_VERSION="\"$(SASS_SASSC_VERSION)\""
+tester_CXXFLAGS = $(AM_CXXFLAGS) -DSASSC_VERSION="\"$(SASS_SASSC_VERSION)\""
+
+if ENABLE_COVERAGE
+nodist_EXTRA_tester_SOURCES = non-existent-file-to-force-CXX-linking.cxx
+endif
+
+TESTS = $(SASS_SPEC_PATH)/sass-spec.rb
+RB_LOG_COMPILER = ./script/tap-runner
+AM_RB_LOG_FLAGS = $(RUBY)
+
+SASS_TEST_FLAGS = -V 3.5 --impl libsass
+SASS_TEST_FLAGS += -r $(SASS_SPEC_PATH)
+SASS_TEST_FLAGS += -c $(top_srcdir)/tester$(EXEEXT)
+AM_TESTS_ENVIRONMENT = TEST_FLAGS='$(SASS_TEST_FLAGS)'
+
+SASS_TESTER = $(RUBY) $(SASS_SPEC_PATH)/sass-spec.rb
+
+test:
+	$(SASS_TESTER) $(SASS_TEST_FLAGS)
+
+test_build:
+	$(SASS_TESTER) $(SASS_TEST_FLAGS)
+
+test_full:
+	$(SASS_TESTER) --run-todo $(SASS_TEST_FLAGS)
+
+test_probe:
+	$(SASS_TESTER) --probe-todo $(SASS_TEST_FLAGS)
+
+.PHONY: test test_build test_full test_probe
+
+endif
+
+SUBDIRS = src

spa/node_modules/node-sass/src/libsass/INSTALL

@@ -0,0 +1 @@
+// Autotools requires us to have this file. Boo.

spa/node_modules/node-sass/src/libsass/LICENSE

@@ -0,0 +1,25 @@
+
+Copyright (C) 2012-2016 by the Sass Open Source Foundation
+
+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.
+
+
+The following files in the spec were taken from the original Ruby Sass project which
+is copyright Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein and under
+the same license.

spa/node_modules/node-sass/src/libsass/Makefile

@@ -0,0 +1,351 @@
+OS       ?= $(shell uname -s)
+CC       ?= gcc
+CXX      ?= g++
+RM       ?= rm -f
+CP       ?= cp -a
+MKDIR    ?= mkdir
+RMDIR    ?= rmdir
+WINDRES  ?= windres
+# Solaris/Illumos flavors
+# ginstall from coreutils
+ifeq ($(OS),SunOS)
+INSTALL  ?= ginstall
+endif
+INSTALL  ?= install
+CFLAGS   ?= -Wall
+CXXFLAGS ?= -Wall
+LDFLAGS  ?= -Wall
+ifeq "x$(COVERAGE)" "x"
+  CFLAGS   += -O2
+  CXXFLAGS += -O2
+  LDFLAGS  += -O2
+else
+  CFLAGS   += -O1 -fno-omit-frame-pointer
+  CXXFLAGS += -O1 -fno-omit-frame-pointer
+  LDFLAGS  += -O1 -fno-omit-frame-pointer
+endif
+LDFLAGS  += -Wl,-undefined,error
+CAT      ?= $(if $(filter $(OS),Windows_NT),type,cat)
+
+ifneq (,$(findstring /cygdrive/,$(PATH)))
+	UNAME := Cygwin
+else
+	ifneq (,$(findstring Windows_NT,$(OS)))
+		UNAME := Windows
+	else
+		ifneq (,$(findstring mingw32,$(MAKE)))
+			UNAME := Windows
+		else
+			ifneq (,$(findstring MINGW32,$(shell uname -s)))
+				UNAME = Windows
+			else
+				UNAME := $(shell uname -s)
+			endif
+		endif
+	endif
+endif
+
+ifeq ($(SASS_LIBSASS_PATH),)
+	SASS_LIBSASS_PATH = $(abspath $(CURDIR))
+endif
+
+ifeq ($(LIBSASS_VERSION),)
+	ifneq ($(wildcard ./.git/ ),)
+		LIBSASS_VERSION ?= $(shell git describe --abbrev=4 --dirty --always --tags)
+	endif
+endif
+
+ifeq ($(LIBSASS_VERSION),)
+	ifneq ($(wildcard VERSION),)
+		LIBSASS_VERSION ?= $(shell $(CAT) VERSION)
+	endif
+endif
+
+ifneq ($(LIBSASS_VERSION),)
+	CFLAGS   += -DLIBSASS_VERSION="\"$(LIBSASS_VERSION)\""
+	CXXFLAGS += -DLIBSASS_VERSION="\"$(LIBSASS_VERSION)\""
+endif
+
+# enable mandatory flag
+ifeq (Windows,$(UNAME))
+	ifneq ($(BUILD),shared)
+		STATIC_ALL     ?= 1
+	endif
+	STATIC_LIBGCC    ?= 1
+	STATIC_LIBSTDCPP ?= 1
+	CXXFLAGS += -std=gnu++0x
+	LDFLAGS  += -std=gnu++0x
+else
+	STATIC_ALL       ?= 0
+	STATIC_LIBGCC    ?= 0
+	STATIC_LIBSTDCPP ?= 0
+	CXXFLAGS += -std=c++0x
+	LDFLAGS  += -std=c++0x
+endif
+
+ifneq ($(SASS_LIBSASS_PATH),)
+	CFLAGS   += -I $(SASS_LIBSASS_PATH)/include
+	CXXFLAGS += -I $(SASS_LIBSASS_PATH)/include
+else
+	# this is needed for mingw
+	CFLAGS   += -I include
+	CXXFLAGS += -I include
+endif
+
+ifneq ($(EXTRA_CFLAGS),)
+	CFLAGS   += $(EXTRA_CFLAGS)
+endif
+ifneq ($(EXTRA_CXXFLAGS),)
+	CXXFLAGS += $(EXTRA_CXXFLAGS)
+endif
+ifneq ($(EXTRA_LDFLAGS),)
+	LDFLAGS  += $(EXTRA_LDFLAGS)
+endif
+
+LDLIBS = -lm
+
+ifneq ($(BUILD),shared)
+	LDLIBS += -lstdc++
+endif
+
+# link statically into lib
+# makes it a lot more portable
+# increases size by about 50KB
+ifeq ($(STATIC_ALL),1)
+	LDFLAGS += -static
+endif
+ifeq ($(STATIC_LIBGCC),1)
+	LDFLAGS += -static-libgcc
+endif
+ifeq ($(STATIC_LIBSTDCPP),1)
+	LDFLAGS += -static-libstdc++
+endif
+
+ifeq ($(UNAME),Darwin)
+	CFLAGS += -stdlib=libc++
+	CXXFLAGS += -stdlib=libc++
+	LDFLAGS += -stdlib=libc++
+endif
+
+ifneq (Windows,$(UNAME))
+	ifneq (FreeBSD,$(UNAME))
+		ifneq (OpenBSD,$(UNAME))
+			LDFLAGS += -ldl
+			LDLIBS += -ldl
+		endif
+	endif
+endif
+
+ifneq ($(BUILD),shared)
+	BUILD := static
+endif
+ifeq ($(DEBUG),1)
+	BUILD := debug-$(BUILD)
+endif
+
+ifeq (,$(TRAVIS_BUILD_DIR))
+	ifeq ($(OS),SunOS)
+		PREFIX ?= /opt/local
+	else
+		PREFIX ?= /usr/local
+	endif
+else
+	PREFIX ?= $(TRAVIS_BUILD_DIR)
+endif
+
+
+SASS_SASSC_PATH ?= sassc
+SASS_SPEC_PATH ?= sass-spec
+SASS_SPEC_SPEC_DIR ?= spec
+SASSC_BIN = $(SASS_SASSC_PATH)/bin/sassc
+RUBY_BIN = ruby
+
+LIB_STATIC = $(SASS_LIBSASS_PATH)/lib/libsass.a
+LIB_SHARED = $(SASS_LIBSASS_PATH)/lib/libsass.so
+
+ifeq (Windows,$(UNAME))
+	ifeq (shared,$(BUILD))
+		CFLAGS     += -D ADD_EXPORTS
+		CXXFLAGS   += -D ADD_EXPORTS
+		LIB_SHARED  = $(SASS_LIBSASS_PATH)/lib/libsass.dll
+	endif
+else
+	ifneq (Cygwin,$(UNAME))
+		CFLAGS   += -fPIC
+		CXXFLAGS += -fPIC
+		LDFLAGS  += -fPIC
+	endif
+endif
+
+ifeq (Windows,$(UNAME))
+	SASSC_BIN = $(SASS_SASSC_PATH)/bin/sassc.exe
+endif
+
+include Makefile.conf
+
+RESOURCES =
+STATICLIB = lib/libsass.a
+SHAREDLIB = lib/libsass.so
+ifeq (Windows,$(UNAME))
+	RESOURCES += res/resource.rc
+	SHAREDLIB  = lib/libsass.dll
+	ifeq (shared,$(BUILD))
+		CFLAGS    += -D ADD_EXPORTS
+		CXXFLAGS  += -D ADD_EXPORTS
+	endif
+else
+	ifneq (Cygwin,$(UNAME))
+		CFLAGS   += -fPIC
+		CXXFLAGS += -fPIC
+		LDFLAGS  += -fPIC
+	endif
+endif
+
+OBJECTS = $(addprefix src/,$(SOURCES:.cpp=.o))
+COBJECTS = $(addprefix src/,$(CSOURCES:.c=.o))
+RCOBJECTS = $(RESOURCES:.rc=.o)
+
+DEBUG_LVL ?= NONE
+
+CLEANUPS ?=
+CLEANUPS += $(RCOBJECTS)
+CLEANUPS += $(COBJECTS)
+CLEANUPS += $(OBJECTS)
+CLEANUPS += $(LIBSASS_LIB)
+
+all: $(BUILD)
+
+debug: $(BUILD)
+
+debug-static: LDFLAGS := -g $(filter-out -O2,$(LDFLAGS))
+debug-static: CFLAGS := -g -DDEBUG -DDEBUG_LVL="$(DEBUG_LVL)" $(filter-out -O2,$(CFLAGS))
+debug-static: CXXFLAGS := -g -DDEBUG -DDEBUG_LVL="$(DEBUG_LVL)" $(filter-out -O2,$(CXXFLAGS))
+debug-static: static
+
+debug-shared: LDFLAGS := -g $(filter-out -O2,$(LDFLAGS))
+debug-shared: CFLAGS := -g -DDEBUG -DDEBUG_LVL="$(DEBUG_LVL)" $(filter-out -O2,$(CFLAGS))
+debug-shared: CXXFLAGS := -g -DDEBUG -DDEBUG_LVL="$(DEBUG_LVL)" $(filter-out -O2,$(CXXFLAGS))
+debug-shared: shared
+
+lib:
+	$(MKDIR) lib
+
+lib/libsass.a: lib $(COBJECTS) $(OBJECTS)
+	$(AR) rcvs $@ $(COBJECTS) $(OBJECTS)
+
+lib/libsass.so: lib $(COBJECTS) $(OBJECTS)
+	$(CXX) -shared $(LDFLAGS) -o $@ $(COBJECTS) $(OBJECTS) $(LDLIBS)
+
+lib/libsass.dll: lib $(COBJECTS) $(OBJECTS) $(RCOBJECTS)
+	$(CXX) -shared $(LDFLAGS) -o $@ $(COBJECTS) $(OBJECTS) $(RCOBJECTS) $(LDLIBS) -s -Wl,--subsystem,windows,--out-implib,lib/libsass.a
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+%.o: %.rc
+	$(WINDRES) -i $< -o $@
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c -o $@ $<
+
+%: %.o static
+	$(CXX) $(CXXFLAGS) -o $@ $+ $(LDFLAGS) $(LDLIBS)
+
+install: install-$(BUILD)
+
+static: $(STATICLIB)
+shared: $(SHAREDLIB)
+
+$(DESTDIR)$(PREFIX):
+	$(MKDIR) $(DESTDIR)$(PREFIX)
+
+$(DESTDIR)$(PREFIX)/lib: $(DESTDIR)$(PREFIX)
+	$(MKDIR) $(DESTDIR)$(PREFIX)/lib
+
+$(DESTDIR)$(PREFIX)/include: $(DESTDIR)$(PREFIX)
+	$(MKDIR) $(DESTDIR)$(PREFIX)/include
+
+$(DESTDIR)$(PREFIX)/include/sass: $(DESTDIR)$(PREFIX)/include
+	$(MKDIR) $(DESTDIR)$(PREFIX)/include/sass
+
+$(DESTDIR)$(PREFIX)/include/%.h: include/%.h \
+                                 $(DESTDIR)$(PREFIX)/include \
+                                 $(DESTDIR)$(PREFIX)/include/sass
+	$(INSTALL) -v -m0644 "$<" "$@"
+
+install-headers: $(DESTDIR)$(PREFIX)/include/sass.h \
+                 $(DESTDIR)$(PREFIX)/include/sass2scss.h \
+                 $(DESTDIR)$(PREFIX)/include/sass/base.h \
+                 $(DESTDIR)$(PREFIX)/include/sass/version.h \
+                 $(DESTDIR)$(PREFIX)/include/sass/values.h \
+                 $(DESTDIR)$(PREFIX)/include/sass/context.h \
+                 $(DESTDIR)$(PREFIX)/include/sass/functions.h
+
+$(DESTDIR)$(PREFIX)/lib/%.a: lib/%.a \
+                             $(DESTDIR)$(PREFIX)/lib
+	@$(INSTALL) -v -m0755 "$<" "$@"
+
+$(DESTDIR)$(PREFIX)/lib/%.so: lib/%.so \
+                             $(DESTDIR)$(PREFIX)/lib
+	@$(INSTALL) -v -m0755 "$<" "$@"
+
+$(DESTDIR)$(PREFIX)/lib/%.dll: lib/%.dll \
+                               $(DESTDIR)$(PREFIX)/lib
+	@$(INSTALL) -v -m0755 "$<" "$@"
+
+install-static: $(DESTDIR)$(PREFIX)/lib/libsass.a
+
+install-shared: $(DESTDIR)$(PREFIX)/lib/libsass.so \
+                install-headers
+
+$(SASSC_BIN): $(BUILD)
+	$(MAKE) -C $(SASS_SASSC_PATH) build-$(BUILD)-dev
+
+sassc: $(SASSC_BIN)
+	$(SASSC_BIN) -v
+
+version: $(SASSC_BIN)
+	$(SASSC_BIN) -h
+	$(SASSC_BIN) -v
+
+test: $(SASSC_BIN)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+
+test_build: $(SASSC_BIN)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+
+test_full: $(SASSC_BIN)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass --run-todo $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+
+test_probe: $(SASSC_BIN)
+	$(RUBY_BIN) $(SASS_SPEC_PATH)/sass-spec.rb -V 3.5 -c $(SASSC_BIN) --impl libsass --probe-todo $(LOG_FLAGS) $(SASS_SPEC_PATH)/$(SASS_SPEC_SPEC_DIR)
+
+clean-objects: lib
+	-$(RM) lib/*.a lib/*.so lib/*.dll lib/*.la
+	-$(RMDIR) lib
+clean: clean-objects
+	$(RM) $(CLEANUPS)
+
+clean-all:
+	$(MAKE) -C $(SASS_SASSC_PATH) clean
+
+lib-file: lib-file-$(BUILD)
+lib-opts: lib-opts-$(BUILD)
+
+lib-file-static:
+	@echo $(LIB_STATIC)
+lib-file-shared:
+	@echo $(LIB_SHARED)
+lib-opts-static:
+	@echo -L"$(SASS_LIBSASS_PATH)/lib"
+lib-opts-shared:
+	@echo -L"$(SASS_LIBSASS_PATH)/lib -lsass"
+
+.PHONY: all static shared sassc \
+        version install-headers \
+        clean clean-all clean-objects \
+        debug debug-static debug-shared \
+        install install-static install-shared \
+        lib-opts lib-opts-shared lib-opts-static \
+        lib-file lib-file-shared lib-file-static
+.DELETE_ON_ERROR:

spa/node_modules/node-sass/src/libsass/Makefile.conf

@@ -0,0 +1,55 @@
+# this is merely a common Makefile multiple implementers can use
+# bigger files (in terms of compile time) tend to go to the top,
+# so they don't end up as the last compile unit when compiling
+# in parallel. But we also want to mix them a little too avoid
+# heavy RAM usage peaks. Other than that the order is arbitrary.
+
+
+SOURCES = \
+	ast.cpp \
+	node.cpp \
+	context.cpp \
+	constants.cpp \
+	functions.cpp \
+	color_maps.cpp \
+	environment.cpp \
+	ast_fwd_decl.cpp \
+	bind.cpp \
+	file.cpp \
+	util.cpp \
+	json.cpp \
+	units.cpp \
+	values.cpp \
+	plugins.cpp \
+	position.cpp \
+	lexer.cpp \
+	parser.cpp \
+	prelexer.cpp \
+	eval.cpp \
+	expand.cpp \
+	listize.cpp \
+	cssize.cpp \
+	extend.cpp \
+	output.cpp \
+	inspect.cpp \
+	emitter.cpp \
+	check_nesting.cpp \
+	remove_placeholders.cpp \
+	sass.cpp \
+	sass_util.cpp \
+	sass_values.cpp \
+	sass_context.cpp \
+	sass_functions.cpp \
+	sass2scss.cpp \
+	backtrace.cpp \
+	operators.cpp \
+	to_c.cpp \
+	to_value.cpp \
+	source_map.cpp \
+	subset_map.cpp \
+	error_handling.cpp \
+	memory/SharedPtr.cpp \
+	utf8_string.cpp \
+	base64vlq.cpp
+
+CSOURCES = cencode.c

spa/node_modules/node-sass/src/libsass/Readme.md

@@ -0,0 +1,104 @@
+LibSass - Sass compiler written in C++
+======================================
+
+Currently maintained by Marcel Greter ([@mgreter]) and Michael Mifsud ([@xzyfer])  
+Originally created by Aaron Leung ([@akhleung]) and Hampton Catlin ([@hcatlin])
+
+[![Unix CI](https://travis-ci.org/sass/libsass.svg?branch=master)](https://travis-ci.org/sass/libsass "Travis CI")
+[![Windows CI](https://ci.appveyor.com/api/projects/status/github/sass/libsass?svg=true)](https://ci.appveyor.com/project/sass/libsass/branch/master "Appveyor CI")
+[![Coverage Status](https://img.shields.io/coveralls/sass/libsass.svg)](https://coveralls.io/r/sass/libsass?branch=feature%2Ftest-travis-ci-3 "Code coverage of spec tests")
+[![Percentage of issues still open](http://isitmaintained.com/badge/open/sass/libsass.svg)](http://isitmaintained.com/project/sass/libsass "Percentage of issues still open")
+[![Average time to resolve an issue](http://isitmaintained.com/badge/resolution/sass/libsass.svg)](http://isitmaintained.com/project/sass/libsass "Average time to resolve an issue")
+[![Bountysource](https://www.bountysource.com/badge/tracker?tracker_id=283068)](https://www.bountysource.com/trackers/283068-libsass?utm_source=283068&utm_medium=shield&utm_campaign=TRACKER_BADGE "Bountysource")
+[![Join us](https://libsass-slack.herokuapp.com/badge.svg)](https://libsass-slack.herokuapp.com/ "Slack communication channels")
+
+
+[LibSass](https://github.com/sass/libsass "LibSass GitHub Project") is just a library!
+If you want to use LibSass to compile Sass, you need an implementer. Some
+implementations are only bindings into other programming languages. But most also
+ship with a command line interface (CLI) you can use directly. There is also
+[SassC](https://github.com/sass/sassc), which is the official lightweight
+CLI tool built by the same people as LibSass.
+
+### Excerpt of "sanctioned" implementations:
+
+- https://github.com/sass/node-sass (Node.js)
+- https://github.com/sass/perl-libsass (Perl)
+- https://github.com/sass/libsass-python (Python)
+- https://github.com/wellington/go-libsass (Go)
+- https://github.com/sass/sassc-ruby (Ruby)
+- https://github.com/sass/libsass-net (C#)
+- https://github.com/medialize/sass.js (JS)
+- https://github.com/bit3/jsass (Java)
+
+This list does not say anything about the quality of either the listed or not listed [implementations](docs/implementations.md)!  
+The authors of the listed projects above are just known to work regularly together with LibSass developers.
+
+About
+-----
+
+LibSass is a C++ port of the original Ruby Sass CSS compiler with a [C API](docs/api-doc.md).
+We coded LibSass with portability and efficiency in mind. You can expect LibSass to be a lot
+faster than Ruby Sass and on par or faster than the best alternative CSS compilers around.
+
+Developing
+----------
+
+As noted above, the LibSass repository does not contain any binaries or other way to execute
+LibSass. Therefore, you need an implementer to develop LibSass. Easiest is to start with
+the official [SassC](http://github.com/sass/sassc) CLI wrapper. It is *guaranteed* to compile
+with the latest code in LibSass master, since it is also used in the CI process. There is no
+limitation here, as you may use any other LibSass implementer to test your LibSass branch!
+
+Testing
+-------
+
+Since LibSass is a pure library, tests are run through the [Sass-Spec](https://github.com/sass/sass-spec)
+project using the [SassC](http://github.com/sass/sassc) CLI wrapper. To run the tests against LibSass while
+developing, you can run `./script/spec`. This will clone SassC and Sass-Spec under the project folder and
+then run the Sass-Spec test suite. You may want to update the clones to ensure you have the latest version.
+Note that the scripts in the `./script` folder are mainly intended for our CI needs.
+
+Building
+--------
+
+To build LibSass you need GCC 4.6+ or Clang/LLVM. If your OS is older, you may need to upgrade
+them first (or install clang as an alternative). On Windows, you need MinGW with GCC 4.6+ or VS 2013
+Update 4+. It is also possible to build LibSass with Clang/LLVM on Windows with various build chains
+and/or command line interpreters.
+
+See the [build docs for further instructions](docs/build.md)!
+
+Compatibility
+-------------
+
+Current LibSass 3.4 should be compatible with Sass 3.4. Please refer to the [sass compatibility
+page](http://sass-compatibility.github.io/) for a more detailed comparison. But note that there
+are still a few incomplete edges which we are aware of. Otherwise LibSass has reached a good level
+of stability, thanks to our ever growing [Sass-Spec test suite](https://github.com/sass/sass-spec).
+
+About Sass
+----------
+
+Sass is a CSS pre-processor language to add on exciting, new, awesome features to CSS. Sass was
+the first language of its kind and by far the most mature and up to date codebase.
+
+Sass was originally conceived of by the co-creator of this library, Hampton Catlin ([@hcatlin]).
+Most of the language has been the result of years of work by Natalie Weizenbaum ([@nex3]) and
+Chris Eppstein ([@chriseppstein]).
+
+For more information about Sass itself, please visit http://sass-lang.com
+
+Initial development of LibSass by Aaron Leung and Hampton Catlin was supported by [Moovweb](http://www.moovweb.com).
+
+Licensing
+---------
+
+Our [MIT license](LICENSE) is designed to be as simple and liberal as possible.
+
+[@hcatlin]: https://github.com/hcatlin
+[@akhleung]: https://github.com/akhleung
+[@chriseppstein]: https://github.com/chriseppstein
+[@nex3]: https://github.com/nex3
+[@mgreter]: https://github.com/mgreter
+[@xzyfer]: https://github.com/xzyfer

spa/node_modules/node-sass/src/libsass/SECURITY.md

@@ -0,0 +1,10 @@
+Serious about security
+======================
+
+The LibSass team recognizes the important contributions the security research
+community can make. We therefore encourage reporting security issues with the
+code contained in this repository.
+
+If you believe you have discovered a security vulnerability, please report it at
+https://hackerone.com/libsass instead of GitHub.
+

spa/node_modules/node-sass/src/libsass/appveyor.yml

@@ -0,0 +1,91 @@
+os: Visual Studio 2013
+
+environment:
+  CTEST_OUTPUT_ON_FAILURE: 1
+  ruby_version: 22-x64
+  TargetPath: sassc/bin/sassc.exe
+  matrix:
+  - Compiler: msvc
+    Config: Release
+    Platform: Win32
+  - Compiler: msvc
+    Config: Debug
+    Platform: Win32
+  - Compiler: msvc
+    Config: Release
+    Platform: Win64
+  - Compiler: mingw
+    Build: static
+  - Compiler: mingw
+    Build: shared
+
+cache:
+  - C:\Ruby%ruby_version%\lib\ruby\gems
+  - C:\mingw64
+
+install:
+  - git clone https://github.com/sass/sassc.git
+  - git clone https://github.com/sass/sass-spec.git
+  - set PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - ps: |
+      if(!(gem which minitest 2>$nul)) { gem install minitest --no-ri --no-rdoc }
+      if ($env:Compiler -eq "mingw" -AND -Not (Test-Path "C:\mingw64")) {
+        # Install MinGW.
+        $file = "x86_64-4.9.2-release-win32-seh-rt_v4-rev3.7z"
+        wget https://bintray.com/artifact/download/drewwells/generic/$file -OutFile $file
+        &7z x -oC:\ $file > $null
+      }
+  - set PATH=C:\mingw64\bin;%PATH%
+  - set CC=gcc
+
+build_script:
+  - ps: |
+      if ($env:Compiler -eq "mingw") {
+        mingw32-make -j4 sassc
+      } else {
+        msbuild /m:4 /p:"Configuration=$env:Config;Platform=$env:Platform" sassc\win\sassc.sln
+      }
+
+      # print the branding art
+      mv script/branding script/branding.ps1
+      script/branding.ps1
+
+      # print the version info
+      &$env:TargetPath -v
+      ruby -v
+
+test_script:
+  - ps: |
+      $PRNR = $env:APPVEYOR_PULL_REQUEST_NUMBER
+      if ($PRNR) {
+        echo "Fetching info for PR $PRNR"
+        wget https://api.github.com/repos/sass/libsass/pulls/$PRNR -OutFile pr.json
+        $json = cat pr.json -Raw
+        $SPEC_PR = [regex]::match($json,'sass\/sass-spec(#|\/pull\/)([0-9]+)').Groups[2].Value
+        if ($SPEC_PR) {
+          echo "Checkout sass spec PR $SPEC_PR"
+          git -C sass-spec fetch -q -u origin pull/$SPEC_PR/head:ci-spec-pr-$SPEC_PR
+          git -C sass-spec checkout -q --force ci-spec-pr-$SPEC_PR
+        }
+      }
+      $env:TargetPath = Join-Path $pwd.Path $env:TargetPath
+      If (Test-Path "$env:TargetPath") {
+        ruby sass-spec/sass-spec.rb -V 3.5 --probe-todo --impl libsass -c $env:TargetPath -s sass-spec/spec
+        if(-not($?)) {
+          echo "sass-spec tests failed"
+          exit 1
+        }
+      } else {
+        echo "spec runner not found (compile error?)"
+        exit 1
+      }
+      Write-Host "Explicitly testing the case when cwd has Cyrillic characters: " -nonewline
+      # See comments in gh-1774 for details.
+      cd sass-spec/spec/libsass/Sáss-UŢF8/
+      &$env:TargetPath ./input.scss 2>&1>$null
+      if(-not($?)) {
+        echo "Failed!"
+        exit 1
+      } else {
+        echo "Success!"
+      }

spa/node_modules/node-sass/src/libsass/configure.ac

@@ -0,0 +1,134 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.61])
+
+AC_INIT([libsass], m4_esyscmd_s([./version.sh]), [support@moovweb.com])
+AC_CONFIG_SRCDIR([src/ast.hpp])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_HEADERS([src/config.h])
+AC_CONFIG_FILES([include/sass/version.h])
+AC_CONFIG_AUX_DIR([script])
+
+# These are flags passed to automake
+# Though they look like gcc flags!
+AM_INIT_AUTOMAKE([foreign parallel-tests -Wall])
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([no])])
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_CXX
+AC_LANG_PUSH([C])
+AC_LANG_PUSH([C++])
+AC_GNU_SOURCE
+# Check fails on Travis, but it works fine
+# AX_CXX_COMPILE_STDCXX_11([ext],[optional])
+AC_CHECK_TOOL([AR], [ar], [false])
+AC_CHECK_TOOL([DLLTOOL], [dlltool], [false])
+AC_CHECK_TOOL([DLLWRAP], [dllwrap], [false])
+AC_CHECK_TOOL([WINDRES], [windres], [false])
+m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
+LT_INIT([dlopen])
+
+# Checks for header files.
+AC_CHECK_HEADERS([unistd.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_TYPE_SIZE_T
+
+# Checks for library functions.
+AC_FUNC_MALLOC
+AC_CHECK_FUNCS([floor getcwd strtol])
+
+# Checks for testing.
+AC_ARG_ENABLE(tests, AS_HELP_STRING([--enable-tests], [enable testing the build]),
+              [enable_tests="$enableval"], [enable_tests=no])
+
+AS_CASE([$host], [*-*-mingw*], [is_mingw32=yes], [is_mingw32=no])
+AM_CONDITIONAL(COMPILER_IS_MINGW32, test "x$is_mingw32" = "xyes")
+
+dnl The dlopen() function is in the C library for *BSD and in
+dnl libdl on GLIBC-based systems
+if test "x$is_mingw32" != "xyes"; then
+  AC_SEARCH_LIBS([dlopen], [dl dld], [], [
+    AC_MSG_ERROR([unable to find the dlopen() function])
+  ])
+fi
+
+if test "x$enable_tests" = "xyes"; then
+  AC_PROG_CC
+  AC_PROG_AWK
+  # test need minitest gem
+  AC_PATH_PROG(RUBY, [ruby])
+  AC_PATH_PROG(TAPOUT, [tapout])
+  AC_REQUIRE_AUX_FILE([tap-driver])
+  AC_REQUIRE_AUX_FILE([tap-runner])
+  AC_ARG_WITH(sassc-dir,
+              AS_HELP_STRING([--with-sassc-dir=<dir>], [specify directory of sassc sources for testing (default: sassc)]),
+              [sassc_dir="$withval"], [sassc_dir="sassc"])
+  AC_CHECK_FILE([$sassc_dir/sassc.c], [], [
+    AC_MSG_ERROR([Unable to find sassc directory.
+You must clone the sassc repository in this directory or specify
+the --with-sassc-dir=<dir> argument.
+])
+  ])
+  SASS_SASSC_PATH=$sassc_dir
+  AC_SUBST(SASS_SASSC_PATH)
+
+  AC_ARG_WITH(sass-spec-dir,
+              AS_HELP_STRING([--with-sass-spec-dir=<dir>], [specify directory of sass-spec for testing (default: sass-spec)]),
+              [sass_spec_dir="$withval"], [sass_spec_dir="sass-spec"])
+  AC_CHECK_FILE([$sass_spec_dir/sass-spec.rb], [], [
+    AC_MSG_ERROR([Unable to find sass-spec directory.
+You must clone the sass-spec repository in this directory or specify
+the --with-sass-spec-dir=<dir> argument.
+])
+  ])
+  # Automake doesn't like its tests in an absolute path, so we make it relative.
+  case $sass_spec_dir in
+    /*)
+      SASS_SPEC_PATH=`$RUBY -e "require 'pathname'; puts Pathname.new('$sass_spec_dir').relative_path_from(Pathname.new('$PWD')).to_s"`
+      ;;
+    *)
+      SASS_SPEC_PATH="$sass_spec_dir"
+      ;;
+  esac
+  AC_SUBST(SASS_SPEC_PATH)
+else
+  # we do not really need these paths for non test build
+  # but automake may error if we do not define them here
+  SASS_SPEC_PATH=sass-spec
+  SASS_SASSC_PATH=sassc
+  AC_SUBST(SASS_SPEC_PATH)
+  AC_SUBST(SASS_SASSC_PATH)
+fi
+
+AM_CONDITIONAL(ENABLE_TESTS, test "x$enable_tests" = "xyes")
+
+AC_ARG_ENABLE([coverage],
+  [AS_HELP_STRING([--enable-coverage],
+    [enable coverage report for test suite])],
+    [enable_cov=$enableval],
+    [enable_cov=no])
+
+if test "x$enable_cov" = "xyes"; then
+
+    AC_CHECK_PROG(GCOV, gcov, gcov)
+
+    # Remove all optimization flags from C[XX]FLAGS
+    changequote({,})
+    CFLAGS=`echo "$CFLAGS -O1 -fno-omit-frame-pointer" | $SED -e 's/-O[0-9]*//g'`
+    CXXFLAGS=`echo "$CXXFLAGS -O1 -fno-omit-frame-pointer" | $SED -e 's/-O[0-9]*//g'`
+    changequote([,])
+
+    AC_SUBST(GCOV)
+fi
+
+AM_CONDITIONAL(ENABLE_COVERAGE, test "x$enable_cov" = "xyes")
+
+AC_SUBST(PACKAGE_VERSION)
+
+AC_MSG_NOTICE([Building libsass ($VERSION)])
+
+AC_CONFIG_FILES([GNUmakefile src/GNUmakefile src/support/libsass.pc])
+AC_OUTPUT

spa/node_modules/node-sass/src/libsass/contrib/libsass.spec

@@ -0,0 +1,66 @@
+Name:           libsass
+Version:        %{version}
+Release:        1%{?dist}
+Summary:        A C/C++ implementation of a Sass compiler
+
+License:        MIT
+URL:            http://libsass.org
+Source0:        %{name}-%{version}.tar.gz
+
+BuildRequires:  gcc-c++ >= 4.7
+BuildRequires:  autoconf
+BuildRequires:  automake
+BuildRequires:  libtool
+
+
+%description
+LibSass is a C/C++ port of the Sass engine. The point is to be simple, fast, and easy to integrate.
+
+%package        devel
+Summary:        Development files for %{name}
+Requires:       %{name}%{?_isa} = %{version}-%{release}
+
+
+%description    devel
+The %{name}-devel package contains libraries and header files for
+developing applications that use %{name}.
+
+
+%prep
+%setup -q
+autoreconf --force --install
+
+
+%build
+%configure --disable-static \
+           --disable-tests \
+           --enable-shared
+
+make %{?_smp_mflags}
+
+
+%install
+%make_install
+find $RPM_BUILD_ROOT -name '*.la' -exec rm -f {} ';'
+
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+
+%files
+%doc Readme.md LICENSE
+%{_libdir}/*.so.*
+
+%files devel
+%doc
+%{_includedir}/*
+%{_libdir}/*.so
+%{_libdir}/pkgconfig/*.pc
+
+
+%changelog
+* Tue Feb 10 2015 Gawain Lynch <gawain.lynch@gmail.com> - 3.1.0-1
+- Initial SPEC file
+

spa/node_modules/node-sass/src/libsass/contrib/plugin.cpp

@@ -0,0 +1,60 @@
+#include <cstring>
+#include <iostream>
+#include <stdint.h>
+#include <sass.h>
+
+// gcc: g++ -shared plugin.cpp -o plugin.so -fPIC -Llib -lsass
+// mingw: g++ -shared plugin.cpp -o plugin.dll -Llib -lsass
+
+extern "C" const char* ADDCALL libsass_get_version() {
+  return libsass_version();
+}
+
+union Sass_Value* custom_function(const union Sass_Value* s_args, Sass_Function_Entry cb, struct Sass_Compiler* comp)
+{
+  // get context/option struct associated with this compiler
+  struct Sass_Context* ctx = sass_compiler_get_context(comp);
+  struct Sass_Options* opts = sass_compiler_get_options(comp);
+  // get the cookie from function descriptor
+  void* cookie = sass_function_get_cookie(cb);
+  // we actually abuse the void* to store an "int"
+  return sass_make_number((intptr_t)cookie, "px");
+}
+
+extern "C" Sass_Function_List ADDCALL libsass_load_functions()
+{
+  // allocate a custom function caller
+  Sass_Function_Entry c_func =
+    sass_make_function("foo()", custom_function, (void*)42);
+  // create list of all custom functions
+  Sass_Function_List fn_list = sass_make_function_list(1);
+  // put the only function in this plugin to the list
+  sass_function_set_list_entry(fn_list, 0, c_func);
+  // return the list
+  return fn_list;
+}
+
+Sass_Import_List custom_importer(const char* cur_path, Sass_Importer_Entry cb, struct Sass_Compiler* comp)
+{
+  // get the cookie from importer descriptor
+  void* cookie = sass_importer_get_cookie(cb);
+  // create a list to hold our import entries
+  Sass_Import_List incs = sass_make_import_list(1);
+  // create our only import entry (route path back)
+  incs[0] = sass_make_import_entry(cur_path, 0, 0);
+  // return imports
+  return incs;
+}
+
+extern "C" Sass_Importer_List ADDCALL libsass_load_importers()
+{
+  // allocate a custom function caller
+  Sass_Importer_Entry c_imp =
+    sass_make_importer(custom_importer, - 99, (void*)42);
+  // create list of all custom functions
+  Sass_Importer_List imp_list = sass_make_importer_list(1);
+  // put the only function in this plugin to the list
+  sass_importer_set_list_entry(imp_list, 0, c_imp);
+  // return the list
+  return imp_list;
+}

spa/node_modules/node-sass/src/libsass/docs/README.md

@@ -0,0 +1,20 @@
+Welcome to the LibSass documentation!
+
+## First Off
+LibSass is just a library. To run the code locally (i.e. to compile your stylesheets), you need an implementer. SassC (get it?) is an implementer written in C. There are a number of other implementations of LibSass - for example Node. We encourage you to write your own port - the whole point of LibSass is that we want to bring Sass to many other languages, not just Ruby!
+
+We're working hard on moving to full parity with Ruby Sass... learn more at the [The-LibSass-Compatibility-Plan](compatibility-plan.md)!
+
+### Implementing LibSass
+
+If you're interested in implementing LibSass in your own project see the [API Documentation](api-doc.md) which now includes implementing
+your own [Sass functions](api-function.md).  You may wish to [look at other implementations](implementations.md) for your language of choice.
+Or make your own!
+
+### Contributing to LibSass
+
+|   Issue Tracker   |            Issue Triage          |     Community Guidelines    |
+|-------------------|----------------------------------|-----------------------------|
+| We're always needing help, so check out our issue tracker, help some people out, and read our article on [Contributing](contributing.md)! It's got all the details on what to do! | To help understand the process of triaging bugs, have a look at our [Issue-Triage](triage.md) document. | Oh, and don't forget we always follow [[Sass Community Guidelines|http://sass-lang.com/community-guidelines]]. Be nice and everyone else will be nice too! |
+
+Please refer to the steps on [Building LibSass](build.md)

spa/node_modules/node-sass/src/libsass/docs/api-context-example.md

@@ -0,0 +1,45 @@
+## Example main.c
+
+```C
+#include <stdio.h>
+#include "sass/context.h"
+
+int main( int argc, const char* argv[] )
+{
+
+  // get the input file from first argument or use default
+  const char* input = argc > 1 ? argv[1] : "styles.scss";
+
+  // create the file context and get all related structs
+  struct Sass_File_Context* file_ctx = sass_make_file_context(input);
+  struct Sass_Context* ctx = sass_file_context_get_context(file_ctx);
+  struct Sass_Options* ctx_opt = sass_context_get_options(ctx);
+
+  // configure some options ...
+  sass_option_set_precision(ctx_opt, 10);
+
+  // context is set up, call the compile step now
+  int status = sass_compile_file_context(file_ctx);
+
+  // print the result or the error to the stdout
+  if (status == 0) puts(sass_context_get_output_string(ctx));
+  else puts(sass_context_get_error_message(ctx));
+
+  // release allocated memory
+  sass_delete_file_context(file_ctx);
+
+  // exit status
+  return status;
+
+}
+```
+
+### Compile main.c
+
+```bash
+gcc -c main.c -o main.o
+gcc -o sample main.o -lsass
+echo "foo { margin: 21px * 2; }" > foo.scss
+./sample foo.scss => "foo { margin: 42px }"
+```
+

spa/node_modules/node-sass/src/libsass/docs/api-context-internal.md

@@ -0,0 +1,163 @@
+```C
+// Input behaviours
+enum Sass_Input_Style {
+  SASS_CONTEXT_NULL,
+  SASS_CONTEXT_FILE,
+  SASS_CONTEXT_DATA,
+  SASS_CONTEXT_FOLDER
+};
+
+// sass config options structure
+struct Sass_Inspect_Options {
+
+  // Output style for the generated css code
+  // A value from above SASS_STYLE_* constants
+  enum Sass_Output_Style output_style;
+
+  // Precision for fractional numbers
+  int precision;
+
+};
+
+// sass config options structure
+struct Sass_Output_Options : Sass_Inspect_Options {
+
+  // String to be used for indentation
+  const char* indent;
+  // String to be used to for line feeds
+  const char* linefeed;
+
+  // Emit comments in the generated CSS indicating
+  // the corresponding source line.
+  bool source_comments;
+
+};
+
+// sass config options structure
+struct Sass_Options : Sass_Output_Options {
+
+  // embed sourceMappingUrl as data uri
+  bool source_map_embed;
+
+  // embed include contents in maps
+  bool source_map_contents;
+
+  // create file urls for sources
+  bool source_map_file_urls;
+
+  // Disable sourceMappingUrl in css output
+  bool omit_source_map_url;
+
+  // Treat source_string as sass (as opposed to scss)
+  bool is_indented_syntax_src;
+
+  // The input path is used for source map
+  // generation. It can be used to define
+  // something with string compilation or to
+  // overload the input file path. It is
+  // set to "stdin" for data contexts and
+  // to the input file on file contexts.
+  char* input_path;
+
+  // The output path is used for source map
+  // generation. LibSass will not write to
+  // this file, it is just used to create
+  // information in source-maps etc.
+  char* output_path;
+
+  // Colon-separated list of paths
+  // Semicolon-separated on Windows
+  // Maybe use array interface instead?
+  char* include_path;
+  char* plugin_path;
+
+  // Include paths (linked string list)
+  struct string_list* include_paths;
+  // Plugin paths (linked string list)
+  struct string_list* plugin_paths;
+
+  // Path to source map file
+  // Enables source map generation
+  // Used to create sourceMappingUrl
+  char* source_map_file;
+
+  // Directly inserted in source maps
+  char* source_map_root;
+
+  // Custom functions that can be called from sccs code
+  Sass_Function_List c_functions;
+
+  // Callback to overload imports
+  Sass_Importer_List c_importers;
+
+  // List of custom headers
+  Sass_Importer_List c_headers;
+
+};
+
+// base for all contexts
+struct Sass_Context : Sass_Options
+{
+
+  // store context type info
+  enum Sass_Input_Style type;
+
+  // generated output data
+  char* output_string;
+
+  // generated source map json
+  char* source_map_string;
+
+  // error status
+  int error_status;
+  char* error_json;
+  char* error_text;
+  char* error_message;
+  // error position
+  char* error_file;
+  size_t error_line;
+  size_t error_column;
+  const char* error_src;
+
+  // report imported files
+  char** included_files;
+
+};
+
+// struct for file compilation
+struct Sass_File_Context : Sass_Context {
+
+  // no additional fields required
+  // input_path is already on options
+
+};
+
+// struct for data compilation
+struct Sass_Data_Context : Sass_Context {
+
+  // provided source string
+  char* source_string;
+  char* srcmap_string;
+
+};
+
+// Compiler states
+enum Sass_Compiler_State {
+  SASS_COMPILER_CREATED,
+  SASS_COMPILER_PARSED,
+  SASS_COMPILER_EXECUTED
+};
+
+// link c and cpp context
+struct Sass_Compiler {
+  // progress status
+  Sass_Compiler_State state;
+  // original c context
+  Sass_Context* c_ctx;
+  // Sass::Context
+  Sass::Context* cpp_ctx;
+  // Sass::Block
+  Sass::Block_Obj root;
+};
+```
+

spa/node_modules/node-sass/src/libsass/docs/api-context.md

@@ -0,0 +1,295 @@
+Sass Contexts come in two flavors:
+
+- `Sass_File_Context`
+- `Sass_Data_Context`
+
+### Basic Usage
+
+```C
+#include "sass/context.h"
+```
+
+***Sass_Options***
+
+```C
+// Precision for fractional numbers
+int precision;
+```
+```C
+// Output style for the generated css code
+// A value from above SASS_STYLE_* constants
+int output_style;
+```
+```C
+// Emit comments in the generated CSS indicating
+// the corresponding source line.
+bool source_comments;
+```
+```C
+// embed sourceMappingUrl as data uri
+bool source_map_embed;
+```
+```C
+// embed include contents in maps
+bool source_map_contents;
+```
+```C
+// create file urls for sources
+bool source_map_file_urls;
+```
+```C
+// Disable sourceMappingUrl in css output
+bool omit_source_map_url;
+```
+```C
+// Treat source_string as sass (as opposed to scss)
+bool is_indented_syntax_src;
+```
+```C
+// The input path is used for source map
+// generating. It can be used to define
+// something with string compilation or to
+// overload the input file path. It is
+// set to "stdin" for data contexts and
+// to the input file on file contexts.
+char* input_path;
+```
+```C
+// The output path is used for source map
+// generating. LibSass will not write to
+// this file, it is just used to create
+// information in source-maps etc.
+char* output_path;
+```
+```C
+// String to be used for indentation
+const char* indent;
+```
+```C
+// String to be used to for line feeds
+const char* linefeed;
+```
+```C
+// Colon-separated list of paths
+// Semicolon-separated on Windows
+char* include_path;
+char* plugin_path;
+```
+```C
+// Additional include paths
+// Must be null delimited
+char** include_paths;
+char** plugin_paths;
+```
+```C
+// Path to source map file
+// Enables the source map generating
+// Used to create sourceMappingUrl
+char* source_map_file;
+```
+```C
+// Directly inserted in source maps
+char* source_map_root;
+```
+```C
+// Custom functions that can be called from Sass code
+Sass_C_Function_List c_functions;
+```
+```C
+// Callback to overload imports
+Sass_C_Import_Callback importer;
+```
+
+***Sass_Context***
+
+```C
+// store context type info
+enum Sass_Input_Style type;
+````
+```C
+// generated output data
+char* output_string;
+```
+```C
+// generated source map json
+char* source_map_string;
+```
+```C
+// error status
+int error_status;
+char* error_json;
+char* error_text;
+char* error_message;
+// error position
+char* error_file;
+size_t error_line;
+size_t error_column;
+```
+```C
+// report imported files
+char** included_files;
+```
+
+***Sass_File_Context***
+
+```C
+// no additional fields required
+// input_path is already on options
+```
+
+***Sass_Data_Context***
+
+```C
+// provided source string
+char* source_string;
+```
+
+### Sass Context API
+
+```C
+// Forward declaration
+struct Sass_Compiler;
+
+// Forward declaration
+struct Sass_Options;
+struct Sass_Context; // : Sass_Options
+struct Sass_File_Context; // : Sass_Context
+struct Sass_Data_Context; // : Sass_Context
+
+// Create and initialize an option struct
+struct Sass_Options* sass_make_options (void);
+// Create and initialize a specific context
+struct Sass_File_Context* sass_make_file_context (const char* input_path);
+struct Sass_Data_Context* sass_make_data_context (char* source_string);
+
+// Call the compilation step for the specific context
+int sass_compile_file_context (struct Sass_File_Context* ctx);
+int sass_compile_data_context (struct Sass_Data_Context* ctx);
+
+// Create a sass compiler instance for more control
+struct Sass_Compiler* sass_make_file_compiler (struct Sass_File_Context* file_ctx);
+struct Sass_Compiler* sass_make_data_compiler (struct Sass_Data_Context* data_ctx);
+
+// Execute the different compilation steps individually
+// Usefull if you only want to query the included files
+int sass_compiler_parse (struct Sass_Compiler* compiler);
+int sass_compiler_execute (struct Sass_Compiler* compiler);
+
+// Release all memory allocated with the compiler
+// This does _not_ include any contexts or options
+void sass_delete_compiler (struct Sass_Compiler* compiler);
+void sass_delete_options(struct Sass_Options* options);
+
+// Release all memory allocated and also ourself
+void sass_delete_file_context (struct Sass_File_Context* ctx);
+void sass_delete_data_context (struct Sass_Data_Context* ctx);
+
+// Getters for Context from specific implementation
+struct Sass_Context* sass_file_context_get_context (struct Sass_File_Context* file_ctx);
+struct Sass_Context* sass_data_context_get_context (struct Sass_Data_Context* data_ctx);
+
+// Getters for Context_Options from Sass_Context
+struct Sass_Options* sass_context_get_options (struct Sass_Context* ctx);
+struct Sass_Options* sass_file_context_get_options (struct Sass_File_Context* file_ctx);
+struct Sass_Options* sass_data_context_get_options (struct Sass_Data_Context* data_ctx);
+void sass_file_context_set_options (struct Sass_File_Context* file_ctx, struct Sass_Options* opt);
+void sass_data_context_set_options (struct Sass_Data_Context* data_ctx, struct Sass_Options* opt);
+
+// Getters for Sass_Context values
+const char* sass_context_get_output_string (struct Sass_Context* ctx);
+int sass_context_get_error_status (struct Sass_Context* ctx);
+const char* sass_context_get_error_json (struct Sass_Context* ctx);
+const char* sass_context_get_error_text (struct Sass_Context* ctx);
+const char* sass_context_get_error_message (struct Sass_Context* ctx);
+const char* sass_context_get_error_file (struct Sass_Context* ctx);
+size_t sass_context_get_error_line (struct Sass_Context* ctx);
+size_t sass_context_get_error_column (struct Sass_Context* ctx);
+const char* sass_context_get_source_map_string (struct Sass_Context* ctx);
+char** sass_context_get_included_files (struct Sass_Context* ctx);
+
+// Getters for Sass_Compiler options (query import stack)
+size_t sass_compiler_get_import_stack_size(struct Sass_Compiler* compiler);
+Sass_Import_Entry sass_compiler_get_last_import(struct Sass_Compiler* compiler);
+Sass_Import_Entry sass_compiler_get_import_entry(struct Sass_Compiler* compiler, size_t idx);
+// Getters for Sass_Compiler options (query function stack)
+size_t sass_compiler_get_callee_stack_size(struct Sass_Compiler* compiler);
+Sass_Callee_Entry sass_compiler_get_last_callee(struct Sass_Compiler* compiler);
+Sass_Callee_Entry sass_compiler_get_callee_entry(struct Sass_Compiler* compiler, size_t idx);
+
+// Take ownership of memory (value on context is set to 0)
+char* sass_context_take_error_json (struct Sass_Context* ctx);
+char* sass_context_take_error_text (struct Sass_Context* ctx);
+char* sass_context_take_error_message (struct Sass_Context* ctx);
+char* sass_context_take_error_file (struct Sass_Context* ctx);
+char* sass_context_take_output_string (struct Sass_Context* ctx);
+char* sass_context_take_source_map_string (struct Sass_Context* ctx);
+```
+
+### Sass Options API
+
+```C
+// Getters for Context_Option values
+int sass_option_get_precision (struct Sass_Options* options);
+enum Sass_Output_Style sass_option_get_output_style (struct Sass_Options* options);
+bool sass_option_get_source_comments (struct Sass_Options* options);
+bool sass_option_get_source_map_embed (struct Sass_Options* options);
+bool sass_option_get_source_map_contents (struct Sass_Options* options);
+bool sass_option_get_source_map_file_urls (struct Sass_Options* options);
+bool sass_option_get_omit_source_map_url (struct Sass_Options* options);
+bool sass_option_get_is_indented_syntax_src (struct Sass_Options* options);
+const char* sass_option_get_indent (struct Sass_Options* options);
+const char* sass_option_get_linefeed (struct Sass_Options* options);
+const char* sass_option_get_input_path (struct Sass_Options* options);
+const char* sass_option_get_output_path (struct Sass_Options* options);
+const char* sass_option_get_source_map_file (struct Sass_Options* options);
+const char* sass_option_get_source_map_root (struct Sass_Options* options);
+Sass_C_Function_List sass_option_get_c_functions (struct Sass_Options* options);
+Sass_C_Import_Callback sass_option_get_importer (struct Sass_Options* options);
+
+// Getters for Context_Option include path array
+size_t sass_option_get_include_path_size(struct Sass_Options* options);
+const char* sass_option_get_include_path(struct Sass_Options* options, size_t i);
+// Plugin paths to load dynamic libraries work the same
+size_t sass_option_get_plugin_path_size(struct Sass_Options* options);
+const char* sass_option_get_plugin_path(struct Sass_Options* options, size_t i);
+
+// Setters for Context_Option values
+void sass_option_set_precision (struct Sass_Options* options, int precision);
+void sass_option_set_output_style (struct Sass_Options* options, enum Sass_Output_Style output_style);
+void sass_option_set_source_comments (struct Sass_Options* options, bool source_comments);
+void sass_option_set_source_map_embed (struct Sass_Options* options, bool source_map_embed);
+void sass_option_set_source_map_contents (struct Sass_Options* options, bool source_map_contents);
+void sass_option_set_source_map_file_urls (struct Sass_Options* options, bool source_map_file_urls);
+void sass_option_set_omit_source_map_url (struct Sass_Options* options, bool omit_source_map_url);
+void sass_option_set_is_indented_syntax_src (struct Sass_Options* options, bool is_indented_syntax_src);
+void sass_option_set_indent (struct Sass_Options* options, const char* indent);
+void sass_option_set_linefeed (struct Sass_Options* options, const char* linefeed);
+void sass_option_set_input_path (struct Sass_Options* options, const char* input_path);
+void sass_option_set_output_path (struct Sass_Options* options, const char* output_path);
+void sass_option_set_plugin_path (struct Sass_Options* options, const char* plugin_path);
+void sass_option_set_include_path (struct Sass_Options* options, const char* include_path);
+void sass_option_set_source_map_file (struct Sass_Options* options, const char* source_map_file);
+void sass_option_set_source_map_root (struct Sass_Options* options, const char* source_map_root);
+void sass_option_set_c_functions (struct Sass_Options* options, Sass_C_Function_List c_functions);
+void sass_option_set_importer (struct Sass_Options* options, Sass_C_Import_Callback importer);
+
+// Push function for paths (no manipulation support for now)
+void sass_option_push_plugin_path (struct Sass_Options* options, const char* path);
+void sass_option_push_include_path (struct Sass_Options* options, const char* path);
+
+// Resolve a file via the given include paths in the sass option struct
+// find_file looks for the exact file name while find_include does a regular sass include
+char* sass_find_file (const char* path, struct Sass_Options* opt);
+char* sass_find_include (const char* path, struct Sass_Options* opt);
+
+// Resolve a file relative to last import or include paths in the sass option struct
+// find_file looks for the exact file name while find_include does a regular sass include
+char* sass_compiler_find_file (const char* path, struct Sass_Compiler* compiler);
+char* sass_compiler_find_include (const char* path, struct Sass_Compiler* compiler);
+```
+
+### More links
+
+- [Sass Context Example](api-context-example.md)
+- [Sass Context Internal](api-context-internal.md)
+

spa/node_modules/node-sass/src/libsass/docs/api-doc.md

@@ -0,0 +1,215 @@
+## Introduction
+
+LibSass wouldn't be much good without a way to interface with it. These
+interface documentations describe the various functions and data structures
+available to implementers. They are split up over three major components, which
+have all their own source files (plus some common functionality).
+
+- [Sass Context](api-context.md) - Trigger and handle the main Sass compilation
+- [Sass Value](api-value.md) - Exchange values and its format with LibSass
+- [Sass Function](api-function.md) - Get invoked by LibSass for function statments
+- [Sass Importer](api-importer.md) - Get invoked by LibSass for @import statments
+
+### Basic usage
+
+First you will need to include the header file!
+This will automatically load all other headers too!
+
+```C
+#include "sass/context.h"
+```
+
+## Basic C Example
+
+```C
+#include <stdio.h>
+#include "sass/context.h"
+
+int main() {
+  puts(libsass_version());
+  return 0;
+}
+```
+
+```bash
+gcc -Wall version.c -lsass -o version && ./version
+```
+
+## More C Examples
+
+- [Sample code for Sass Context](api-context-example.md)
+- [Sample code for Sass Value](api-value-example.md)
+- [Sample code for Sass Function](api-function-example.md)
+- [Sample code for Sass Importer](api-importer-example.md)
+
+## Compiling your code
+
+The most important is your sass file (or string of sass code). With this, you
+will want to start a LibSass compiler. Here is some pseudocode describing the
+process. The compiler has two different modes: direct input as a string with
+`Sass_Data_Context` or LibSass will do file reading for you by using
+`Sass_File_Context`. See the code for a list of options available
+[Sass_Options](https://github.com/sass/libsass/blob/36feef0/include/sass/interface.h#L18)
+
+**Building a file compiler**
+
+    context = sass_make_file_context("file.scss")
+    options = sass_file_context_get_options(context)
+    sass_option_set_precision(options, 1)
+    sass_option_set_source_comments(options, true)
+
+    sass_file_context_set_options(context, options)
+
+    compiler = sass_make_file_compiler(sass_context)
+    sass_compiler_parse(compiler)
+    sass_compiler_execute(compiler)
+
+    output = sass_context_get_output_string(context)
+    // Retrieve errors during compilation
+    error_status = sass_context_get_error_status(context)
+    json_error = sass_context_get_error_json(context)
+    // Release memory dedicated to the C compiler
+    sass_delete_compiler(compiler)
+
+**Building a data compiler**
+
+    context = sass_make_data_context("div { a { color: blue; } }")
+    options = sass_data_context_get_options(context)
+    sass_option_set_precision(options, 1)
+    sass_option_set_source_comments(options, true)
+
+    sass_data_context_set_options(context, options)
+
+    compiler = sass_make_data_compiler(context)
+    sass_compiler_parse(compiler)
+    sass_compiler_execute(compiler)
+
+    output = sass_context_get_output_string(context)
+    // div a { color: blue; }
+    // Retrieve errors during compilation
+    error_status = sass_context_get_error_status(context)
+    json_error = sass_context_get_error_json(context)
+    // Release memory dedicated to the C compiler
+    sass_delete_compiler(compiler)
+
+## Sass Context Internals
+
+Everything is stored in structs:
+
+```C
+struct Sass_Options;
+struct Sass_Context : Sass_Options;
+struct Sass_File_context : Sass_Context;
+struct Sass_Data_context : Sass_Context;
+```
+
+This mirrors very well how `libsass` uses these structures.
+
+- `Sass_Options` holds everything you feed in before the compilation. It also hosts
+`input_path` and `output_path` options, because they are used to generate/calculate
+relative links in source-maps. The `input_path` is shared with `Sass_File_Context`.
+- `Sass_Context` holds all the data returned by the compilation step.
+- `Sass_File_Context` is a specific implementation that requires no additional fields
+- `Sass_Data_Context` is a specific implementation that adds the `input_source` field
+
+Structs can be down-casted to access `context` or `options`!
+
+## Memory handling and life-cycles
+
+We keep memory around for as long as the main [context](api-context.md) object
+is not destroyed (`sass_delete_context`). LibSass will create copies of most
+inputs/options beside the main sass code. You need to allocate and fill that
+buffer before passing it to LibSass. You may also overtake memory management
+from libsass for certain return values (i.e. `sass_context_take_output_string`).
+
+```C
+// to allocate buffer to be filled
+void* sass_alloc_memory(size_t size);
+// to allocate a buffer from existing string
+char* sass_copy_c_string(const char* str);
+// to free overtaken memory when done
+void sass_free_memory(void* ptr);
+```
+
+## Miscellaneous API functions
+
+```C
+// Some convenient string helper function
+char* sass_string_unquote (const char* str);
+char* sass_string_quote (const char* str, const char quote_mark);
+
+// Get compiled libsass version
+const char* libsass_version(void);
+
+// Implemented sass language version
+// Hardcoded version 3.4 for time being
+const char* libsass_language_version(void);
+```
+
+## Common Pitfalls
+
+**input_path**
+
+The `input_path` is part of `Sass_Options`, but it also is the main option for
+`Sass_File_Context`. It is also used to generate relative file links in source-
+maps. Therefore it is pretty usefull to pass this information if you have a
+`Sass_Data_Context` and know the original path.
+
+**output_path**
+
+Be aware that `libsass` does not write the output file itself. This option
+merely exists to give `libsass` the proper information to generate links in
+source-maps. The file has to be written to the disk by the
+binding/implementation. If the `output_path` is omitted, `libsass` tries to
+extrapolate one from the `input_path` by replacing (or adding) the file ending
+with `.css`.
+
+## Error Codes
+
+The `error_code` is integer value which indicates the type of error that
+occurred inside the LibSass process. Following is the list of error codes along
+with the short description:
+
+* 1: normal errors like parsing or `eval` errors
+* 2: bad allocation error (memory error)
+* 3: "untranslated" C++ exception (`throw std::exception`)
+* 4: legacy string exceptions ( `throw const char*` or `std::string` )
+* 5: Some other unknown exception
+
+Although for the API consumer, error codes do not offer much value except
+indicating whether *any* error occurred during the compilation, it helps
+debugging the LibSass internal code paths.
+
+## Real-World Implementations
+
+The proof is in the pudding, so we have highlighted a few implementations that
+should be on par with the latest LibSass interface version. Some of them may not
+have all features implemented!
+
+1. [Perl Example](https://github.com/sass/perl-libsass/blob/master/lib/CSS/Sass.xs)
+2. [Go Example](https://godoc.org/github.com/wellington/go-libsass#example-Compiler--Stdin)
+3. [Node Example](https://github.com/sass/node-sass/blob/master/src/binding.cpp)
+
+## ABI forward compatibility
+
+We use a functional API to make dynamic linking more robust and future
+compatible. The API is not yet 100% stable, so we do not yet guarantee
+[ABI](https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html) forward
+compatibility.
+
+## Plugins (experimental)
+
+LibSass can load plugins from directories. Just define `plugin_path` on context
+options to load all plugins from the directories. To implement plugins, please
+consult the following example implementations.
+
+- https://github.com/mgreter/libsass-glob
+- https://github.com/mgreter/libsass-math
+- https://github.com/mgreter/libsass-digest
+
+## Internal Structs
+
+- [Sass Context Internals](api-context-internal.md)
+- [Sass Value Internals](api-value-internal.md)
+- [Sass Function Internals](api-function-internal.md)
+- [Sass Importer Internals](api-importer-internal.md)

spa/node_modules/node-sass/src/libsass/docs/api-function-example.md

@@ -0,0 +1,67 @@
+## Example main.c
+
+```C
+#include <stdio.h>
+#include <stdint.h>
+#include "sass/context.h"
+
+union Sass_Value* call_fn_foo(const union Sass_Value* s_args, Sass_Function_Entry cb, struct Sass_Compiler* comp)
+{
+  // get context/option struct associated with this compiler
+  struct Sass_Context* ctx = sass_compiler_get_context(comp);
+  struct Sass_Options* opts = sass_compiler_get_options(comp);
+  // get information about previous importer entry from the stack
+  Sass_Import_Entry import = sass_compiler_get_last_import(comp);
+  const char* prev_abs_path = sass_import_get_abs_path(import);
+  const char* prev_imp_path = sass_import_get_imp_path(import);
+  // get the cookie from function descriptor
+  void* cookie = sass_function_get_cookie(cb);
+  // we actually abuse the void* to store an "int"
+  return sass_make_number((intptr_t)cookie, "px");
+}
+
+int main( int argc, const char* argv[] )
+{
+
+  // get the input file from first argument or use default
+  const char* input = argc > 1 ? argv[1] : "styles.scss";
+
+  // create the file context and get all related structs
+  struct Sass_File_Context* file_ctx = sass_make_file_context(input);
+  struct Sass_Context* ctx = sass_file_context_get_context(file_ctx);
+  struct Sass_Options* ctx_opt = sass_context_get_options(ctx);
+
+  // allocate a custom function caller
+  Sass_Function_Entry fn_foo =
+    sass_make_function("foo()", call_fn_foo, (void*)42);
+
+  // create list of all custom functions
+  Sass_Function_List fn_list = sass_make_function_list(1);
+  sass_function_set_list_entry(fn_list, 0, fn_foo);
+  sass_option_set_c_functions(ctx_opt, fn_list);
+
+  // context is set up, call the compile step now
+  int status = sass_compile_file_context(file_ctx);
+
+  // print the result or the error to the stdout
+  if (status == 0) puts(sass_context_get_output_string(ctx));
+  else puts(sass_context_get_error_message(ctx));
+
+  // release allocated memory
+  sass_delete_file_context(file_ctx);
+
+  // exit status
+  return status;
+
+}
+```
+
+### Compile main.c
+
+```bash
+gcc -c main.c -o main.o
+gcc -o sample main.o -lsass
+echo "foo { margin: foo(); }" > foo.scss
+./sample foo.scss => "foo { margin: 42px }"
+```
+

spa/node_modules/node-sass/src/libsass/docs/api-function-internal.md

@@ -0,0 +1,8 @@
+```C
+// Struct to hold custom function callback
+struct Sass_Function {
+  const char*      signature;
+  Sass_Function_Fn function;
+  void*            cookie;
+};
+```

spa/node_modules/node-sass/src/libsass/docs/api-function.md

@@ -0,0 +1,74 @@
+Sass functions are used to define new custom functions callable by Sass code. They are also used to overload debug or error statements. You can also define a fallback function, which is called for every unknown function found in the Sass code. Functions get passed zero or more `Sass_Values` (a `Sass_List` value) and they must also return a `Sass_Value`. Return a `Sass_Error` if you want to signal an error.
+
+## Special signatures
+
+- `*` - Fallback implementation
+- `@warn` - Overload warn statements
+- `@error` - Overload error statements
+- `@debug` - Overload debug statements
+
+Note: The fallback implementation will be given the name of the called function as the first argument, before all the original function arguments. These features are pretty new and should be considered experimental.
+
+### Basic Usage
+
+```C
+#include "sass/functions.h"
+```
+
+## Sass Function API
+
+```C
+// Forward declaration
+struct Sass_Compiler;
+struct Sass_Function;
+
+// Typedef helpers for custom functions lists
+typedef struct Sass_Function (*Sass_Function_Entry);
+typedef struct Sass_Function* (*Sass_Function_List);
+// Typedef defining function signature and return type
+typedef union Sass_Value* (*Sass_Function_Fn)
+  (const union Sass_Value*, Sass_Function_Entry cb, struct Sass_Compiler* compiler);
+
+// Creators for sass function list and function descriptors
+Sass_Function_List sass_make_function_list (size_t length);
+Sass_Function_Entry sass_make_function (const char* signature, Sass_Function_Fn cb, void* cookie);
+// In case you need to free them yourself
+void sass_delete_function (Sass_Function_Entry entry);
+void sass_delete_function_list (Sass_Function_List list);
+
+// Setters and getters for callbacks on function lists
+Sass_Function_Entry sass_function_get_list_entry(Sass_Function_List list, size_t pos);
+void sass_function_set_list_entry(Sass_Function_List list, size_t pos, Sass_Function_Entry cb);
+
+// Setters to insert an entry into the import list (you may also use [] access directly)
+// Since we are dealing with pointers they should have a guaranteed and fixed size
+void sass_import_set_list_entry (Sass_Import_List list, size_t idx, Sass_Import_Entry entry);
+Sass_Import_Entry sass_import_get_list_entry (Sass_Import_List list, size_t idx);
+
+// Getters for custom function descriptors
+const char* sass_function_get_signature (Sass_Function_Entry cb);
+Sass_Function_Fn sass_function_get_function (Sass_Function_Entry cb);
+void* sass_function_get_cookie (Sass_Function_Entry cb);
+
+// Getters for callee entry
+const char* sass_callee_get_name (Sass_Callee_Entry);
+const char* sass_callee_get_path (Sass_Callee_Entry);
+size_t sass_callee_get_line (Sass_Callee_Entry);
+size_t sass_callee_get_column (Sass_Callee_Entry);
+enum Sass_Callee_Type sass_callee_get_type (Sass_Callee_Entry);
+Sass_Env_Frame sass_callee_get_env (Sass_Callee_Entry);
+
+// Getters and Setters for environments (lexical, local and global)
+union Sass_Value* sass_env_get_lexical (Sass_Env_Frame, const char*);
+void sass_env_set_lexical (Sass_Env_Frame, const char*, union Sass_Value*);
+union Sass_Value* sass_env_get_local (Sass_Env_Frame, const char*);
+void sass_env_set_local (Sass_Env_Frame, const char*, union Sass_Value*);
+union Sass_Value* sass_env_get_global (Sass_Env_Frame, const char*);
+void sass_env_set_global (Sass_Env_Frame, const char*, union Sass_Value*);
+```
+
+### More links
+
+- [Sass Function Example](api-function-example.md)
+- [Sass Function Internal](api-function-internal.md)
+

spa/node_modules/node-sass/src/libsass/docs/api-importer-example.md

@@ -0,0 +1,112 @@
+## Example importer.c
+
+```C
+#include <stdio.h>
+#include <string.h>
+#include "sass/context.h"
+
+Sass_Import_List sass_importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp)
+{
+  // get the cookie from importer descriptor
+  void* cookie = sass_importer_get_cookie(cb);
+  Sass_Import_List list = sass_make_import_list(2);
+  char* local = sass_copy_c_string("local { color: green; }");
+  char* remote = sass_copy_c_string("remote { color: red; }");
+  list[0] = sass_make_import_entry("/tmp/styles.scss", local, 0);
+  list[1] = sass_make_import_entry("http://www.example.com", remote, 0);
+  return list;
+}
+
+int main( int argc, const char* argv[] )
+{
+
+  // get the input file from first argument or use default
+  const char* input = argc > 1 ? argv[1] : "styles.scss";
+
+  // create the file context and get all related structs
+  struct Sass_File_Context* file_ctx = sass_make_file_context(input);
+  struct Sass_Context* ctx = sass_file_context_get_context(file_ctx);
+  struct Sass_Options* ctx_opt = sass_context_get_options(ctx);
+
+  // allocate custom importer
+  Sass_Importer_Entry c_imp =
+    sass_make_importer(sass_importer, 0, 0);
+  // create list for all custom importers
+  Sass_Importer_List imp_list = sass_make_importer_list(1);
+  // put only the importer on to the list
+  sass_importer_set_list_entry(imp_list, 0, c_imp);
+  // register list on to the context options
+  sass_option_set_c_importers(ctx_opt, imp_list);
+  // context is set up, call the compile step now
+  int status = sass_compile_file_context(file_ctx);
+
+  // print the result or the error to the stdout
+  if (status == 0) puts(sass_context_get_output_string(ctx));
+  else puts(sass_context_get_error_message(ctx));
+
+  // release allocated memory
+  sass_delete_file_context(file_ctx);
+
+  // exit status
+  return status;
+
+}
+```
+
+Compile importer.c
+
+```bash
+gcc -c importer.c -o importer.o
+gcc -o importer importer.o -lsass
+echo "@import 'foobar';" > importer.scss
+./importer importer.scss
+```
+
+## Importer Behavior Examples
+
+```C
+Sass_Import_List importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp) {
+  // let LibSass handle the import request
+  return NULL;
+}
+
+Sass_Import_List importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp) {
+  // let LibSass handle the request
+  // swallows »@import "http://…"« pass-through
+  // (arguably a bug)
+  Sass_Import_List list = sass_make_import_list(1);
+  list[0] = sass_make_import_entry(path, 0, 0);
+  return list;
+}
+
+Sass_Import_List importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp) {
+  // return an error to halt execution
+  Sass_Import_List list = sass_make_import_list(1);
+  const char* message = "some error message";
+  list[0] = sass_make_import_entry(path, 0, 0);
+  sass_import_set_error(list[0], sass_copy_c_string(message), 0, 0);
+  return list;
+}
+
+Sass_Import_List importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp) {
+  // let LibSass load the file identifed by the importer
+  Sass_Import_List list = sass_make_import_list(1);
+  list[0] = sass_make_import_entry("/tmp/file.scss", 0, 0);
+  return list;
+}
+
+Sass_Import_List importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp) {
+  // completely hide the import
+  // (arguably a bug)
+  Sass_Import_List list = sass_make_import_list(0);
+  return list;
+}
+
+Sass_Import_List importer(const char* path, Sass_Importer_Entry cb, struct Sass_Compiler* comp) {
+  // completely hide the import
+  // (arguably a bug)
+  Sass_Import_List list = sass_make_import_list(1);
+  list[0] = sass_make_import_entry(0, 0, 0);
+  return list;
+}
+```

spa/node_modules/node-sass/src/libsass/docs/api-importer-internal.md

@@ -0,0 +1,20 @@
+```C
+// External import entry
+struct Sass_Import {
+  char* imp_path; // path as found in the import statement
+  char *abs_path; // path after importer has resolved it
+  char* source;
+  char* srcmap;
+  // error handling
+  char* error;
+  size_t line;
+  size_t column;
+};
+
+// Struct to hold importer callback
+struct Sass_Importer {
+  Sass_Importer_Fn importer;
+  double           priority;
+  void*            cookie;
+};
+```

spa/node_modules/node-sass/src/libsass/docs/api-importer.md

@@ -0,0 +1,86 @@
+By using custom importers, Sass stylesheets can be implemented in any possible way, such as by being loaded via a remote server. Please note: this feature is experimental and is implemented differently than importers in Ruby Sass. Imports must be relative to the parent import context and therefore we need to pass this information to the importer callback. This is currently done by passing the complete import string/path of the previous import context.
+
+## Return Imports
+
+You actually have to return a list of imports, since some importers may want to import multiple files from one import statement (ie. a glob/star importer).  The memory you pass with source and srcmap is taken over by LibSass and freed automatically when the import is done. You are also allowed to return `0` instead of a list, which will tell LibSass to handle the import by itself (as if no custom importer was in use).
+
+```C
+Sass_Import_Entry* rv = sass_make_import_list(1);
+rv[0] = sass_make_import(rel, abs, source, srcmap);
+```
+
+Every import will then be included in LibSass. You are allowed to only return a file path without any loaded source. This way you can ie. implement rewrite rules for import paths and leave the loading part for LibSass.
+
+Please note that LibSass doesn't use the srcmap parameter yet. It has been added to not deprecate the C-API once support has been implemented. It will be used to re-map the actual sourcemap with the provided ones.
+
+### Basic Usage
+
+```C
+#include "sass/functions.h"
+```
+
+## Sass Importer API
+
+```C
+// Forward declaration
+struct Sass_Import;
+
+// Forward declaration
+struct Sass_C_Import_Descriptor;
+
+// Typedef defining the custom importer callback
+typedef struct Sass_C_Import_Descriptor (*Sass_C_Import_Callback);
+// Typedef defining the importer c function prototype
+typedef Sass_Import_Entry* (*Sass_C_Import_Fn) (const char* url, const char* prev, void* cookie);
+
+// Creators for custom importer callback (with some additional pointer)
+// The pointer is mostly used to store the callback into the actual function
+Sass_C_Import_Callback sass_make_importer (Sass_C_Import_Fn, void* cookie);
+
+// Getters for import function descriptors
+Sass_C_Import_Fn sass_import_get_function (Sass_C_Import_Callback fn);
+void* sass_import_get_cookie (Sass_C_Import_Callback fn);
+
+// Deallocator for associated memory
+void sass_delete_importer (Sass_C_Import_Callback fn);
+
+// Creator for sass custom importer return argument list
+Sass_Import_Entry* sass_make_import_list (size_t length);
+// Creator for a single import entry returned by the custom importer inside the list
+Sass_Import_Entry sass_make_import_entry (const char* path, char* source, char* srcmap);
+Sass_Import_Entry sass_make_import (const char* rel, const char* abs, char* source, char* srcmap);
+
+// set error message to abort import and to print out a message (path from existing object is used in output)
+Sass_Import_Entry sass_import_set_error(Sass_Import_Entry import, const char* message, size_t line, size_t col);
+
+// Setters to insert an entry into the import list (you may also use [] access directly)
+// Since we are dealing with pointers they should have a guaranteed and fixed size
+void sass_import_set_list_entry (Sass_Import_Entry* list, size_t idx, Sass_Import_Entry entry);
+Sass_Import_Entry sass_import_get_list_entry (Sass_Import_Entry* list, size_t idx);
+
+// Getters for import entry
+const char* sass_import_get_imp_path (Sass_Import_Entry);
+const char* sass_import_get_abs_path (Sass_Import_Entry);
+const char* sass_import_get_source (Sass_Import_Entry);
+const char* sass_import_get_srcmap (Sass_Import_Entry);
+// Explicit functions to take ownership of these items
+// The property on our struct will be reset to NULL
+char* sass_import_take_source (Sass_Import_Entry);
+char* sass_import_take_srcmap (Sass_Import_Entry);
+
+// Getters for import error entries
+size_t sass_import_get_error_line (Sass_Import_Entry);
+size_t sass_import_get_error_column (Sass_Import_Entry);
+const char* sass_import_get_error_message (Sass_Import_Entry);
+
+// Deallocator for associated memory (incl. entries)
+void sass_delete_import_list (Sass_Import_Entry*);
+// Just in case we have some stray import structs
+void sass_delete_import (Sass_Import_Entry);
+```
+
+### More links
+
+- [Sass Importer Example](api-importer-example.md)
+- [Sass Importer Internal](api-importer-internal.md)
+

spa/node_modules/node-sass/src/libsass/docs/api-value-example.md

@@ -0,0 +1,55 @@
+## Example operation.c
+
+```C
+#include <stdio.h>
+#include <string.h>
+#include "sass/values.h"
+
+int main( int argc, const char* argv[] )
+{
+
+  // create two new sass values to be added
+  union Sass_Value* string = sass_make_string("String");
+  union Sass_Value* number = sass_make_number(42, "nits");
+
+  // invoke the add operation which returns a new sass value
+  union Sass_Value* total = sass_value_op(ADD, string, number);
+
+  // no further use for the two operands
+  sass_delete_value(string);
+  sass_delete_value(number);
+
+  // this works since libsass will always return a
+  // string for add operations with a string as the
+  // left hand side. But you should never rely on it!
+  puts(sass_string_get_value(total));
+
+  // invoke stringification (uncompressed with precision of 5)
+  union Sass_Value* result = sass_value_stringify(total, false, 5);
+
+  // no further use for the sum
+  sass_delete_value(total);
+
+  // print the result - you may want to make
+  // sure result is indeed a string, altough
+  // stringify guarantees to return a string
+  // if (sass_value_is_string(result)) {}
+  // really depends on your level of paranoia
+  puts(sass_string_get_value(result));
+
+  // finally free result
+  sass_delete_value(result);
+
+  // exit status
+  return 0;
+
+}
+```
+
+## Compile operation.c
+
+```bash
+gcc -c operation.c -o operation.o
+gcc -o operation operation.o -lsass
+./operation # => String42nits
+```

spa/node_modules/node-sass/src/libsass/docs/api-value-internal.md

@@ -0,0 +1,76 @@
+```C
+struct Sass_Unknown {
+  enum Sass_Tag tag;
+};
+
+struct Sass_Boolean {
+  enum Sass_Tag tag;
+  bool          value;
+};
+
+struct Sass_Number {
+  enum Sass_Tag tag;
+  double        value;
+  char*         unit;
+};
+
+struct Sass_Color {
+  enum Sass_Tag tag;
+  double        r;
+  double        g;
+  double        b;
+  double        a;
+};
+
+struct Sass_String {
+  enum Sass_Tag tag;
+  char*         value;
+};
+
+struct Sass_List {
+  enum Sass_Tag       tag;
+  enum Sass_Separator separator;
+  size_t              length;
+  // null terminated "array"
+  union Sass_Value**  values;
+};
+
+struct Sass_Map {
+  enum Sass_Tag        tag;
+  size_t               length;
+  struct Sass_MapPair* pairs;
+};
+
+struct Sass_Null {
+  enum Sass_Tag tag;
+};
+
+struct Sass_Error {
+  enum Sass_Tag tag;
+  char*         message;
+};
+
+struct Sass_Warning {
+  enum Sass_Tag tag;
+  char*         message;
+};
+
+union Sass_Value {
+  struct Sass_Unknown unknown;
+  struct Sass_Boolean boolean;
+  struct Sass_Number  number;
+  struct Sass_Color   color;
+  struct Sass_String  string;
+  struct Sass_List    list;
+  struct Sass_Map     map;
+  struct Sass_Null    null;
+  struct Sass_Error   error;
+  struct Sass_Warning   warning;
+};
+
+struct Sass_MapPair {
+  union Sass_Value* key;
+  union Sass_Value* value;
+};
+```
+

spa/node_modules/node-sass/src/libsass/docs/api-value.md

@@ -0,0 +1,154 @@
+`Sass_Values` are used to pass values and their types between the implementer
+and LibSass. Sass knows various different value types (including nested arrays
+and hash-maps). If you implement a binding to another programming language, you
+have to find a way to [marshal][1] (convert) `Sass_Values` between the target
+language and C. `Sass_Values` are currently only used by custom functions, but
+it should also be possible to use them without a compiler context.
+
+[1]: https://en.wikipedia.org/wiki/Marshalling_%28computer_science%29
+
+### Basic Usage
+
+```C
+#include "sass/values.h"
+```
+
+```C
+// Type for Sass values
+enum Sass_Tag {
+  SASS_BOOLEAN,
+  SASS_NUMBER,
+  SASS_COLOR,
+  SASS_STRING,
+  SASS_LIST,
+  SASS_MAP,
+  SASS_NULL,
+  SASS_ERROR,
+  SASS_WARNING
+};
+
+// Tags for denoting Sass list separators
+enum Sass_Separator {
+  SASS_COMMA,
+  SASS_SPACE,
+  // only used internally to represent a hash map before evaluation
+  // otherwise we would be too early to check for duplicate keys
+  SASS_HASH
+};
+
+// Value Operators
+enum Sass_OP {
+  AND, OR,                   // logical connectives
+  EQ, NEQ, GT, GTE, LT, LTE, // arithmetic relations
+  ADD, SUB, MUL, DIV, MOD,   // arithmetic functions
+  NUM_OPS                    // so we know how big to make the op table
+};
+```
+
+### Sass Value API
+
+```C
+// Forward declaration
+union Sass_Value;
+
+// Creator functions for all value types
+union Sass_Value* sass_make_null    (void);
+union Sass_Value* sass_make_boolean (bool val);
+union Sass_Value* sass_make_string  (const char* val);
+union Sass_Value* sass_make_qstring (const char* val);
+union Sass_Value* sass_make_number  (double val, const char* unit);
+union Sass_Value* sass_make_color   (double r, double g, double b, double a);
+union Sass_Value* sass_make_list    (size_t len, enum Sass_Separator sep, bool is_bracketed);
+union Sass_Value* sass_make_map     (size_t len);
+union Sass_Value* sass_make_error   (const char* msg);
+union Sass_Value* sass_make_warning (const char* msg);
+
+// Generic destructor function for all types
+// Will release memory of all associated Sass_Values
+// Means we will delete recursively for lists and maps
+void sass_delete_value (union Sass_Value* val);
+
+// Make a deep cloned copy of the given sass value
+union Sass_Value* sass_clone_value (const union Sass_Value* val);
+
+// Stringify a Sass_Values and also return the result as a Sass_Value (of type STRING)
+union Sass_Value* sass_value_stringify (const union Sass_Value* a, bool compressed, int precision);
+
+// Execute an operation for two Sass_Values and return the result as a Sass_Value too
+union Sass_Value* sass_value_op (enum Sass_OP op, const union Sass_Value* a, const union Sass_Value* b);
+
+// Return the sass tag for a generic sass value
+// Check is needed before accessing specific values!
+enum Sass_Tag sass_value_get_tag (const union Sass_Value* v);
+
+// Check value to be of a specific type
+// Can also be used before accessing properties!
+bool sass_value_is_null (const union Sass_Value* v);
+bool sass_value_is_number (const union Sass_Value* v);
+bool sass_value_is_string (const union Sass_Value* v);
+bool sass_value_is_boolean (const union Sass_Value* v);
+bool sass_value_is_color (const union Sass_Value* v);
+bool sass_value_is_list (const union Sass_Value* v);
+bool sass_value_is_map (const union Sass_Value* v);
+bool sass_value_is_error (const union Sass_Value* v);
+bool sass_value_is_warning (const union Sass_Value* v);
+
+// Getters and setters for Sass_Number
+double sass_number_get_value (const union Sass_Value* v);
+void sass_number_set_value (union Sass_Value* v, double value);
+const char* sass_number_get_unit (const union Sass_Value* v);
+void sass_number_set_unit (union Sass_Value* v, char* unit);
+
+// Getters and setters for Sass_String
+const char* sass_string_get_value (const union Sass_Value* v);
+void sass_string_set_value (union Sass_Value* v, char* value);
+bool sass_string_is_quoted(const union Sass_Value* v);
+void sass_string_set_quoted(union Sass_Value* v, bool quoted);
+
+// Getters and setters for Sass_Boolean
+bool sass_boolean_get_value (const union Sass_Value* v);
+void sass_boolean_set_value (union Sass_Value* v, bool value);
+
+// Getters and setters for Sass_Color
+double sass_color_get_r (const union Sass_Value* v);
+void sass_color_set_r (union Sass_Value* v, double r);
+double sass_color_get_g (const union Sass_Value* v);
+void sass_color_set_g (union Sass_Value* v, double g);
+double sass_color_get_b (const union Sass_Value* v);
+void sass_color_set_b (union Sass_Value* v, double b);
+double sass_color_get_a (const union Sass_Value* v);
+void sass_color_set_a (union Sass_Value* v, double a);
+
+// Getter for the number of items in list
+size_t sass_list_get_length (const union Sass_Value* v);
+// Getters and setters for Sass_List
+enum Sass_Separator sass_list_get_separator (const union Sass_Value* v);
+void sass_list_set_separator (union Sass_Value* v, enum Sass_Separator value);
+bool sass_list_get_is_bracketed (const union Sass_Value* v);
+void sass_list_set_is_bracketed (union Sass_Value* v, bool value);
+// Getters and setters for Sass_List values
+union Sass_Value* sass_list_get_value (const union Sass_Value* v, size_t i);
+void sass_list_set_value (union Sass_Value* v, size_t i, union Sass_Value* value);
+
+// Getter for the number of items in map
+size_t sass_map_get_length (const union Sass_Value* v);
+// Getters and setters for Sass_Map keys and values
+union Sass_Value* sass_map_get_key (const union Sass_Value* v, size_t i);
+void sass_map_set_key (union Sass_Value* v, size_t i, union Sass_Value*);
+union Sass_Value* sass_map_get_value (const union Sass_Value* v, size_t i);
+void sass_map_set_value (union Sass_Value* v, size_t i, union Sass_Value*);
+
+// Getters and setters for Sass_Error
+char* sass_error_get_message (const union Sass_Value* v);
+void sass_error_set_message (union Sass_Value* v, char* msg);
+
+// Getters and setters for Sass_Warning
+char* sass_warning_get_message (const union Sass_Value* v);
+void sass_warning_set_message (union Sass_Value* v, char* msg);
+```
+
+### More links
+
+- [Sass Value Example](api-value-example.md)
+- [Sass Value Internal](api-value-internal.md)
+

spa/node_modules/node-sass/src/libsass/docs/build-on-darwin.md

@@ -0,0 +1,27 @@
+To install LibSass, make sure the OS X build tools are installed:
+
+    xcode-select --install
+
+## Homebrew
+
+To install homebrew, see [http://brew.sh](http://brew.sh)
+
+    ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+
+You can install the latest version of LibSass quite easily with brew.
+
+    brew install --HEAD libsass
+
+To update this, do:
+
+    brew reinstall --HEAD libsass
+
+Brew will build static and shared libraries, and a `libsass.pc` file in `/usr/local/lib/pkgconfig`.
+
+To use `libsass.pc`, make sure this path is in your `PKG_CONFIG_PATH`
+
+    export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
+
+## Manually
+
+See the linux instructions [Building-with-autotools](build-with-autotools.md) or [Building-with-makefiles](build-with-makefiles.md)

spa/node_modules/node-sass/src/libsass/docs/build-on-gentoo.md

@@ -0,0 +1,55 @@
+Here are two ebuilds to compile LibSass and sassc on gentoo linux. If you do not know how to use these ebuilds, you should probably read the gentoo wiki page about [portage overlays](http://wiki.gentoo.org/wiki/Overlay).
+
+## www-misc/libsass/libsass-9999.ebuild
+```ebuild
+EAPI=4
+
+inherit eutils git-2 autotools
+
+DESCRIPTION="A C/C++ implementation of a Sass compiler."
+HOMEPAGE="http://libsass.org/"
+EGIT_PROJECT='libsass'
+EGIT_REPO_URI="https://github.com/sass/libsass.git"
+LICENSE="MIT"
+SLOT="0"
+KEYWORDS=""
+IUSE=""
+DEPEND=""
+RDEPEND="${DEPEND}"
+DEPEND="${DEPEND}"
+
+pkg_pretend() {
+    # older gcc is not supported
+    local major=$(gcc-major-version)
+    local minor=$(gcc-minor-version)
+    [[ "${MERGE_TYPE}" != "binary" && ( $major > 4 || ( $major == 4 && $minor < 5 ) ) ]] && \
+        die "Sorry, but gcc earlier than 4.5 will not work for LibSass."
+}
+
+src_prepare() {
+   eautoreconf
+}
+```
+
+## www-misc/sassc/sassc-9999.ebuild
+```ebuild
+EAPI=4
+
+inherit eutils git-2 autotools
+
+DESCRIPTION="Command Line Tool for LibSass."
+HOMEPAGE="http://libsass.org/"
+EGIT_PROJECT='sassc'
+EGIT_REPO_URI="https://github.com/sass/sassc.git"
+LICENSE="MIT"
+SLOT="0"
+KEYWORDS=""
+IUSE=""
+DEPEND="www-misc/libsass"
+RDEPEND="${DEPEND}"
+DEPEND="${DEPEND}"
+
+src_prepare() {
+   eautoreconf
+}
+```

spa/node_modules/node-sass/src/libsass/docs/build-on-windows.md

@@ -0,0 +1,139 @@
+We support builds via MingGW and via Visual Studio Community 2013.
+Both should be considered experimental (MinGW was better tested)!
+
+## Building via MingGW (makefiles)
+
+First grab the latest [MinGW for windows][1] installer. Once it is installed, you can click on continue or open the Installation Manager via `bin\mingw-get.exe`.
+
+You need to have the following components installed:
+![Visualization of components installed in the interface](https://cloud.githubusercontent.com/assets/282293/5525466/947bf396-89e6-11e4-841d-4aa916f14de1.png)
+
+Next we need to install [git for windows][2]. You probably want to check the option to add it to the global path, but you do not need to install the unix tools.
+
+If you want to run the spec test-suite you also need [ruby][3] and a few gems available. Grab the [latest installer][3] and make sure to add it the global path. Then install the missing gems:
+
+```bash
+gem install minitest
+```
+
+### Mount the mingw root directory
+
+As mentioned in the [MinGW Getting Started](http://www.mingw.org/wiki/Getting_Started#toc5) guide, you should edit `C:\MinGW\msys\1.0\etc\fstab` to contain the following line:
+
+```
+C:\MinGW   /mingw
+```
+
+### Starting a "MingGW" console
+
+Create a batch file with this content:
+```bat
+@echo off
+set PATH=C:\MinGW\bin;%PATH%
+REM only needed if not already available
+set PATH=%PROGRAMFILES%\git\bin;%PATH%
+REM C:\MinGW\msys\1.0\msys.bat
+cmd
+```
+
+Execute it and make sure these commands can be called: `git`, `mingw32-make`, `rm` and `gcc`! Once this is all set, you should be ready to compile `libsass`!
+
+### Get the sources
+
+```bash
+# using git is preferred
+git clone https://github.com/sass/libsass.git
+# only needed for sassc and/or testsuite
+git clone https://github.com/sass/sassc.git libsass/sassc
+git clone https://github.com/sass/sass-spec.git libsass/sass-spec
+```
+
+### Decide for static or shared library
+
+`libsass` can be built and linked as a `static` or as a `shared` library. The default is `static`. To change it you can set the `BUILD` environment variable:
+
+```bat
+set BUILD="shared"
+```
+
+### Compile the library
+```bash
+mingw32-make -C libsass
+```
+
+### Results can be found in
+```bash
+$ ls libsass/lib
+libsass.a  libsass.dll  libsass.so
+```
+
+### Run the spec test-suite
+```bash
+mingw32-make -C libsass test_build
+```
+
+## Building via MingGW 64bit (makefiles)
+Building libass to dll on window 64bit.
+
++ downloads  [MinGW64 for windows7 64bit](http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/4.9.2/threads-win32/seh/x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z/download) , and unzip to "C:\mingw64".
+
++ Create a batch file with this content:
+
+```bat
+@echo off
+set PATH=C:\mingw64\bin;%PATH%
+set CC=gcc
+REM only needed if not already available
+set PATH=%PROGRAMFILES%\Git\bin;%PATH%
+REM C:\MinGW\msys\1.0\msys.bat
+cmd
+```
+
++ By default , mingw64 dll will depends on "​m​i​n​g​w​m​1​0​.​d​l​l​、​ ​l​i​b​g​c​c​_​s​_​d​w​2​-​1​.​d​l​l​" , we can modify Makefile to fix this:(add "-static")
+
+``` bash
+lib/libsass.dll: $(COBJECTS) $(OBJECTS) $(RCOBJECTS)
+	$(MKDIR) lib
+	$(CXX) -shared $(LDFLAGS) -o $@ $(COBJECTS) $(OBJECTS) $(RCOBJECTS) $(LDLIBS) -s -static -Wl,--subsystem,windows,--out-implib,lib/libsass.a
+```
+
++ Compile the library
+
+```bash
+mingw32-make -C libsass
+```
+
+By the way , if you are using java jna , [JNAerator](http://jnaerator.googlecode.com/) is a good tool.
+
+## Building via Visual Studio Community 2013
+
+Open a Visual Studio 2013 command prompt:
+- `VS2013 x86 Native Tools Command Prompt`
+
+Note: When I installed the community edition, I only got the 2012 command prompts. I copied them from the Startmenu to the Desktop and adjusted the paths from `Visual Studio 11.0` to `Visual Studio 12.0`. Since `libsass` uses some `C++11` features, you need at least a MSVC 2013 compiler (v120).
+
+### Get the source
+```bash
+# using git is preferred
+git clone https://github.com/sass/libsass.git
+git clone https://github.com/sass/sassc.git libsass/sassc
+# only needed if you want to run the testsuite
+git clone https://github.com/sass/sass-spec.git libsass/sass-spec
+```
+
+### Compile sassc
+
+Sometimes `msbuild` seems not available from the command prompt. Just search for it and add it to the global path. It seems to be included in the .net folders too.
+
+```bat
+cd libsass
+REM set PATH=%PATH%;%PROGRAMFILES%\MSBuild\12.0\Bin
+msbuild /m:4 /p:Configuration=Release win\libsass.sln
+REM running the spec test-suite manually (needs ruby and minitest gem)
+ruby sass-spec\sass-spec.rb -V 3.5 -c win\bin\sassc.exe -s --impl libsass sass-spec/spec
+cd ..
+```
+
+[1]: http://sourceforge.net/projects/mingw/files/latest/download?source=files
+[2]: https://msysgit.github.io/
+[3]: http://rubyinstaller.org/

spa/node_modules/node-sass/src/libsass/docs/build-shared-library.md

@@ -0,0 +1,35 @@
+This page is mostly intended for people that want to build a system library that gets distributed via RPMs or other means. This is currently in a experimental phase, as we currently do not really guarantee any ABI forward compatibility. The C API was rewritten to make this possible in the future, but we want to wait some more time till we can call this final and stable.
+
+Building via autotools
+--
+
+You want to build a system library only via autotools, since it will create the proper `libtool` files to make it loadable on multiple systems. We hope this works correctly, but nobody of the `libsass` core team has much knowledge in this area. Therefore we are open for comments or improvements by people that have more experience in that matter (like package maintainers from various linux distributions).
+
+```bash
+apt-get install autoconf libtool
+git clone https://github.com/sass/libsass.git
+cd libsass
+autoreconf --force --install
+./configure \
+  --disable-tests \
+  --disable-static \
+  --enable-shared \
+  --prefix=/usr
+make -j5 install
+cd ..
+```
+
+This should install these files
+```bash
+# $ ls -la /usr/lib/libsass.*
+/usr/lib/libsass.la
+/usr/lib/libsass.so -> libsass.so.0.0.9
+/usr/lib/libsass.so.0 -> libsass.so.0.0.9
+/usr/lib/libsass.so.0.0.9
+# $ ls -la /usr/include/sass*
+/usr/include/sass.h
+/usr/include/sass2scss.h
+/usr/include/sass/context.h
+/usr/include/sass/functions.h
+/usr/include/sass/values.h
+```

spa/node_modules/node-sass/src/libsass/docs/build-with-autotools.md

@@ -0,0 +1,78 @@
+### Get the sources
+```bash
+# using git is preferred
+git clone https://github.com/sass/libsass.git
+# only needed for sassc and/or testsuite
+git clone https://github.com/sass/sassc.git libsass/sassc
+git clone https://github.com/sass/sass-spec.git libsass/sass-spec
+```
+
+### Prerequisites
+
+In order to run autotools you need a few tools installed on your system.
+```bash
+yum install automake libtool # RedHat Linux
+emerge -a automake libtool # Gentoo Linux
+pkgin install automake libtool # SmartOS
+```
+
+
+### Create configure script
+```bash
+cd libsass
+autoreconf --force --install
+cd ..
+```
+
+### Create custom makefiles
+```bash
+cd libsass
+./configure \
+  --disable-tests \
+  --disable-shared \
+  --prefix=/usr
+cd ..
+```
+
+### Build the library
+```bash
+make -C libsass -j5
+```
+
+### Install the library
+The library will be installed to the location given as `prefix` to `configure`. This is standard behavior for autotools and not `libsass` specific.
+```bash
+make -C libsass -j5 install
+```
+
+### Configure options
+The `configure` script is created by autotools. To get an overview of available options you can call `./configure --help`. When you execute this script, it will create specific makefiles, which you then use via the regular make command.
+
+There are some `libsass` specific options:
+
+```
+Optional Features:
+  --enable-tests              enable testing the build
+  --enable-coverage           enable coverage report for test suite
+  --enable-shared             build shared libraries [default=yes]
+  --enable-static             build static libraries [default=yes]
+
+Optional Packages:
+  --with-sassc-dir=<dir>      specify directory of sassc sources for
+                              testing (default: sassc)
+  --with-sass-spec-dir=<dir>  specify directory of sass-spec for testing
+                              (default: sass-spec)
+```
+
+### Build sassc and run spec test-suite
+
+```bash
+cd libsass
+autoreconf --force --install
+./configure \
+  --enable-tests \
+  --enable-shared \
+  --prefix=/usr
+make -j5 test_build
+cd ..
+```

spa/node_modules/node-sass/src/libsass/docs/build-with-makefiles.md

@@ -0,0 +1,68 @@
+### Get the sources
+```bash
+# using git is preferred
+git clone https://github.com/sass/libsass.git
+# only needed for sassc and/or testsuite
+git clone https://github.com/sass/sassc.git libsass/sassc
+git clone https://github.com/sass/sass-spec.git libsass/sass-spec
+```
+
+### Decide for static or shared library
+
+`libsass` can be built and linked as a `static` or as a `shared` library. The default is `static`. To change it you can set the `BUILD` environment variable:
+
+```bash
+export BUILD="shared"
+```
+
+Alternatively you can also define it directly when calling make:
+
+```bash
+BUILD="shared" make ...
+```
+
+### Compile the library
+```bash
+make -C libsass -j5
+```
+
+### Results can be found in
+```bash
+$ ls libsass/lib
+libsass.a libsass.so
+```
+
+### Install onto the system
+
+We recommend to use [autotools to install](build-with-autotools.md) libsass onto the
+system, since that brings all the benefits of using libtools as the main install method.
+If you still want to install libsass via the makefile, you need to make sure that gnu
+`install` utility (or compatible) is installed on your system.
+```bash
+yum install coreutils # RedHat Linux
+emerge -a coreutils # Gentoo Linux
+pkgin install coreutils # SmartOS
+```
+
+You can set the install location by setting `PREFIX`
+```bash
+PREFIX="/opt/local" make install
+```
+
+
+### Compling sassc
+
+```bash
+# Let build know library location
+export SASS_LIBSASS_PATH="`pwd`/libsass"
+# Invokes the sassc makefile
+make -C libsass -j5 sassc
+```
+
+### Run the spec test-suite
+
+```bash
+# needs ruby available
+# also gem install minitest
+make -C libsass -j5 test_build
+```

spa/node_modules/node-sass/src/libsass/docs/build-with-mingw.md

@@ -0,0 +1,107 @@
+## Building LibSass with MingGW (makefiles)
+
+First grab the latest [MinGW for windows][1] installer. Once it is installed, you can click on continue or open the Installation Manager via `bin\mingw-get.exe`.
+
+You need to have the following components installed:
+![](https://cloud.githubusercontent.com/assets/282293/5525466/947bf396-89e6-11e4-841d-4aa916f14de1.png)
+
+Next we need to install [git for windows][2]. You probably want to check the option to add it to the global path, but you do not need to install the unix tools.
+
+If you want to run the spec test-suite you also need [ruby][3] and a few gems available. Grab the [latest installer][3] and make sure to add it the global path. Then install the missing gems:
+
+```bash
+gem install minitest
+```
+
+### Mount the mingw root directory
+
+As mentioned in the [MinGW Getting Started](http://www.mingw.org/wiki/Getting_Started#toc5) guide, you should edit `C:\MinGW\msys\1.0\etc\fstab` to contain the following line:
+
+```
+C:\MinGW   /mingw
+```
+
+### Starting a "MingGW" console
+
+Create a batch file with this content:
+```bat
+@echo off
+set PATH=C:\MinGW\bin;%PATH%
+REM only needed if not already available
+set PATH=%PROGRAMFILES%\git\bin;%PATH%
+REM C:\MinGW\msys\1.0\msys.bat
+cmd
+```
+
+Execute it and make sure these commands can be called: `git`, `mingw32-make`, `rm` and `gcc`! Once this is all set, you should be ready to compile `libsass`!
+
+### Get the sources
+
+```bash
+# using git is preferred
+git clone https://github.com/sass/libsass.git
+# only needed for sassc and/or testsuite
+git clone https://github.com/sass/sassc.git libsass/sassc
+git clone https://github.com/sass/sass-spec.git libsass/sass-spec
+```
+
+### Decide for static or shared library
+
+`libsass` can be built and linked as a `static` or as a `shared` library. The default is `static`. To change it you can set the `BUILD` environment variable:
+
+```bat
+set BUILD="shared"
+```
+
+### Compile the library
+```bash
+mingw32-make -C libsass
+```
+
+### Results can be found in
+```bash
+$ ls libsass/lib
+libsass.a  libsass.dll  libsass.so
+```
+
+### Run the spec test-suite
+```bash
+mingw32-make -C libsass test_build
+```
+
+## Building via MingGW 64bit (makefiles)
+Building libass to dll on window 64bit.
+
+Download [MinGW64 for windows7 64bit](http://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/4.9.2/threads-win32/seh/x86_64-4.9.2-release-win32-seh-rt_v3-rev0.7z/download) and unzip to "C:\mingw64".
+
+Create a batch file with this content:
+
+```bat
+@echo off
+set PATH=C:\mingw64\bin;%PATH%
+set CC=gcc
+REM only needed if not already available
+set PATH=%PROGRAMFILES%\Git\bin;%PATH%
+REM C:\MinGW\msys\1.0\msys.bat
+cmd
+```
+
+By default, mingw64 dll will depends on "​m​i​n​g​w​m​1​0​.​d​l​l​、​ ​l​i​b​g​c​c​_​s​_​d​w​2​-​1​.​d​l​l​", we can modify Makefile to fix this:(add "-static")
+
+``` bash
+lib/libsass.dll: $(COBJECTS) $(OBJECTS) $(RCOBJECTS)
+	$(MKDIR) lib
+	$(CXX) -shared $(LDFLAGS) -o $@ $(COBJECTS) $(OBJECTS) $(RCOBJECTS) $(LDLIBS) -s -static -Wl,--subsystem,windows,--out-implib,lib/libsass.a
+```
+
+Compile the library
+
+```bash
+mingw32-make -C libsass
+```
+
+By the way, if you are using java jna, [JNAerator](http://jnaerator.googlecode.com/) is a good tool.
+
+[1]: http://sourceforge.net/projects/mingw/files/latest/download?source=files
+[2]: https://msysgit.github.io/
+[3]: http://rubyinstaller.org/

spa/node_modules/node-sass/src/libsass/docs/build-with-visual-studio.md

@@ -0,0 +1,90 @@
+## Building LibSass with Visual Studio
+
+### Requirements:
+
+The minimum requirement to build LibSass with Visual Studio is "Visual Studio 2013 Express for Desktop".
+
+Additionally, it is recommended to have `git` installed and available in `PATH`, so to deduce the `libsass` version information. For instance, if GitHub for Windows (https://windows.github.com/) is installed, the `PATH` will have an entry resembling: `X:\Users\<YOUR_NAME>\AppData\Local\GitHub\PortableGit_<SOME_GUID>\cmd\` (where `X` is the drive letter of system drive). If `git` is not available, inquiring the LibSass version will result in `[NA]`.
+
+### Build Steps:
+
+#### From Visual Studio:
+
+On opening the `win\libsass.sln` solution and build (Ctrl+Shift+B) to build `libsass.dll`.
+
+To Build LibSass as a static Library, it is recommended to set an environment variable `LIBSASS_STATIC_LIB` before launching the project:
+
+```cmd
+cd path\to\libsass
+SET LIBSASS_STATIC_LIB=1
+::
+:: or in PowerShell:
+:: $env:LIBSASS_STATIC_LIB=1
+::
+win\libsass.sln
+```
+
+Visual Studio will form the filtered source tree as shown below:
+
+![image](https://cloud.githubusercontent.com/assets/3840695/9298985/aae9e072-44bf-11e5-89eb-e7995c098085.png)
+
+`Header Files` contains the .h and .hpp files, while `Source Files` covers `.c` and `.cpp`. The other used headers/sources will appear under `External Dependencies`.
+
+If there is a LibSass code file appearing under External Dependencies, it can be changed by altering the `win\libsass.vcxproj.filters` file or dragging in Solution Explorer.
+
+#### From Command Prompt:
+
+Notice that in the following commands:
+
+* If the platform is 32-bit Windows, replace `ProgramFiles(x86)` with `ProgramFiles`.
+* To build with Visual Studio 2015, replace `12.0` with `14.0` in the aforementioned command.
+
+Open a command prompt:
+
+To build dynamic/shared library (`libsass.dll`):
+
+```cmd
+:: debug build:
+"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln
+
+:: release build:
+"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln ^
+/p:Configuration=Release
+```
+
+To build static library (`libsass.lib`):
+
+```cmd
+:: debug build:
+"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln ^
+/p:LIBSASS_STATIC_LIB=1
+
+:: release build:
+"%ProgramFiles(x86)%\MSBuild\12.0\Bin\MSBuild" win\libsass.sln ^
+/p:LIBSASS_STATIC_LIB=1 /p:Configuration=Release
+```
+
+#### From PowerShell:
+
+To build dynamic/shared library (`libsass.dll`):
+
+```powershell
+# debug build:
+&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln
+
+# release build:
+&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln `
+/p:Configuration=Release
+```
+
+To build static library (`libsass.lib`):
+
+```powershell
+# build:
+&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln `
+/p:LIBSASS_STATIC_LIB=1
+
+# release build:
+&"${env:ProgramFiles(x86)}\MSBuild\12.0\Bin\MSBuild" win\libsass.sln `
+/p:LIBSASS_STATIC_LIB=1 /p:Configuration=Release
+```

spa/node_modules/node-sass/src/libsass/docs/build.md

@@ -0,0 +1,97 @@
+`libsass` is only a library and does not do much on its own. You need an implementation that you can use from the [command line][6]. Or some [bindings|Implementations][9] to use it within your favorite programming language. You should be able to get [`sassc`][6] running by following the instructions in this guide.
+
+Before starting, see [setup dev environment](setup-environment.md).
+
+Building on different Operating Systems
+--
+
+We try to keep the code as OS independent and standard compliant as possible. Reading files from the file-system has some OS depending code, but will ultimately fall back to a posix compatible implementation. We do use some `C++11` features, but are so far only committed to use `unordered_map`. This means you will need a pretty recent compiler on most systems (gcc 4.5 seems to be the minimum).
+
+### Building on Linux (and other *nix flavors)
+
+Linux is the main target for `libsass` and we support two ways to build `libsass` here. The old plain makefiles should still work on most systems (including MinGW), while the autotools build is preferred if you want to create a [system library] (experimental).
+
+- [Building with makefiles][1]
+- [Building with autotools][2]
+
+### Building on Windows (experimental)
+
+Windows build support was added very recently and should be considered experimental. Credits go to @darrenkopp and @am11 for their work on getting `libsass` and `sassc` to compile with visual studio!
+
+- [Building with MinGW][3]
+- [Building with Visual Studio][11]
+
+### Building on Max OS X (untested)
+
+Works the same as on linux, but you can also install LibSass via `homebrew`.
+
+- [Building on Mac OS X][10]
+
+### Building a system library (experimental)
+
+Since `libsass` is a library, it makes sense to install it as a shared library on your system. On linux this means creating a `.so` library via autotools. This should work pretty well already, but we are not yet committed to keep the ABI 100% stable. This should be the case once we increase the version number for the library to 1.0.0 or higher. On Windows you should be able get a `dll` by creating a shared build with MinGW. There is currently no target in the MSVC project files to do this.
+
+- [Building shared system library][4]
+
+Compiling with clang instead of gcc
+--
+
+To use clang you just need to set the appropriate environment variables:
+
+```bash
+export CC=/usr/bin/clang
+export CXX=/usr/bin/clang++
+```
+
+Running the spec test-suite
+--
+
+We constantly and automatically test `libsass` against the official [spec test-suite][5]. To do this we need to have a test-runner (which is written in ruby) and a command-line tool ([`sassc`][6]) to run the tests. Therefore we need to additionally compile `sassc`. To do this, the build files of all three projects need to work together. This may not have the same quality for all build flavors. You definitely need to have ruby (2.1?) installed (version 1.9 seems to cause problems at least on windows). You also need some gems installed:
+
+```bash
+ruby -v
+gem install minitest
+# should be optional
+gem install minitap
+```
+
+Including the LibSass version
+--
+
+There is a function in `libsass` to query the current version. This has to be defined at compile time. We use a C macro for this, which can be defined by calling `g++ -DLIBSASS_VERSION="\"x.y.z.\""`. The two quotes are necessary, since it needs to end up as a valid C string. Normally you do not need to do anything if you use the makefiles or autotools. They will try to fetch the version via git directly. If you only have the sources without the git repo, you can pass the version as an environment variable to `make` or `configure`:
+
+```
+export LIBSASS_VERSION="x.y.z."
+```
+
+Continuous Integration
+--
+
+We use two CI services to automatically test all commits against the latest [spec test-suite][5].
+
+- [LibSass on Travis-CI (linux)][7]
+[![Build Status](https://travis-ci.org/sass/libsass.png?branch=master)](https://travis-ci.org/sass/libsass)
+- [LibSass on AppVeyor (windows)][8]
+[![Build status](https://ci.appveyor.com/api/projects/status/github/sass/libsass?svg=true)](https://ci.appveyor.com/project/mgreter/libsass-513/branch/master)
+
+Why not using CMake?
+--
+
+There were some efforts to get `libsass` to compile with CMake, which should make it easier to create build files for linux and windows. Unfortunately this was not completed. But we are certainly open for PRs!
+
+Miscellaneous
+--
+
+- [Ebuilds for Gentoo Linux](build-on-gentoo.md)
+
+[1]: build-with-makefiles.md
+[2]: build-with-autotools.md
+[3]: build-with-mingw.md
+[4]: build-shared-library.md
+[5]: https://github.com/sass/sass-spec
+[6]: https://github.com/sass/sassc
+[7]: https://github.com/sass/libsass/blob/master/.travis.yml
+[8]: https://github.com/sass/libsass/blob/master/appveyor.yml
+[9]: implementations.md
+[10]: build-on-darwin.md
+[11]: build-with-visual-studio.md