sass

method compileAsync

compileAsync: (
    path: string,
    options?: Options<'async'>
) => Promise<CompileResult>;

• The compileAsync method exposed through an Async Compiler instance while it is active. If this is called after dispose on the Async Compiler instance, an error will be thrown.

  During the Async Compiler instance's lifespan, given the same input, this will return an identical result to the compileAsync method exposed at the module root.

method compileStringAsync

compileStringAsync: (
    source: string,
    options?: StringOptions<'async'>
) => Promise<CompileResult>;

• The compileStringAsync method exposed through an Async Compiler instance while it is active. If this is called after dispose on the Async Compiler instance, an error will be thrown.

  During the Async Compiler instance's lifespan, given the same input, this will return an identical result to the compileStringAsync method exposed at the module root.

method dispose

dispose: () => Promise<void>;

• Ends the lifespan of this Async Compiler instance. After this is invoked, all subsequent calls to the Compiler instance's compileAsync or compileStringAsync methods will result in an error.

  Any compilations that are submitted before dispose will not be cancelled, and will be allowed to settle.

  After all compilations have been settled and Sass completes any internal task cleanup, dispose will resolve its promise.

constructor

constructor(value: string);

• Creates a Sass CalculationInterpolation with the given value.

property value

readonly value: string;

• Returns the interpolation's value field.

method equals

equals: (other: unknown) => boolean;

method hashCode

hashCode: () => number;

constructor

constructor(
    operator: CalculationOperator,
    left: CalculationValue,
    right: CalculationValue
);

• Creates a Sass CalculationOperation with the given operator, left, and right values.

  Throws

  Error if left or right are quoted SassStrings.

property left

readonly left: CalculationValue;

• Returns the operation's left field.

property operator

readonly operator: CalculationOperator;

• Returns the operation's operator field.

property right

readonly right: CalculationValue;

• Returns the operation's right field.

method equals

equals: (other: unknown) => boolean;

method hashCode

hashCode: () => number;

method compile

compile: (path: string, options?: Options<'sync'>) => CompileResult;

• The compile method exposed through a Compiler instance while it is active. If this is called after dispose on the Compiler instance, an error will be thrown.

  During the Compiler instance's lifespan, given the same input, this will return an identical result to the compile method exposed at the module root.

method compileString

compileString: (
    source: string,
    options?: StringOptions<'sync'>
) => CompileResult;

• The compileString method exposed through a Compiler instance while it is active. If this is called after dispose on the Compiler instance, an error will be thrown.

  During the Compiler instance's lifespan, given the same input, this will return an identical result to the compileString method exposed at the module root.

method dispose

dispose: () => void;

• Ends the lifespan of this Compiler instance. After this is invoked, all calls to the Compiler instance's compile or compileString methods will result in an error.

property message

message: string;

• A human-friendly representation of the exception.

  Because many tools simply print Error.message directly, this includes not only the textual description of what went wrong (the sassMessage) but also an indication of where in the Sass stylesheet the error occurred (the span) and the Sass stack trace at the point of error (the sassStack).

property sassMessage

readonly sassMessage: string;

• A textual description of what went wrong.

  Unlike message, this does *not* include representations of span or sassStack.

property sassStack

readonly sassStack: string;

• A human-friendly representation of the Sass stack trace at the point of error.

property span

readonly span: SourceSpan;

• The location the error occurred in the Sass file that triggered it.

method toString

toString: () => string;

• Returns the same string as message.

constructor

constructor(entryPointDirectory?: string);

