sass-embedded-go 1.104.0-alpha0

package/lib/src/vendor/sass/value/string.d.ts

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

package/lib/src/version.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright 2024 Google LLC. Use of this source code is governed by an
+// MIT-style license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+class Version {
+    major;
+    minor;
+    patch;
+    constructor(major, minor, patch) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+    }
+    static parse(version) {
+        const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+        if (match === null) {
+            throw new Error(`Invalid version ${version}`);
+        }
+        return new Version(parseInt(match[1]), parseInt(match[2]), parseInt(match[3]));
+    }
+    toString() {
+        return `${this.major}.${this.minor}.${this.patch}`;
+    }
+}
+exports.Version = Version;
+//# sourceMappingURL=version.js.map

package/lib/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../lib/src/version.ts"],"names":[],"mappings":";AAAA,uEAAuE;AACvE,gEAAgE;AAChE,uCAAuC;;;AAIvC;IAEa,KAAK;IACL,KAAK;IACL,KAAK;IAHhB,YACW,KAAa,EACb,KAAa,EACb,KAAa;qBAFb,KAAK;qBACL,KAAK;qBACL,KAAK;IACb,CAAC;IACJ,MAAM,CAAC,KAAK,CAAC,OAAe;QAC1B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QACrD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,mBAAmB,OAAO,EAAE,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,IAAI,OAAO,CAChB,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAClB,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAClB,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CACnB,CAAC;IACJ,CAAC;IACD,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;IACrD,CAAC;CACF"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "sass-embedded-go",
+  "version": "1.104.0-alpha0",
+  "description": "sass-embedded-compatible host API backed by the go-sass embedded compiler.",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "files": ["lib/**/*", "types/**/*", "LICENSE", "README.md"],
+  "exports": {
+    "import": {
+      "types": "./types/index.m.d.ts",
+      "default": "./lib/index.mjs"
+    },
+    "types": "./types/index.d.ts",
+    "default": "./lib/index.js"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "2.13.0",
+    "colorjs.io": "0.5.2",
+    "immutable": "5.1.9",
+    "rxjs": "7.8.2",
+    "supports-color": "8.1.1",
+    "sync-child-process": "1.0.2",
+    "varint": "6.0.0"
+  },
+  "optionalDependencies": {
+    "sass-embedded-go-darwin-arm64": "1.104.0-alpha0",
+    "sass-embedded-go-darwin-x64": "1.104.0-alpha0",
+    "sass-embedded-go-linux-arm64": "1.104.0-alpha0",
+    "sass-embedded-go-linux-musl-arm64": "1.104.0-alpha0",
+    "sass-embedded-go-linux-musl-x64": "1.104.0-alpha0",
+    "sass-embedded-go-linux-x64": "1.104.0-alpha0",
+    "sass-embedded-go-win32-arm64": "1.104.0-alpha0",
+    "sass-embedded-go-win32-x64": "1.104.0-alpha0"
+  }
+}

package/types/compile.d.ts

