less 4.9.1 → 5.0.0-alpha.10

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/browser-dev.js

@@ -0,0 +1,86 @@
+/**
+ * Less.js v5 — browser build (powered by Jess).
+ *
+ * A single-file, in-browser Less→CSS compiler. It drives `@jesscss/compiler`'s
+ * `renderToResult` with an inline `source` and NO `filePath`, so the Node-only
+ * config-discovery layer (cosmiconfig/env-paths/fs) is never reached. `@import`
+ * / file access is unsupported here (see build/browser-stubs/fs.js).
+ *
+ * Bundled to an IIFE that defines `window.less` with the same public shape as
+ * the Less 4.x browser build: `less.render(input, options?, callback?)` returns
+ * a Promise and also invokes the err-first callback when one is given.
+ *
+ * @module less/browser-dev
+ */
+
+import { Compiler } from '@jesscss/compiler';
+import { createLessOptions, mapRenderResult } from './options.js';
+
+/* Injected at build time from packages/less/package.json. */
+/* global __LESS_VERSION__ */
+const semver = typeof __LESS_VERSION__ === 'string' ? __LESS_VERSION__ : '5.0.0-alpha.0';
+const versionArray = semver.split('.').map((n) => parseInt(n, 10) || 0).slice(0, 3);
+
+/**
+ * Build a Less-4.x-shaped error from the first Jess diagnostic. No fs fallback:
+ * in the browser there is no file to re-read for the source extract.
+ * @param {import('./options.js').JessRenderResult} result
+ */
+function createRenderError(result) {
+  const diagnostic = (result?.errors || [])[0];
+  const error = new Error(diagnostic?.message || 'Less render failed');
+  error.type = diagnostic?.phase || 'Syntax';
+  error.filename = diagnostic?.filePath || 'input';
+  error.line = diagnostic?.line || 1;
+  error.column = diagnostic?.column || 1;
+  const lines = diagnostic?.lines;
+  error.extract = Array.isArray(lines) ? lines.map(String) : undefined;
+  error.jessErrors = result?.errors || [];
+  error.jessWarnings = result?.warnings || [];
+  return error;
+}
+
+/**
+ * Render Less source to CSS. Mirrors the Less 4.x API: `options` and `callback`
+ * are both optional, `callback` may be passed as the second argument, and the
+ * returned Promise resolves to a `{ css, warnings }` result. When a callback is
+ * given it is invoked err-first and the Promise is still returned.
+ * @param {string} input Less source
+ * @param {object|Function} [options] Less-style options (math, collapseNesting, plugins) — or the callback
+ * @param {Function} [callback] err-first `(error, result)` callback
+ * @returns {Promise<{ css: string, warnings?: unknown[] }>}
+ */
+function render(input, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  options = options || {};
+  const promise = (async () => {
+    const { configOptions } = createLessOptions(options);
+    // ponytail: fresh Compiler per call — no defaultPlugins hook, so no
+    // node-modules import plugin and no @jesscss/plugin-js. Single-file preview
+    // rarely re-renders in a hot loop; a cache map is not worth the surface.
+    const compiler = new Compiler(configOptions);
+    const result = await compiler.renderToResult(
+      { source: input, language: 'less', extension: '.less' },
+      { ...configOptions, suppressWarnings: true }
+    );
+    if (result.errors?.length) {
+      throw createRenderError(result);
+    }
+    return mapRenderResult(result, options);
+  })();
+  if (typeof callback === 'function') {
+    promise.then((result) => callback(null, result), (error) => callback(error));
+  }
+  return promise;
+}
+
+const less = {
+  version: versionArray,
+  render,
+};
+
+export default less;
+export { render, versionArray as version };

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,64 @@
+/**
+ * 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[=MODE]    Flatten nested rules: native (default), or compact.');
+    console.log('  -x, --compress               Compress output by removing whitespace.');
+    console.log('  --math=MODE                  Math mode: parens-division (default), always, or parens.');
+    console.log('  --unit-mode=MODE             Unit handling in math: preserve (default), strict, or loose (Less 4.x guessing).');
+    console.log('  --strict-units[=on|off]      Deprecated: on is --unit-mode=strict, off is the default (preserve).');
+    console.log('  --source-map[=FILE]          Emit a source map (FILE, or <destination>.map by default).');
+    console.log('  --source-map-inline          Embed the source map as a data URI instead of a file.');
+    console.log('  --source-map-include-source  Embed the source files in the map (sourcesContent).');
+    console.log('  --source-map-rootpath=PATH   Prepend PATH to every source in the map.');
+    console.log('  --source-map-basepath=PATH   Strip PATH from the front of every source in the map.');
+    console.log('  --source-map-url=URL         Override the sourceMappingURL annotation.');
+    console.log('  --rewrite-urls[=all|local|off]  Rewrite url(...) references in imported files.');
+    console.log('  --rootpath=PATH              Prepend PATH to url(...) and import references.');
+    console.log('  --url-args=ARGS             Append ARGS (e.g. cache-buster) to every url(...).');
+    console.log('');
+    console.log('This release intentionally supports a smaller CLI surface.');
+    console.log('Browser compilation, legacy plugin flags, and lint-only mode are not supported.');
+    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,82 @@
+/**
+ * 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';
+  /**
+   * How to flatten authored nesting. Less v5 preserves authored nesting by
+   * default (`false`). `'native'` applies the CSS Nesting desugaring (parent
+   * wrapped in `:is()`, child selector lists distributed — specificity-faithful,
+   * matching the browser and Less 4.x); `'compact'` additionally folds
+   * same-combinator descendant runs into a single `:is()`. `true` is a
+   * deprecated alias for `'native'`.
+   */
+  collapseNesting?: boolean | 'native' | 'compact';
+  /** Minified output. */
+  compress?: boolean;
+  /** Prepend a path to every rewritten `url(...)` and imported reference. */
+  rootpath?: string;
+  /** Rewrite relative `url(...)` against the importing file: `'all'` | `'local'` | `'off'` (or boolean). */
+  rewriteUrls?: boolean | 'all' | 'local' | 'off';
+  /** Append a query string to every non-data `url(...)`. */
+  urlArgs?: string;
+  /**
+   * Emit a source map. `true` turns it on with defaults; the object form (or the
+   * flat legacy `sourceMap*` options) configures it. Returned as `result.map`.
+   */
+  sourceMap?: boolean | {
+    sourceMapURL?: string;
+    sourceMapFilename?: string;
+    sourceMapFullFilename?: string;
+    sourceMapRootpath?: string;
+    sourceMapBasepath?: string;
+    sourceMapFileInline?: boolean;
+    sourceMapOutputFilename?: string;
+    outputSourceFiles?: boolean;
+    disableSourcemapAnnotation?: boolean;
+  };
+  sourceMapURL?: string;
+  sourceMapFilename?: string;
+  sourceMapFullFilename?: string;
+  sourceMapRootpath?: string;
+  sourceMapBasepath?: string;
+  sourceMapFileInline?: boolean;
+  sourceMapOutputFilename?: string;
+  outputSourceFiles?: boolean;
+  disableSourcemapAnnotation?: 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;