sass 1.45.0-rc.1 → 1.45.0-rc.2

package/package.json

@@ -1 +1 @@
-{"name":"sass","description":"A pure JavaScript implementation of Sass.","license":"MIT","bugs":"https://github.com/sass/dart-sass/issues","homepage":"https://github.com/sass/dart-sass","repository":{"type":"git","url":"https://github.com/sass/dart-sass"},"author":{"name":"Natalie Weizenbaum","email":"nweiz@google.com","url":"https://github.com/nex3"},"engines":{"node":">=8.9.0"},"dependencies":{"chokidar":">=3.0.0 <4.0.0","immutable":"^4.0.0"},"keywords":["style","scss","sass","preprocessor","css"],"version":"1.45.0-rc.1","bin":{"sass":"sass.js"},"main":"sass.default.dart.js","exports":{"default":"./sass.default.dart.js"}}
+{"name":"sass","description":"A pure JavaScript implementation of Sass.","license":"MIT","bugs":"https://github.com/sass/dart-sass/issues","homepage":"https://github.com/sass/dart-sass","repository":{"type":"git","url":"https://github.com/sass/dart-sass"},"author":{"name":"Natalie Weizenbaum","email":"nweiz@google.com","url":"https://github.com/nex3"},"engines":{"node":">=8.9.0"},"dependencies":{"chokidar":">=3.0.0 <4.0.0","immutable":"^4.0.0","source-map-js":">=0.6.2 <2.0.0"},"keywords":["style","scss","sass","preprocessor","css"],"types":"types/index.d.ts","version":"1.45.0-rc.2","bin":{"sass":"sass.js"},"main":"sass.default.dart.js","exports":{"default":"./sass.default.dart.js"}}

package/sass.dart.js

@@ -1867,7 +1867,7 @@ self.readline = _cli_pkg_requires.readline;
       J.set$sassFalse$x(self.exports, C.SassBoolean_false0);
       J.set$Exception$x(self.exports, $.$get$exceptionClass());
       J.set$Logger$x(self.exports, {silent: {warn: B.allowInteropNamed("sass.Logger.silent.warn", new B.main_closure0()), debug: B.allowInteropNamed("sass.Logger.silent.debug", new B.main_closure1())}});
-      J.set$info$x(self.exports, "dart-sass\t1.45.0-rc.1\t(Sass Compiler)\t[Dart]\ndart2js\t2.14.4\t(Dart Compiler)\t[Dart]");
+      J.set$info$x(self.exports, "dart-sass\t1.45.0-rc.2\t(Sass Compiler)\t[Dart]\ndart2js\t2.14.4\t(Dart Compiler)\t[Dart]");
       V.updateSourceSpanPrototype();
       J.set$render$x(self.exports, B.allowInteropNamed("sass.render", Q.legacy__render$closure()));
       J.set$renderSync$x(self.exports, B.allowInteropNamed("sass.renderSync", Q.legacy__renderSync$closure()));
