styles-config 2.0.0-alpha.5 → 2.0.0-alpha.7

package/lib/index.cjs

@@ -0,0 +1,245 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let cosmiconfig = require("cosmiconfig");
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch);
+let path = require("path");
+path = __toESM(path);
+//#region src/loader.ts
+const explorer = (0, cosmiconfig.cosmiconfig)("styles", {
+	searchPlaces: [
+		"styles.config.ts",
+		"styles.config.js",
+		"styles.config.mts",
+		"styles.config.mjs",
+		"styles.config.cjs",
+		"styles.config.cts"
+	],
+	loaders: {
+		".mts": cosmiconfig.defaultLoadersSync[".ts"],
+		".cts": cosmiconfig.defaultLoadersSync[".ts"],
+		".mjs": cosmiconfig.defaultLoadersSync[".js"],
+		".cjs": cosmiconfig.defaultLoadersSync[".cjs"]
+	}
+});
+const explorerSync = (0, cosmiconfig.cosmiconfigSync)("styles", {
+	searchPlaces: [
+		"styles.config.ts",
+		"styles.config.js",
+		"styles.config.mts",
+		"styles.config.mjs",
+		"styles.config.cjs",
+		"styles.config.cts"
+	],
+	loaders: {
+		".mts": cosmiconfig.defaultLoadersSync[".ts"],
+		".cts": cosmiconfig.defaultLoadersSync[".ts"],
+		".mjs": cosmiconfig.defaultLoadersSync[".js"],
+		".cjs": cosmiconfig.defaultLoadersSync[".cjs"]
+	}
+});
+/**
+* Load styles configuration from the file system (async)
+* @param searchFrom - Directory to search from (defaults to process.cwd())
+* @returns Configuration object or null if not found
+*/
+async function loadConfig(searchFrom) {
+	const result = await explorer.search(searchFrom);
+	return result?.config ? normalizeConfig(result.config) : null;
+}
+/**
+* Load styles configuration from the file system (sync)
+* @param searchFrom - Directory to search from (defaults to process.cwd())
+* @returns Configuration object or empty object if not found
+*/
+function loadConfigSync(searchFrom) {
+	const result = explorerSync.search(searchFrom);
+	return result?.config ? normalizeConfig(result.config) : {};
+}
+/**
+* Load styles configuration with metadata (sync).
+* Includes config file path when a config file is discovered.
+*/
+function loadConfigSyncWithMeta(searchFrom) {
+	const result = explorerSync.search(searchFrom);
+	return {
+		config: result?.config ? normalizeConfig(result.config) : {},
+		configFilePath: result?.filepath
+	};
+}
+/**
+* Load styles configuration from a specific file path (async)
+* @param filePath - Path to the config file
+* @returns Configuration object or null if not found
+*/
+async function loadConfigFromPath(filePath) {
+	const result = await explorer.load(filePath);
+	return result?.config ? normalizeConfig(result.config) : null;
+}
+/**
+* Load styles configuration from a specific file path (sync)
+* @param filePath - Path to the config file
+* @returns Configuration object or empty object if not found
+*/
+function loadConfigFromPathSync(filePath) {
+	const result = explorerSync.load(filePath);
+	return result?.config ? normalizeConfig(result.config) : {};
+}
+/**
+* Normalize config object - handle default exports and ensure proper type
+*/
+function isStylesConfig(value) {
+	return typeof value === "object" && value !== null;
+}
+function normalizeConfig(config) {
+	if (isStylesConfig(config) && "default" in config) return normalizeConfig(config.default);
+	if (isStylesConfig(config)) return config;
+	return {};
+}
+//#endregion
+//#region src/options.ts
+/**
+* Expand the `strict` convenience preset. When `strict` is truthy, fills the
+* strict bundle for any governed option left `undefined` — an explicitly set
+* option always wins. Modeled after `tsconfig`'s `strict`: it only *sets*
+* semantic options, it is not itself a mode. Sets the strictest value of each
+* governed axis (`equalityMode: 'exact'` is the no-coercion dialect).
+*
+* Returns a new object (never mutates the input); a no-op when `strict` is falsy.
+*/
+function applyStrictPreset(opts) {
+	if (!opts?.strict) return opts;
+	const filled = { ...opts };
+	filled.unitMode ??= "strict";
+	filled.equalityMode ??= "exact";
+	filled.leakyScope ??= false;
+	filled.allowOverloadedImport ??= false;
+	return filled;
+}
+/**
+* Map of file extensions to language keys
+*/
+const extensionToLanguage = new Map([
+	[".less", "less"],
+	[".scss", "scss"],
+	[".sass", "scss"],
+	[".jess", "jess"],
+	[".css", "css"]
+]);
+/**
+* Infer language from a file path's extension
+*/
+function inferLanguage(filePath) {
+	if (!filePath) return;
+	const ext = path.default.extname(filePath).toLowerCase();
+	return extensionToLanguage.get(ext);
+}
+/**
+* Check if a file path matches a pattern (exact path, relative path, or glob)
+*/
+function matchesFile(pattern, filePath) {
+	if (!pattern || !filePath) return false;
+	const normalizedPattern = path.default.normalize(pattern);
+	const normalizedFile = path.default.normalize(filePath);
+	if (normalizedPattern === normalizedFile) return true;
+	if (path.default.basename(normalizedFile) === normalizedPattern) return true;
+	const isMatch = (0, picomatch.default)(pattern, { dot: true });
+	return isMatch(filePath) || isMatch(normalizedFile);
+}
+/**
+* Get matching options from an array of file-based options.
+* Returns merged options from:
+* 1. All entries without a `file` property (defaults)
+* 2. All entries whose `file` pattern matches the given path
+*
+* Later entries override earlier ones.
+*/
+function getMatchingOptions(options, filePath) {
+	if (!options) return {};
+	const optionsArray = Array.isArray(options) ? options : [options];
+	let result = {};
+	for (const opt of optionsArray) if (!opt.file || filePath && matchesFile(opt.file, filePath)) {
+		const { file, ...rest } = opt;
+		result = {
+			...result,
+			...rest
+		};
+	}
+	return result;
+}
+/**
+* Get merged options by combining compile, language, input, and output settings.
+*
+* Merge priority (later wins):
+* 1. compile options (base)
+* 2. language-specific options (inferred from input extension or explicitly specified)
+* 3. matched input options (if input path provided and matches)
+* 4. matched output options (if output path provided and matches)
+*
+* @param config - The styles configuration object
+* @param params - Options specifying language, input file, and output file
+* @returns Merged options object
+*
+* @example
+* // Get Less options for a specific input/output (language inferred from .less extension)
+* const options = getOptions(config, {
+*   input: 'src/styles/main.less',
+*   output: 'dist/main.css'
+* });
+*
+* @example
+* // Explicitly specify language
+* const options = getOptions(config, { language: 'less' });
+*
+* @example
+* // Get base options without language-specific settings
+* const options = getOptions(config);
+*/
+function getOptions(config = {}, params = {}) {
+	const { input: inputFile, output: outputFile } = params;
+	const { compile = {}, input, output, language: languageConfig = {} } = config;
+	const language = params.language ?? inferLanguage(inputFile);
+	const languageOptions = language ? languageConfig[language] ?? {} : {};
+	const matchedInput = getMatchingOptions(input, inputFile);
+	const matchedOutput = getMatchingOptions(output, outputFile);
+	return {
+		mathMode: compile.mathMode,
+		unitMode: compile.unitMode,
+		equalityMode: compile.equalityMode,
+		allowExtendSelectors: compile.allowExtendSelectors,
+		disableScriptModules: compile.disableScriptModules ?? compile.disablePluginRule,
+		paths: compile.searchPaths,
+		...languageOptions,
+		...matchedInput,
+		...matchedOutput
+	};
+}
+//#endregion
+exports.applyStrictPreset = applyStrictPreset;
+exports.getOptions = getOptions;
+exports.loadConfig = loadConfig;
+exports.loadConfigFromPath = loadConfigFromPath;
+exports.loadConfigFromPathSync = loadConfigFromPathSync;
+exports.loadConfigSync = loadConfigSync;
+exports.loadConfigSyncWithMeta = loadConfigSyncWithMeta;

