less 4.9.0 → 5.0.0-alpha.1

package/index.cjs

@@ -1,2 +1,5 @@
-// CJS entry — requires the pre-built CJS bundle
-module.exports = require('./dist/less-node.cjs');
+// CJS entry: unwrap the Rollup namespace so require('less') returns the Less API object.
+const bundle = require('./dist/less-node.cjs');
+
+module.exports = bundle.default || bundle;
+Object.assign(module.exports, bundle);

package/lib/index.js

@@ -0,0 +1,164 @@
+/**
+ * Less.js v5 — powered by Jess
+ *
+ * This module provides a Less-compatible API backed by the Jess compiler.
+ * It supports the same `less.render()` interface that Less 4.x users expect,
+ * while delegating all parsing, evaluation, and output to Jess with the
+ * `@jesscss/plugin-less` and `@jesscss/plugin-less-compat` plugins.
+ *
+ * @module less
+ */
+
+import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { Compiler } from '@jesscss/compiler';
+import nodeModulesPlugin from '@jesscss/plugin-node-modules';
+import { createLessOptions, getCompilerCacheKey, mapRenderResult } from './options.js';
+import { version } from './version.js';
+import { logger } from './logger.js';
+import { lesscHelper } from './lessc-helper.js';
+
+const compilerCache = new Map();
+const lessVersion = version.array;
+
+function normalizeDiagnosticLines(lines, lineNumber, filePath) {
+  if (Array.isArray(lines)) {
+    return lines.map((line) => typeof line === 'string' ? line : String(line));
+  }
+  if (lines && typeof lines === 'object') {
+    const current = Number(lineNumber) || 1;
+    return [current - 1, current, current + 1]
+      .filter((line) => line > 0 && Object.prototype.hasOwnProperty.call(lines, line))
+      .map((line) => {
+        const value = lines[line];
+        return typeof value === 'string' ? value : String(value);
+      });
+  }
+  if (typeof filePath === 'string') {
+    try {
+      const sourceLines = readFileSync(filePath, 'utf8').split(/\r?\n/);
+      const current = Number(lineNumber) || 1;
+      return [current - 1, current, current + 1]
+        .filter((line) => line > 0 && line <= sourceLines.length)
+        .map((line) => sourceLines[line - 1]);
+    } catch {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+function createRenderErrorFromJessDiagnostic(result, filePath) {
+  const errors = result?.errors || [];
+  const diagnostic = errors[0];
+  const error = new Error(diagnostic?.message || 'Less render failed');
+
+  error.type = diagnostic?.phase || 'Syntax';
+  error.filename = diagnostic?.filePath || filePath;
+  error.line = diagnostic?.line || 1;
+  error.column = diagnostic?.column || 1;
+  error.extract = normalizeDiagnosticLines(diagnostic?.lines, error.line, error.filename);
+  error.jessErrors = errors;
+  error.jessWarnings = result?.warnings || [];
+
+  return error;
+}
+
+/**
+ * @param {object} configOptions
+ */
+function getCompiler(configOptions) {
+  const cacheKey = getCompilerCacheKey(configOptions);
+  let compiler = compilerCache.get(cacheKey);
+  if (!compiler) {
+    compiler = new Compiler(configOptions, {
+      defaultPlugins: context => [nodeModulesPlugin({ basePath: context.resolutionBaseDir })],
+      scriptPluginSpecifier: '@jesscss/plugin-js',
+      scriptPluginResolveFrom: import.meta.url
+    });
+    compilerCache.set(cacheKey, compiler);
+  }
+  return compiler;
+}
+
+/**
+ * Render Less source to CSS.
+ *
+ * @param {string} input - Less source string
+ * @param {import('./options.js').LessRenderOptions} [options={}]
+ * @param {Function} [callback] - Optional Node-style callback(err, result)
+ * @returns {Promise<import('./options.js').LessRenderResult>}
+ */
+function render(input, options = {}, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  const promise = (async () => {
+    const { configOptions, filePath } = createLessOptions(options, { source: input });
+    const compiler = getCompiler(configOptions);
+
+    const result = await compiler.renderToResult(
+      { source: input, filePath, language: 'less', extension: '.less' },
+      { ...configOptions, suppressWarnings: true }
+    );
+
+    if (result.errors?.length) {
+      throw createRenderErrorFromJessDiagnostic(result, filePath);
+    }
+
+    return mapRenderResult(result, options);
+  })();
+
+  if (callback) {
+    promise.then(
+      result => callback(null, result),
+      err => callback(err)
+    );
+  }
+  return promise;
+}
+
+/**
+ * Render a Less file to CSS.
+ *
+ * @param {string} filePath - Absolute or relative path to .less file
+ * @param {import('./options.js').LessRenderOptions} [options={}]
+ * @returns {Promise<import('./options.js').LessRenderResult>}
+ */
+async function renderFile(filePath, options = {}) {
+  const source = await readFile(filePath, 'utf8');
+  const { configOptions } = createLessOptions(options, { source });
+  const compiler = getCompiler(configOptions);
+
+  const result = await compiler.renderToResult(filePath, { ...configOptions, suppressWarnings: true });
+  if (result.errors?.length) {
+    throw createRenderErrorFromJessDiagnostic(result, filePath);
+  }
+  return mapRenderResult(result, options);
+}
+
+/**
+ * COMPAT GAP (v5): the Less 4.x `less.functions` (custom-function registry via
+ * `less.functions.functionRegistry.add/addMultiple`) and `less.tree` (node
+ * constructors) are intentionally NOT present on the Jess-backed build. Jess
+ * registers custom functions with `defineFunction(name, fn, opts)` supplied
+ * through the compiler config/plugins, and its values are Jess nodes, not
+ * `less.tree.*`. Providing these as throwing stubs would break feature-detection
+ * (`if (less.functions)`), so they are left absent until a real compat surface
+ * (registry -> defineFunction bridge + tree-node shims) is built. Tracked for
+ * the broader Less-runner/API-parity work; see also test/less-test.js guards.
+ *
+ * @type {import('./types.js').LessStatic}
+ */
+const less = {
+  version: lessVersion,
+  render,
+  renderFile,
+  logger,
+  lesscHelper,
+  Compiler,
+};
+
+export default less;
+export { render, renderFile, logger, lesscHelper, Compiler, lessVersion as version };

package/lib/lessc-helper.js

@@ -0,0 +1,52 @@
+/**
+ * Helper functions for lessc CLI.
+ * Adapted from lib.bak/less-node/lessc-helper.js.
+ * @module less/lib/lessc-helper
+ */
+
+/** @type {Record<string, [number, number]>} */
+const STYLES = {
+  reset: [0, 0],
+  bold: [1, 22],
+  inverse: [7, 27],
+  underline: [4, 24],
+  yellow: [33, 39],
+  green: [32, 39],
+  red: [31, 39],
+  grey: [90, 39],
+};
+
+const lesscHelper = {
+  /** @param {string} str @param {string} style */
+  stylize(str, style) {
+    const s = STYLES[style] ?? STYLES.reset;
+    return `\x1b[${s[0]}m${str}\x1b[${s[1]}m`;
+  },
+
+  printUsage() {
+    console.log('usage: lessc [option option=parameter ...] <source> [destination]');
+    console.log('');
+    console.log('If source is set to `-\' (dash or hyphen-minus), input is read from stdin.');
+    console.log('');
+    console.log('options:');
+    console.log('  -h, --help                   Prints help (this message) and exit.');
+    console.log('  -I PATH, -IPATH              Adds an import search path.');
+    console.log('  --include-path=PATHS         Sets include paths. Separated by `:\'. `;\' also supported on windows.');
+    console.log('  --no-color                   Disables colorized output.');
+    console.log('  -s, --silent                 Suppresses output of error messages.');
+    console.log('  --quiet                      Suppresses output of warnings.');
+    console.log('  -v, --version                Prints version number and exit.');
+    console.log('  --verbose                    Be verbose.');
+    console.log('  --collapse-nesting           Flatten nested rules after preserving source-order cascade.');
+    console.log('');
+    console.log('This release intentionally supports a smaller CLI surface.');
+    console.log('Source maps, browser compilation, legacy plugin flags, lint-only mode, and');
+    console.log('URL rewrite flags will be revisited in later alphas.');
+    console.log('');
+    console.log('Report bugs to: http://github.com/less/less.js/issues');
+    console.log('Home page: <http://lesscss.org/>');
+  },
+};
+
+export { lesscHelper };
+export default lesscHelper;

package/lib/logger.js

@@ -0,0 +1,76 @@
+/**
+ * Less logger wired to Jess's logger singleton.
+ * Forwards to Jess and maintains Less-style addListener/removeListener for compatibility.
+ * @module less/lib/logger
+ */
+
+import { logger as jessLogger } from '@jesscss/core';
+
+/** @typedef {{ error?: (msg: string) => void, warn?: (msg: string) => void, info?: (msg: string) => void, debug?: (msg: string) => void }} LogListener */
+
+/** @type {LogListener[]} */
+const _listeners = [];
+
+/** @param {'error'|'warn'|'info'|'debug'} type @param {string} msg */
+function _fireEvent(type, msg) {
+  for (const listener of _listeners) {
+    const fn = listener[type];
+    if (fn) fn(msg);
+  }
+}
+
+// Wrap Jess's logger so Less listeners receive Jess's log output without
+// writing directly to stderr/stdout. Library consumers should be able to catch
+// `less.render()` rejections without surprise terminal output; the CLI owns
+// deciding whether/how to print diagnostics.
+jessLogger.configure?.({
+  log(...args) {
+    _fireEvent('debug', args.map(String).join(' '));
+  },
+  info(...args) {
+    _fireEvent('info', args.map(String).join(' '));
+  },
+  warn(...args) {
+    _fireEvent('warn', args.map(String).join(' '));
+  },
+  error(...args) {
+    _fireEvent('error', args.map(String).join(' '));
+  },
+});
+
+/** Less-compatible logger backed by Jess's singleton */
+const logger = {
+  /** @param {string} msg */
+  error(msg) {
+    _fireEvent('error', msg);
+  },
+
+  /** @param {string} msg */
+  warn(msg) {
+    _fireEvent('warn', msg);
+  },
+
+  /** @param {string} msg */
+  info(msg) {
+    _fireEvent('info', msg);
+  },
+
+  /** @param {string} msg */
+  debug(msg) {
+    _fireEvent('debug', msg);
+  },
+
+  /** @param {LogListener} listener */
+  addListener(listener) {
+    _listeners.push(listener);
+  },
+
+  /** @param {LogListener} listener */
+  removeListener(listener) {
+    const i = _listeners.indexOf(listener);
+    if (i >= 0) _listeners.splice(i, 1);
+  },
+};
+
+export { logger };
+export default logger;

package/lib/options.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Options mapping between Less render options and Jess compiler config.
+ */
+
+export interface LessRenderOptions {
+  filename?: string;
+  paths?: string[];
+  /**
+   * Legacy Less render plugins are routed through the alpha compatibility
+   * layer. File-manager, pre/post-processor, and @plugin execution are not
+   * alpha.1-supported surfaces yet.
+   */
+  plugins?: unknown[];
+  math?: number | 'always' | 'parens-division' | 'parens' | 'strict';
+  /**
+   * Opt into Less 4-style flattened output. Less v5 preserves authored nesting
+   * by default.
+   */
+  collapseNesting?: boolean;
+  /** @internal Jess alpha benchmark-only flag for source graphs already proven @plugin-free. */
+  __jessSkipLessCompatWhenPluginFree?: boolean;
+}
+
+export interface LessRenderResult {
+  css: string;
+  map?: string;
+  imports?: string[];
+}
+
+export interface JessRenderResult {
+  css?: string;
+  map?: string | object;
+  imports?: string[];
+}
+
+export function createLessOptions(options?: LessRenderOptions): {
+  configOptions: object;
+  filePath?: string;
+};
+
+export function getCompilerCacheKey(configOptions: object): string;
+
+export function mapRenderResult(
+  result: JessRenderResult,
+  options?: LessRenderOptions
+): LessRenderResult;

package/lib/options.js

@@ -0,0 +1,145 @@
+/**
+ * Options mapping between Less render options and Jess compiler config.
+ * @module less/lib/options
+ */
+
+import lessPlugin from '@jesscss/plugin-less';
+import { lessCompatPlugin } from '@jesscss/plugin-less-compat';
+
+const unsupportedAlphaOptions = new Map([
+  ['sourceMap', 'source maps are not supported'],
+  ['sourceMapFilename', 'source maps are not supported'],
+  ['sourceMapRootpath', 'source maps are not supported'],
+  ['sourceMapBasepath', 'source maps are not supported'],
+  ['sourceMapURL', 'source maps are not supported'],
+  ['sourceMapFileInline', 'source maps are not supported'],
+  ['globalVars', 'global variable injection is not supported'],
+  ['modifyVars', 'modify-var injection is not supported'],
+  ['strictUnits', 'strict unit mode is not supported'],
+  ['rootpath', 'URL rootpath rewriting is not supported'],
+  ['rewriteUrls', 'URL rewriting is not supported'],
+  ['urlArgs', 'URL argument rewriting is not supported'],
+  ['javascriptEnabled', 'JavaScript evaluation is not supported'],
+  ['compress', 'compressed output is not supported'],
+]);
+
+function validateAlphaOptions(options) {
+  for (const [name, reason] of unsupportedAlphaOptions) {
+    if (Object.prototype.hasOwnProperty.call(options, name)) {
+      throw new Error(`${name} is not supported: ${reason}`);
+    }
+  }
+}
+
+/**
+ * @param {any} value
+ * @param {WeakSet<object>} [seen]
+ * @returns {string}
+ */
+function stableStringify(value, seen = new WeakSet()) {
+  if (value == null || typeof value !== 'object') {
+    if (typeof value === 'function') {
+      return JSON.stringify(`[function ${value.name || 'anonymous'}]`);
+    }
+    return JSON.stringify(value);
+  }
+  if (seen.has(value)) {
+    return '"[Circular]"';
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item, seen)).join(',')}]`;
+  }
+  if (value.name && typeof value.name === 'string' && ('install' in value || 'parser' in value || 'opts' in value)) {
+    return stableStringify({
+      plugin: value.name,
+      opts: value.opts || {},
+    }, seen);
+  }
+  const entries = Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key], seen)}`);
+  return `{${entries.join(',')}}`;
+}
+
+/**
+ * Map Less render options to Jess compiler config.
+ * @param {import('./options.js').LessRenderOptions} [options] Less-style options
+ * @returns {{ configOptions: object, filePath?: string }}
+ */
+export function createLessOptions(options) {
+  const opts = options || {};
+  validateAlphaOptions(opts);
+  const filePath = opts.filename || undefined;
+  const lessPlugins = Array.isArray(opts.plugins) ? opts.plugins : [];
+  const skipLessCompat =
+    opts.__jessSkipLessCompatWhenPluginFree === true && lessPlugins.length === 0;
+
+  const math = /** @type {number|string|undefined} */ (opts.math);
+  const mathMode =
+    math === 0 || math === 'always' ? 'always' :
+    math === 2 || math === 'parens' || math === 'strict' ? 'parens' :
+    'parens-division';
+
+  const plugins = [lessPlugin()];
+  if (!skipLessCompat) {
+    plugins.push(lessCompatPlugin({ plugins: lessPlugins }));
+  }
+
+  const configOptions = {
+    compile: {
+      searchPaths: opts.paths || [],
+      mathMode,
+      plugins,
+    },
+    // Less v5 preserves authored nesting unless its explicit compatibility
+    // switch requests flattened CSS. Keep that public Less option at the
+    // wrapper boundary; Jess owns the one renderer and its output mode.
+    // A file's styles.config may use an output array. A file-less output entry
+    // is the compiler's documented per-render override for that shape, so an
+    // explicit public Less option remains authoritative over fixture config.
+    output: Object.prototype.hasOwnProperty.call(opts, 'collapseNesting')
+      ? [{ collapseNesting: opts.collapseNesting === true }]
+      : {},
+    language: {},
+  };
+
+  return { configOptions, filePath };
+}
+
+/**
+ * Stable compiler cache key for a Jess compiler configured from Less options.
+ * @param {object} configOptions Jess compiler config
+ * @returns {string}
+ */
+export function getCompilerCacheKey(configOptions) {
+  return stableStringify(configOptions);
+}
+
+/**
+ * Map Jess render result to Less-style result.
+ * @param {import('./options.js').JessRenderResult} result Jess compiler result
+ * @param {import('./options.js').LessRenderOptions} [options] Original Less options
+ * @returns {import('./options.js').LessRenderResult}
+ */
+export function mapRenderResult(result, options) {
+  const opts = options || {};
+  /** @type {import('./options.js').LessRenderResult} */
+  const out = {
+    css: result.css ?? '',
+  };
+
+  if (result.imports && Array.isArray(result.imports)) {
+    out.imports = result.imports;
+  }
+
+  // Structured Jess warnings (e.g. selector/parentless-ampersand). Exposed so
+  // callers and tests can assert them, mirroring how errors surface.
+  if (result.warnings && Array.isArray(result.warnings)) {
+    out.warnings = result.warnings;
+  }
+
+  return out;
+}
+
+export default { createLessOptions, getCompilerCacheKey, mapRenderResult };

