$

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());
+};

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');
+};

node_modules/node-sass/lib/extensions.js

@@ -0,0 +1,456 @@
+/*!
+ * 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';
+    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;

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;

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);
+};

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;