package/lib/index.js

@@ -1,4 +1,214 @@
-export * from './types.js';
-export * from './loader.js';
-export * from './options.js';
-//# sourceMappingURL=index.js.map
+import { cosmiconfig, cosmiconfigSync, defaultLoadersSync } from "cosmiconfig";
+import picomatch from "picomatch";
+import path from "path";
+//#region src/loader.ts
+const explorer = cosmiconfig("styles", {
+	searchPlaces: [
+		"styles.config.ts",
+		"styles.config.js",
+		"styles.config.mts",
+		"styles.config.mjs",
+		"styles.config.cjs",
+		"styles.config.cts"
+	],
+	loaders: {
+		".mts": defaultLoadersSync[".ts"],
+		".cts": defaultLoadersSync[".ts"],
+		".mjs": defaultLoadersSync[".js"],
+		".cjs": defaultLoadersSync[".cjs"]
+	}
+});
+const explorerSync = cosmiconfigSync("styles", {
+	searchPlaces: [
+		"styles.config.ts",
+		"styles.config.js",
+		"styles.config.mts",
+		"styles.config.mjs",
+		"styles.config.cjs",
+		"styles.config.cts"
+	],
+	loaders: {
+		".mts": defaultLoadersSync[".ts"],
+		".cts": defaultLoadersSync[".ts"],
+		".mjs": defaultLoadersSync[".js"],
+		".cjs": defaultLoadersSync[".cjs"]
+	}
+});
+/**
+* Load styles configuration from the file system (async)
+* @param searchFrom - Directory to search from (defaults to process.cwd())
+* @returns Configuration object or null if not found
+*/
+async function loadConfig(searchFrom) {
+	const result = await explorer.search(searchFrom);
+	return result?.config ? normalizeConfig(result.config) : null;
+}
+/**
+* Load styles configuration from the file system (sync)
+* @param searchFrom - Directory to search from (defaults to process.cwd())
+* @returns Configuration object or empty object if not found
+*/
+function loadConfigSync(searchFrom) {
+	const result = explorerSync.search(searchFrom);
+	return result?.config ? normalizeConfig(result.config) : {};
+}
+/**
+* Load styles configuration with metadata (sync).
+* Includes config file path when a config file is discovered.
+*/
+function loadConfigSyncWithMeta(searchFrom) {
+	const result = explorerSync.search(searchFrom);
+	return {
+		config: result?.config ? normalizeConfig(result.config) : {},
+		configFilePath: result?.filepath
+	};
+}
+/**
+* Load styles configuration from a specific file path (async)
+* @param filePath - Path to the config file
+* @returns Configuration object or null if not found
+*/
+async function loadConfigFromPath(filePath) {
+	const result = await explorer.load(filePath);
+	return result?.config ? normalizeConfig(result.config) : null;
+}
+/**
+* Load styles configuration from a specific file path (sync)
+* @param filePath - Path to the config file
+* @returns Configuration object or empty object if not found
+*/
+function loadConfigFromPathSync(filePath) {
+	const result = explorerSync.load(filePath);
+	return result?.config ? normalizeConfig(result.config) : {};
+}
+/**
+* Normalize config object - handle default exports and ensure proper type
+*/
+function isStylesConfig(value) {
+	return typeof value === "object" && value !== null;
+}
+function normalizeConfig(config) {
+	if (isStylesConfig(config) && "default" in config) return normalizeConfig(config.default);
+	if (isStylesConfig(config)) return config;
+	return {};
+}
+//#endregion
+//#region src/options.ts
+/**
+* Expand the `strict` convenience preset. When `strict` is truthy, fills the
+* strict bundle for any governed option left `undefined` — an explicitly set
+* option always wins. Modeled after `tsconfig`'s `strict`: it only *sets*
+* semantic options, it is not itself a mode. Sets the strictest value of each
+* governed axis (`equalityMode: 'exact'` is the no-coercion dialect).
+*
+* Returns a new object (never mutates the input); a no-op when `strict` is falsy.
+*/
+function applyStrictPreset(opts) {
+	if (!opts?.strict) return opts;
+	const filled = { ...opts };
+	filled.unitMode ??= "strict";
+	filled.equalityMode ??= "exact";
+	filled.leakyScope ??= false;
+	filled.allowOverloadedImport ??= false;
+	return filled;
+}
+/**
+* Map of file extensions to language keys
+*/
+const extensionToLanguage = new Map([
+	[".less", "less"],
+	[".scss", "scss"],
+	[".sass", "scss"],
+	[".jess", "jess"],
+	[".css", "css"]
+]);
+/**
+* Infer language from a file path's extension
+*/
+function inferLanguage(filePath) {
+	if (!filePath) return;
+	const ext = path.extname(filePath).toLowerCase();
+	return extensionToLanguage.get(ext);
+}
+/**
+* Check if a file path matches a pattern (exact path, relative path, or glob)
+*/
+function matchesFile(pattern, filePath) {
+	if (!pattern || !filePath) return false;
+	const normalizedPattern = path.normalize(pattern);
+	const normalizedFile = path.normalize(filePath);
+	if (normalizedPattern === normalizedFile) return true;
+	if (path.basename(normalizedFile) === normalizedPattern) return true;
+	const isMatch = picomatch(pattern, { dot: true });
+	return isMatch(filePath) || isMatch(normalizedFile);
+}
+/**
+* Get matching options from an array of file-based options.
+* Returns merged options from:
+* 1. All entries without a `file` property (defaults)
+* 2. All entries whose `file` pattern matches the given path
+*
+* Later entries override earlier ones.
+*/
+function getMatchingOptions(options, filePath) {
+	if (!options) return {};
+	const optionsArray = Array.isArray(options) ? options : [options];
+	let result = {};
+	for (const opt of optionsArray) if (!opt.file || filePath && matchesFile(opt.file, filePath)) {
+		const { file, ...rest } = opt;
+		result = {
+			...result,
+			...rest
+		};
+	}
+	return result;
+}
+/**
+* Get merged options by combining compile, language, input, and output settings.
+*
+* Merge priority (later wins):
+* 1. compile options (base)
+* 2. language-specific options (inferred from input extension or explicitly specified)
+* 3. matched input options (if input path provided and matches)
+* 4. matched output options (if output path provided and matches)
+*
+* @param config - The styles configuration object
+* @param params - Options specifying language, input file, and output file
+* @returns Merged options object
+*
+* @example
+* // Get Less options for a specific input/output (language inferred from .less extension)
+* const options = getOptions(config, {
+*   input: 'src/styles/main.less',
+*   output: 'dist/main.css'
+* });
+*
+* @example
+* // Explicitly specify language
+* const options = getOptions(config, { language: 'less' });
+*
+* @example
+* // Get base options without language-specific settings
+* const options = getOptions(config);
+*/
+function getOptions(config = {}, params = {}) {
+	const { input: inputFile, output: outputFile } = params;
+	const { compile = {}, input, output, language: languageConfig = {} } = config;
+	const language = params.language ?? inferLanguage(inputFile);
+	const languageOptions = language ? languageConfig[language] ?? {} : {};
+	const matchedInput = getMatchingOptions(input, inputFile);
+	const matchedOutput = getMatchingOptions(output, outputFile);
+	return {
+		mathMode: compile.mathMode,
+		unitMode: compile.unitMode,
+		equalityMode: compile.equalityMode,
+		allowExtendSelectors: compile.allowExtendSelectors,
+		disableScriptModules: compile.disableScriptModules ?? compile.disablePluginRule,
+		paths: compile.searchPaths,
+		...languageOptions,
+		...matchedInput,
+		...matchedOutput
+	};
+}
+//#endregion
+export { applyStrictPreset, getOptions, loadConfig, loadConfigFromPath, loadConfigFromPathSync, loadConfigSync, loadConfigSyncWithMeta };

