npm 中文文档

node-sass


Warning:LibSass and Node Sass are 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.

Node version support policy


Supported Node.js versions vary by release, please consult the releases page.
Node versions that hit end of life https://github.com/nodejs/Release, will be dropped from support at each node-sass release (major, minor).
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.
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 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+ 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

:--- :---
undefined

Alpine Linux macOS Windows x64 Linting

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


  1. ``` shell
  2. npm install node-sass
  3. ```

Some users have reported issues installing on Ubuntu due to node being registered to another package. Follow the official NodeJS docs to install NodeJS so that #!/usr/bin/env node correctly resolves.

Compiling on Windows machines requires the node-gyp prerequisites.

Are you seeing the following error? Check out our Troubleshooting guide.

  1. ``` sh
  2. SyntaxError: Use of const in strict mode.

  4. ```

Having installation troubles? Check out our Troubleshooting guide.

Install from mirror in China


  1. ``` shell
  2. npm install -g mirror-config-china --registry=https://registry.npmmirror.com
  3. npm install node-sass
  4. ```

Usage


  1. ``` js
  2. var sass = require('node-sass');
  3. sass.render({
  4.   file: scss_filename,
  5.   [, options..]
  6. }, function(err, result) { /*...*/ });
  7. // OR
  8. var result = sass.renderSync({
  9.   data: scss_content
  10.   [, options..]
  11. });
  12. ```

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:

  1. ``` js
  2. done(new Error('doesn\'t exist!'));
  3. // or return synchronously
  4. return new Error('nothing to do here');
  5. ```

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 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:

  1. ``` js
  2. var Color = require('node-sass').types.Color,
  3.   c1 = new Color(255, 0, 0),
  4.   c2 = new Color(0xff0088cc);
  5. ```

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


  1. ``` js
  2. sass.renderSync({
  3.   data: '#{headings(2,5)} { color: #08c; }',
  4.   functions: {
  5.     'headings($from: 0, $to: 6)': function(from, to) {
  6.       var i, f = from.getValue(), t = to.getValue(),
  7.           list = new sass.types.List(t - f + 1);

  9.       for (i = f; i <= t; i++) {
  10.         list.setValue(i - f, new sass.types.String('h' + i));
  11.       }

  13.       return list;
  14.     }
  15.   }
  16. });
  17. ```

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 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.

Attentionenabling this option will notwrite 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

  1. ``` js
  2. sass.render({
  3.     ...
  4.     outFile: yourPathTotheFile,
  5.   }, function(error, result) { // node-style callback from v3.0.0 onwards
  6.     if(!error){
  7.       // No errors during the compilation, write this result on the disk
  8.       fs.writeFile(yourPathTotheFile, result.css, function(err){
  9.         if(!err){
  10.           //file written on disk
  11.         }
  12.       });
  13.     }
  14.   });
  15. });
  16. ```

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


  1. ``` js
  2. var sass = require('node-sass');
  3. sass.render({
  4.   file: '/path/to/myFile.scss',
  5.   data: 'body{background:blue; a{color:black;}}',
  6.   importer: function(url, prev, done) {
  7.     // url is the path in import as is, which LibSass encountered.
  8.     // prev is the previously resolved path.
  9.     // done is an optional callback, either consume it or return value synchronously.
  10.     // this.options contains this options hash, this.callback contains the node-style callback
  11.     someAsyncFunction(url, prev, function(result){
  12.       done({
  13.         file: result.path, // only one of them is required, see section Special Behaviours.
  14.         contents: result.data
  15.       });
  16.     });
  17.     // OR
  18.     var result = someSyncFunction(url, prev);
  19.     return {file: result.path, contents: result.data};
  20.   },
  21.   includePaths: [ 'lib/', 'mod/' ],
  22.   outputStyle: 'compressed'
  23. }, function(error, result) { // node-style callback from v3.0.0 onwards
  24.   if (error) {
  25.     console.log(error.status); // used to be "code" in v2x and below
  26.     console.log(error.column);
  27.     console.log(error.message);
  28.     console.log(error.line);
  29.   }
  30.   else {
  31.     console.log(result.css.toString());

  33.     console.log(result.stats);

  35.     console.log(result.map.toString());
  36.     // or better
  37.     console.log(JSON.stringify(result.map)); // note, JSON.stringify accepts Buffer too
  38.   }
  39. });
  40. // OR
  41. var result = sass.renderSync({
  42.   file: '/path/to/file.scss',
  43.   data: 'body{background:blue; a{color:black;}}',
  44.   outputStyle: 'compressed',
  45.   outFile: '/to/my/output.css',
  46.   sourceMap: true, // or an absolute or relative (to outFile) path
  47.   importer: function(url, prev