package/lib/types.js

@@ -0,0 +1,20 @@
+/**
+ * JSDoc type definitions for Less.js v5 (Jess wrapper).
+ * @module less/lib/types
+ */
+
+/**
+ * @typedef {import('./options.js').LessRenderResult} LessRenderResult
+ */
+
+/**
+ * @typedef {Object} LessStatic
+ * @property {number[]} version Less-compatible version tuple
+ * @property {function(string, import('./options.js').LessRenderOptions?, function?): Promise<LessRenderResult>} render Render Less to CSS
+ * @property {function(string, import('./options.js').LessRenderOptions?): Promise<LessRenderResult>} renderFile Render Less file to CSS
+ * @property {import('./logger.js').default} logger Logger instance
+ * @property {import('./lessc-helper.js').default} lesscHelper CLI helper
+ * @property {object} Compiler Jess Compiler class
+ */
+
+export {};

package/lib/version.js

@@ -0,0 +1,19 @@
+/**
+ * Version info for Less.js v5 (Jess wrapper).
+ * @module less/lib/version
+ */
+
+import { createRequire } from 'module';
+import parseNodeVersion from 'parse-node-version';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+const semver = pkg.version || '5.0.0-alpha.0';
+const parsed = parseNodeVersion(`v${semver}`);
+
+export const version = {
+  semver,
+  array: [parsed.major, parsed.minor, parsed.patch],
+};
+
+export default version;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "less",
-	"version": "4.9.0",
+	"version": "5.0.0-alpha.1",
 	"description": "Leaner CSS",
 	"homepage": "http://lesscss.org",
 	"author": {
@@ -15,7 +15,7 @@
 	},
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/less/less.js.git"
+		"url": "git+https://github.com/less/less.js.git"
 	},
 	"master": {
 		"url": "https://github.com/less/less.js/blob/master/",
@@ -24,21 +24,17 @@
 	"license": "Apache-2.0",
 	"type": "module",
 	"bin": {
-		"lessc": "./bin/lessc"
+		"lessc": "bin/lessc"
 	},
 	"main": "./dist/less-node.cjs",
 	"exports": {
 		".": {
-			"browser": "./dist/less.cjs",
-			"import": "./lib/less-node/index.js",
+			"import": "./lib/index.js",
 			"require": "./dist/less-node.cjs",
-			"default": "./lib/less-node/index.js"
+			"default": "./lib/index.js"
 		},
 		"./lib/*": "./lib/*",
-		"./dist/less-node.cjs": "./dist/less-node.cjs",
-		"./dist/less.cjs": "./dist/less.cjs",
-		"./dist/less.js": "./dist/less.js",
-		"./dist/less.min.js": "./dist/less.min.js"
+		"./dist/less-node.cjs": "./dist/less-node.cjs"
 	},
 	"directories": {
 		"test": "./test"
@@ -51,30 +47,25 @@
 		"index.cjs",
 		"README.md"
 	],
-	"browser": "./dist/less.js",
 	"engines": {
-		"node": ">=18"
+		"node": "^20.19.0 || >=22.12.0"
 	},
 	"scripts": {
-		"quicktest": "grunt quicktest",
-		"test": "grunt test",
-		"test:node": "grunt test:node",
-		"test:coverage": "c8 -r lcov -r json-summary -r text-summary -r html --include=\"lib/**/*.js\" --include=\"bin/**/*.js\" --exclude=\"dist/**\" --exclude=\"**/*.test.js\" --exclude=\"**/*.spec.js\" --exclude=\"test/**\" --exclude=\"tmp/**\" --exclude=\"**/abstract-file-manager.js\" --exclude=\"**/abstract-plugin-loader.js\" grunt shell:test && node scripts/coverage-report.js && node scripts/coverage-lines.js",
-		"grunt": "grunt",
+		"quicktest": "npm run test:legacy-node",
+		"test:alpha": "npm run typecheck && npm run build && npm run test:lessc && node test/jess-alpha-fast-path.mjs && node test/alpha-support.mjs && node test/alpha-fixtures.mjs",
+		"test:lessc": "node test/lessc-alpha.mjs",
+		"test": "npm run test:alpha",
+		"test:module": "node test/test-es6.js && node test/test-cjs.cjs",
+		"test:legacy-node": "node test/index.js",
+		"test:node": "npm run test:module",
+		"test:coverage": "c8 -r lcov -r json-summary -r text-summary -r html --include=\"lib/**/*.js\" --include=\"bin/**/*.js\" --exclude=\"dist/**\" --exclude=\"**/*.test.js\" --exclude=\"**/*.spec.js\" --exclude=\"test/**\" --exclude=\"tmp/**\" --exclude=\"**/abstract-file-manager.js\" --exclude=\"**/abstract-plugin-loader.js\" npm run test:legacy-node && node scripts/coverage-report.js && node scripts/coverage-lines.js",
 		"lint": "eslint '**/*.{ts,js}'",
 		"lint:fix": "eslint '**/*.{ts,js}' --fix",
 		"typecheck": "tsc --noEmit",
 		"build": "node build/rollup.js --dist",
-		"prepublishOnly": "npm run typecheck && grunt dist && grunt test:node"
-	},
-	"optionalDependencies": {
-		"errno": "^0.1.1",
-		"graceful-fs": "^4.1.2",
-		"probe-image-size": "^7.2.3",
-		"make-dir": "^5.1.0",
-		"mime": "^1.4.1",
-		"needle": "^3.1.0",
-		"source-map": "~0.6.0"
+		"benchmark": "node benchmark/benchmark-runner.cjs",
+		"benchmark:all": "node benchmark/run-and-compare.mjs",
+		"prepublishOnly": "npm run typecheck && npm run build && npm run test:lessc"
 	},
 	"devDependencies": {
 		"@less/test-data": "workspace:*",
@@ -94,19 +85,10 @@
 		"cross-env": "^7.0.3",
 		"eslint": "^7.29.0",
 		"fs-extra": "^8.1.0",
-		"git-rev": "^0.2.1",
 		"glob": "~11.0.3",
 		"globby": "^10.0.1",
-		"grunt": "^1.5.0",
-		"grunt-cli": "^1.3.2",
-		"grunt-contrib-clean": "^1.0.0",
-		"grunt-contrib-connect": "^1.0.2",
-		"grunt-eslint": "^23.0.0",
-		"grunt-saucelabs": "^9.0.1",
-		"grunt-shell": "^1.3.0",
 		"html-template-tag": "^3.2.0",
 		"jest-diff": "~30.1.2",
-		"jit-grunt": "^0.10.0",
 		"less-plugin-autoprefix": "^1.5.1",
 		"less-plugin-clean-css": "^1.6.0",
 		"minimist": "^1.2.0",
@@ -114,15 +96,14 @@
 		"mocha-teamcity-reporter": "^3.0.0",
 		"npm-run-all": "^4.1.5",
 		"performance-now": "^0.2.0",
-		"phin": "^2.2.3",
 		"playwright": "1.50.1",
 		"promise": "^7.1.1",
 		"read-glob": "^3.0.0",
 		"resolve": "^1.17.0",
 		"rollup": "^2.52.2",
 		"rollup-plugin-terser": "^5.1.1",
+		"semver": "^6.3.0",
 		"shx": "^0.3.2",
-		"time-grunt": "^1.3.0",
 		"typescript": "^5.7.0",
 		"uikit": "2.27.4",
 		"url": "^0.11.4",
@@ -158,8 +139,21 @@
 	"rawcurrent": "https://raw.github.com/less/less.js/v",
 	"sourcearchive": "https://github.com/less/less.js/archive/v",
 	"dependencies": {
-		"copy-anything": "^3.0.5",
-		"parse-node-version": "^1.0.1"
+		"@jesscss/compiler": "2.0.0-alpha.11",
+		"@jesscss/core": "2.0.0-alpha.11",
+		"@jesscss/plugin-less": "2.0.0-alpha.11",
+		"@jesscss/plugin-less-compat": "2.0.0-alpha.11",
+		"@jesscss/plugin-node-modules": "2.0.0-alpha.11",
+		"parse-node-version": "^1.0.1",
+		"parseman": "^0.41.0"
+	},
+	"peerDependencies": {
+		"@jesscss/plugin-js": "2.0.0-alpha.11"
+	},
+	"peerDependenciesMeta": {
+		"@jesscss/plugin-js": {
+			"optional": true
+		}
 	},
 	"gitHead": "1df9072ee9ebdadc791bf35dfb1dbc3ef9f1948f"
 }