package/lib/options.d.ts

@@ -1,4 +1,25 @@
 import type { StylesConfig } from './types.js';
+/**
+ * Options bag the `strict` preset can expand. Any bag carrying a `strict` flag
+ * plus the semantic modes it governs.
+ */
+export interface StrictPresetOptions {
+    strict?: boolean;
+    unitMode?: 'loose' | 'preserve' | 'strict';
+    equalityMode?: 'less' | 'sass' | 'exact';
+    leakyScope?: boolean;
+    allowOverloadedImport?: boolean;
+}
+/**
+ * Expand the `strict` convenience preset. When `strict` is truthy, fills the
+ * strict bundle for any governed option left `undefined` — an explicitly set
+ * option always wins. Modeled after `tsconfig`'s `strict`: it only *sets*
+ * semantic options, it is not itself a mode. Sets the strictest value of each
+ * governed axis (`equalityMode: 'exact'` is the no-coercion dialect).
+ *
+ * Returns a new object (never mutates the input); a no-op when `strict` is falsy.
+ */
+export declare function applyStrictPreset<T extends StrictPresetOptions>(opts: T): T;
 /**
  * Options for retrieving merged configuration
  */

package/lib/types.d.ts

@@ -7,36 +7,39 @@ export type MathMode = 'always' | 'parens-division' | 'parens' | 'strict';
  */
 export type UnitMode = 'loose' | 'preserve' | 'strict';
 /**
- * Equality/coercion modes for guard comparisons.
+ * Function-call resolution modes — mirrors {@link UnitMode}. Governs an optional
+ * (global) function call that matched a registered function but couldn't be
+ * evaluated: `preserve` renders it as-is (+ warning), `error` throws.
  */
