apps/supplier-dispatch-h5
9
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first

Browse Source
This commit is contained in:
周林芳
2023-08-11 10:45:20 +08:00
commit 161ca982f3
31850 changed files with 2706500 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1563
node_modules/sass/LICENSE generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

173
node_modules/sass/README.md generated vendored Normal file
View File

@ -0,0 +1,173 @@
A pure JavaScript implementation of [Sass][sass]. **Sass makes CSS fun again**.
<table>
<tr>
<td>
<img width="118px" alt="Sass logo" src="https://rawgit.com/sass/sass-site/master/source/assets/img/logos/logo.svg" />
</td>
<td valign="middle">
<a href="https://www.npmjs.com/package/sass"><img width="100%" alt="npm statistics" src="https://nodei.co/npm/sass.png?downloads=true"></a>
</td>
<td valign="middle">
<a href="https://github.com/sass/dart-sass/actions"><img alt="GitHub actions build status" src="https://github.com/sass/dart-sass/workflows/CI/badge.svg"></a>
<br>
<a href="https://ci.appveyor.com/project/nex3/dart-sass"><img alt="Appveyor build status" src="https://ci.appveyor.com/api/projects/status/84rl9hvu8uoecgef?svg=true"></a>
</td>
</tr>
</table>
[sass]: https://sass-lang.com/
This package is a distribution of [Dart Sass][], compiled to pure JavaScript
with no native code or external dependencies. It provides a command-line `sass`
executable and a Node.js API.
[Dart Sass]: https://github.com/sass/dart-sass
* [Usage](#usage)
* [See Also](#see-also)
* [Behavioral Differences from Ruby Sass](#behavioral-differences-from-ruby-sass)
## Usage
You can install Sass globally using `npm install -g sass` which will provide
access to the `sass` executable. You can also add it to your project using
`npm install --save-dev sass`. This provides the executable as well as a
library:
[npm]: https://www.npmjs.com/package/sass
```js
const sass = require('sass');
const result = sass.compile(scssFilename);
// OR
// Note that `compileAsync()` is substantially slower than `compile()`.
const result = await sass.compileAsync(scssFilename);
```
See [the Sass website][js api] for full API documentation.
[js api]: https://sass-lang.com/documentation/js-api
### Legacy API
Dart Sass also supports an older JavaScript API that's fully compatible with
[Node Sass] (with a few exceptions listed below), with support for both the
[`render()`] and [`renderSync()`] functions. This API is considered deprecated
and will be removed in Dart Sass 2.0.0, so it should be avoided in new projects.
[Node Sass]: https://github.com/sass/node-sass
[`render()`]: https://sass-lang.com/documentation/js-api/functions/render
[`renderSync()`]: https://sass-lang.com/documentation/js-api/functions/renderSync
Sass's support for the legacy JavaScript API has the following limitations:
* Only the `"expanded"` and `"compressed"` values of [`outputStyle`] are
supported.
* Dart Sass doesn't support the [`precision`] option. Dart Sass defaults to a
sufficiently high precision for all existing browsers, and making this
customizable would make the code substantially less efficient.
* Dart Sass doesn't support the [`sourceComments`] option. Source maps are the
recommended way of locating the origin of generated selectors.
[`outputStyle`]: https://sass-lang.com/documentation/js-api/interfaces/LegacySharedOptions#outputStyle
[`precision`]: https://github.com/sass/node-sass#precision
[`sourceComments`]: https://github.com/sass/node-sass#sourcecomments
## See Also
* [Dart Sass][], from which this package is compiled, can be used either as a
stand-alone executable or as a Dart library. Running Dart Sass on the Dart VM
is substantially faster than running the pure JavaScript version, so this may
be appropriate for performance-sensitive applications. The Dart API is also
(currently) more user-friendly than the JavaScript API. See
[the Dart Sass README][Using Dart Sass] for details on how to use it.
* [Node Sass][], which is a wrapper around [LibSass][], the C++ implementation
of Sass. Node Sass supports the same API as this package and is also faster
(although it's usually a little slower than Dart Sass). However, it requires a
native library which may be difficult to install, and it's generally slower to
add features and fix bugs.
[Using Dart Sass]: https://github.com/sass/dart-sass#using-dart-sass
[Node Sass]: https://www.npmjs.com/package/node-sass
[LibSass]: https://sass-lang.com/libsass
## Behavioral Differences from Ruby Sass
There are a few intentional behavioral differences between Dart Sass and Ruby
Sass. These are generally places where Ruby Sass has an undesired behavior, and
it's substantially easier to implement the correct behavior than it would be to
implement compatible behavior. These should all have tracking bugs against Ruby
Sass to update the reference behavior.
1. `@extend` only accepts simple selectors, as does the second argument of
`selector-extend()`. See [issue 1599][].
2. Subject selectors are not supported. See [issue 1126][].
3. Pseudo selector arguments are parsed as `<declaration-value>`s rather than
having a more limited custom parsing. See [issue 2120][].
4. The numeric precision is set to 10. See [issue 1122][].
5. The indented syntax parser is more flexible: it doesn't require consistent
indentation across the whole document. See [issue 2176][].
6. Colors do not support channel-by-channel arithmetic. See [issue 2144][].
7. Unitless numbers aren't `==` to unit numbers with the same value. In
addition, map keys follow the same logic as `==`-equality. See
[issue 1496][].
8. `rgba()` and `hsla()` alpha values with percentage units are interpreted as
percentages. Other units are forbidden. See [issue 1525][].
9. Too many variable arguments passed to a function is an error. See
[issue 1408][].
10. Allow `@extend` to reach outside a media query if there's an identical
`@extend` defined outside that query. This isn't tracked explicitly, because
it'll be irrelevant when [issue 1050][] is fixed.
11. Some selector pseudos containing placeholder selectors will be compiled
where they wouldn't be in Ruby Sass. This better matches the semantics of
the selectors in question, and is more efficient. See [issue 2228][].
12. The old-style `:property value` syntax is not supported in the indented
syntax. See [issue 2245][].
13. The reference combinator is not supported. See [issue 303][].
14. Universal selector unification is symmetrical. See [issue 2247][].
15. `@extend` doesn't produce an error if it matches but fails to unify. See
[issue 2250][].
16. Dart Sass currently only supports UTF-8 documents. We'd like to support
more, but Dart currently doesn't support them. See [dart-lang/sdk#11744][],
for example.
[issue 1599]: https://github.com/sass/sass/issues/1599
[issue 1126]: https://github.com/sass/sass/issues/1126
[issue 2120]: https://github.com/sass/sass/issues/2120
[issue 1122]: https://github.com/sass/sass/issues/1122
[issue 2176]: https://github.com/sass/sass/issues/2176
[issue 2144]: https://github.com/sass/sass/issues/2144
[issue 1496]: https://github.com/sass/sass/issues/1496
[issue 1525]: https://github.com/sass/sass/issues/1525
[issue 1408]: https://github.com/sass/sass/issues/1408
[issue 1050]: https://github.com/sass/sass/issues/1050
[issue 2228]: https://github.com/sass/sass/issues/2228
[issue 2245]: https://github.com/sass/sass/issues/2245
[issue 303]: https://github.com/sass/sass/issues/303
[issue 2247]: https://github.com/sass/sass/issues/2247
[issue 2250]: https://github.com/sass/sass/issues/2250
[dart-lang/sdk#11744]: https://github.com/dart-lang/sdk/issues/11744
Disclaimer: this is not an official Google product.

75
node_modules/sass/package.json generated vendored Normal file
View File

@ -0,0 +1,75 @@
{
"_from": "sass@1.65.1",
"_id": "sass@1.65.1",
"_inBundle": false,
"_integrity": "sha512-9DINwtHmA41SEd36eVPQ9BJKpn7eKDQmUHmpI0y5Zv2Rcorrh0zS+cFrt050hdNbmmCNKTW3hV5mWfuegNRsEA==",
"_location": "/sass",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "sass@1.65.1",
"name": "sass",
"escapedName": "sass",
"rawSpec": "1.65.1",
"saveSpec": null,
"fetchSpec": "1.65.1"
},
"_requiredBy": [
"/"
],
"_resolved": "https://registry.npmjs.org/sass/-/sass-1.65.1.tgz",
"_shasum": "8f283b0c26335a88246a448d22e1342ba2ea1432",
"_spec": "sass@1.65.1",
"_where": "C:\\Users\\zhouxueli\\Desktop\\scheduling-app",
"author": {
"name": "Natalie Weizenbaum",
"email": "nweiz@google.com",
"url": "https://github.com/nex3"
},
"bin": {
"sass": "sass.js"
},
"bugs": {
"url": "https://github.com/sass/dart-sass/issues"
},
"bundleDependencies": false,
"dependencies": {
"chokidar": ">=3.0.0 <4.0.0",
"immutable": "^4.0.0",
"source-map-js": ">=0.6.2 <2.0.0"
},
"deprecated": false,
"description": "A pure JavaScript implementation of Sass.",
"engines": {
"node": ">=14.0.0"
},
"exports": {
"types": "./types/index.d.ts",
"node": {
"require": "./sass.node.js",
"default": "./sass.node.mjs"
},
"default": {
"require": "./sass.default.cjs",
"default": "./sass.default.js"
}
},
"homepage": "https://github.com/sass/dart-sass",
"keywords": [
"style",
"scss",
"sass",
"preprocessor",
"css"
],
"license": "MIT",
"main": "sass.node.js",
"name": "sass",
"repository": {
"type": "git",
"url": "git+https://github.com/sass/dart-sass.git"
},
"types": "types/index.d.ts",
"version": "1.65.1"
}

115937
node_modules/sass/sass.dart.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

8
node_modules/sass/sass.default.cjs generated vendored Normal file
View File

@ -0,0 +1,8 @@
require('./sass.dart.js');
const library = globalThis._cliPkgExports.pop();
if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports;
library.load({
immutable: require("immutable"),
});
module.exports = library;

39
node_modules/sass/sass.default.js generated vendored Normal file
View File

@ -0,0 +1,39 @@
import * as immutable from "immutable"
import "./sass.dart.js";
const _cliPkgLibrary = globalThis._cliPkgExports.pop();
if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports;
const _cliPkgExports = {};
_cliPkgLibrary.load({immutable}, _cliPkgExports);
export const compile = _cliPkgExports.compile;
export const compileAsync = _cliPkgExports.compileAsync;
export const compileString = _cliPkgExports.compileString;
export const compileStringAsync = _cliPkgExports.compileStringAsync;
export const Logger = _cliPkgExports.Logger;
export const SassArgumentList = _cliPkgExports.SassArgumentList;
export const SassBoolean = _cliPkgExports.SassBoolean;
export const SassCalculation = _cliPkgExports.SassCalculation;
export const CalculationOperation = _cliPkgExports.CalculationOperation;
export const CalculationInterpolation = _cliPkgExports.CalculationInterpolation;
export const SassColor = _cliPkgExports.SassColor;
export const SassFunction = _cliPkgExports.SassFunction;
export const SassList = _cliPkgExports.SassList;
export const SassMap = _cliPkgExports.SassMap;
export const SassNumber = _cliPkgExports.SassNumber;
export const SassString = _cliPkgExports.SassString;
export const Value = _cliPkgExports.Value;
export const CustomFunction = _cliPkgExports.CustomFunction;
export const ListSeparator = _cliPkgExports.ListSeparator;
export const sassFalse = _cliPkgExports.sassFalse;
export const sassNull = _cliPkgExports.sassNull;
export const sassTrue = _cliPkgExports.sassTrue;
export const Exception = _cliPkgExports.Exception;
export const PromiseOr = _cliPkgExports.PromiseOr;
export const info = _cliPkgExports.info;
export const render = _cliPkgExports.render;
export const renderSync = _cliPkgExports.renderSync;
export const TRUE = _cliPkgExports.TRUE;
export const FALSE = _cliPkgExports.FALSE;
export const NULL = _cliPkgExports.NULL;
export const types = _cliPkgExports.types;

16
node_modules/sass/sass.js generated vendored Normal file
View File

@ -0,0 +1,16 @@
#!/usr/bin/env node
require('./sass.dart.js');
var library = globalThis._cliPkgExports.pop();
if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports;
library.load({
readline: require("readline"),
chokidar: require("chokidar"),
util: require("util"),
stream: require("stream"),
fs: require("fs"),
immutable: require("immutable"),
});
library.cli_pkg_main_0_(process.argv.slice(2));

11
node_modules/sass/sass.node.js generated vendored Normal file
View File

@ -0,0 +1,11 @@
require('./sass.dart.js');
const library = globalThis._cliPkgExports.pop();
if (globalThis._cliPkgExports.length === 0) delete globalThis._cliPkgExports;
library.load({
util: require("util"),
stream: require("stream"),
fs: require("fs"),
immutable: require("immutable"),
});
module.exports = library;

169
node_modules/sass/sass.node.mjs generated vendored Normal file
View File

@ -0,0 +1,169 @@
import cjs from "./sass.node.js";
export const compile = cjs.compile;
export const compileAsync = cjs.compileAsync;
export const compileString = cjs.compileString;
export const compileStringAsync = cjs.compileStringAsync;
export const Logger = cjs.Logger;
export const SassArgumentList = cjs.SassArgumentList;
export const SassBoolean = cjs.SassBoolean;
export const SassCalculation = cjs.SassCalculation;
export const CalculationOperation = cjs.CalculationOperation;
export const CalculationInterpolation = cjs.CalculationInterpolation;
export const SassColor = cjs.SassColor;
export const SassFunction = cjs.SassFunction;
export const SassList = cjs.SassList;
export const SassMap = cjs.SassMap;
export const SassNumber = cjs.SassNumber;
export const SassString = cjs.SassString;
export const Value = cjs.Value;
export const CustomFunction = cjs.CustomFunction;
export const ListSeparator = cjs.ListSeparator;
export const sassFalse = cjs.sassFalse;
export const sassNull = cjs.sassNull;
export const sassTrue = cjs.sassTrue;
export const Exception = cjs.Exception;
export const PromiseOr = cjs.PromiseOr;
export const info = cjs.info;
export const render = cjs.render;
export const renderSync = cjs.renderSync;
export const TRUE = cjs.TRUE;
export const FALSE = cjs.FALSE;
export const NULL = cjs.NULL;
export const types = cjs.types;
let printedDefaultExportDeprecation = false;
function defaultExportDeprecation() {
if (printedDefaultExportDeprecation) return;
printedDefaultExportDeprecation = true;
console.error(
"`import sass from 'sass'` is deprecated.\n" +
"Please use `import * as sass from 'sass'` instead.");
}
export default {
get compile() {
defaultExportDeprecation();
return cjs.compile;
},
get compileAsync() {
defaultExportDeprecation();
return cjs.compileAsync;
},
get compileString() {
defaultExportDeprecation();
return cjs.compileString;
},
get compileStringAsync() {
defaultExportDeprecation();
return cjs.compileStringAsync;
},
get Logger() {
defaultExportDeprecation();
return cjs.Logger;
},
get SassArgumentList() {
defaultExportDeprecation();
return cjs.SassArgumentList;
},
get SassBoolean() {
defaultExportDeprecation();
return cjs.SassBoolean;
},
get SassCalculation() {
defaultExportDeprecation();
return cjs.SassCalculation;
},
get CalculationOperation() {
defaultExportDeprecation();
return cjs.CalculationOperation;
},
get CalculationInterpolation() {
defaultExportDeprecation();
return cjs.CalculationInterpolation;
},
get SassColor() {
defaultExportDeprecation();
return cjs.SassColor;
},
get SassFunction() {
defaultExportDeprecation();
return cjs.SassFunction;
},
get SassList() {
defaultExportDeprecation();
return cjs.SassList;
},
get SassMap() {
defaultExportDeprecation();
return cjs.SassMap;
},
get SassNumber() {
defaultExportDeprecation();
return cjs.SassNumber;
},
get SassString() {
defaultExportDeprecation();
return cjs.SassString;
},
get Value() {
defaultExportDeprecation();
return cjs.Value;
},
get CustomFunction() {
defaultExportDeprecation();
return cjs.CustomFunction;
},
get ListSeparator() {
defaultExportDeprecation();
return cjs.ListSeparator;
},
get sassFalse() {
defaultExportDeprecation();
return cjs.sassFalse;
},
get sassNull() {
defaultExportDeprecation();
return cjs.sassNull;
},
get sassTrue() {
defaultExportDeprecation();
return cjs.sassTrue;
},
get Exception() {
defaultExportDeprecation();
return cjs.Exception;
},
get PromiseOr() {
defaultExportDeprecation();
return cjs.PromiseOr;
},
get info() {
defaultExportDeprecation();
return cjs.info;
},
get render() {
defaultExportDeprecation();
return cjs.render;
},
get renderSync() {
defaultExportDeprecation();
return cjs.renderSync;
},
get TRUE() {
defaultExportDeprecation();
return cjs.TRUE;
},
get FALSE() {
defaultExportDeprecation();
return cjs.FALSE;
},
get NULL() {
defaultExportDeprecation();
return cjs.NULL;
},
get types() {
defaultExportDeprecation();
return cjs.types;
},
};

153
node_modules/sass/types/compile.d.ts generated vendored Normal file
View File

@ -0,0 +1,153 @@
import {RawSourceMap} from 'source-map-js';
import {Options, StringOptions} from './options';
/**
* The result of compiling Sass to CSS. Returned by {@link compile}, {@link
* compileAsync}, {@link compileString}, and {@link 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 {@link Importer} return {@link
* ImporterResult.sourceMapUrl}.
*
* This is set if and only if {@link Options.sourceMap} is `true`.
*/
sourceMap?: RawSourceMap;
}
/**
* Synchronously compiles the Sass file at `path` to CSS. If it succeeds it
* returns a {@link CompileResult}, and if it fails it throws an {@link
* Exception}.
*
* This only allows synchronous {@link Importer}s and {@link 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 {@link CompileResult} if it succeeds and rejects with an
* {@link Exception} if it fails.
*
* This only allows synchronous or asynchronous {@link Importer}s and
* {@link CustomFunction}s.
*
* **Heads up!** When using Dart Sass, **{@link compile} is almost twice as fast
* as {@link 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 {@link CompileResult}, and if it fails it throws an
* {@link Exception}.
*
* This only allows synchronous {@link Importer}s and {@link 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 {@link CompileResult} if it succeeds
* and rejects with an {@link Exception} if it fails.
*
* This only allows synchronous or asynchronous {@link Importer}s and {@link
* CustomFunction}s.
*
* **Heads up!** When using Dart Sass, **{@link compile} is almost twice as fast
* as {@link 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>;

41
node_modules/sass/types/exception.d.ts generated vendored Normal file
View File

@ -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 {@link sassMessage})
* but also an indication of where in the Sass stylesheet the error occurred
* (the {@link span}) and the Sass stack trace at the point of error (the
* {@link sassStack}).
*/
message: string;
/**
* A textual description of what went wrong.
*
* Unlike {@link message}, this does *not* include representations of {@link
* span} or {@link 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 {@link message}. */
toString(): string;
}

298
node_modules/sass/types/importer.d.ts generated vendored Normal file
View File

@ -0,0 +1,298 @@
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 {@link 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 {@link Options.importers} or {@link StringOptionsWithImporter.importer}.
*
* @typeParam sync - A `FileImporter<'sync'>`'s {@link findFileUrl} must return
* synchronously, but in return it can be passed to {@link compile} and {@link
* compileString} in addition to {@link compileAsync} and {@link
* compileStringAsync}.
*
* A `FileImporter<'async'>`'s {@link findFileUrl} may either return
* synchronously or asynchronously, but it can only be used with {@link
* compileAsync} and {@link compileStringAsync}.
*
* @example
*
* ```js
* const {pathToFileURL} = 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 {@link Importer}, the compiler will automatically handle relative
* loads for a {@link FileImporter}. See {@link 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 {@link 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 {@link compileAsync} and {@link compileStringAsync}, not {@link
* compile} or {@link 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 {@link Options.importers} or {@link StringOptionsWithImporter.importer}.
*
* Importers that simply redirect to files on disk are encouraged to use the
* {@link FileImporter} interface instead.
*
* ### 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 {@link canonicalize} with `"db:foo/bar/baz"`.
* - {@link 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 {@link load} with `new
* URL("db:foo/bar/baz/_index.scss")`.
* - {@link load} returns an {@link ImporterResult} that the compiler uses as
* the contents of the module.
*
* See {@link Options.importers} for more details on the way loads are resolved
* using multiple importers and load paths.
*
* @typeParam sync - An `Importer<'sync'>`'s {@link canonicalize} and {@link
* load} must return synchronously, but in return it can be passed to {@link
* compile} and {@link compileString} in addition to {@link compileAsync} and
* {@link compileStringAsync}.
*
* An `Importer<'async'>`'s {@link canonicalize} and {@link load} may either
* return synchronously or asynchronously, but it can only be used with {@link
* compileAsync} and {@link compileStringAsync}.
*
* @example
*
* ```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 {@link canonicalize} multiple times with the same URL must return
* the same result. Calling {@link canonicalize} with a URL returned by a
* previous call to {@link 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 {@link
* 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 {@link canonicalize} with `"db:foo/bar/baz/mixins"`.
* - {@link canonicalize} returns `new URL("db:foo/bar/baz/_mixins.scss")`.
*
* Because of this, {@link canonicalize} must return a meaningful result when
* called with a URL relative to one returned by an earlier call to {@link
* canonicalize}.
*
* @param url - The loaded URL. Since this might be relative, it's represented
* as a string rather than a {@link 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 {@link compileAsync} and {@link compileStringAsync}, not {@link
* compile} or {@link 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 {@link canonicalize}, although not every
* call to {@link canonicalize} will result in a call to {@link 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 {@link compileAsync} and {@link compileStringAsync}, not {@link
* compile} or {@link 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 {@link Importer}.
*
* @category Importer
*/
export interface ImporterResult {
/** The contents of the stylesheet. */
contents: string;
/** The syntax with which to parse {@link 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;
}

85
node_modules/sass/types/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,85 @@
// 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 {
CalculationInterpolation,
CalculationOperation,
CalculationOperator,
CalculationValue,
ListSeparator,
SassArgumentList,
SassBoolean,
SassCalculation,
SassColor,
SassFunction,
SassList,
SassMap,
SassNumber,
SassString,
Value,
sassFalse,
sassNull,
sassTrue,
} from './value';
// Legacy APIs
export {LegacyException} from './legacy/exception';
export {
FALSE,
LegacyAsyncFunction,
LegacyAsyncFunctionDone,
LegacyFunction,
LegacySyncFunction,
LegacyValue,
NULL,
TRUE,
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;

55
node_modules/sass/types/legacy/exception.d.ts generated vendored Normal file
View File

@ -0,0 +1,55 @@
/**
* The exception type thrown by {@link renderSync} and passed as the error to
* {@link render}'s callback.
*
* @category Legacy
* @deprecated This is only thrown by the legacy {@link render} and {@link
* renderSync} APIs. Use {@link compile}, {@link compileString}, {@link
* compileAsync}, and {@link 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
* {@link toString}, which is itself the same as {@link 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 {@link 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 {@link LegacyStringOptions.data} without a
* corresponding {@link LegacyStringOptions.file}, this is the special
* string `"stdin"`.
*/
file?: string;
}

757
node_modules/sass/types/legacy/function.d.ts generated vendored Normal file
View File

@ -0,0 +1,757 @@
import {LegacyPluginThis} from './plugin_this';
/**
* A synchronous callback that implements a custom Sass function. This can be
* passed to {@link LegacySharedOptions.functions} for either {@link render} or
* {@link renderSync}.
*
* If this throws an error, Sass will treat that as the function failing with
* that error message.
*
* ```js
* const result = sass.renderSync({
* file: 'style.scss',
* functions: {
* "sum($arg1, $arg2)": (arg1, arg2) => {
* if (!(arg1 instanceof sass.types.Number)) {
* throw new Error("$arg1: Expected a number");
* } else if (!(arg2 instanceof sass.types.Number)) {
* throw new Error("$arg2: Expected a number");
* }
* return new sass.types.Number(arg1.getValue() + arg2.getValue());
* }
* }
* });
* ```
*
* @param args - One argument for each argument that's declared in the signature
* that's passed to {@link LegacySharedOptions.functions}. If the signature
* [takes arbitrary
* arguments](https://sass-lang.com/documentation/at-rules/function#taking-arbitrary-arguments),
* they're passed as a single argument list in the last argument.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacySyncFunction = (
this: LegacyPluginThis,
...args: LegacyValue[]
) => LegacyValue;
/**
* An asynchronous callback that implements a custom Sass function. This can be
* passed to {@link LegacySharedOptions.functions}, but only for {@link render}.
*
* An asynchronous function must return `undefined`. Its final argument will
* always be a callback, which it should call with the result of the function
* once it's done running.
*
* If this throws an error, Sass will treat that as the function failing with
* that error message.
*
* ```js
* sass.render({
* file: 'style.scss',
* functions: {
* "sum($arg1, $arg2)": (arg1, arg2, done) => {
* if (!(arg1 instanceof sass.types.Number)) {
* throw new Error("$arg1: Expected a number");
* } else if (!(arg2 instanceof sass.types.Number)) {
* throw new Error("$arg2: Expected a number");
* }
* done(new sass.types.Number(arg1.getValue() + arg2.getValue()));
* }
* }
* }, (result, error) => {
* // ...
* });
* ```
*
* This is passed one argument for each argument that's declared in the
* signature that's passed to {@link LegacySharedOptions.functions}. If the
* signature [takes arbitrary
* arguments](https://sass-lang.com/documentation/at-rules/function#taking-arbitrary-arguments),
* they're passed as a single argument list in the last argument before the
* callback.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyAsyncFunction =
| ((this: LegacyPluginThis, done: (result: LegacyValue) => void) => void)
| ((
this: LegacyPluginThis,
arg1: LegacyValue,
done: LegacyAsyncFunctionDone
) => void)
| ((
this: LegacyPluginThis,
arg1: LegacyValue,
arg2: LegacyValue,
done: LegacyAsyncFunctionDone
) => void)
| ((
this: LegacyPluginThis,
arg1: LegacyValue,
arg2: LegacyValue,
arg3: LegacyValue,
done: LegacyAsyncFunctionDone
) => void)
| ((
this: LegacyPluginThis,
arg1: LegacyValue,
arg2: LegacyValue,
arg3: LegacyValue,
arg4: LegacyValue,
done: LegacyAsyncFunctionDone
) => void)
| ((
this: LegacyPluginThis,
arg1: LegacyValue,
arg2: LegacyValue,
arg3: LegacyValue,
arg4: LegacyValue,
arg5: LegacyValue,
done: LegacyAsyncFunctionDone
) => void)
| ((
this: LegacyPluginThis,
arg1: LegacyValue,
arg2: LegacyValue,
arg3: LegacyValue,
arg4: LegacyValue,
arg5: LegacyValue,
arg6: LegacyValue,
done: LegacyAsyncFunctionDone
) => void)
| ((
this: LegacyPluginThis,
...args: [...LegacyValue[], LegacyAsyncFunctionDone]
) => void);
/**
* The function called by a {@link LegacyAsyncFunction} to indicate that it's
* finished.
*
* @param result - If this is a {@link LegacyValue}, that indicates that the
* function call completed successfully. If it's a {@link types.Error}, that
* indicates that the function call failed.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyAsyncFunctionDone = (
result: LegacyValue | types.Error
) => void;
/**
* A callback that implements a custom Sass function. For {@link renderSync},
* this must be a {@link LegacySyncFunction} which returns its result directly;
* for {@link render}, it may be either a {@link LegacySyncFunction} or a {@link
* LegacyAsyncFunction} which calls a callback with its result.
*
* See {@link LegacySharedOptions.functions} for more details.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link CustomFunction} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyFunction<sync extends 'sync' | 'async'> = sync extends 'async'
? LegacySyncFunction | LegacyAsyncFunction
: LegacySyncFunction;
/**
* A type representing all the possible values that may be passed to or returned
* from a {@link LegacyFunction}.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Value} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyValue =
| types.Null
| types.Number
| types.String
| types.Boolean
| types.Color
| types.List
| types.Map;
/**
* A shorthand for `sass.types.Boolean.TRUE`.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link sassTrue} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export const TRUE: types.Boolean<true>;
/**
* A shorthand for `sass.types.Boolean.FALSE`.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link sassFalse} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export const FALSE: types.Boolean<false>;
/**
* A shorthand for `sass.types.Null.NULL`.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link sassNull} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export const NULL: types.Null;
/**
* The namespace for value types used in the legacy function API.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Value} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export namespace types {
/**
* The class for Sass's singleton [`null`
* value](https://sass-lang.com/documentation/values/null). The value itself
* can be accessed through the {@link NULL} field.
*/
export class Null {
/** Sass's singleton `null` value. */
static readonly NULL: Null;
}
/**
* Sass's [number type](https://sass-lang.com/documentation/values/numbers).
*/
export class Number {
/**
* @param value - The numeric value of the number.
*
* @param unit - If passed, the number's unit.
*
* Complex units can be represented as
* `<unit>*<unit>*.../<unit>*<unit>*...`, with numerator units on the
* left-hand side of the `/` and denominator units on the right. A number
* with only numerator units may omit the `/` and the units after it, and a
* number with only denominator units may be represented
* with no units before the `/`.
*
* @example
*
* ```scss
* new sass.types.Number(0.5); // == 0.5
* new sass.types.Number(10, "px"); // == 10px
* new sass.types.Number(10, "px*px"); // == 10px * 1px
* new sass.types.Number(10, "px/s"); // == math.div(10px, 1s)
* new sass.types.Number(10, "px*px/s*s"); // == 10px * math.div(math.div(1px, 1s), 1s)
* ```
*/
constructor(value: number, unit?: string);
/**
* Returns the value of the number, ignoring units.
*
* **Heads up!** This means that `96px` and `1in` will return different
* values, even though they represent the same length.
*
* @example
*
* ```js
* const number = new sass.types.Number(10, "px");
* number.getValue(); // 10
* ```
*/
getValue(): number;
/**
* Destructively modifies this number by setting its numeric value to
* `value`, independent of its units.
*
* @deprecated Use {@link constructor} instead.
*/
setValue(value: number): void;
/**
* Returns a string representation of this number's units. Complex units are
* returned in the same format that {@link constructor} accepts them.
*
* @example
*
* ```js
* // number is `10px`.
* number.getUnit(); // "px"
*
* // number is `math.div(10px, 1s)`.
* number.getUnit(); // "px/s"
* ```
*/
getUnit(): string;
/**
* Destructively modifies this number by setting its units to `unit`,
* independent of its numeric value. Complex units are specified in the same
* format as {@link constructor}.
*
* @deprecated Use {@link constructor} instead.
*/
setUnit(unit: string): void;
}
/**
* Sass's [string type](https://sass-lang.com/documentation/values/strings).
*
* **Heads up!** This API currently provides no way of distinguishing between
* a [quoted](https://sass-lang.com/documentation/values/strings#quoted) and
* [unquoted](https://sass-lang.com/documentation/values/strings#unquoted)
* string.
*/
export class String {
/**
* Creates an unquoted string with the given contents.
*
* **Heads up!** This API currently provides no way of creating a
* [quoted](https://sass-lang.com/documentation/values/strings#quoted)
* string.
*/
constructor(value: string);
/**
* Returns the contents of the string. If the string contains escapes,
* those escapes are included literally if it’s
* [unquoted](https://sass-lang.com/documentation/values/strings#unquoted),
* while the values of the escapes are included if it’s
* [quoted](https://sass-lang.com/documentation/values/strings#quoted).
*
* @example
*
* ```
* // string is `Arial`.
* string.getValue(); // "Arial"
*
* // string is `"Helvetica Neue"`.
* string.getValue(); // "Helvetica Neue"
*
* // string is `\1F46D`.
* string.getValue(); // "\\1F46D"
*
* // string is `"\1F46D"`.
* string.getValue(); // "👭"
* ```
*/
getValue(): string;
/**
* Destructively modifies this string by setting its numeric value to
* `value`.
*
* **Heads up!** Even if the string was originally quoted, this will cause
* it to become unquoted.
*
* @deprecated Use {@link constructor} instead.
*/
setValue(value: string): void;
}
/**
* Sass's [boolean type](https://sass-lang.com/documentation/values/booleans).
*
* Custom functions should respect Sass’s notion of
* [truthiness](https://sass-lang.com/documentation/at-rules/control/if#truthiness-and-falsiness)
* by treating `false` and `null` as falsey and everything else as truthy.
*
* **Heads up!** Boolean values can't be constructed, they can only be
* accessed through the {@link TRUE} and {@link FALSE} constants.
*/
export class Boolean<T extends boolean = boolean> {
/**
* Returns `true` if this is Sass's `true` value and `false` if this is
* Sass's `false` value.
*
* @example
*
* ```js
* // boolean is `true`.
* boolean.getValue(); // true
* boolean === sass.types.Boolean.TRUE; // true
*
* // boolean is `false`.
* boolean.getValue(); // false
* boolean === sass.types.Boolean.FALSE; // true
* ```
*/
getValue(): T;
/** Sass's `true` value. */
static readonly TRUE: Boolean<true>;
/** Sass's `false` value. */
static readonly FALSE: Boolean<false>;
}
/**
* Sass's [color type](https://sass-lang.com/documentation/values/colors).
*/
export class Color {
/**
* Creates a new Sass color with the given red, green, blue, and alpha
* channels. The red, green, and blue channels must be integers between 0
* and 255 (inclusive), and alpha must be between 0 and 1 (inclusive).
*
* @example
*
* ```js
* new sass.types.Color(107, 113, 127); // #6b717f
* new sass.types.Color(0, 0, 0, 0); // rgba(0, 0, 0, 0)
* ```
*/
constructor(r: number, g: number, b: number, a?: number);
/**
* Creates a new Sass color with alpha, red, green, and blue channels taken
* from respective two-byte chunks of a hexidecimal number.
*
* @example
*
* ```js
* new sass.types.Color(0xff6b717f); // #6b717f
* new sass.types.Color(0x00000000); // rgba(0, 0, 0, 0)
* ```
*/
constructor(argb: number);
/**
* Returns the red channel of the color as an integer from 0 to 255.
*
* @example
*
* ```js
* // color is `#6b717f`.
* color.getR(); // 107
*
* // color is `#b37399`.
* color.getR(); // 179
* ```
*/
getR(): number;
/**
* Sets the red channel of the color. The value must be an integer between 0
* and 255 (inclusive).
*
* @deprecated Use {@link constructor} instead.
*/
setR(value: number): void;
/**
* Returns the green channel of the color as an integer from 0 to 255.
*
* @example
*
* ```js
* // color is `#6b717f`.
* color.getG(); // 113
*
* // color is `#b37399`.
* color.getG(); // 115
* ```
*/
getG(): number;
/**
* Sets the green channel of the color. The value must be an integer between
* 0 and 255 (inclusive).
*
* @deprecated Use {@link constructor} instead.
*/
setG(value: number): void;
/**
* Returns the blue channel of the color as an integer from 0 to 255.
*
* @example
*
* ```js
* // color is `#6b717f`.
* color.getB(); // 127
*
* // color is `#b37399`.
* color.getB(); // 153
* ```
*/
getB(): number;
/**
* Sets the blue channel of the color. The value must be an integer between
* 0 and 255 (inclusive).
*
* @deprecated Use {@link constructor} instead.
*/
setB(value: number): void;
/**
* Returns the alpha channel of the color as a number from 0 to 1.
*
* @example
*
* ```js
* // color is `#6b717f`.
* color.getA(); // 1
*
* // color is `transparent`.
* color.getA(); // 0
* ```
*/
getA(): number;
/**
* Sets the alpha channel of the color. The value must be between 0 and 1
* (inclusive).
*
* @deprecated Use {@link constructor} instead.
*/
setA(value: number): void;
}
/**
* Sass's [list type](https://sass-lang.com/documentation/values/lists).
*
* **Heads up!** This list type’s methods use 0-based indexing, even though
* within Sass lists use 1-based indexing. These methods also don’t support
* using negative numbers to index backwards from the end of the list.
*/
export class List {
/**
* Creates a new Sass list.
*
* **Heads up!** The initial values of the list elements are undefined.
* These elements must be set using {@link setValue} before accessing them
* or passing the list back to Sass.
*
* @example
*
* ```js
* const list = new sass.types.List(3);
* list.setValue(0, new sass.types.Number(10, "px"));
* list.setValue(1, new sass.types.Number(15, "px"));
* list.setValue(2, new sass.types.Number(32, "px"));
* list; // 10px, 15px, 32px
* ```
*
* @param length - The number of (initially undefined) elements in the list.
* @param commaSeparator - If `true`, the list is comma-separated; otherwise,
* it's space-separated. Defaults to `true`.
*/
constructor(length: number, commaSeparator?: boolean);
/**
* Returns the element at `index`, or `undefined` if that value hasn't yet
* been set.
*
* @example
*
* ```js
* // list is `10px, 15px, 32px`
* list.getValue(0); // 10px
* list.getValue(2); // 32px
* ```
*
* @param index - A (0-based) index into this list.
* @throws `Error` if `index` is less than 0 or greater than or equal to the
* number of elements in this list.
*/
getValue(index: number): LegacyValue | undefined;
/**
* Sets the element at `index` to `value`.
*
* @example
*
* ```js
* // list is `10px, 15px, 32px`
* list.setValue(1, new sass.types.Number(18, "px"));
* list; // 10px, 18px, 32px
* ```
*
* @param index - A (0-based) index into this list.
* @throws `Error` if `index` is less than 0 or greater than or equal to the
* number of elements in this list.
*/
setValue(index: number, value: LegacyValue): void;
/**
* Returns `true` if this list is comma-separated and `false` otherwise.
*
* @example
*
* ```js
* // list is `10px, 15px, 32px`
* list.getSeparator(); // true
*
* // list is `1px solid`
* list.getSeparator(); // false
* ```
*/
getSeparator(): boolean;
/**
* Sets whether the list is comma-separated.
*
* @param isComma - `true` to make the list comma-separated, `false` otherwise.
*/
setSeparator(isComma: boolean): void;
/**
* Returns the number of elements in the list.
*
* @example
*
* ```js
* // list is `10px, 15px, 32px`
* list.getLength(); // 3
*
* // list is `1px solid`
* list.getLength(); // 2
* ```
*/
getLength(): number;
}
/**
* Sass's [map type](https://sass-lang.com/documentation/values/maps).
*
* **Heads up!** This map type is represented as a list of key-value pairs
* rather than a mapping from keys to values. The only way to find the value
* associated with a given key is to iterate through the map checking for that
* key. Maps created through this API are still forbidden from having duplicate
* keys.
*/
export class Map {
/**
* Creates a new Sass map.
*
* **Heads up!** The initial keys and values of the map are undefined. They
* must be set using {@link setKey} and {@link setValue} before accessing
* them or passing the map back to Sass.
*
* @example
*
* ```js
* const map = new sass.types.Map(2);
* map.setKey(0, new sass.types.String("width"));
* map.setValue(0, new sass.types.Number(300, "px"));
* map.setKey(1, new sass.types.String("height"));
* map.setValue(1, new sass.types.Number(100, "px"));
* map; // (width: 300px, height: 100px)
* ```
*
* @param length - The number of (initially undefined) key/value pairs in the map.
*/
constructor(length: number);
/**
* Returns the value in the key/value pair at `index`.
*
* @example
*
* ```js
* // map is `(width: 300px, height: 100px)`
* map.getValue(0); // 300px
* map.getValue(1); // 100px
* ```
*
* @param index - A (0-based) index of a key/value pair in this map.
* @throws `Error` if `index` is less than 0 or greater than or equal to the
* number of pairs in this map.
*/
getValue(index: number): LegacyValue;
/**
* Sets the value in the key/value pair at `index` to `value`.
*
* @example
*
* ```js
* // map is `("light": 200, "medium": 400, "bold": 600)`
* map.setValue(1, new sass.types.Number(300));
* map; // ("light": 200, "medium": 300, "bold": 600)
* ```
*
* @param index - A (0-based) index of a key/value pair in this map.
* @throws `Error` if `index` is less than 0 or greater than or equal to the
* number of pairs in this map.
*/
setValue(index: number, value: LegacyValue): void;
/**
* Returns the key in the key/value pair at `index`.
*
* @example
*
* ```js
* // map is `(width: 300px, height: 100px)`
* map.getKey(0); // width
* map.getKey(1); // height
* ```
*
* @param index - A (0-based) index of a key/value pair in this map.
* @throws `Error` if `index` is less than 0 or greater than or equal to the
* number of pairs in this map.
*/
getKey(index: number): LegacyValue;
/**
* Sets the value in the key/value pair at `index` to `value`.
*
* @example
*
* ```js
* // map is `("light": 200, "medium": 400, "bold": 600)`
* map.setValue(1, new sass.types.String("lighter"));
* map; // ("lighter": 200, "medium": 300, "bold": 600)
* ```
*
* @param index - A (0-based) index of a key/value pair in this map.
* @throws `Error` if `index` is less than 0 or greater than or equal to the
* number of pairs in this map.
*/
setKey(index: number, key: LegacyValue): void;
/**
* Returns the number of key/value pairs in this map.
*
* @example
*
* ```js
* // map is `("light": 200, "medium": 400, "bold": 600)`
* map.getLength(); // 3
*
* // map is `(width: 300px, height: 100px)`
* map.getLength(); // 2
* ```
*/
getLength(): number;
}
/**
* An error that can be returned from a Sass function to signal that it
* encountered an error. This is the only way to signal an error
* asynchronously from a {@link LegacyAsyncFunction}.
*/
export class Error {
constructor(message: string);
}
}

169
node_modules/sass/types/legacy/importer.d.ts generated vendored Normal file
View File

@ -0,0 +1,169 @@
import {LegacyPluginThis} from './plugin_this';
/**
* The value of `this` in the context of a {@link LegacyImporter} function.
*
* @category Legacy
* @deprecated This is only used by the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Importer} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
interface LegacyImporterThis extends LegacyPluginThis {
/**
* Whether the importer 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).
*
* @compatibility dart: "1.33.0", node: false
*/
fromImport: boolean;
}
/**
* The result of running a {@link LegacyImporter}. It must be one of the
* following types:
*
* * An object with the key `contents` whose value is the contents of a stylesheet
* (in SCSS syntax). This causes Sass to load that stylesheet’s contents.
*
* * An object with the key `file` whose value is a path on disk. This causes Sass
* to load that file as though it had been imported directly.
*
* * `null`, which indicates that it doesn’t recognize the URL and another
* importer should be tried instead.
*
* * An [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
* object, indicating that importing failed.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link ImporterResult} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyImporterResult =
| {file: string}
| {contents: string}
| Error
| null;
/**
* A synchronous callback that implements custom Sass loading logic for
* [`@import` rules](https://sass-lang.com/documentation/at-rules/import) and
* [`@use` rules](https://sass-lang.com/documentation/at-rules/use). This can be
* passed to {@link LegacySharedOptions.importer} for either {@link render} or
* {@link renderSync}.
*
* See {@link LegacySharedOptions.importer} for more detailed documentation.
*
* ```js
* sass.renderSync({
* file: "style.scss",
* importer: [
* function(url, prev) {
* if (url != "big-headers") return null;
*
* return {
* contents: 'h1 { font-size: 40px; }'
* };
* }
* ]
* });
* ```
*
* @param url - The `@use` or `@import` rule’s URL as a string, exactly as it
* appears in the stylesheet.
*
* @param prev - A string identifying the stylesheet that contained the `@use`
* or `@import`. This string’s format depends on how that stylesheet was loaded:
*
* * If the stylesheet was loaded from the filesystem, it’s the absolute path of
* its file.
* * If the stylesheet was loaded from an importer that returned its contents,
* it’s the URL of the `@use` or `@import` rule that loaded it.
* * If the stylesheet came from the data option, it’s the string "stdin".
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Importer} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
type LegacySyncImporter = (
this: LegacyImporterThis,
url: string,
prev: string
) => LegacyImporterResult;
/**
* An asynchronous callback that implements custom Sass loading logic for
* [`@import` rules](https://sass-lang.com/documentation/at-rules/import) and
* [`@use` rules](https://sass-lang.com/documentation/at-rules/use). This can be
* passed to {@link LegacySharedOptions.importer} for either {@link render} or
* {@link renderSync}.
*
* An asynchronous importer must return `undefined`, and then call `done` with
* the result of its {@link LegacyImporterResult} once it's done running.
*
* See {@link LegacySharedOptions.importer} for more detailed documentation.
*
* ```js
* sass.render({
* file: "style.scss",
* importer: [
* function(url, prev, done) {
* if (url != "big-headers") done(null);
*
* done({
* contents: 'h1 { font-size: 40px; }'
* });
* }
* ]
* });
* ```
*
* @param url - The `@use` or `@import` rule’s URL as a string, exactly as it
* appears in the stylesheet.
*
* @param prev - A string identifying the stylesheet that contained the `@use`
* or `@import`. This string’s format depends on how that stylesheet was loaded:
*
* * If the stylesheet was loaded from the filesystem, it’s the absolute path of
* its file.
* * If the stylesheet was loaded from an importer that returned its contents,
* it’s the URL of the `@use` or `@import` rule that loaded it.
* * If the stylesheet came from the data option, it’s the string "stdin".
*
* @param done - The callback to call once the importer has finished running.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Importer} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
type LegacyAsyncImporter = (
this: LegacyImporterThis,
url: string,
prev: string,
done: (result: LegacyImporterResult) => void
) => void;
/**
* A callback that implements custom Sass loading logic for [`@import`
* rules](https://sass-lang.com/documentation/at-rules/import) and [`@use`
* rules](https://sass-lang.com/documentation/at-rules/use). For {@link
* renderSync}, this must be a {@link LegacySyncImporter} which returns its
* result directly; for {@link render}, it may be either a {@link
* LegacySyncImporter} or a {@link LegacyAsyncImporter} which calls a callback
* with its result.
*
* See {@link LegacySharedOptions.importer} for more details.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Importer} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyImporter<sync = 'sync' | 'async'> = sync extends 'async'
? LegacySyncImporter | LegacyAsyncImporter
: LegacySyncImporter;

641
node_modules/sass/types/legacy/options.d.ts generated vendored Normal file
View File

@ -0,0 +1,641 @@
import {Logger} from '../logger';
import {LegacyImporter} from './importer';
import {LegacyFunction} from './function';
/**
* Options for {@link render} and {@link renderSync} that are shared between
* {@link LegacyFileOptions} and {@link LegacyStringOptions}.
*
* @typeParam sync - This lets the TypeScript checker verify that {@link
* LegacyAsyncImporter}s and {@link LegacyAsyncFunction}s aren't passed to
* {@link renderSync}.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Options} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export interface LegacySharedOptions<sync extends 'sync' | 'async'> {
/**
* This array of strings option provides [load
* paths](https://sass-lang.com/documentation/at-rules/import#load-paths) for
* Sass to look for stylesheets. Earlier load paths will take precedence over
* later ones.
*
* ```js
* sass.renderSync({
* file: "style.scss",
* includePaths: ["node_modules/bootstrap/dist/css"]
* });
* ```
*
* Load paths are also loaded from the `SASS_PATH` environment variable, if
* it’s set. This variable should be a list of paths separated by `;` (on
* Windows) or `:` (on other operating systems). Load paths from the
* `includePaths` option take precedence over load paths from `SASS_PATH`.
*
* ```sh
* $ SASS_PATH=node_modules/bootstrap/dist/css sass style.scss style.css
* ```
*
* @category Input
* @compatibility feature: "SASS_PATH", dart: "1.15.0", node: "3.9.0"
*
* Earlier versions of Dart Sass and Node Sass didn’t support the `SASS_PATH`
* environment variable.
*/
includePaths?: string[];
/**
* Whether the generated CSS should use spaces or tabs for indentation.
*
* ```js
* const result = sass.renderSync({
* file: "style.scss",
* indentType: "tab",
* indentWidth: 1
* });
*
* result.css.toString();
* // "h1 {\n\tfont-size: 40px;\n}\n"
* ```
*
* @defaultValue `'space'`
* @category Output
* @compatibility dart: true, node: "3.0.0"
*/
indentType?: 'space' | 'tab';
/**
* How many spaces or tabs (depending on {@link indentType}) should be used
* per indentation level in the generated CSS. It must be between 0 and 10
* (inclusive).
*
* @defaultValue `2`
* @category Output
* @compatibility dart: true, node: "3.0.0"
*/
indentWidth?: number;
/**
* Which character sequence to use at the end of each line in the generated
* CSS. It can have the following values:
*
* * `'lf'` uses U+000A LINE FEED.
* * `'lfcr'` uses U+000A LINE FEED followed by U+000D CARRIAGE RETURN.
* * `'cr'` uses U+000D CARRIAGE RETURN.
* * `'crlf'` uses U+000D CARRIAGE RETURN followed by U+000A LINE FEED.
*
* @defaultValue `'lf'`
* @category Output
* @compatibility dart: true, node: "3.0.0"
*/
linefeed?: 'cr' | 'crlf' | 'lf' | 'lfcr';
/**
* If `true`, Sass won't add a link from the generated CSS to the source map.
*
* ```js
* const result = sass.renderSync({
* file: "style.scss",
* sourceMap: "out.map",
* omitSourceMapUrl: true
* })
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px;
* // }
* ```
*
* @defaultValue `false`
* @category Source Maps
*/
omitSourceMapUrl?: boolean;
/**
* The location that Sass expects the generated CSS to be saved to. It’s used
* to determine the URL used to link from the generated CSS to the source map,
* and from the source map to the Sass source files.
*
* **Heads up!** Despite the name, Sass does *not* write the CSS output to
* this file. The caller must do that themselves.
*
* ```js
* result = sass.renderSync({
* file: "style.scss",
* sourceMap: true,
* outFile: "out.css"
* })
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px;
* // }
* // /*# sourceMappingURL=out.css.map * /
* ```
*
* @category Source Maps
*/
outFile?: string;
/**
* The output style of the compiled CSS. There are four possible output styles:
*
* * `"expanded"` (the default for Dart Sass) writes each selector and
* declaration on its own line.
*
* * `"compressed"` removes as many extra characters as possible, and writes
* the entire stylesheet on a single line.
*
* * `"nested"` (the default for Node Sass, not supported by Dart Sass)
* indents CSS rules to match the nesting of the Sass source.
*
* * `"compact"` (not supported by Dart Sass) puts each CSS rule on its own single line.
*
* @example
*
* ```js
* const source = `
* h1 {
* font-size: 40px;
* code {
* font-face: Roboto Mono;
* }
* }`;
*
* let result = sass.renderSync({
* data: source,
* outputStyle: "expanded"
* });
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px;
* // }
* // h1 code {
* // font-face: Roboto Mono;
* // }
*
* result = sass.renderSync({
* data: source,
* outputStyle: "compressed"
* });
* console.log(result.css.toString());
* // h1{font-size:40px}h1 code{font-face:Roboto Mono}
*
* result = sass.renderSync({
* data: source,
* outputStyle: "nested"
* });
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px; }
* // h1 code {
* // font-face: Roboto Mono; }
*
* result = sass.renderSync({
* data: source,
* outputStyle: "compact"
* });
* console.log(result.css.toString());
* // h1 { font-size: 40px; }
* // h1 code { font-face: Roboto Mono; }
* ```
*
* @category Output
*/
outputStyle?: 'compressed' | 'expanded' | 'nested' | 'compact';
/**
* Whether or not Sass should generate a source map. If it does, the source
* map will be available as {@link LegacyResult.map} (unless {@link
* sourceMapEmbed} is `true`).
*
* If this option is a string, it’s the path that the source map is expected
* to be written to, which is used to link to the source map from the
* generated CSS and to link *from* the source map to the Sass source files.
* Note that if `sourceMap` is a string and {@link outFile} isn’t passed, Sass
* assumes that the CSS will be written to the same directory as the file
* option if it’s passed.
*
* If this option is `true`, the path is assumed to be {@link outFile} with
* `.map` added to the end. If it’s `true` and {@link outFile} isn’t passed,
* it has no effect.
*
* @example
*
* ```js
* let result = sass.renderSync({
* file: "style.scss",
* sourceMap: "out.map"
* })
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px;
* // }
* // /*# sourceMappingURL=out.map * /
*
* result = sass.renderSync({
* file: "style.scss",
* sourceMap: true,
* outFile: "out.css"
* })
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px;
* // }
* // /*# sourceMappingURL=out.css.map * /
* ```
*
* @defaultValue `false`
* @category Source Maps
*/
sourceMap?: boolean | string;
/**
* Whether to embed the entire contents of the Sass files that contributed to
* the generated CSS in the source map. This may produce very large source
* maps, but it guarantees that the source will be available on any computer
* no matter how the CSS is served.
*
* @example
*
* ```js
* sass.renderSync({
* file: "style.scss",
* sourceMap: "out.map",
* sourceMapContents: true
* })
* ```
*
* @defaultValue `false`
* @category Source Maps
*/
sourceMapContents?: boolean;
/**
* Whether to embed the contents of the source map file in the generated CSS,
* rather than creating a separate file and linking to it from the CSS.
*
* @example
*
* ```js
* sass.renderSync({
* file: "style.scss",
* sourceMap: "out.map",
* sourceMapEmbed: true
* });
* ```
*
* @defaultValue `false`
* @category Source Maps
*/
sourceMapEmbed?: boolean;
/**
* If this is passed, it's prepended to all the links from the source map to
* the Sass source files.
*
* @category Source Maps
*/
sourceMapRoot?: string;
/**
* Additional handler(s) for loading files when a [`@use`
* rule](https://sass-lang.com/documentation/at-rules/use) or an [`@import`
* rule](https://sass-lang.com/documentation/at-rules/import) is encountered.
* It can either be a single {@link LegacyImporter} function, or an array of
* {@link LegacyImporter}s.
*
* Importers take the URL of the `@import` or `@use` rule and return a {@link
* LegacyImporterResult} indicating how to handle that rule. For more details,
* see {@link LegacySyncImporter} and {@link LegacyAsyncImporter}.
*
* Loads are resolved by trying, in order:
*
* * Loading a file from disk relative to the file in which the `@use` or
* `@import` appeared.
*
* * Each custom importer.
*
* * Loading a file relative to the current working directory.
*
* * Each load path in {@link includePaths}.
*
* * Each load path specified in the `SASS_PATH` environment variable, which
* should be semicolon-separated on Windows and colon-separated elsewhere.
*
* @example
*
* ```js
* sass.render({
* file: "style.scss",
* importer: [
* // This importer uses the synchronous API, and can be passed to either
* // renderSync() or render().
* function(url, prev) {
* // This generates a stylesheet from scratch for `@use "big-headers"`.
* if (url != "big-headers") return null;
*
* return {
* contents: `
* h1 {
* font-size: 40px;
* }`
* };
* },
*
* // This importer uses the asynchronous API, and can only be passed to
* // render().
* function(url, prev, done) {
* // Convert `@use "foo/bar"` to "node_modules/foo/sass/bar".
* const components = url.split('/');
* const innerPath = components.slice(1).join('/');
* done({
* file: `node_modules/${components.first}/sass/${innerPath}`
* });
* }
* ]
* }, function(err, result) {
* // ...
* });
* ```
*
* @category Plugins
* @compatibility dart: true, node: "3.0.0"
*
* Versions of Node Sass before 3.0.0 don’t support arrays of importers, nor
* do they support importers that return `Error` objects.
*
* Versions of Node Sass before 2.0.0 don’t support the `importer` option at
* all.
*
* @compatibility feature: "Import order", dart: "1.20.2", node: false
*
* Versions of Dart Sass before 1.20.2 preferred resolving imports using
* {@link includePaths} before resolving them using custom importers.
*
* All versions of Node Sass currently pass imports to importers before
* loading them relative to the file in which the `@import` appears. This
* behavior is considered incorrect and should not be relied on because it
* violates the principle of *locality*, which says that it should be possible
* to reason about a stylesheet without knowing everything about how the
* entire system is set up. If a user tries to import a stylesheet relative to
* another stylesheet, that import should *always* work. It shouldn’t be
* possible for some configuration somewhere else to break it.
*/
importer?: LegacyImporter<sync> | LegacyImporter<sync>[];
/**
* Additional built-in Sass functions that are available in all stylesheets.
* This option takes an object whose keys are Sass function signatures and
* whose values are {@link LegacyFunction}s. Each function should take the
* same arguments as its signature.
*
* Functions are passed subclasses of {@link LegacyValue}, and must return the
* same.
*
* **Heads up!** When writing custom functions, it’s important to ensure that
* all the arguments are the types you expect. Otherwise, users’ stylesheets
* could crash in hard-to-debug ways or, worse, compile to meaningless CSS.
*
* @example
*
* ```js
* sass.render({
* data: `
* h1 {
* font-size: pow(2, 5) * 1px;
* }`,
* functions: {
* // This function uses the synchronous API, and can be passed to either
* // renderSync() or render().
* 'pow($base, $exponent)': function(base, exponent) {
* if (!(base instanceof sass.types.Number)) {
* throw "$base: Expected a number.";
* } else if (base.getUnit()) {
* throw "$base: Expected a unitless number.";
* }
*
* if (!(exponent instanceof sass.types.Number)) {
* throw "$exponent: Expected a number.";
* } else if (exponent.getUnit()) {
* throw "$exponent: Expected a unitless number.";
* }
*
* return new sass.types.Number(
* Math.pow(base.getValue(), exponent.getValue()));
* },
*
* // This function uses the asynchronous API, and can only be passed to
* // render().
* 'sqrt($number)': function(number, done) {
* if (!(number instanceof sass.types.Number)) {
* throw "$number: Expected a number.";
* } else if (number.getUnit()) {
* throw "$number: Expected a unitless number.";
* }
*
* done(new sass.types.Number(Math.sqrt(number.getValue())));
* }
* }
* }, function(err, result) {
* console.log(result.css.toString());
* // h1 {
* // font-size: 32px;
* // }
* });
* ```
*
* @category Plugins
*/
functions?: {[key: string]: LegacyFunction<sync>};
/**
* By default, if the CSS document contains non-ASCII characters, Sass adds a
* `@charset` declaration (in expanded output mode) or a byte-order mark (in
* compressed mode) to indicate its encoding to browsers or other consumers.
* If `charset` is `false`, these annotations are omitted.
*
* @category Output
* @compatibility dart: "1.39.0", node: false
*/
charset?: boolean;
/**
* If this option is set to `true`, Sass won’t print warnings that are caused
* by dependencies. A “dependency” is defined as any file that’s loaded
* through {@link includePaths} or {@link importer}. Stylesheets that are
* imported relative to the entrypoint are not considered dependencies.
*
* This is useful for silencing deprecation warnings that you can’t fix on
* your own. However, please <em>also</em> notify your dependencies of the deprecations
* so that they can get fixed as soon as possible!
*
* **Heads up!** If {@link render} or {@link renderSync} is called without
* {@link LegacyFileOptions.file} or {@link LegacyStringOptions.file},
* <em>all</em> stylesheets it loads will be considered dependencies. Since it
* doesn’t have a path of its own, everything it loads is coming from a load
* path rather than a relative import.
*
* @defaultValue `false`
* @category Messages
* @compatibility dart: "1.35.0", node: false
*/
quietDeps?: boolean;
/**
* By default, Dart Sass will print only five instances of the same
* deprecation warning per compilation to avoid deluging users in console
* noise. If you set `verbose` to `true`, it will instead print every
* deprecation warning it encounters.
*
* @defaultValue `false`
* @category Messages
* @compatibility dart: "1.35.0", node: false
*/
verbose?: boolean;
/**
* An object to use to handle warnings and/or debug messages from Sass.
*
* By default, Sass emits warnings and debug messages to standard error, but
* if {@link Logger.warn} or {@link Logger.debug} is set, this will invoke
* them instead.
*
* The special value {@link Logger.silent} can be used to easily silence all
* messages.
*
* @category Messages
* @compatibility dart: "1.43.0", node: false
*/
logger?: Logger;
}
/**
* If {@link file} is passed without {@link data}, Sass will load the stylesheet
* at {@link file} and compile it to CSS.
*
* @typeParam sync - This lets the TypeScript checker verify that {@link
* LegacyAsyncImporter}s and {@link LegacyAsyncFunction}s aren't passed to
* {@link renderSync}.
*/
export interface LegacyFileOptions<sync extends 'sync' | 'async'>
extends LegacySharedOptions<sync> {
/**
* The path to the file for Sass to load and compile. If the file’s extension
* is `.scss`, it will be parsed as SCSS; if it’s `.sass`, it will be parsed
* as the indented syntax; and if it’s `.css`, it will be parsed as plain CSS.
* If it has no extension, it will be parsed as SCSS.
*
* @example
*
* ```js
* sass.renderSync({file: "style.scss"});
* ```
*
* @category Input
* @compatibility feature: "Plain CSS files", dart: "1.11.0", node: "partial"
*
* Node Sass and older versions of Dart Sass support loading files with the
* extension `.css`, but contrary to the specification they’re treated as SCSS
* files rather than being parsed as CSS. This behavior has been deprecated
* and should not be relied on. Any files that use Sass features should use
* the `.scss` extension.
*
* All versions of Node Sass and Dart Sass otherwise support the file option
* as described below.
*/
file: string;
/**
* See {@link LegacyStringOptions.file} for documentation of passing {@link
* file} along with {@link data}.
*
* @category Input
*/
data?: never;
}
/**
* If {@link data} is passed, Sass will use it as the contents of the stylesheet
* to compile.
*
* @typeParam sync - This lets the TypeScript checker verify that {@link
* LegacyAsyncImporter}s and {@link LegacyAsyncFunction}s aren't passed to
* {@link renderSync}.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link StringOptions} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export interface LegacyStringOptions<sync extends 'sync' | 'async'>
extends LegacySharedOptions<sync> {
/**
* The contents of the stylesheet to compile. Unless {@link file} is passed as
* well, the stylesheet’s URL is set to `"stdin"`.
*
* By default, this stylesheet is parsed as SCSS. This can be controlled using
* {@link indentedSyntax}.
*
* @example
*
* ```js
* sass.renderSync({
* data: `
* h1 {
* font-size: 40px;
* }`
* });
* ```
*
* @category Input
*/
data: string;
/**
* If `file` and {@link data} are both passed, `file` is used as the path of
* the stylesheet for error reporting, but {@link data} is used as the
* contents of the stylesheet. In this case, `file`’s extension is not used to
* determine the syntax of the stylesheet.
*
* @category Input
*/
file?: string;
/**
* This flag controls whether {@link data} is parsed as the indented syntax or
* not.
*
* @example
*
* ```js
* sass.renderSync({
* data: `
* h1
* font-size: 40px`,
* indentedSyntax: true
* });
* ```
*
* @defaultValue `false`
* @category Input
*/
indentedSyntax?: boolean;
}
/**
* Options for {@link render} and {@link renderSync}. This can either be {@link
* LegacyFileOptions} to load a file from disk, or {@link LegacyStringOptions}
* to compile a string of Sass code.
*
* See {@link LegacySharedOptions} for options that are shared across both file
* and string inputs.
*
* @category Legacy
* @deprecated This only works with the legacy {@link render} and {@link
* renderSync} APIs. Use {@link Options} with {@link compile}, {@link
* compileString}, {@link compileAsync}, and {@link compileStringAsync} instead.
*/
export type LegacyOptions<sync extends 'sync' | 'async'> =
| LegacyFileOptions<sync>
| LegacyStringOptions<sync>;

74
node_modules/sass/types/legacy/plugin_this.d.ts generated vendored Normal file
View File

@ -0,0 +1,74 @@
/**
* The value of `this` in the context of a {@link LegacyImporter} or {@link
* LegacyFunction} callback.
*
* @category Legacy
* @deprecated This is only used by the legacy {@link render} and {@link
* renderSync} APIs. Use {@link compile}, {@link compileString}, {@link
* compileAsync}, and {@link compileStringAsync} instead.
*/
export interface LegacyPluginThis {
/**
* A partial representation of the options passed to {@link render} or {@link
* renderSync}.
*/
options: {
/** The same {@link LegacyPluginThis} instance that contains this object. */
context: LegacyPluginThis;
/**
* The value passed to {@link LegacyFileOptions.file} or {@link
* LegacyStringOptions.file}.
*/
file?: string;
/** The value passed to {@link LegacyStringOptions.data}. */
data?: string;
/**
* The value passed to {@link LegacySharedOptions.includePaths} separated by
* `";"` on Windows or `":"` on other operating systems. This always
* includes the current working directory as the first entry.
*/
includePaths: string;
/** Always the number 10. */
precision: 10;
/** Always the number 1. */
style: 1;
/** 1 if {@link LegacySharedOptions.indentType} was `"tab"`, 0 otherwise. */
indentType: 1 | 0;
/**
* The value passed to {@link LegacySharedOptions.indentWidth}, or `2`
* otherwise.
*/
indentWidth: number;
/**
* The value passed to {@link LegacySharedOptions.linefeed}, or `"\n"`
* otherwise.
*/
linefeed: '\r' | '\r\n' | '\n' | '\n\r';
/** A partially-constructed {@link LegacyResult} object. */
result: {
/** Partial information about the compilation in progress. */
stats: {
/**
* The number of milliseconds between 1 January 1970 at 00:00:00 UTC and
* the time at which Sass compilation began.
*/
start: number;
/**
* {@link LegacyFileOptions.file} if it was passed, otherwise the string
* `"data"`.
*/
entry: string;
};
};
};
}

139
node_modules/sass/types/legacy/render.d.ts generated vendored Normal file
View File

@ -0,0 +1,139 @@
import {LegacyException} from './exception';
import {LegacyOptions} from './options';
/**
* The object returned by {@link render} and {@link renderSync} after a
* successful compilation.
*
* @category Legacy
* @deprecated This is only used by the legacy {@link render} and {@link
* renderSync} APIs. Use {@link compile}, {@link compileString}, {@link
* compileAsync}, and {@link compileStringAsync} instead.
*/
export interface LegacyResult {
/**
* The compiled CSS. This can be converted to a string by calling
* [Buffer.toString](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end).
*
* @example
*
* ```js
* const result = sass.renderSync({file: "style.scss"});
*
* console.log(result.css.toString());
* ```
*/
css: Buffer;
/**
* The source map that maps the compiled CSS to the source files from which it
* was generated. This can be converted to a string by calling
* [Buffer.toString](https://nodejs.org/api/buffer.html#buffer_buf_tostring_encoding_start_end).
*
* This is `undefined` unless either
*
* * {@link LegacySharedOptions.sourceMap} is a string; or
* * {@link LegacySharedOptions.sourceMap} is `true` and
* {@link LegacySharedOptions.outFile} is set.
*
* The source map uses absolute [`file:`
* URLs](https://en.wikipedia.org/wiki/File_URI_scheme) to link to the Sass
* source files, except if the source file comes from {@link
* LegacyStringOptions.data} in which case it lists its URL as `"stdin"`.
*
* @example
*
* ```js
* const result = sass.renderSync({
* file: "style.scss",
* sourceMap: true,
* outFile: "style.css"
* })
*
* console.log(result.map.toString());
* ```
*/
map?: Buffer;
/** Additional information about the compilation. */
stats: {
/**
* The absolute path of {@link LegacyFileOptions.file} or {@link
* LegacyStringOptions.file}, or `"data"` if {@link
* LegacyStringOptions.file} wasn't set.
*/
entry: string;
/**
* The number of milliseconds between 1 January 1970 at 00:00:00 UTC and the
* time at which Sass compilation began.
*/
start: number;
/**
* The number of milliseconds between 1 January 1970 at 00:00:00 UTC and the
* time at which Sass compilation ended.
*/
end: number;
/**
* The number of milliseconds it took to compile the Sass file. This is
* always equal to `start` minus `end`.
*/
duration: number;
/**
* An array of the absolute paths of all Sass files loaded during
* compilation. If a stylesheet was loaded from a {@link LegacyImporter}
* that returned the stylesheet’s contents, the raw string of the `@use` or
* `@import` that loaded that stylesheet included in this array.
*/
includedFiles: string[];
};
}
/**
* This function synchronously compiles a Sass file to CSS. If it succeeds, it
* returns the result, and if it fails it throws an error.
*
* @example
*
* ```js
* const sass = require('sass'); // or require('node-sass');
*
* const result = sass.renderSync({file: "style.scss"});
* // ...
* ```
*
* @category Legacy
* @deprecated Use {@link compile} or {@link compileString} instead.
*/
export function renderSync(options: LegacyOptions<'sync'>): LegacyResult;
/**
* This function asynchronously compiles a Sass file to CSS, and calls
* `callback` with a {@link LegacyResult} if compilation succeeds or {@link
* LegacyException} if it fails.
*
* **Heads up!** When using Dart Sass, **{@link renderSync} is almost twice as
* fast as {@link render}** by default, due to the overhead of making the entire
* evaluation process asynchronous.
*
* ```js
* const sass = require('sass'); // or require('node-sass');
*
* sass.render({
* file: "style.scss"
* }, function(err, result) {
* // ...
* });
* ```
*
* @category Legacy
* @deprecated Use {@link compileAsync} or {@link compileStringAsync} instead.
*/
export function render(
options: LegacyOptions<'async'>,
callback: (exception?: LegacyException, result?: LegacyResult) => void
): void;

94
node_modules/sass/types/logger/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,94 @@
import {SourceSpan} from './source_span';
export {SourceLocation} from './source_location';
export {SourceSpan} from './source_span';
/**
* An object that can be passed to {@link LegacySharedOptions.logger} to control
* how Sass emits warnings and debug messages.
*
* @example
*
* ```js
* const fs = require('fs');
* const sass = require('sass');
*
* let log = "";
* sass.renderSync({
* file: 'input.scss',
* logger: {
* warn(message, options) {
* if (options.span) {
* log += `${span.url}:${span.start.line}:${span.start.column}: ` +
* `${message}\n`;
* } else {
* log += `::: ${message}\n`;
* }
* }
* }
* });
*
* fs.writeFileSync('log.txt', log);
* ```
*
* @category Logger
*/
export interface Logger {
/**
* This method is called when Sass emits a warning, whether due to a [`@warn`
* rule](https://sass-lang.com/documentation/at-rules/warn) or a warning
* generated by the Sass compiler.
*
* If this is `undefined`, Sass will print warnings to standard error.
*
* @param message - The warning message.
* @param options.deprecation - Whether this is a deprecation warning.
* @param options.span - The location in the Sass source code that generated this
* warning.
* @param options.stack - The Sass stack trace at the point the warning was issued.
*/
warn?(
message: string,
options: {
deprecation: boolean;
span?: SourceSpan;
stack?: string;
}
): void;
/**
* This method is called when Sass emits a debug message due to a [`@debug`
* rule](https://sass-lang.com/documentation/at-rules/debug).
*
* If this is `undefined`, Sass will print debug messages to standard error.
*
* @param message - The debug message.
* @param options.span - The location in the Sass source code that generated this
* debug message.
*/
debug?(message: string, options: {span: SourceSpan}): void;
}
/**
* A namespace for built-in {@link Logger}s.
*
* @category Logger
* @compatibility dart: "1.43.0", node: false
*/
export namespace Logger {
/**
* A {@link Logger} that silently ignores all warnings and debug messages.
*
* @example
*
* ```js
* const sass = require('sass');
*
* const result = sass.renderSync({
* file: 'input.scss',
* logger: sass.Logger.silent,
* });
* ```
*/
export const silent: Logger;
}

21
node_modules/sass/types/logger/source_location.d.ts generated vendored Normal file
View File

@ -0,0 +1,21 @@
/**
* A specific location within a source file.
*
* This is always associated with a {@link SourceSpan} which indicates *which*
* file it refers to.
*
* @category Logger
*/
export interface SourceLocation {
/**
* The 0-based index of this location within its source file, in terms of
* UTF-16 code units.
*/
offset: number;
/** The 0-based line number of this location. */
line: number;
/** The 0-based column number of this location. */
column: number;
}

34
node_modules/sass/types/logger/source_span.d.ts generated vendored Normal file
View File

@ -0,0 +1,34 @@
import {SourceLocation} from './source_location';
/**
* A span of text within a source file.
*
* @category Logger
*/
export interface SourceSpan {
/** The beginning of this span, inclusive. */
start: SourceLocation;
/**
* The end of this span, exclusive.
*
* If {@link start} and {@link end} refer to the same location, the span has
* zero length and refers to the point immediately after {@link start} and
* before the next character.
*/
end: SourceLocation;
/** The canonical URL of the file this span refers to. */
url?: URL;
/** The text covered by the span. */
text: string;
/**
* Text surrounding the span.
*
* If this is set, it must include only whole lines, and it must include at
* least all line(s) which are partially covered by this span.
*/
context?: string;
}

439
node_modules/sass/types/options.d.ts generated vendored Normal file
View File

@ -0,0 +1,439 @@
import {FileImporter, Importer} from './importer';
import {Logger} from './logger';
import {Value} from './value';
import {PromiseOr} from './util/promise_or';
/**
* Syntaxes supported by Sass:
*
* - `'scss'` is the [SCSS
* syntax](https://sass-lang.com/documentation/syntax#scss).
* - `'indented'` is the [indented
* syntax](https://sass-lang.com/documentation/syntax#the-indented-syntax)
* - `'css'` is plain CSS, which is parsed like SCSS but forbids the use of any
* special Sass features.
*
* @category Options
*/
export type Syntax = 'scss' | 'indented' | 'css';
/**
* Possible output styles for the compiled CSS:
*
* - `"expanded"` (the default for Dart Sass) writes each selector and
* declaration on its own line.
*
* - `"compressed"` removes as many extra characters as possible, and writes
* the entire stylesheet on a single line.
*
* @category Options
*/
export type OutputStyle = 'expanded' | 'compressed';
/**
* A callback that implements a custom Sass function. This can be passed to
* {@link Options.functions}.
*
* ```js
* const result = sass.compile('style.scss', {
* functions: {
* "sum($arg1, $arg2)": (args) => {
* const arg1 = args[0].assertNumber('arg1');
* const value1 = arg1.value;
* const value2 = args[1].assertNumber('arg2')
* .convertValueToMatch(arg1, 'arg2', 'arg1');
* return new sass.SassNumber(value1 + value2).coerceToMatch(arg1);
* }
* }
* });
* ```
*
* @typeParam sync - A `CustomFunction<'sync'>` must return synchronously, but
* in return it can be passed to {@link compile} and {@link compileString} in
* addition to {@link compileAsync} and {@link compileStringAsync}.
*
* A `CustomFunction<'async'>` may either return synchronously or
* asynchronously, but it can only be used with {@link compileAsync} and {@link
* compileStringAsync}.
*
* @param args - An array of arguments passed by the function's caller. If the
* function takes [arbitrary
* arguments](https://sass-lang.com/documentation/at-rules/function#taking-arbitrary-arguments),
* the last element will be a {@link SassArgumentList}.
*
* @returns The function's result. This may be in the form of a `Promise`, but
* if it is the function may only be passed to {@link compileAsync} and {@link
* compileStringAsync}, not {@link compile} or {@link compileString}.
*
* @throws any - This function may throw an error, which the Sass compiler will
* treat as the function call failing. 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 custom
* functions to throw plain strings.
*
* @category Custom Function
*/
export type CustomFunction<sync extends 'sync' | 'async'> = (
args: Value[]
) => PromiseOr<Value, sync>;
/**
* Options that can be passed to {@link compile}, {@link compileAsync}, {@link
* compileString}, or {@link compileStringAsync}.
*
* @typeParam sync - This lets the TypeScript checker verify that asynchronous
* {@link Importer}s, {@link FileImporter}s, and {@link CustomFunction}s aren't
* passed to {@link compile} or {@link compileString}.
*
* @category Options
*/
export interface Options<sync extends 'sync' | 'async'> {
/**
* If this is `true`, the compiler will exclusively use ASCII characters in
* its error and warning messages. Otherwise, it may use non-ASCII Unicode
* characters as well.
*
* @defaultValue `false`
* @category Messages
*/
alertAscii?: boolean;
/**
* If this is `true`, the compiler will use ANSI color escape codes in its
* error and warning messages. If it's `false`, it won't use these. If it's
* undefined, the compiler will determine whether or not to use colors
* depending on whether the user is using an interactive terminal.
*
* @category Messages
*/
alertColor?: boolean;
/**
* If `true`, the compiler may prepend `@charset "UTF-8";` or U+FEFF
* (byte-order marker) if it outputs non-ASCII CSS.
*
* If `false`, the compiler never emits these byte sequences. This is ideal
* when concatenating or embedding in HTML `<style>` tags. (The output will
* still be UTF-8.)
*
* @defaultValue `true`
* @category Output
* @compatibility dart: "1.54.0", node: false
*/
charset?: boolean;
/**
* Additional built-in Sass functions that are available in all stylesheets.
* This option takes an object whose keys are Sass function signatures like
* you'd write for the [`@function
* rule`](https://sass-lang.com/documentation/at-rules/function) and whose
* values are {@link CustomFunction}s.
*
* Functions are passed subclasses of {@link Value}, and must return the same.
* If the return value includes {@link SassCalculation}s they will be
* simplified before being returned.
*
* When writing custom functions, it's important to make them as user-friendly
* and as close to the standards set by Sass's core functions as possible. Some
* good guidelines to follow include:
*
* * Use `Value.assert*` methods, like {@link Value.assertString}, to cast
* untyped `Value` objects to more specific types. For values that were
* passed directly as arguments, pass in the argument name as well. This
* ensures that the user gets good error messages when they pass in the
* wrong type to your function.
*
* * Individual classes may have more specific `assert*` methods, like {@link
* SassNumber.assertInt}, which should be used when possible.
*
* * In Sass, every value counts as a list. Rather than trying to detect the
* {@link SassList} type, you should use {@link Value.asList} to treat all
* values as lists.
*
* * When manipulating values like lists, strings, and numbers that have
* metadata (comma versus space separated, bracketed versus unbracketed,
* quoted versus unquoted, units), the output metadata should match the
* input metadata.
*
* * When in doubt, lists should default to comma-separated, strings should
* default to quoted, and numbers should default to unitless.
*
* * In Sass, lists and strings use one-based indexing and use negative
* indices to index from the end of value. Functions should follow these
* conventions. {@link Value.sassIndexToListIndex} and {@link
* SassString.sassIndexToStringIndex} can be used to do this automatically.
*
* * String indexes in Sass 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, `"a😊b".charCodeAt(1)` returns `0xD83D`, whereas in Sass
* `str-slice("a😊b", 1, 1)` returns `"😊"`. Functions should follow Sass's
* convention. {@link SassString.sassIndexToStringIndex} can be used to do
* this automatically, and the {@link SassString.sassLength} getter can be
* used to access a string's length in code points.
*
* @example
*
* ```js
* sass.compileString(`
* h1 {
* font-size: pow(2, 5) * 1px;
* }`, {
* functions: {
* // Note: in real code, you should use `math.pow()` from the built-in
* // `sass:math` module.
* 'pow($base, $exponent)': function(args) {
* const base = args[0].assertNumber('base').assertNoUnits('base');
* const exponent =
* args[1].assertNumber('exponent').assertNoUnits('exponent');
*
* return new sass.SassNumber(Math.pow(base.value, exponent.value));
* }
* }
* });
* ```
*
* @category Plugins
*/
functions?: Record<string, CustomFunction<sync>>;
/**
* Custom importers that control how Sass resolves loads from rules like
* [`@use`](https://sass-lang.com/documentation/at-rules/use) and
* [`@import`](https://sass-lang.com/documentation/at-rules/import).
*
* Loads are resolved by trying, in order:
*
* - The importer that was used to load the current stylesheet, with the
* loaded URL resolved relative to the current stylesheet's canonical URL.
*
* - Each {@link Importer} or {@link FileImporter} in {@link importers}, in
* order.
*
* - Each load path in {@link loadPaths}, in order.
*
* If none of these return a Sass file, the load fails and Sass throws an
* error.
*
* @category Plugins
*/
importers?: (Importer<sync> | FileImporter<sync>)[];
/**
* Paths in which to look for stylesheets loaded by rules like
* [`@use`](https://sass-lang.com/documentation/at-rules/use) and
* [`@import`](https://sass-lang.com/documentation/at-rules/import).
*
* A load path `loadPath` is equivalent to the following {@link FileImporter}:
*
* ```js
* {
* findFileUrl(url) {
* // Load paths only support relative URLs.
* if (/^[a-z]+:/i.test(url)) return null;
* return new URL(url, pathToFileURL(loadPath));
* }
* }
* ```
*
* @category Input
*/
loadPaths?: string[];
/**
* An object to use to handle warnings and/or debug messages from Sass.
*
* By default, Sass emits warnings and debug messages to standard error, but
* if {@link Logger.warn} or {@link Logger.debug} is set, this will invoke
* them instead.
*
* The special value {@link Logger.silent} can be used to easily silence all
* messages.
*
* @category Messages
*/
logger?: Logger;
/**
* If this option is set to `true`, Sass won’t print warnings that are caused
* by dependencies. A “dependency” is defined as any file that’s loaded
* through {@link loadPaths} or {@link importers}. Stylesheets that are
* imported relative to the entrypoint are not considered dependencies.
*
* This is useful for silencing deprecation warnings that you can’t fix on
* your own. However, please <em>also</em> notify your dependencies of the deprecations
* so that they can get fixed as soon as possible!
*
* **Heads up!** If {@link compileString} or {@link compileStringAsync} is
* called without {@link StringOptionsWithoutImporter.url}, <em>all</em>
* stylesheets it loads will be considered dependencies. Since it doesn’t have
* a path of its own, everything it loads is coming from a load path rather
* than a relative import.
*
* @defaultValue `false`
* @category Messages
*/
quietDeps?: boolean;
/**
* Whether or not Sass should generate a source map. If it does, the source
* map will be available as {@link CompileResult.sourceMap}.
*
* **Heads up!** Sass doesn't automatically add a `sourceMappingURL` comment
* to the generated CSS. It's up to callers to do that, since callers have
* full knowledge of where the CSS and the source map will exist in relation
* to one another and how they'll be served to the browser.
*
* @defaultValue `false`
* @category Output
*/
sourceMap?: boolean;
/**
* Whether Sass should include the sources in the generated source map.
*
* This option has no effect if {@link sourceMap} is `false`.
*
* @defaultValue `false`
* @category Output
*/
sourceMapIncludeSources?: boolean;
/**
* The {@link OutputStyle} of the compiled CSS.
*
* @example
*
* ```js
* const source = `
* h1 {
* font-size: 40px;
* code {
* font-face: Roboto Mono;
* }
* }`;
*
* let result = sass.compileString(source, {style: "expanded"});
* console.log(result.css.toString());
* // h1 {
* // font-size: 40px;
* // }
* // h1 code {
* // font-face: Roboto Mono;
* // }
*
* result = sass.compileString(source, {style: "compressed"})
* console.log(result.css.toString());
* // h1{font-size:40px}h1 code{font-face:Roboto Mono}
* ```
*
* @category Output
*/
style?: OutputStyle;
/**
* By default, Dart Sass will print only five instances of the same
* deprecation warning per compilation to avoid deluging users in console
* noise. If you set `verbose` to `true`, it will instead print every
* deprecation warning it encounters.
*
* @defaultValue `false`
* @category Messages
*/
verbose?: boolean;
}
/**
* Options that can be passed to {@link compileString} or {@link
* compileStringAsync}.
*
* If the {@link StringOptionsWithImporter.importer} field isn't passed, the
* entrypoint file can load files relative to itself if a `file://` URL is
* passed to the {@link url} field.
*
* @typeParam sync - This lets the TypeScript checker verify that asynchronous
* {@link Importer}s, {@link FileImporter}s, and {@link CustomFunction}s aren't
* passed to {@link compile} or {@link compileString}.
*
* @category Options
*/
export interface StringOptionsWithoutImporter<sync extends 'sync' | 'async'>
extends Options<sync> {
/**
* The {@link Syntax} to use to parse the entrypoint stylesheet.
*
* @default `'scss'`
*
* @category Input
*/
syntax?: Syntax;
/**
* The canonical URL of the entrypoint stylesheet.
*
* A relative load's URL is first resolved relative to {@link url}, then
* resolved to a file on disk if it's a `file://` URL. If it can't be resolved
* to a file on disk, it's then passed to {@link importers} and {@link
* loadPaths}.
*
* @category Input
*/
url?: URL;
}
/**
* Options that can be passed to {@link compileString} or {@link
* compileStringAsync}.
*
* If the {@link StringOptionsWithImporter.importer} field is passed, the
* entrypoint file uses it to load files relative to itself and the {@link url}
* field is mandatory.
*
* @typeParam sync - This lets the TypeScript checker verify that asynchronous
* {@link Importer}s, {@link FileImporter}s, and {@link CustomFunction}s aren't
* passed to {@link compile} or {@link compileString}.
*
* @category Options
*/
export interface StringOptionsWithImporter<sync extends 'sync' | 'async'>
extends StringOptionsWithoutImporter<sync> {
/**
* The importer to use to handle loads that are relative to the entrypoint
* stylesheet.
*
* A relative load's URL is first resolved relative to {@link url}, then
* passed to {@link importer}. If the importer doesn't recognize it, it's then
* passed to {@link importers} and {@link loadPaths}.
*
* @category Input
*/
importer: Importer<sync> | FileImporter<sync>;
/**
* The canonical URL of the entrypoint stylesheet. If this is passed along
* with {@link importer}, it's used to resolve relative loads in the
* entrypoint stylesheet.
*
* @category Input
*/
url: URL;
}
/**
* Options that can be passed to {@link compileString} or {@link
* compileStringAsync}.
*
* This is a {@link StringOptionsWithImporter} if it has a {@link
* StringOptionsWithImporter.importer} field, and a {@link
* StringOptionsWithoutImporter} otherwise.
*
* @typeParam sync - This lets the TypeScript checker verify that asynchronous
* {@link Importer}s, {@link FileImporter}s, and {@link CustomFunction}s aren't
* passed to {@link compile} or {@link compileString}.
*
* @category Options
*/
export type StringOptions<sync extends 'sync' | 'async'> =
| StringOptionsWithImporter<sync>
| StringOptionsWithoutImporter<sync>;

17
node_modules/sass/types/util/promise_or.d.ts generated vendored Normal file
View File

@ -0,0 +1,17 @@
/**
* A utility type for choosing between synchronous and asynchronous return
* values.
*
* This is used as the return value for plugins like {@link CustomFunction},
* {@link Importer}, and {@link FileImporter} so that TypeScript enforces that
* asynchronous plugins are only passed to {@link compileAsync} and {@link
* compileStringAsync}, not {@link compile} or {@link compileString}.
*
* @typeParam sync - If this is `'sync'`, this can only be a `T`. If it's
* `'async'`, this can be either a `T` or a `Promise<T>`.
*
* @category Other
*/
export type PromiseOr<T, sync extends 'sync' | 'async'> = sync extends 'async'
? T | Promise<T>
: T;

47
node_modules/sass/types/value/argument_list.d.ts generated vendored Normal file
View File

@ -0,0 +1,47 @@
import {List, OrderedMap} from 'immutable';
import {Value} from './index';
import {SassList, ListSeparator} from './list';
/**
* Sass's [argument list
* type](https://sass-lang.com/documentation/values/lists#argument-lists).
*
* An argument list comes from a rest argument. It's distinct from a normal
* {@link SassList} in that it may contain a keyword map as well as the
* positional arguments.
*
* @category Custom Function
*/
export class SassArgumentList extends SassList {
/**
* Creates a new argument list.
*
* @param contents - The positional arguments that make up the primary
* contents of the list. This may be either a plain JavaScript array or an
* immutable {@link List} from the [`immutable`
* package](https://immutable-js.com/).
*
* @param 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 {@link OrderedMap}
* from the [`immutable` package](https://immutable-js.com/)
*
* @param separator - The separator for this list. Defaults to `','`.
*/
constructor(
contents: Value[] | List<Value>,
keywords: Record<string, Value> | OrderedMap<string, Value>,
separator?: ListSeparator
);
/**
* The keyword arguments attached to this argument list.
*
* The argument names don't include `$`.
*
* @returns An immutable {@link OrderedMap} from the [`immutable`
* package](https://immutable-js.com/).
*/
get keywords(): OrderedMap<string, Value>;
}

29
node_modules/sass/types/value/boolean.d.ts generated vendored Normal file
View File

@ -0,0 +1,29 @@
import {Value} from './index';
/**
* Sass's [`true` value](https://sass-lang.com/documentation/values/booleans).
*
* @category Custom Function
*/
export const sassTrue: SassBoolean;
/**
* Sass's [`false` value](https://sass-lang.com/documentation/values/booleans).
*
* @category Custom Function
*/
export const sassFalse: SassBoolean;
/**
* Sass's [boolean type](https://sass-lang.com/documentation/values/booleans).
*
* @category Custom Function
*/
export class SassBoolean extends Value {
private constructor();
/**
* Whether this value is `true` or `false`.
*/
get value(): boolean;
}

137
node_modules/sass/types/value/calculation.d.ts generated vendored Normal file
View File

@ -0,0 +1,137 @@
import {List, ValueObject} from 'immutable';
import {Value, SassNumber, SassString} from './index';
/**
* The type of values that can be arguments to a {@link SassCalculation}.
* @category Custom Function
* */
export type CalculationValue =
| SassNumber
| SassCalculation
| SassString
| CalculationOperation
| CalculationInterpolation;
/**
* Sass's [calculation
* type](https://sass-lang.com/documentation/values/calculations).
*
* Note: in the JS API calculations are not simplified eagerly. This also means
* that unsimplified calculations are not equal to the numbers they would be
* simplified to.
*
* @category Custom Function
*/
export class SassCalculation extends Value {
/**
* Creates a value that represents `calc(argument)`.
*
* @throws `Error` if `argument` is a quoted {@link SassString}
* @returns A calculation with the name `calc` and `argument` as its single
* argument.
*/
static calc(argument: CalculationValue): SassCalculation;
/**
* Creates a value that represents `min(arguments...)`.
*
* @throws `Error` if `arguments` contains a quoted {@link SassString}
* @returns A calculation with the name `min` and `arguments` as its
* arguments.
*/
static min(
arguments: CalculationValue[] | List<CalculationValue>
): SassCalculation;
/**
* Creates a value that represents `max(arguments...)`.
*
* @throws `Error` if `arguments` contains a quoted {@link SassString}
* @returns A calculation with the name `max` and `arguments` as its
* arguments.
*/
static max(
arguments: CalculationValue[] | List<CalculationValue>
): SassCalculation;
/**
* Creates a value that represents `clamp(value, min, max)`.
*
* @throws `Error` if any of `value`, `min`, or `max` are a quoted
* {@link 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 {@link SassString} or {@link CalculationInterpolation}.
@returns A calculation with the name `clamp` and `min`, `value`, and `max`
as it's arguments, excluding any arguments that are undefined.
*/
static clamp(
min: CalculationValue,
value?: CalculationValue,
max?: CalculationValue
): SassCalculation;
/** Returns the calculation's `name` field. */
get name(): string;
/** Returns a list of the calculation's `arguments` */
get arguments(): List<CalculationValue>;
}
/**
* The set of possible operators in a Sass calculation.
* @category Custom Function
*/
export type CalculationOperator = '+' | '-' | '*' | '/';
/**
* A binary operation that can appear in a {@link SassCalculation}.
* @category Custom Function
*/
export class CalculationOperation implements ValueObject {
/**
* Creates a Sass CalculationOperation with the given `operator`, `left`, and
* `right` values.
* @throws `Error` if `left` or `right` are quoted {@link SassString}s.
*/
constructor(
operator: CalculationOperator,
left: CalculationValue,
right: CalculationValue
);
/** Returns the operation's `operator` field. */
get operator(): CalculationOperator;
/** Returns the operation's `left` field. */
get left(): CalculationValue;
/** Returns the operation's `right` field. */
get right(): CalculationValue;
equals(other: unknown): boolean;
hashCode(): number;
}
/**
* A string injected into a {@link SassCalculation} using interpolation. Unlike
* unquoted strings, interpolations are always surrounded in parentheses when
* they appear in {@link CalculationOperation}s.
* @category Custom Function
*/
export class CalculationInterpolation implements ValueObject {
/**
* Creates a Sass CalculationInterpolation with the given `value`.
*/
constructor(value: string);
/**
* Returns the interpolation's `value` field.
*/
get value(): string;
equals(other: unknown): boolean;
hashCode(): number;
}

128
node_modules/sass/types/value/color.d.ts generated vendored Normal file
View File

@ -0,0 +1,128 @@
import {Value} from './index';
/**
* Sass's [color type](https://sass-lang.com/documentation/values/colors).
*
* No matter what representation was originally used to create this color, all
* of its channels are accessible.
*
* @category Custom Function
*/
export class SassColor extends Value {
/**
* 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(options: {
red: number;
green: number;
blue: 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(options: {
hue: number;
saturation: number;
lightness: 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`.
*/
constructor(options: {
hue: number;
whiteness: number;
blackness: number;
alpha?: number;
});
/** This color's red channel, between `0` and `255`. */
get red(): number;
/** This color's green channel, between `0` and `255`. */
get green(): number;
/** This color's blue channel, between `0` and `255`. */
get blue(): number;
/** This color's hue, between `0` and `360`. */
get hue(): number;
/** This color's saturation, between `0` and `100`. */
get saturation(): number;
/** This color's lightness, between `0` and `100`. */
get lightness(): number;
/** This color's whiteness, between `0` and `100`. */
get whiteness(): number;
/** This color's blackness, between `0` and `100`. */
get blackness(): number;
/** This color's alpha channel, between `0` and `1`. */
get alpha(): number;
/**
* Changes one or more of this color's RGB channels and returns the result.
*/
change(options: {
red?: number;
green?: number;
blue?: number;
alpha?: number;
}): SassColor;
/**
* Changes one or more of this color's HSL channels and returns the result.
*/
change(options: {
hue?: number;
saturation?: number;
lightness?: number;
alpha?: number;
}): SassColor;
/**
* Changes one or more of this color's HWB channels and returns the result.
*/
change(options: {
hue?: number;
whiteness?: number;
blackness?: number;
alpha?: number;
}): SassColor;
}

22
node_modules/sass/types/value/function.d.ts generated vendored Normal file
View File

@ -0,0 +1,22 @@
import {Value} from './index';
/**
* Sass's [function type](https://sass-lang.com/documentation/values/functions).
*
* **Heads up!** Although first-class Sass functions can be processed by custom
* functions, there's no way to invoke them outside of a Sass stylesheet.
*
* @category Custom Function
*/
export class SassFunction extends Value {
/**
* Creates a new first-class function that can be invoked using
* [`meta.call()`](https://sass-lang.com/documentation/modules/meta#call).
*
* @param signature - The function signature, like you'd write for the
* [`@function rule`](https://sass-lang.com/documentation/at-rules/function).
* @param callback - The callback that's invoked when this function is called,
* just like for a {@link CustomFunction}.
*/
constructor(signature: string, callback: (args: Value[]) => Value);
}

189
node_modules/sass/types/value/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,189 @@
import {List, ValueObject} from 'immutable';
import {SassBoolean} from './boolean';
import {SassCalculation} from './calculation';
import {SassColor} from './color';
import {SassFunction} from './function';
import {ListSeparator} from './list';
import {SassMap} from './map';
import {SassNumber} from './number';
import {SassString} from './string';
export {SassArgumentList} from './argument_list';
export {SassBoolean, sassTrue, sassFalse} from './boolean';
export {
SassCalculation,
CalculationValue,
CalculationOperator,
CalculationOperation,
CalculationInterpolation,
} from './calculation';
export {SassColor} from './color';
export {SassFunction} from './function';
export {SassList, ListSeparator} from './list';
export {SassMap} from './map';
export {SassNumber} from './number';
export {SassString} from './string';
/**
* Sass's [`null` value](https://sass-lang.com/documentation/values/null).
*
* @category Custom Function
*/
export const sassNull: Value;
/**
* The abstract base class of Sass's value types.
*
* This is passed to and returned by {@link CustomFunction}s, which are passed
* into the Sass implementation using {@link Options.functions}.
*
* @category Custom Function
*/
export abstract class Value implements ValueObject {
protected constructor();
/**
* 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 {@link List} from the [`immutable`
* package](https://immutable-js.com/).
*/
get asList(): List<Value>;
/**
* 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.
*/
get hasBrackets(): boolean;
/**
* Whether the value counts as `true` in an `@if` statement and other
* contexts.
*/
get isTruthy(): boolean;
/**
* Returns JavaScript's `null` value if this is {@link sassNull}, and returns
* `this` otherwise.
*/
get realNull(): null | Value;
/**
* 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.
*/
get separator(): ListSeparator;
/**
* Converts `sassIndex` into a JavaScript-style index into the list returned
* by {@link 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.
*
* @param sassIndex - The Sass-style index into this as a list.
* @param 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 {@link asList}.
*/
sassIndexToListIndex(sassIndex: Value, name?: string): number;
/**
* 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.
*/
get(index: number): Value | undefined;
/**
* Throws if `this` isn't a {@link SassBoolean}.
*
* **Heads up!** Functions should generally use {@link isTruthy} rather than
* requiring a literal boolean.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertBoolean(name?: string): SassBoolean;
/**
* Throws if `this` isn't a {@link SassCalculation}.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertCalculation(name?: string): SassCalculation;
/**
* Throws if `this` isn't a {@link SassColor}.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertColor(name?: string): SassColor;
/**
* Throws if `this` isn't a {@link SassFunction}.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertFunction(name?: string): SassFunction;
/**
* Throws if `this` isn't a {@link SassMap}.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertMap(name?: string): SassMap;
/**
* Throws if `this` isn't a {@link SassNumber}.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertNumber(name?: string): SassNumber;
/**
* Throws if `this` isn't a {@link SassString}.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertString(name?: string): SassString;
/**
* Returns `this` as a map if it counts as one (empty lists count as empty
* maps) or `null` if it doesn't.
*/
tryMap(): SassMap | null;
/** Returns whether `this` represents the same value as `other`. */
equals(other: Value): boolean;
/** Returns a hash code that can be used to store `this` in a hash map. */
hashCode(): number;
/** @hidden */
toString(): string;
}

54
node_modules/sass/types/value/list.d.ts generated vendored Normal file
View File

@ -0,0 +1,54 @@
import {List} from 'immutable';
import {Value} from './index';
/**
* Possible separators used by Sass lists. The special separator `null` is only
* used for lists with fewer than two elements, and indicates that the separator
* has not yet been decided for this list.
*
* @category Custom Function
*/
export type ListSeparator = ',' | '/' | ' ' | null;
/**
* Sass's [list type](https://sass-lang.com/documentation/values/lists).
*
* @category Custom Function
*/
export class SassList extends Value {
/**
* Creates a new list.
*
* @param contents - The contents of the list. This may be either a plain
* JavaScript array or an immutable {@link List} from the [`immutable`
* package](https://immutable-js.com/).
*
* @param options.separator - The separator to use between elements of this
* list. Defaults to `','`.
*
* @param options.brackets - Whether the list has square brackets. Defaults to
* `false`.
*/
constructor(
contents: Value[] | List<Value>,
options?: {
separator?: ListSeparator;
brackets?: boolean;
}
);
/**
* Creates an empty list.
*
* @param options.separator - The separator to use between elements of this
* list. Defaults to `','`.
*
* @param options.brackets - Whether the list has square brackets. Defaults to
* `false`.
*/
constructor(options?: {separator?: ListSeparator; brackets?: boolean});
/** @hidden */
get separator(): ListSeparator;
}

41
node_modules/sass/types/value/map.d.ts generated vendored Normal file
View File

@ -0,0 +1,41 @@
import {OrderedMap} from 'immutable';
import {SassList} from './list';
import {Value} from './index';
/**
* Sass's [map type](https://sass-lang.com/documentation/values/maps).
*
* @category Custom Function
*/
export class SassMap extends Value {
/**
* Creates a new map.
*
* @param contents - The contents of the map. This is an immutable
* `OrderedMap` from the [`immutable` package](https://immutable-js.com/).
* Defaults to an empty map.
*/
constructor(contents?: OrderedMap<Value, Value>);
/**
* Returns the contents of this map as an immutable {@link OrderedMap} from the
* [`immutable` package](https://immutable-js.com/).
*/
get contents(): OrderedMap<Value, Value>;
/**
* 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.
*/
get(key: Value): Value | undefined;
/** Inherited from {@link Value.get}. */
get(index: number): SassList | undefined;
/** @hidden */
tryMap(): SassMap;
}

305
node_modules/sass/types/value/number.d.ts generated vendored Normal file
View File

@ -0,0 +1,305 @@
import {List} from 'immutable';
import {Value} from './index';
/**
* Sass's [number type](https://sass-lang.com/documentation/values/numbers).
*
* @category Custom Function
*/
export class SassNumber extends Value {
/**
* 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.
*
* @param value - The number's numeric value.
*
* @param unit - If this is a string, it's used as the single numerator unit
* for the number.
*
* @param 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 {@link List} from the [`immutable`
* package](https://immutable-js.com/).
*
* @param 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 {@link List} from the [`immutable`
* package](https://immutable-js.com/).
*/
constructor(
value: number,
unit?:
| string
| {
numeratorUnits?: string[] | List<string>;
denominatorUnits?: string[] | List<string>;
}
);
/** This number's numeric value. */
get value(): number;
/** Whether {@link value} is an integer according to Sass's equality logic. */
get isInt(): boolean;
/**
* If {@link value} is an integer according to {@link isInt}, returns {@link
* value} rounded to that integer. If it's not an integer, returns `null`.
*/
get asInt(): number | null;
/**
* This number's numerator units as an immutable {@link List} from the
* [`immutable` package](https://immutable-js.com/).
*/
get numeratorUnits(): List<string>;
/**
* This number's denominator units as an immutable {@link List} from the
* [`immutable` package](https://immutable-js.com/).
*/
get denominatorUnits(): List<string>;
/** Whether this number has any numerator or denominator units. */
get hasUnits(): boolean;
/**
* If {@link value} is an integer according to {@link isInt}, returns it
* rounded to that integer. Otherwise, throws an error.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertInt(name?: string): number;
/**
* Returns {@link value} if it's within `min` and `max`. If {@link value} is
* equal to `min` or `max` according to Sass's equality, returns `min` or
* `max` respectively. Otherwise, throws an error.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertInRange(min: number, max: number, name?: string): number;
/**
* If this number has no units, returns it. Otherwise, throws an error.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertNoUnits(name?: string): SassNumber;
/**
* If this number has `unit` as its only unit (and as a numerator), returns
* this number. Otherwise, throws an error.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
assertUnit(unit: string, name?: string): SassNumber;
/** Whether this number has `unit` as its only unit (and as a numerator). */
hasUnit(unit: string): boolean;
/**
* Whether this has exactly one numerator unit, and that unit is compatible
* with `unit`.
*/
compatibleWithUnit(unit: string): boolean;
/**
* Returns a copy of this number, converted to the units represented by
* `newNumerators` and `newDenominators`.
*
* @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.
*
* @param newNumerators - The numerator units to convert this number to. This
* may be either a plain JavaScript array or an immutable {@link List} from
* the [`immutable` package](https://immutable-js.com/).
*
* @param newDenominators - The denominator units to convert this number to.
* This may be either a plain JavaScript array or an immutable {@link List}
* from the [`immutable` package](https://immutable-js.com/).
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
convert(
newNumerators: string[] | List<string>,
newDenominators: string[] | List<string>,
name?: string
): SassNumber;
/**
* Returns a copy of this number, converted to the same units as `other`.
*
* @throws `Error` if this number's units are incompatible with `other`'s
* units, or if either number is unitless but the other is not.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*
* @param otherName - The name of the function argument `other` came from
* (without the `$`) if it came from an argument. Used for error reporting.
*/
convertToMatch(
other: SassNumber,
name?: string,
otherName?: string
): SassNumber;
/**
* Returns {@link value}, converted to the units represented by
* `newNumerators` and `newDenominators`.
*
* @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.
*
* @param newNumerators - The numerator units to convert {@link value} to.
* This may be either a plain JavaScript array or an immutable {@link List}
* from the [`immutable` package](https://immutable-js.com/).
*
* @param newDenominators - The denominator units to convert {@link value} to.
* This may be either a plain JavaScript array or an immutable {@link List}
* from the [`immutable` package](https://immutable-js.com/).
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
convertValue(
newNumerators: string[] | List<string>,
newDenominators: string[] | List<string>,
name?: string
): number;
/**
* Returns {@link value}, converted to the same units as `other`.
*
* @throws `Error` if this number's units are incompatible with `other`'s
* units, or if either number is unitless but the other is not.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*
* @param otherName - The name of the function argument `other` came from
* (without the `$`) if it came from an argument. Used for error reporting.
*/
convertValueToMatch(
other: SassNumber,
name?: string,
otherName?: string
): number;
/**
* Returns a copy of this number, converted to the units represented by
* `newNumerators` and `newDenominators`.
*
* Unlike {@link 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.
*
* @throws `Error` if this number's units are incompatible with
* `newNumerators` and `newDenominators`.
*
* @param newNumerators - The numerator units to convert this number to. This
* may be either a plain JavaScript array or an immutable {@link List} from
* the [`immutable` package](https://immutable-js.com/).
*
* @param newDenominators - The denominator units to convert this number to.
* This may be either a plain JavaScript array or an immutable {@link List}
* from the [`immutable` package](https://immutable-js.com/).
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
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 {@link 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.
*
* @throws `Error` if this number's units are incompatible with `other`'s
* units.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*
* @param otherName - The name of the function argument `other` came from
* (without the `$`) if it came from an argument. Used for error reporting.
*/
coerceToMatch(
other: SassNumber,
name?: string,
otherName?: string
): SassNumber;
/**
* Returns {@link value}, converted to the units represented by
* `newNumerators` and `newDenominators`.
*
* Unlike {@link 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.
*
* @throws `Error` if this number's units are incompatible with
* `newNumerators` and `newDenominators`.
*
* @param newNumerators - The numerator units to convert {@link value} to.
* This may be either a plain JavaScript array or an immutable {@link List}
* from the [`immutable` package](https://immutable-js.com/).
*
* @param newDenominators - The denominator units to convert {@link value} to.
* This may be either a plain JavaScript array or an immutable {@link List}
* from the [`immutable` package](https://immutable-js.com/).
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*/
coerceValue(
newNumerators: string[] | List<string>,
newDenominators: string[] | List<string>,
name?: string
): number;
/**
* Returns {@link value}, converted to the units represented by
* `newNumerators` and `newDenominators`.
*
* Unlike {@link 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.
*
* @throws `Error` if this number's units are incompatible with `other`'s
* units.
*
* @param name - The name of the function argument `this` came from (without
* the `$`) if it came from an argument. Used for error reporting.
*
* @param otherName - The name of the function argument `other` came from
* (without the `$`) if it came from an argument. Used for error reporting.
*/
coerceValueToMatch(
other: SassNumber,
name?: string,
otherName?: string
): number;
}

84
node_modules/sass/types/value/string.d.ts generated vendored Normal file
View File

@ -0,0 +1,84 @@
import {Value} from './index';
/**
* Sass's [string type](https://sass-lang.com/documentation/values/strings).
*
* @category Custom Function
*/
export class SassString extends Value {
/**
* Creates a new string.
*
* @param 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.
*
* @param options.quotes - Whether the string is quoted. Defaults to `true`.
*/
constructor(
text: string,
options?: {
quotes?: boolean;
}
);
/**
* Creates an empty string.
*
* @param options.quotes - Whether the string is quoted. Defaults to `true`.
*/
constructor(options?: {quotes?: boolean});
/**
* 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.
*/
get text(): string;
/** Whether this string has quotes. */
get hasQuotes(): boolean;
/**
* 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`.
*/
get sassLength(): number;
/**
* Converts `sassIndex` to a JavaScript index into {@link 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.
*/
sassIndexToStringIndex(sassIndex: Value, name?: string): number;
}