@@ -0,0 +1,342 @@
+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;
+}
+
+/**
+ * The result of creating a synchronous compiler. Returned by
+ * {@link initCompiler}.
+ *
+ * @category Compile
+ */
+export class Compiler {
+  /**
+   * Throws an error if constructed directly, instead of via
+   * {@link initCompiler}.
+   */
+  private constructor();
+
+  /**
+   * The {@link compile} method exposed through a Compiler instance while it is
+   * active. If this is called after {@link dispose} on the Compiler
+   * instance, an error will be thrown.
+   *
+   * During the Compiler instance's lifespan, given the same input, this will
+   * return an identical result to the {@link compile} method exposed at the
+   * module root.
+   */
+  compile(path: string, options?: Options<'sync'>): CompileResult;
+
+  /**
+   * The {@link compileString} method exposed through a Compiler instance while
+   * it is active. If this is called after {@link dispose} on the Compiler
+   * instance, an error will be thrown.
+   *
+   * During the Compiler instance's lifespan, given the same input, this will
+   * return an identical result to the {@link compileString} method exposed at
+   * the module root.
+   */
+  compileString(source: string, options?: StringOptions<'sync'>): CompileResult;
+
+  /**
+   * Ends the lifespan of this Compiler instance. After this is invoked, all
+   * calls to the Compiler instance's {@link compile} or {@link compileString}
+   * methods will result in an error.
+   */
+  dispose(): void;
+}
+
+/**
+ * The result of creating an asynchronous compiler. Returned by
+ * {@link initAsyncCompiler}.
+ *
+ * @category Compile
+ */
+export class AsyncCompiler {
+  /**
+   * Throws an error if constructed directly, instead of via
+   * {@link initAsyncCompiler}.
+   */
+  private constructor();
+
+  /**
+   * The {@link compileAsync} method exposed through an Async Compiler instance
+   * while it is active. If this is called after {@link dispose} on the Async
+   * Compiler instance, an error will be thrown.
+   *
+   * During the Async Compiler instance's lifespan, given the same input, this
+   * will return an identical result to the {@link compileAsync} method exposed
+   * at the module root.
+   */
+  compileAsync(
+    path: string,
+    options?: Options<'async'>
+  ): Promise<CompileResult>;
+
+  /**
+   * The {@link compileStringAsync} method exposed through an Async Compiler
+   * instance while it is active. If this is called after {@link dispose} on the
+   * Async Compiler instance, an error will be thrown.
+   *
+   * During the Async Compiler instance's lifespan, given the same input, this
+   * will return an identical result to the {@link compileStringAsync} method
+   * exposed at the module root.
+   */
+  compileStringAsync(
+    source: string,
+    options?: StringOptions<'async'>
+  ): Promise<CompileResult>;
+
+  /**
+   * Ends the lifespan of this Async Compiler instance. After this is invoked,
+   * all subsequent calls to the Compiler instance's `compileAsync` or
+   * `compileStringAsync` methods will result in an error.
+   *
+   * Any compilations that are submitted before `dispose` will not be cancelled,
+   * and will be allowed to settle.
+   *
+   * After all compilations have been settled and Sass completes any internal
+   * task cleanup, `dispose` will resolve its promise.
+   */
+  dispose(): Promise<void>;
+}
+
+/**
+ * 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.
+ *
+ * **Heads up!** When using the [sass-embedded] npm package for single
+ * compilations, **{@link compileAsync} is almost always faster than
+ * {@link compile}**, due to the overhead of emulating synchronous messaging
+ * with worker threads and concurrent compilations being blocked on main thread.
+ *
+ * If you are running multiple compilations with the [sass-embedded] npm
+ * package, using a {@link Compiler} will provide some speed improvements over
+ * the module-level methods, and an {@link AsyncCompiler} will be much faster.
+ *
+ * [sass-embedded]: https://www.npmjs.com/package/sass-embedded
+ *
+ * @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 the `sass` npm package, **{@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.
+ *
+ * **Heads up!** When using the [sass-embedded] npm package for single
+ * compilations, **{@link compileStringAsync} is almost always faster than
+ * {@link compileString}**, due to the overhead of emulating synchronous
+ * messaging with worker threads and concurrent compilations being blocked on
+ * main thread.
+ *
+ * If you are running multiple compilations with the [sass-embedded] npm
+ * package, using a {@link Compiler} will provide some speed improvements over
+ * the module-level methods, and an {@link AsyncCompiler} will be much faster.
+ *
+ * [sass-embedded]: https://www.npmjs.com/package/sass-embedded
+ *
+ * @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 the `sass` npm package, **{@link compileString} is
+ * almost twice as fast as {@link compileStringAsync}**, 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>;
+
+/**
+ * Creates a synchronous {@link Compiler}. Each compiler instance exposes the
+ * {@link compile} and {@link compileString} methods within the lifespan of the
+ * Compiler. Given identical input, these methods will return results identical
+ * to their counterparts exposed at the module root. To use asynchronous
+ * compilation, use {@link initAsyncCompiler}.
+ *
+ * When calling the compile functions multiple times, using a compiler instance
+ * with the [sass-embedded] npm package is much faster than using the top-level
+ * compilation methods or the [sass] npm package.
+ *
+ * [sass-embedded]: https://www.npmjs.com/package/sass-embedded
+ *
+ * [sass]: https://www.npmjs.com/package/sass
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass');
+ * function setup() {
+ *   const compiler = sass.initCompiler();
+ *   const result1 = compiler.compileString('a {b: c}').css;
+ *   const result2 = compiler.compileString('a {b: c}').css;
+ *   compiler.dispose();
+ *
+ *   // throws error
+ *   const result3 = sass.compileString('a {b: c}').css;
+ * }
+ * ```
+ * @category Compile
+ * @compatibility dart: "1.70.0", node: false
+ */
+export function initCompiler(): Compiler;
+
+/**
+ * Creates an asynchronous {@link AsyncCompiler}. Each compiler
+ * instance exposes the {@link compileAsync} and {@link compileStringAsync}
+ * methods within the lifespan of the Compiler. Given identical input, these
+ * methods will return results identical to their counterparts exposed at the
+ * module root. To use synchronous compilation, use {@link initCompiler};
+ *
+ * When calling the compile functions multiple times, using a compiler instance
+ * with the [sass-embedded] npm package is much faster than using the top-level
+ * compilation methods or the [sass] npm package.
+ *
+ * [sass-embedded]: https://www.npmjs.com/package/sass-embedded
+ *
+ * [sass]: https://www.npmjs.com/package/sass
+ *
+ * @example
+ *
+ * ```js
+ * const sass = require('sass');
+ * async function setup() {
+ *   const compiler = await sass.initAsyncCompiler();
+ *   const result1 = await compiler.compileStringAsync('a {b: c}').css;
+ *   const result2 = await compiler.compileStringAsync('a {b: c}').css;
+ *   await compiler.dispose();
+ *
+ *   // throws error
+ *   const result3 = await sass.compileStringAsync('a {b: c}').css;
+ * }
+ * ```
+ * @category Compile
+ * @compatibility dart: "1.70.0", node: false
+ */
+export function initAsyncCompiler(): Promise<AsyncCompiler>;