-export type EqualityMode = 'coerce' | 'strict';
-export interface JavaScriptSandboxConfig {
-    /**
-     * Allow network access for script execution runtime.
-     * @default false
-     */
-    allowHttp?: boolean;
-    /**
-     * Optional host allowlist when `allowHttp` is enabled.
-     */
-    allowNetHosts?: string[];
-    /**
-     * Optional explicit filesystem root for script reads.
-     * If omitted, compiler resolves using entry/config roots.
-     */
-    jsReadRoot?: string;
-}
-export type CompileJavaScriptOption = true | JavaScriptSandboxConfig;
+export type FunctionMode = 'preserve' | 'error';
+/**
+ * Equality dialects for guard comparisons — named by dialect (Less 4.x and Sass
+ * diverge in opposite directions), not by strictness:
+ * - `less`: Less 4.x equality (numeric coercion; quoted vs unquoted distinct)
+ * - `sass`: Dart Sass equality (unit-strict; quote-insensitive strings)
+ * - `exact`: no coercion — operands must be the same node type
+ */
+export type EqualityMode = 'less' | 'sass' | 'exact';
+export type ExtendSelectorKind = 'simple' | 'basic' | 'pseudo' | 'complex' | 'compound';
 /**
  * Less compiler options
  * Based on less.js default-options.js and bin/lessc
  */
 export interface LessOptions {
+    /**
+     * Restrict which selector shapes are allowed in extend targets.
+     * When set, any other selector kind is a parse error.
+     */
+    allowExtendSelectors?: ExtendSelectorKind[];
     /**
      * Inline Javascript - @plugin still allowed
      * @default false
      */
     javascriptEnabled?: boolean;
+    /**
+     * @deprecated Use `disableScriptModules` instead.
+     */
+    disablePluginRule?: boolean;
     /**
      * Outputs a makefile import dependency list to stdout.
      * @default false
@@ -124,11 +127,21 @@ export interface LessOptions {
      * @default 'preserve'
      */
     unitMode?: UnitMode;
+    /**
+     * How to handle an optional/global function call that matched a registered
+     * function but couldn't be evaluated (no matching signature, or it threw) —
+     * e.g. `unit(80/16)`, `color("x")`. Mirrors {@link unitMode}.
+     * - 'preserve': render the call as-is (like an unknown CSS function) + warn
+     * - 'error': throw the underlying function error (Less 4.x behavior)
+     * Unknown function names always render as-is regardless.
+     * @default 'preserve'
+     */
+    functionMode?: FunctionMode;
     /**
      * How to handle equality/coercion in guards and comparisons.
-     * - 'coerce': Less-compatible coercion behavior
+     * - 'loose': Less-compatible loose (coercive) equality (JS '==')
      * - 'strict': type-strict behavior
-     * @default 'coerce'
+     * @default 'loose'
      */
     equalityMode?: EqualityMode;
     /**
@@ -201,6 +214,26 @@ export interface LessOptions {
      * @default false
      */
     quiet?: boolean;
+    /**
+     * Convenience preset. When `true`, sets the strict bundle for any of the
+     * following left `undefined` (individual options always win):
+     * - `unitMode: 'strict'`
+     * - `equalityMode: 'exact'` (the no-coercion dialect)
+     * - `leakyScope: false`
+     * - `allowOverloadedImport: false`
+     *
+     * Modeled after `tsconfig` `strict`: it only *sets* semantic options, it is not
+     * itself a mode.
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * Whether re-importing a file/namespace may contribute *overloaded* (duplicated,
+     * additively-merged) definitions rather than being de-duplicated like Less's
+     * `@import (once)`. `strict` sets this to `false`.
+     * @default true
+     */
+    allowOverloadedImport?: boolean;
     /**
      * @deprecated This is legacy Less behavior.
      *
@@ -212,7 +245,7 @@ export interface LessOptions {
      * - Both mixins and detached rulesets: Mixin and VarDeclaration nodes are 'private'
      * @default true
      */
-    leakyRules?: boolean;
+    leakyScope?: boolean;
     /**
      * Whether to collapse nested selectors (Less 1.x-4.x style flattening)
      * When true, nested selectors like `.parent { .child { } }` are flattened to `.parent .child { }`
@@ -228,6 +261,13 @@ export interface LessOptions {
      */
     bubbleRootAtRules?: boolean;
 }