• The NodePackageImporter has an optional entryPointDirectory option, which is the directory where the Node Package Importer should start when resolving pkg: URLs in sources other than files on disk. This will be used as the parentURL in the [Node Module Resolution](https://nodejs.org/api/esm.html#resolution-algorithm-specification) algorithm.

  In order to be found by the Node Package Importer, a package will need to be inside a node_modules folder located in the entryPointDirectory, or one of its parent directories, up to the filesystem root.

  Relative paths will be resolved relative to the current working directory. If a path is not provided, this defaults to the parent directory of the Node.js entrypoint. If that's not available, this will throw an error.

constructor

constructor(contents: any, keywords: any, separator?: ListSeparator);

• Creates a new argument list.

  Parameter contents

  The positional arguments that make up the primary contents of the list. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter keywords

  The keyword arguments attached to this argument list, whose names should exclude $. This can be either a plain JavaScript object with argument names as fields, or an immutable OrderedMap from the [immutable package](https://immutable-js.com/)

  Parameter separator

  The separator for this list. Defaults to ','.

property keywords

readonly keywords: OrderedMap<string, Value>;

• The keyword arguments attached to this argument list.

  The argument names don't include $.

  Returns

  An immutable OrderedMap from the [immutable package](https://immutable-js.com/).

property value

readonly value: boolean;

• Whether this value is true or false.

property arguments

readonly arguments: List<CalculationValue>;

• Returns a list of the calculation's arguments

property name

readonly name: string;

• Returns the calculation's name field.

method calc

static calc: (argument: CalculationValue) => SassCalculation;

• Creates a value that represents calc(argument).

  Returns

  A calculation with the name calc and argument as its single argument.

  Throws

  Error if argument is a quoted SassString

method clamp

static clamp: (
    min: CalculationValue,
    value?: CalculationValue,
    max?: CalculationValue
) => SassCalculation;

• Creates a value that represents clamp(value, min, max).

  Returns

  A calculation with the name clamp and min, value, and max as it's arguments, excluding any arguments that are undefined.

  Throws

  Error if any of value, min, or max are a quoted SassString.

  Throws

  Error if value is undefined and max is not undefined.

  Throws

  Error if either value or max is undefined and neither min nor value is a SassString or CalculationInterpolation.

method max

static max: (
    arguments: CalculationValue[] | List<CalculationValue>
) => SassCalculation;

• Creates a value that represents max(arguments...).

  Returns

  A calculation with the name max and arguments as its arguments.

  Throws

  Error if arguments contains a quoted SassString

method min

static min: (
    arguments: CalculationValue[] | List<CalculationValue>
) => SassCalculation;

• Creates a value that represents min(arguments...).

  Returns

  A calculation with the name min and arguments as its arguments.

  Throws

  Error if arguments contains a quoted SassString

constructor

constructor(options: {
    red: number;
    green: number;
    blue: number;
    alpha?: number;
});

• Creates an RGB color.

  **Only** undefined should be passed to indicate a missing alpha. If null is passed instead, it will be treated as a [missing component] in future versions of Dart Sass. See [breaking changes] for details.

  [missing component]: https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#missing_color_components [breaking changes]: /documentation/breaking-changes/null-alpha

  Throws

  Error if red, green, and blue aren't between 0 and 255, or if alpha isn't between 0 and 1.

constructor

constructor(options: {
    hue: number;
    saturation: number;
    lightness: number;
    alpha?: number;
});

• Creates an HSL color.

  **Only** undefined should be passed to indicate a missing alpha. If null is passed instead, it will be treated as a [missing component] in future versions of Dart Sass. See [breaking changes] for details.

  [missing component]: https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#missing_color_components [breaking changes]: /documentation/breaking-changes/null-alpha

  Throws

  Error if saturation or lightness aren't between 0 and 100, or if alpha isn't between 0 and 1.

constructor

constructor(options: {
    hue: number;
    whiteness: number;
    blackness: number;
    alpha?: number;
});

• Creates an HWB color.

  **Only** undefined should be passed to indicate a missing alpha. If null is passed instead, it will be treated as a [missing component] in future versions of Dart Sass. See [breaking changes] for details.

  [missing component]: https://developer.mozilla.org/en-US/docs/Web/CSS/color_value#missing_color_components [breaking changes]: /documentation/breaking-changes/null-alpha

  Throws

  Error if whiteness or blackness aren't between 0 and 100, or if alpha isn't between 0 and 1.

property alpha

readonly alpha: number;

• This color's alpha channel, between 0 and 1.

property blackness

readonly blackness: number;

• This color's blackness, between 0 and 100.

property blue

readonly blue: number;

• This color's blue channel, between 0 and 255.

property green

readonly green: number;

• This color's green channel, between 0 and 255.

property hue

readonly hue: number;

• This color's hue, between 0 and 360.

property lightness

readonly lightness: number;

• This color's lightness, between 0 and 100.

property red

readonly red: number;

• This color's red channel, between 0 and 255.

property saturation

readonly saturation: number;

• This color's saturation, between 0 and 100.

property whiteness

readonly whiteness: number;

• This color's whiteness, between 0 and 100.

method change

change: {
    (options: {
        red?: number;
        green?: number;
        blue?: number;
        alpha?: number;
    }): SassColor;
    (options: {
        hue?: number;
        saturation?: number;
        lightness?: number;
        alpha?: number;
    }): SassColor;
    (options: {
        hue?: number;
        whiteness?: number;
        blackness?: number;
        alpha?: number;
    }): SassColor;
};

• Changes one or more of this color's RGB channels and returns the result.

• Changes one or more of this color's HSL channels and returns the result.

• Changes one or more of this color's HWB channels and returns the result.

constructor

constructor(signature: string, callback: (args: Value[]) => Value);

• Creates a new first-class function that can be invoked using [meta.call()](https://sass-lang.com/documentation/modules/meta#call).

  Parameter signature

  The function signature, like you'd write for the [@function rule](https://sass-lang.com/documentation/at-rules/function).

  Parameter callback

  The callback that's invoked when this function is called, just like for a CustomFunction.

constructor

constructor(
    contents: any,
    options?: { separator?: ListSeparator; brackets?: boolean }
);

• Creates a new list.

  Parameter contents

  The contents of the list. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter

  options.separator - The separator to use between elements of this list. Defaults to ','.

  Parameter

  options.brackets - Whether the list has square brackets. Defaults to false.

constructor

constructor(options?: { separator?: ListSeparator; brackets?: boolean });

• Creates an empty list.

  Parameter

  options.separator - The separator to use between elements of this list. Defaults to ','.

  Parameter

  options.brackets - Whether the list has square brackets. Defaults to false.

property separator

readonly separator: ListSeparator;

constructor

constructor(contents?: OrderedMap<Value, Value>);

• Creates a new map.

  Parameter contents

  The contents of the map. This is an immutable OrderedMap from the [immutable package](https://immutable-js.com/). Defaults to an empty map.

property contents

readonly contents: OrderedMap<Value, Value>;

• Returns the contents of this map as an immutable OrderedMap from the [immutable package](https://immutable-js.com/).

method get

get: { (key: Value): Value | undefined; (index: number): SassList };

• Returns the value associated with key in this map, or undefined if key isn't in the map.

  This is a shorthand for this.contents.get(key), although it may be more efficient in some cases.

• Inherited from Value.get.

method tryMap

tryMap: () => SassMap;

constructor

constructor();

• It is not possible to construct a Sass mixin outside of Sass. Attempting to construct one will throw an exception.

constructor

constructor(
    value: number,
    unit?:
        | string
        | {
              numeratorUnits?: string[] | List<string>;
              denominatorUnits?: string[] | List<string>;
          }
);

• Creates a new number with more complex units than just a single numerator.

  Upon construction, any compatible numerator and denominator units are simplified away according to the conversion factor between them.

  Parameter value

  The number's numeric value.

  Parameter unit

  If this is a string, it's used as the single numerator unit for the number.

  Parameter

  unit.numeratorUnits - If passed, these are the numerator units to use for the number. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter

  unit.denominatorUnits - If passed, these are the denominator units to use for the number. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

property asInt

readonly asInt: number;

• If value is an integer according to isInt, returns value rounded to that integer. If it's not an integer, returns null.

property denominatorUnits

readonly denominatorUnits: List<string>;

• This number's denominator units as an immutable List from the [immutable package](https://immutable-js.com/).

property hasUnits

readonly hasUnits: boolean;

• Whether this number has any numerator or denominator units.

property isInt

readonly isInt: boolean;

• Whether value is an integer according to Sass's equality logic.

property numeratorUnits

readonly numeratorUnits: List<string>;

• This number's numerator units as an immutable List from the [immutable package](https://immutable-js.com/).

property value

readonly value: number;

• This number's numeric value.

method assertInRange

assertInRange: (min: number, max: number, name?: string) => number;

• Returns value if it's within min and max. If value is equal to min or max according to Sass's equality, returns min or max respectively. Otherwise, throws an error.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertInt

assertInt: (name?: string) => number;

• If value is an integer according to isInt, returns it rounded to that integer. Otherwise, throws an error.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertNoUnits

assertNoUnits: (name?: string) => SassNumber;

• If this number has no units, returns it. Otherwise, throws an error.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertUnit

assertUnit: (unit: string, name?: string) => SassNumber;

• If this number has unit as its only unit (and as a numerator), returns this number. Otherwise, throws an error.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method coerce

coerce: (
    newNumerators: string[] | List<string>,
    newDenominators: string[] | List<string>,
    name?: string
) => SassNumber;

• Returns a copy of this number, converted to the units represented by newNumerators and newDenominators.

  Unlike convert this does *not* throw an error if this number is unitless and either newNumerators or newDenominators are not empty, or vice-versa. Instead, it treats all unitless numbers as convertible to and from all units without changing the value.

  Parameter newNumerators

  The numerator units to convert this number to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter newDenominators

  The denominator units to convert this number to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with newNumerators and newDenominators.

method coerceToMatch

coerceToMatch: (
    other: SassNumber,
    name?: string,
    otherName?: string
) => SassNumber;

• Returns a copy of this number, converted to the units represented by newNumerators and newDenominators.

  Unlike convertToMatch this does *not* throw an error if this number is unitless and either newNumerators or newDenominators are not empty, or vice-versa. Instead, it treats all unitless numbers as convertible to and from all units without changing the value.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Parameter otherName

  The name of the function argument other came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with other's units.

method coerceValue

coerceValue: (
    newNumerators: string[] | List<string>,
    newDenominators: string[] | List<string>,
    name?: string
) => number;

• Returns value, converted to the units represented by newNumerators and newDenominators.

  Unlike convertValue this does *not* throw an error if this number is unitless and either newNumerators or newDenominators are not empty, or vice-versa. Instead, it treats all unitless numbers as convertible to and from all units without changing the value.

  Parameter newNumerators

  The numerator units to convert value to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter newDenominators

  The denominator units to convert value to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with newNumerators and newDenominators.

method coerceValueToMatch

coerceValueToMatch: (
    other: SassNumber,
    name?: string,
    otherName?: string
) => number;

• Returns value, converted to the units represented by newNumerators and newDenominators.

  Unlike convertValueToMatch this does *not* throw an error if this number is unitless and either newNumerators or newDenominators are not empty, or vice-versa. Instead, it treats all unitless numbers as convertible to and from all units without changing the value.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Parameter otherName

  The name of the function argument other came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with other's units.

method compatibleWithUnit

compatibleWithUnit: (unit: string) => boolean;

• Whether this has exactly one numerator unit, and that unit is compatible with unit.

method convert

convert: (
    newNumerators: string[] | List<string>,
    newDenominators: string[] | List<string>,
    name?: string
) => SassNumber;

• Returns a copy of this number, converted to the units represented by newNumerators and newDenominators.

  Parameter newNumerators

  The numerator units to convert this number to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter newDenominators

  The denominator units to convert this number to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with newNumerators and newDenominators; or if this number is unitless and either newNumerators or newDenominators are not empty, or vice-versa.

method convertToMatch

convertToMatch: (
    other: SassNumber,
    name?: string,
    otherName?: string
) => SassNumber;

• Returns a copy of this number, converted to the same units as other.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Parameter otherName

  The name of the function argument other came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with other's units, or if either number is unitless but the other is not.

method convertValue

convertValue: (
    newNumerators: string[] | List<string>,
    newDenominators: string[] | List<string>,
    name?: string
) => number;

• Returns value, converted to the units represented by newNumerators and newDenominators.

  Parameter newNumerators

  The numerator units to convert value to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter newDenominators

  The denominator units to convert value to. This may be either a plain JavaScript array or an immutable List from the [immutable package](https://immutable-js.com/).

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with newNumerators and newDenominators; or if this number is unitless and either newNumerators or newDenominators are not empty, or vice-versa.

method convertValueToMatch

convertValueToMatch: (
    other: SassNumber,
    name?: string,
    otherName?: string
) => number;

• Returns value, converted to the same units as other.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

  Parameter otherName

  The name of the function argument other came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error if this number's units are incompatible with other's units, or if either number is unitless but the other is not.

method hasUnit

hasUnit: (unit: string) => boolean;

• Whether this number has unit as its only unit (and as a numerator).

constructor

constructor(text: string, options?: { quotes?: boolean });

• Creates a new string.

  Parameter text

  The contents of the string. For quoted strings, this is the semantic content—any escape sequences that were been written in the source text are resolved to their Unicode values. For unquoted strings, though, escape sequences are preserved as literal backslashes.

  Parameter

  options.quotes - Whether the string is quoted. Defaults to true.

constructor

constructor(options?: { quotes?: boolean });

• Creates an empty string.

  Parameter

  options.quotes - Whether the string is quoted. Defaults to true.

property hasQuotes

readonly hasQuotes: boolean;

• Whether this string has quotes.

property sassLength

readonly sassLength: number;

• Sass's notion of this string's length.

  Sass treats strings as a series of Unicode code points while JavaScript treats them as a series of UTF-16 code units. For example, the character U+1F60A SMILING FACE WITH SMILING EYES is a single Unicode code point but is represented in UTF-16 as two code units (0xD83D and 0xDE0A). So in JavaScript, "n😊b".length returns 4, whereas in Sass string.length("n😊b") returns 3.

property text

readonly text: string;

• The contents of the string.

  For quoted strings, this is the semantic content—any escape sequences that were been written in the source text are resolved to their Unicode values. For unquoted strings, though, escape sequences are preserved as literal backslashes.

  This difference allows us to distinguish between identifiers with escapes, such as url\u28 http://example.com\u29, and unquoted strings that contain characters that aren't valid in identifiers, such as url(http://example.com). Unfortunately, it also means that we don't consider foo and f\6F\6F the same string.

method sassIndexToStringIndex

sassIndexToStringIndex: (sassIndex: Value, name?: string) => number;

• Converts sassIndex to a JavaScript index into text.

  Sass indices are one-based, while JavaScript indices are zero-based. Sass indices may also be negative in order to index from the end of the string.

  In addition, Sass indices refer to Unicode code points while JavaScript string indices refer to UTF-16 code units. For example, the character U+1F60A SMILING FACE WITH SMILING EYES is a single Unicode code point but is represented in UTF-16 as two code units (0xD83D and 0xDE0A). So in JavaScript, "n😊b".charCodeAt(1) returns 0xD83D, whereas in Sass string.slice("n😊b", 1, 1) returns "😊".

  This function converts Sass's code point indices to JavaScript's code unit indices. This means it's O(n) in the length of text.

  Throws

  Error - If sassIndex isn't a number, if that number isn't an integer, or if that integer isn't a valid index for this string.

constructor

protected constructor();

property asList

readonly asList: List<Value>;

• This value as a list.

  All SassScript values can be used as lists. Maps count as lists of pairs, and all other values count as single-value lists.

  Returns

  An immutable List from the [immutable package](https://immutable-js.com/).

property hasBrackets

readonly hasBrackets: boolean;

• Whether this value as a list has brackets.

  All SassScript values can be used as lists. Maps count as lists of pairs, and all other values count as single-value lists.

property isTruthy

readonly isTruthy: boolean;

• Whether the value counts as true in an @if statement and other contexts.

property realNull

readonly realNull: Value;

• Returns JavaScript's null value if this is sassNull, and returns this otherwise.

property separator

readonly separator: ListSeparator;

• The separator for this value as a list.

  All SassScript values can be used as lists. Maps count as lists of pairs, and all other values count as single-value lists.

method assertBoolean

assertBoolean: (name?: string) => SassBoolean;

• Throws if this isn't a SassBoolean.

  **Heads up!** Functions should generally use isTruthy rather than requiring a literal boolean.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertCalculation

assertCalculation: (name?: string) => SassCalculation;

• Throws if this isn't a SassCalculation.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertColor

assertColor: (name?: string) => SassColor;

• Throws if this isn't a SassColor.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertFunction

assertFunction: (name?: string) => SassFunction;

• Throws if this isn't a SassFunction.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertMap

assertMap: (name?: string) => SassMap;

• Throws if this isn't a SassMap.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertMixin

assertMixin: (name?: string) => SassMixin;

• Throws if this isn't a SassMixin.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertNumber

assertNumber: (name?: string) => SassNumber;

• Throws if this isn't a SassNumber.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method assertString

assertString: (name?: string) => SassString;

• Throws if this isn't a SassString.

  Parameter name

  The name of the function argument this came from (without the $) if it came from an argument. Used for error reporting.

method equals

equals: (other: Value) => boolean;

• Returns whether this represents the same value as other.

method get

get: (index: number) => Value | undefined;

• Returns the value at index index in this value as a list, or undefined if index isn't valid for this list.

  All SassScript values can be used as lists. Maps count as lists of pairs, and all other values count as single-value lists.

  This is a shorthand for this.asList.get(index), although it may be more efficient in some cases.

  **Heads up!** This method uses the same indexing conventions as the immutable package: unlike Sass the index of the first element is 0, but like Sass negative numbers index from the end of the list.

method hashCode

hashCode: () => number;

• Returns a hash code that can be used to store this in a hash map.

method sassIndexToListIndex

sassIndexToListIndex: (sassIndex: Value, name?: string) => number;

• Converts sassIndex into a JavaScript-style index into the list returned by asList.

  Sass indexes are one-based, while JavaScript indexes are zero-based. Sass indexes may also be negative in order to index from the end of the list.

  Parameter sassIndex

  The Sass-style index into this as a list.

  Parameter name

  The name of the function argument sassIndex came from (without the $) if it came from an argument. Used for error reporting.

  Throws

  Error If sassIndex isn't a number, if that number isn't an integer, or if that integer isn't a valid index for asList.

method toString

toString: () => string;

method tryMap

tryMap: () => SassMap | null;

• Returns this as a map if it counts as one (empty lists count as empty maps) or null if it doesn't.

constructor

constructor(major: number, minor: number, patch: number);

• Constructs a new version.

  All components must be non-negative integers.

  Parameter major

  The major version.

  Parameter minor

  The minor version.

  Parameter patch

  The patch version.

property major

readonly major: number;

property minor

readonly minor: number;

property patch

readonly patch: number;

method parse

static parse: (version: string) => Version;

• Parses a version from a string.

  This throws an error if a valid version can't be parsed.

  Parameter version

  A string in the form "major.minor.patch".

property containingUrl

containingUrl: URL | null;

• The canonical URL of the file that contains the load, if that information is available.

  For an Importer, this is only passed when the url parameter is a relative URL _or_ when its [URL scheme] is included in Importer.nonCanonicalScheme. This ensures that canonical URLs are always resolved the same way regardless of context.

  [URL scheme]: https://developer.mozilla.org/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_URL#scheme

  For a FileImporter, this is always available as long as Sass knows the canonical URL of the containing file.

property fromImport

fromImport: boolean;

• Whether this is being invoked because of a Sass @import rule, as opposed to a @use or @forward rule.

  This should *only* be used for determining whether or not to load [import-only files](https://sass-lang.com/documentation/at-rules/import#import-only-files).

property css

css: string;

• The generated CSS.

  Note that this *never* includes a sourceMapUrl comment—it's up to the caller to determine where to save the source map and how to link to it from the stylesheet.

property loadedUrls

loadedUrls: URL[];

• The canonical URLs of all the stylesheets that were loaded during the Sass compilation. The order of these URLs is not guaranteed.

property sourceMap

sourceMap?: RawSourceMap;

• The object representation of the source map that maps locations in the generated CSS back to locations in the Sass source code.

  This typically uses absolute file: URLs to refer to Sass files, although this can be controlled by having a custom Importer return ImporterResult.sourceMapUrl.

  This is set if and only if Options.sourceMap is true.

property deprecatedIn

deprecatedIn: status extends 'future' | 'user' ? null : Version;

• The version this deprecation first became active in.

property description

description?: string;

• A human-readable description of this deprecation.

property id

id: id;

• The unique ID of this deprecation.

property obsoleteIn

obsoleteIn: status extends 'obsolete' ? Version : null;

• The version this deprecation became obsolete in.

property status

status: status;

• The current status of this deprecation.

property 'abs-percent'

'abs-percent': Deprecation<'abs-percent'>;

• Deprecation for passing percentages to the Sass abs() function.

  This deprecation became active in Dart Sass 1.65.0.

property 'bogus-combinators'

'bogus-combinators': Deprecation<'bogus-combinators'>;

• Deprecation for leading, trailing, and repeated combinators.

  This deprecation became active in Dart Sass 1.54.0.

property 'call-string'

'call-string': Deprecation<'call-string'>;

• Deprecation for passing a string to call instead of using get-function.

  This deprecation has been active in all versions of Dart Sass.

property 'color-module-compat'

'color-module-compat': Deprecation<'color-module-compat'>;

• Deprecation for using color module functions in place of plain CSS functions.

  This deprecation became active in Dart Sass 1.23.0.

property 'duplicate-var-flags'

'duplicate-var-flags': Deprecation<'duplicate-var-flags'>;

• Deprecation for using !default or !global multiple times for one variable.

  This deprecation became active in Dart Sass 1.62.0.

property 'fs-importer-cwd'

'fs-importer-cwd': Deprecation<'fs-importer-cwd'>;

• Deprecation for using the current working directory as an implicit load path.

  This deprecation became active in Dart Sass 1.73.0.

property 'function-units'

'function-units': Deprecation<'function-units'>;

• Deprecation for passing invalid units to certain built-in functions.

  This deprecation became active in Dart Sass 1.56.0.

property 'moz-document'

'moz-document': Deprecation<'moz-document'>;

• Deprecation for parsing @-moz-document.

  This deprecation became active in Dart Sass 1.7.2.

property 'new-global'

'new-global': Deprecation<'new-global'>;

• Deprecation for declaring new variables with !global.

  This deprecation became active in Dart Sass 1.17.2.

property 'null-alpha'

'null-alpha': Deprecation<'null-alpha'>;

• Deprecation for passing null as alpha in the JS API.

  This deprecation became active in Dart Sass 1.62.3.

property 'relative-canonical'

'relative-canonical': Deprecation<'relative-canonical'>;

• Deprecation for imports using relative canonical URLs.

  This deprecation became active in Dart Sass 1.17.2.

property 'slash-div'

'slash-div': Deprecation<'slash-div'>;

• Deprecation for treating / as division.

  This deprecation became active in Dart Sass 1.33.0.

property 'strict-unary'

'strict-unary': Deprecation<'strict-unary'>;

• Deprecation for ambiguous + and - operators.

  This deprecation became active in Dart Sass 1.55.0.

property 'user-authored'

'user-authored': Deprecation<'user-authored', 'user'>;

• Used for any user-emitted deprecation warnings.

property elseif

elseif: Deprecation<'elseif'>;

• Deprecation for @elseif.

  This deprecation became active in Dart Sass 1.3.2.

property import

import: Deprecation<'import'>;

• Deprecation for @import rules.

  This deprecation is not yet active, but will be soon.