@@ -20418,7 +20418,7 @@ self.readline = _cli_pkg_requires.readline;
           switch ($async$goto) {
             case 0:
               // Function start
-              $async$returnValue = "1.45.0-rc.1 compiled with dart2js 2.14.4";
+              $async$returnValue = "1.45.0-rc.2 compiled with dart2js 2.14.4";
               // goto return
               $async$goto = 1;
               break;

package/types/compile.d.ts

@@ -0,0 +1,153 @@
+import {URL} from 'url';
+import {RawSourceMap} from 'source-map-js';
+
+import {Options, StringOptions} from './options';
+
+/**
+ * The result of compiling Sass to CSS. Returned by [[compile]],
+ * [[compileAsync]], [[compileString]], and [[compileStringAsync]].
+ *
+ * @category Compile
+ */
+export interface CompileResult {
+  /**
+   * 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.
+   */
+  css: string;
+
+  /**
+   * The canonical URLs of all the stylesheets that were loaded during the
+   * Sass compilation. The order of these URLs is not guaranteed.
+   */
+  loadedUrls: URL[];
+
+  /**
+   * 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`.
+   */
+  sourceMap?: RawSourceMap;
+}
+
+/**
+ * Synchronously compiles the Sass file at `path` to CSS. If it succeeds it
+ * returns a [[CompileResult]], and if it fails it throws an [[Exception]].
+ *
+ * This only allows synchronous [[Importer]]s and [[CustomFunction]]s.
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass');
+ *
+ * const result = sass.compile("style.scss");
+ * console.log(result.css);
+ * ```
+ *
+ * @category Compile
+ * @compatibility dart: "1.45.0", node: false
+ */
+export function compile(path: string, options?: Options<'sync'>): CompileResult;
+
+/**
+ * Asynchronously compiles the Sass file at `path` to CSS. Returns a promise
+ * that resolves with a [[CompileResult]] if it succeeds and rejects with an
+ * [[Exception]] if it fails.
+ *
+ * This only allows synchronous or asynchronous [[Importer]]s and
+ * [[CustomFunction]]s.
+ *
+ * **Heads up!** When using Dart Sass, **[[compile]] is almost twice as fast as
+ * [[compileAsync]]**, due to the overhead of making the entire evaluation
+ * process asynchronous.
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass');
+ *
+ * const result = await sass.compileAsync("style.scss");
+ * console.log(result.css);
+ * ```
+ *
+ * @category Compile
+ * @compatibility dart: "1.45.0", node: false
+ */
+export function compileAsync(
+  path: string,
+  options?: Options<'async'>
+): Promise<CompileResult>;
+
+/**
+ * Synchronously compiles a stylesheet whose contents is `source` to CSS. If it
+ * succeeds it returns a [[CompileResult]], and if it fails it throws an
+ * [[Exception]].
+ *
+ * This only allows synchronous [[Importer]]s and [[CustomFunction]]s.
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass');
+ *
+ * const result = sass.compileString(`
+ * h1 {
+ *   font-size: 40px;
+ *   code {
+ *     font-face: Roboto Mono;
+ *   }
+ * }`);
+ * console.log(result.css);
+ * ```
+ *
+ * @category Compile
+ * @compatibility dart: "1.45.0", node: false
+ */
+export function compileString(
+  source: string,
+  options?: StringOptions<'sync'>
+): CompileResult;
+
+/**
+ * Asynchronously compiles a stylesheet whose contents is `source` to CSS.
+ * Returns a promise that resolves with a [[CompileResult]] if it succeeds and
+ * rejects with an [[Exception]] if it fails.
+ *
+ * This only allows synchronous or asynchronous [[Importer]]s and
+ * [[CustomFunction]]s.
+ *
+ * **Heads up!** When using Dart Sass, **[[compile]] is almost twice as fast as
+ * [[compileAsync]]**, due to the overhead of making the entire evaluation
+ * process asynchronous.
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass');
+ *
+ * const result = await sass.compileStringAsync(`
+ * h1 {
+ *   font-size: 40px;
+ *   code {
+ *     font-face: Roboto Mono;
+ *   }
+ * }`);
+ * console.log(result.css);
+ * ```
+ *
+ * @category Compile
+ * @compatibility dart: "1.45.0", node: false
+ */
+export function compileStringAsync(
+  source: string,
+  options?: StringOptions<'async'>
+): Promise<CompileResult>;

package/types/exception.d.ts

@@ -0,0 +1,41 @@
+import {SourceSpan} from './logger';
+
+/**
+ * An exception thrown because a Sass compilation failed.
+ *
+ * @category Other
+ */
+export class Exception extends Error {
+  private constructor();
+
+  /**
+   * 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]]).
+   */
+  message: string;
+
+  /**
+   * A textual description of what went wrong.
+   *
+   * Unlike [[message]], this does *not* include representations of [[span]] or
+   * [[sassStack]].
+   */
+  readonly sassMessage: string;
+
+  /**
+   * A human-friendly representation of the Sass stack trace at the point of
+   * error.
+   */
+  readonly sassStack: string;
+
+  /** The location the error occurred in the Sass file that triggered it. */
+  readonly span: SourceSpan;
+
+  /** Returns the same string as [[message]]. */
+  toString(): string;
+}

package/types/importer.d.ts

@@ -0,0 +1,296 @@
+import {URL} from 'url';
+
+import {Syntax} from './options';
+import {PromiseOr} from './util/promise_or';
+
+/**
+ * A special type of importer that redirects all loads to existing files on
+ * disk. Although this is less powerful than a full [[Importer]], it
+ * automatically takes care of Sass features like resolving partials and file
+ * extensions and of loading the file from disk.
+ *
+ * Like all importers, this implements custom Sass loading logic for [`@use`
+ * rules](https://sass-lang.com/documentation/at-rules/use) and [`@import`
+ * rules](https://sass-lang.com/documentation/at-rules/import). It can be passed
+ * to [[Options.importers]] or [[StringOptionsWithImporter.importer]].
+ *
+ * @typeParam sync - A `FileImporter<'sync'>`'s [[findFileUrl]] must return
+ * synchronously, but in return it can be passed to [[compile]] and
+ * [[compileString]] in addition to [[compileAsync]] and [[compileStringAsync]].
+ *
+ * A `FileImporter<'async'>`'s [[findFileUrl]] may either return synchronously
+ * or asynchronously, but it can only be used with [[compileAsync]] and
+ * [[compileStringAsync]].
+ *
+ * @example
+ *
+ * ```js
+ * const {fileURLToPath} = require('url');
+ *
+ * sass.compile('style.scss', {
+ *   importers: [{
+ *     // An importer that redirects relative URLs starting with "~" to
+ *     // `node_modules`.
+ *     findFileUrl(url) {
+ *       if (!url.startsWith('~')) return null;
+ *       return new URL(url.substring(1), pathToFileURL('node_modules'));
+ *     }
+ *   }]
+ * });
+ * ```
+ *
+ * @category Importer
+ */
+export interface FileImporter<
+  sync extends 'sync' | 'async' = 'sync' | 'async'
+> {
+  /**
+   * A callback that's called to partially resolve a load (such as
+   * [`@use`](https://sass-lang.com/documentation/at-rules/use) or
+   * [`@import`](https://sass-lang.com/documentation/at-rules/import)) to a file
+   * on disk.
+   *
+   * Unlike an [[Importer]], the compiler will automatically handle relative
+   * loads for a [[FileImporter]]. See [[Options.importers]] for more details on
+   * the way loads are resolved.
+   *
+   * @param url - The loaded URL. Since this might be relative, it's represented
+   * as a string rather than a [[URL]] object.
+   *
+   * @param options.fromImport - 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).
+   *
+   * @returns An absolute `file:` URL if this importer recognizes the `url`.
+   * This may be only partially resolved: the compiler will automatically look
+   * for [partials](https://sass-lang.com/documentation/at-rules/use#partials),
+   * [index files](https://sass-lang.com/documentation/at-rules/use#index-files),
+   * and file extensions based on the returned URL. An importer may also return
+   * a fully resolved URL if it so chooses.
+   *
+   * If this importer doesn't recognize the URL, it should return `null` instead
+   * to allow other importers or {@link Options.loadPaths | load paths} to
+   * handle it.
+   *
+   * This may also return a `Promise`, but if it does the importer may only be
+   * passed to [[compileAsync]] and [[compileStringAsync]], not [[compile]] or
+   * [[compileString]].
+   *
+   * @throws any - If this importer recognizes `url` but determines that it's
+   * invalid, it may throw an exception that will be wrapped by Sass. If the
+   * exception object has a `message` property, it will be used as the wrapped
+   * exception's message; otherwise, the exception object's `toString()` will be
+   * used. This means it's safe for importers to throw plain strings.
+   */
+  findFileUrl(
+    url: string,
+    options: {fromImport: boolean}
+  ): PromiseOr<URL | null, sync>;
+
+  /** @hidden */
+  canonicalize?: never;
+}
+
+/**
+ * An object that implements custom Sass loading logic for [`@use`
+ * rules](https://sass-lang.com/documentation/at-rules/use) and [`@import`
+ * rules](https://sass-lang.com/documentation/at-rules/import). It can be passed
+ * to [[Options.importers]] or [[StringOptionsWithImporter.importer]].
+ *
+ * Importers that simply redirect to files on disk are encouraged to use the
+ * [[FileImporter]] interface instead.
+ *
+ * See [[Options.importers]] for more details on the way loads are resolved.
+ *
+ * @typeParam sync - An `Importer<'sync'>`'s [[canonicalize]] and [[load]] must
+ * return synchronously, but in return it can be passed to [[compile]] and
+ * [[compileString]] in addition to [[compileAsync]] and [[compileStringAsync]].
+ *
+ * An `Importer<'async'>`'s [[canonicalize]] and [[load]] may either return
+ * synchronously or asynchronously, but it can only be used with
+ * [[compileAsync]] and [[compileStringAsync]].
+ *
+ * @example Resolving a Load
+ *
+ * This is the process of resolving a load using a custom importer:
+ *
+ * - The compiler encounters `@use "db:foo/bar/baz"`.
+ * - It calls [[canonicalize]] with `"db:foo/bar/baz"`.
+ * - [[canonicalize]] returns `new URL("db:foo/bar/baz/_index.scss")`.
+ * - If the compiler has already loaded a stylesheet with this canonical URL, it
+ *   re-uses the existing module.
+ * - Otherwise, it calls [[load]] with `new URL("db:foo/bar/baz/_index.scss")`.
+ * - [[load]] returns an [[ImporterResult]] that the compiler uses as the
+ *   contents of the module.
+ *
+ * @example Code Sample
+ *
+ * ```js
+ * sass.compile('style.scss', {
+ *   // An importer for URLs like `bgcolor:orange` that generates a
+ *   // stylesheet with the given background color.
+ *   importers: [{
+ *     canonicalize(url) {
+ *       if (!url.startsWith('bgcolor:')) return null;
+ *       return new URL(url);
+ *     },
+ *     load(canonicalUrl) {
+ *       return {
+ *         contents: `body {background-color: ${canonicalUrl.pathname}}`,
+ *         syntax: 'scss'
+ *       };
+ *     }
+ *   }]
+ * });
+ * ```
+ *
+ * @category Importer
+ */
+export interface Importer<sync extends 'sync' | 'async' = 'sync' | 'async'> {
+  /**
+   * If `url` is recognized by this importer, returns its canonical format.
+   *
+   * If Sass has already loaded a stylesheet with the returned canonical URL, it
+   * re-uses the existing parse tree (and the loaded module for `@use`). This
+   * means that importers **must ensure** that the same canonical URL always
+   * refers to the same stylesheet, *even across different importers*. As such,
+   * importers are encouraged to use unique URL schemes to disambiguate between
+   * one another.
+   *
+   * As much as possible, custom importers should canonicalize URLs the same way
+   * as the built-in filesystem importer:
+   *
+   * - The importer should look for stylesheets by adding the prefix `_` to the
+   *   URL's basename, and by adding the extensions `.sass` and `.scss` if the
+   *   URL doesn't already have one of those extensions. For example, if the
+   *   URL was `foo/bar/baz`, the importer would look for:
+   *   - `foo/bar/baz.sass`
+   *   - `foo/bar/baz.scss`
+   *   - `foo/bar/_baz.sass`
+   *   - `foo/bar/_baz.scss`
+   *
+   *   If the URL was `foo/bar/baz.scss`, the importer would just look for:
+   *   - `foo/bar/baz.scss`
+   *   - `foo/bar/_baz.scss`
+   *
+   *   If the importer finds a stylesheet at more than one of these URLs, it
+   *   should throw an exception indicating that the URL is ambiguous. Note that
+   *   if the extension is explicitly specified, a stylesheet with the opposite
+   *   extension is allowed to exist.
+   *
+   * - If none of the possible paths is valid, the importer should perform the
+   *   same resolution on the URL followed by `/index`. In the example above,
+   *   it would look for:
+   *   - `foo/bar/baz/index.sass`
+   *   - `foo/bar/baz/index.scss`
+   *   - `foo/bar/baz/_index.sass`
+   *   - `foo/bar/baz/_index.scss`
+   *
+   *   As above, if the importer finds a stylesheet at more than one of these
+   *   URLs, it should throw an exception indicating that the import is
+   *   ambiguous.
+   *
+   * If no stylesheets are found, the importer should return `null`.
+   *
+   * Calling [[canonicalize]] multiple times with the same URL must return the
+   * same result. Calling [[canonicalize]] with a URL returned by a previous
+   * call to [[canonicalize]] must return that URL.
+   *
+   * Relative loads in stylesheets loaded from an importer are handled by
+   * resolving the loaded URL relative to the canonical URL of the stylesheet
+   * that contains it, and passing that URL back to the importer's
+   * [[canonicalize]] method. For example, suppose the "Resolving a Load"
+   * example {@link Importer | above} returned a stylesheet that contained
+   * `@use "mixins"`:
+   *
+   * - The compiler resolves the URL `mixins` relative to the current
+   *   stylesheet's canonical URL `db:foo/bar/baz/_index.scss` to get
+   *   `db:foo/bar/baz/mixins`.
+   * - It calls [[canonicalize]] with `"db:foo/bar/baz/mixins"`.
+   * - [[canonicalize]] returns `new URL("db:foo/bar/baz/_mixins.scss")`.
+   *
+   * Because of this, [[canonicalize]] must return a meaningful result when
+   * called with a URL relative to one returned by an earlier call to
+   * [[canonicalize]].
+   *
+   * @param url - The loaded URL. Since this might be relative, it's represented
+   * as a string rather than a [[URL]] object.
+   *
+   * @param options.fromImport - 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).
+   *
+   * @returns An absolute URL if this importer recognizes the `url`, or `null`
+   * if it doesn't. If this returns `null`, other importers or {@link
+   * Options.loadPaths | load paths} may handle the load.
+   *
+   * This may also return a `Promise`, but if it does the importer may only be
+   * passed to [[compileAsync]] and [[compileStringAsync]], not [[compile]] or
+   * [[compileString]].
+   *
+   * @throws any - If this importer recognizes `url` but determines that it's
+   * invalid, it may throw an exception that will be wrapped by Sass. If the
+   * exception object has a `message` property, it will be used as the wrapped
+   * exception's message; otherwise, the exception object's `toString()` will be
+   * used. This means it's safe for importers to throw plain strings.
+   */
+  canonicalize(
+    url: string,
+    options: {fromImport: boolean}
+  ): PromiseOr<URL | null, sync>;
+
+  /**
+   * Loads the Sass text for the given `canonicalUrl`, or returns `null` if this
+   * importer can't find the stylesheet it refers to.
+   *
+   * @param canonicalUrl - The canonical URL of the stylesheet to load. This is
+   * guaranteed to come from a call to [[canonicalize]], although not every call
+   * to [[canonicalize]] will result in a call to [[load]].
+   *
+   * @returns The contents of the stylesheet at `canonicalUrl` if it can be
+   * loaded, or `null` if it can't.
+   *
+   * This may also return a `Promise`, but if it does the importer may only be
+   * passed to [[compileAsync]] and [[compileStringAsync]], not [[compile]] or
+   * [[compileString]].
+   *
+   * @throws any - If this importer finds a stylesheet at `url` but it fails to
+   * load for some reason, or if `url` is uniquely associated with this importer
+   * but doesn't refer to a real stylesheet, the importer may throw an exception
+   * that will be wrapped by Sass. If the exception object has a `message`
+   * property, it will be used as the wrapped exception's message; otherwise,
+   * the exception object's `toString()` will be used. This means it's safe for
+   * importers to throw plain strings.
+   */
+  load(canonicalUrl: URL): PromiseOr<ImporterResult | null, sync>;
+
+  /** @hidden */
+  findFileUrl?: never;
+}
+
+/**
+ * The result of successfully loading a stylesheet with an [[Importer]].
+ *
+ * @category Importer
+ */
+export interface ImporterResult {
+  /** The contents of the stylesheet. */
+  contents: string;
+
+  /** The syntax with which to parse [[contents]]. */
+  syntax: Syntax;
+
+  /**
+   * The URL to use to link to the loaded stylesheet's source code in source
+   * maps. A `file:` URL is ideal because it's accessible to both browsers and
+   * other build tools, but an `http:` URL is also acceptable.
+   *
+   * If this isn't set, it defaults to a `data:` URL that contains the contents
+   * of the loaded stylesheet.
+   */
+  sourceMapUrl?: URL;
+}

package/types/index.d.ts

@@ -0,0 +1,76 @@
+// This is a mirror of the JS API definitions in `spec/js-api`, but with comments
+// written to provide user-facing documentation rather than to specify behavior for
+// implementations.
+
+export {
+  CompileResult,
+  compile,
+  compileAsync,
+  compileString,
+  compileStringAsync,
+} from './compile';
+export {Exception} from './exception';
+export {FileImporter, Importer, ImporterResult} from './importer';
+export {Logger, SourceSpan, SourceLocation} from './logger';
+export {
+  CustomFunction,
+  Options,
+  OutputStyle,
+  StringOptions,
+  StringOptionsWithImporter,
+  StringOptionsWithoutImporter,
+  Syntax,
+} from './options';
+export {PromiseOr} from './util/promise_or';
+export {
+  ListSeparator,
+  SassArgumentList,
+  SassBoolean,
+  SassColor,
+  SassFunction,
+  SassList,
+  SassMap,
+  SassNumber,
+  SassString,
+  Value,
+  sassFalse,
+  sassNull,
+  sassTrue,
+} from './value';
+
+// Legacy APIs
+export {LegacyException} from './legacy/exception';
+export {
+  LegacyAsyncFunction,
+  LegacySyncFunction,
+  LegacyFunction,
+  LegacyValue,
+  types,
+} from './legacy/function';
+export {
+  LegacyAsyncImporter,
+  LegacyImporter,
+  LegacyImporterResult,
+  LegacyImporterThis,
+  LegacySyncImporter,
+} from './legacy/importer';
+export {
+  LegacySharedOptions,
+  LegacyFileOptions,
+  LegacyStringOptions,
+  LegacyOptions,
+} from './legacy/options';
+export {LegacyPluginThis} from './legacy/plugin_this';
+export {LegacyResult, render, renderSync} from './legacy/render';
+
+/**
+ * Information about the Sass implementation. This always begins with a unique
+ * identifier for the Sass implementation, followed by U+0009 TAB, followed by
+ * its npm package version. Some implementations include additional information
+ * as well, but not in any standardized format.
+ *
+ * * For Dart Sass, the implementation name is `dart-sass`.
+ * * For Node Sass, the implementation name is `node-sass`.
+ * * For the embedded host, the implementation name is `sass-embedded`.
+ */
+export const info: string;

package/types/legacy/exception.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The exception type thrown by [[renderSync]] and passed as the error to
+ * [[render]]'s callback.
+ *
+ * @category Legacy
+ * @deprecated This is only thrown by the legacy [[render]] and [[renderSync]]
+ * APIs. Use [[compile]], [[compileString]], [[compileAsync]], and
+ * [[compileStringAsync]] instead.
+ */
+export interface LegacyException extends Error {
+  /**
+   * The error message. For Dart Sass, when possible this includes a highlighted
+   * indication of where in the source file the error occurred as well as the
+   * Sass stack trace.
+   */
+  message: string;
+
+  /**
+   * The error message. For Dart Sass, this is the same as the result of calling
+   * [[toString]], which is itself the same as [[message]] but with the prefix
+   * "Error:".
+   */
+  formatted: string;
+
+  /**
+   * The (1-based) line number on which the error occurred, if this exception is
+   * associated with a specific Sass file location.
+   */
+  line?: number;
+
+  /**
+   * The (1-based) column number within [[line]] at which the error occurred, if
+   * this exception is associated with a specific Sass file location.
+   */
+  column?: number;
+
+  /**
+   * Analogous to the exit code for an executable. `1` for an error caused by a
+   * Sass file, `3` for any other type of error.
+   */
+  status: number;
+
+  /**
+   * If this exception was caused by an error in a Sass file, this will
+   * represent the Sass file's location. It can be in one of three formats:
+   *
+   * * If the Sass file was loaded from disk, this is the path to that file.
+   * * If the Sass file was generated by an importer, this is its canonical URL.
+   * * If the Sass file was passed as [[LegacyStringOptions.data]] without a
+   *   corresponding [[LegacyStringOptions.file]], this is the special string
+   *   `"stdin"`.
+   */
+  file?: string;
+}