+export interface ScssOptions {
+    allowExtendSelectors?: ExtendSelectorKind[];
+    unitMode?: UnitMode;
+    equalityMode?: EqualityMode;
+    collapseNesting?: boolean;
+    [key: string]: any;
+}
 /**
  * Base interface for file-matching options
  */
@@ -244,9 +284,17 @@ export interface FileMatchOptions {
 export interface InputOptions extends FileMatchOptions {
     mathMode?: MathMode;
     unitMode?: UnitMode;
+    functionMode?: FunctionMode;
     equalityMode?: EqualityMode;
+    strict?: boolean;
+    allowOverloadedImport?: boolean;
+    allowExtendSelectors?: ExtendSelectorKind[];
+    disableScriptModules?: boolean;
+    /**
+     * @deprecated Use `disableScriptModules` instead.
+     */
+    disablePluginRule?: boolean;
     searchPaths?: string[];
-    enableJavaScript?: boolean;
     javascriptEnabled?: boolean;
     paths?: string[];
     globalVars?: Record<string, string> | null;
@@ -254,7 +302,7 @@ export interface InputOptions extends FileMatchOptions {
     strictImports?: boolean | 'error';
     rewriteUrls?: boolean | 'all' | 'local' | 'off';
     rootpath?: string;
-    leakyRules?: boolean;
+    leakyScope?: boolean;
     collapseNesting?: boolean;
     bubbleRootAtRules?: boolean;
     /** Allow additional language-specific options */
@@ -292,11 +340,28 @@ export interface StylesConfig {
          */
         plugins?: Array<any | string>;
         searchPaths?: string[];
-        enableJavaScript?: boolean;
-        javascript?: CompileJavaScriptOption;
         mathMode?: MathMode;
         unitMode?: UnitMode;
+        functionMode?: FunctionMode;
         equalityMode?: EqualityMode;
+        /** See {@link LessOptions.strict}. Expanded onto the other compile modes. */
+        strict?: boolean;
+        /** See {@link LessOptions.allowOverloadedImport}. */
+        allowOverloadedImport?: boolean;
+        /** See {@link LessOptions.leakyScope}. */
+        leakyScope?: boolean;
+        allowExtendSelectors?: ExtendSelectorKind[];
+        disableScriptModules?: boolean;
+        /**
+         * @deprecated Use `disableScriptModules` instead.
+         */
+        disablePluginRule?: boolean;
+        /**
+         * Filesystem root that Less `@plugin` / script-module scripts are allowed to
+         * be read from. When set, it overrides the default (the entry file's
+         * directory). Paths outside this root are rejected by @jesscss/plugin-js.
+         */
+        jsReadRoot?: string;
     };
     /**
      * Input file options. Can be a single object for defaults, or an array
@@ -312,9 +377,9 @@ export interface StylesConfig {
     output?: OutputOptions | OutputOptions[];
     language?: {
         less?: LessOptions;
-        scss?: Record<string, any>;
+        scss?: ScssOptions;
         css?: Record<string, any>;
         jess?: Record<string, any>;
-        [key: string]: LessOptions | Record<string, any> | undefined;
+        [key: string]: LessOptions | ScssOptions | Record<string, any> | undefined;
     };
 }