less 4.9.1 → 5.0.0-alpha.10

package/bin/lessc

@@ -1,678 +1,354 @@
 #!/usr/bin/env node
 
-/* eslint indent: [2, 2, {"SwitchCase": 1}] */
+/**
+ * Less compiler (Jess-powered) — compiles .less files to CSS.
+ */
 
 import path from 'path';
-import os from 'os';
-import { createRequire } from 'module';
-import fs from '../lib/less-node/fs.js';
-import * as utils from '../lib/less/utils.js';
-import * as Constants from '../lib/less/constants.js';
-import less from '../lib/less-node/index.js';
-
-const require = createRequire(import.meta.url);
-
-var errno;
+import fs from 'fs';
+import less from '../lib/index.js';
+import { version as versionInfo } from '../lib/version.js';
+import { outputDiagnostics } from '@jesscss/compiler/diagnostics';
+
+const args = process.argv.slice(1);
+let options = { paths: [], filename: '' };
+let input = null;
+let output = null;
+let silent = false;
+let quiet = false;
+let verbose = false;
+let sourceMapEnabled = false;
+let sourceMapExplicitFile = null;
+const sourceMapOptions = {};
+
+const unsupportedOptions = new Map([
+  ['--plugin', 'legacy lessc plugin flags are not supported'],
+  ['--depends', 'dependency-only output is not supported'],
+  ['--lint', 'lint-only mode is not supported'],
+  ['--clean-css', 'clean-css compression is not supported'],
+  ['--global-var', 'global variable injection is not supported'],
+  ['--modify-var', 'modify-var injection is not supported'],
+  ['--js', 'JavaScript evaluation is not supported'],
+  ['--no-js', 'JavaScript evaluation flags are not supported'],
+]);
+
+function stripTerminalFormatting(value) {
+  return String(value)
+    .replace(/\x1B\]8;;[^\x1B]*(?:\x1B\\|\x07)/gu, '')
+    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/gu, '');
+}
 
-try {
-  errno = require('errno');
-} catch (err) {
-  errno = null;
+function renderLogMessage(value) {
+  const message = String(value);
+  return options.color === false ? stripTerminalFormatting(message) : message;
 }
 
-var pluginManager = new less.PluginManager(less);
-var fileManager = new less.FileManager();
-var plugins = [];
-var queuePlugins = [];
-var args = process.argv.slice(1);
-var silent = false;
-var quiet = false;
-var verbose = false;
-var options = less.options;
-options.plugins = plugins;
-options.reUsePluginManager = true;
-var sourceMapOptions = {};
-var continueProcessing = true;
+function captureJessDiagnostics(errors, warnings) {
+  const originalStdoutWrite = process.stdout.write;
+  const originalWrite = process.stderr.write;
+  let captured = '';
+  const captureDiagnosticWrite = function captureDiagnosticWrite(chunk, ...args) {
+    captured += String(chunk);
+    if (typeof args.at(-1) === 'function') {
+      args.at(-1)();
+    }
+    return true;
+  };
+  process.stdout.write = captureDiagnosticWrite;
+  process.stderr.write = captureDiagnosticWrite;
+  try {
+    outputDiagnostics(errors, warnings, {
+      suppressWarnings: quiet,
+      breakOnError: false,
+      verbose
+    });
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalWrite;
+  }
+  return options.color === false ? stripTerminalFormatting(captured) : captured;
+}
 
-var checkArgFunc = function checkArgFunc(arg, option) {
-  if (!option) {
-    console.error(''.concat(arg, ' option requires a parameter'));
-    continueProcessing = false;
-    process.exitCode = 1;
+function outputJessDiagnostics(errors, warnings = []) {
+  const relevantWarnings = quiet ? [] : warnings;
+  if ((!Array.isArray(errors) || errors.length === 0) && relevantWarnings.length === 0) {
     return false;
   }
-
+  process.stderr.write(captureJessDiagnostics(errors || [], relevantWarnings));
   return true;
-};
-
-var checkBooleanArg = function checkBooleanArg(arg) {
-  var onOff = /^((on|t|true|y|yes)|(off|f|false|n|no))$/i.exec(arg);
+}
 
-  if (!onOff) {
-    console.error(' unable to parse '.concat(arg, ' as a boolean. use one of on/t/true/y/yes/off/f/false/n/no'));
-    continueProcessing = false;
-    process.exitCode = 1;
+function outputJessError(err) {
+  if (!Array.isArray(err?.jessErrors) || err.jessErrors.length === 0) {
     return false;
   }
+  outputJessDiagnostics(err.jessErrors, err.jessWarnings || []);
+  return true;
+}
 
-  return Boolean(onOff[2]);
-};
-
-var parseVariableOption = function parseVariableOption(option, variables) {
-  var parts = option.split('=', 2);
-  variables[parts[0]] = parts[1];
-};
+function splitSearchPaths(value) {
+  return String(value || '')
+    .split(path.delimiter)
+    .filter(Boolean);
+}
 
-var sourceMapFileInline = false;
-var pendingDeprecations = [];
+function failUnsupportedOption(arg, reason) {
+  console.error(`lessc: ${arg} is not supported`);
+  if (reason) {
+    console.error(`lessc: ${reason}`);
+  }
+  console.error('lessc: run `lessc --help` for supported options.');
+  process.exit(1);
+}
 
 function printUsage() {
   less.lesscHelper.printUsage();
-
-  pluginManager.Loader.printUsage(plugins);
-  continueProcessing = false;
+  process.exit(0);
 }
 
-function render() {
-  if (!continueProcessing) {
-    return;
-  }
-
-  var input = args[1];
-
-  if (input && input != '-') {
-    input = path.resolve(process.cwd(), input);
-  }
-
-  var output = args[2];
-  var outputbase = args[2];
-
-  if (output) {
-    output = path.resolve(process.cwd(), output);
-  }
-
-  if (options.disablePluginRule && queuePlugins.length > 0) {
-    console.error('--plugin and --disable-plugin-rule may not be used at the same time');
-    process.exitCode = 1;
-    return;
-  }
-
-  if (options.sourceMap) {
-    // Validate conflicting options
-    if (sourceMapOptions.sourceMapURL && sourceMapOptions.disableSourcemapAnnotation) {
-      console.error('You cannot provide flag --source-map-url with --source-map-no-annotation.');
-      console.error('Please remove one of those flags.');
-      process.exitcode = 1;
-      return;
+function parseArgs() {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-h' || arg === '--help') {
+      printUsage();
     }
-
-    // Handle explicit sourceMapFullFilename (from --source-map=filename)
-    // Normalization of other options (sourceMapBasepath, sourceMapRootpath, etc.)
-    // is handled automatically in parse-tree.js
-    if (sourceMapOptions.sourceMapFullFilename && !sourceMapFileInline) {
-      var mapFilename = path.resolve(process.cwd(), sourceMapOptions.sourceMapFullFilename);
-      var mapDir = path.dirname(mapFilename);
-
-      if (output) {
-        var outputDir = path.dirname(output);
-        // Set sourceMapOutputFilename relative to map directory
-        sourceMapOptions.sourceMapOutputFilename = path.join(
-          path.relative(mapDir, outputDir),
-          path.basename(output)
-        );
-        // Set sourceMapFilename relative to output directory (for sourceMappingURL comment)
-        sourceMapOptions.sourceMapFilename = path.join(
-          path.relative(outputDir, mapDir),
-          path.basename(sourceMapOptions.sourceMapFullFilename)
-        );
-      } else {
-        // No output filename, just use basename
-        sourceMapOptions.sourceMapOutputFilename = path.basename(output || 'output.css');
-        sourceMapOptions.sourceMapFilename = path.basename(sourceMapOptions.sourceMapFullFilename);
-      }
-    } else if (!sourceMapOptions.sourceMapFullFilename && output && !sourceMapFileInline) {
-      // No explicit sourcemap filename, derive from output
-      sourceMapOptions.sourceMapOutputFilename = path.basename(output);
-      sourceMapOptions.sourceMapFullFilename = ''.concat(output, '.map');
-    } else if (!output && !sourceMapFileInline) {
-      console.error('the sourcemap option only has an optional filename if the css filename is given');
-      console.error('consider adding --source-map-map-inline which embeds the sourcemap into the css');
-      process.exitCode = 1;
-      return;
+    if (arg === '-v' || arg === '--version') {
+      console.log(`lessc ${versionInfo.semver} (Less Compiler) [Jess]`);
+      process.exit(0);
     }
-  }
-
-  if (!input) {
-    console.error('lessc: no input files');
-    console.error('');
-    printUsage();
-    process.exitCode = 1;
-    return;
-  }
-
-  var mkdirp;
-  var ensureDirectory = function ensureDirectory(filepath) {
-    var dir = path.dirname(filepath);
-    var cmd;
-    var existsSync = fs.existsSync || path.existsSync;
-
-    if (!existsSync(dir)) {
-      if (mkdirp === undefined) {
-        try {
-          mkdirp = require('make-dir');
-        } catch (e) {
-          mkdirp = null;
-        }
-      }
-
-      cmd = mkdirp && mkdirp.sync || fs.mkdirSync;
-      cmd(dir);
+    if (arg === '-s' || arg === '--silent') {
+      silent = true;
+      continue;
     }
-  };
-
-  if (options.depends) {
-    if (!outputbase) {
-      console.error('option --depends requires an output path to be specified');
-      process.exitCode = 1;
-      return;
+    if (arg === '--quiet') {
+      quiet = true;
+      continue;
     }
-
-    process.stdout.write(''.concat(outputbase, ': '));
-  }
-
-  if (!sourceMapFileInline) {
-    var writeSourceMap = function writeSourceMap() {
-      var output = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-      var onDone = arguments.length > 1 ? arguments[1] : undefined;
-      var filename = sourceMapOptions.sourceMapFullFilename;
-      ensureDirectory(filename);
-
-      // To fix https://github.com/less/less.js/issues/3646
-      output = output.toString();
-
-      fs.writeFile(filename, output, 'utf8', function (err) {
-        if (err) {
-          var description = 'Error: ';
-
-          if (errno && errno.errno[err.errno]) {
-            description += errno.errno[err.errno].description;
-          } else {
-            description += ''.concat(err.code, ' ').concat(err.message);
-          }
-
-          console.error('lessc: failed to create file '.concat(filename));
-          console.error(description);
-          process.exitCode = 1;
-        } else {
-          less.logger.info('lessc: wrote '.concat(filename));
-        }
-
-        onDone();
-      });
-    };
-  }
-
-  var writeSourceMapIfNeeded = function writeSourceMapIfNeeded(output, onDone) {
-    if (options.sourceMap && !sourceMapFileInline) {
-      writeSourceMap(output, onDone);
-    } else {
-      onDone();
+    if (arg === '--verbose') {
+      verbose = true;
+      continue;
     }
-  };
-
-  var writeOutput = function writeOutput(output, result, onSuccess) {
-    if (options.depends) {
-      onSuccess();
-    } else if (output) {
-      ensureDirectory(output);
-
-      fs.writeFile(output, result.css, {
-        encoding: 'utf8'
-      }, function (err) {
-        if (err) {
-          var description = 'Error: ';
-
-          if (errno && errno.errno[err.errno]) {
-            description += errno.errno[err.errno].description;
-          } else {
-            description += ''.concat(err.code, ' ').concat(err.message);
-          }
-
-          console.error('lessc: failed to create file '.concat(output));
-          console.error(description);
-          process.exitCode = 1;
-        } else {
-          less.logger.info('lessc: wrote '.concat(output));
-
-          onSuccess();
-        }
-      });
-    } else if (!options.depends) {
-      process.stdout.write(result.css);
-      onSuccess();
+    const collapseNestingMatch = arg.match(/^--collapse-nesting(?:=(.+))?$/);
+    if (collapseNestingMatch) {
+      options.collapseNesting = collapseNestingMatch[1] ?? true;
+      continue;
     }
-  };
-
-  var logDependencies = function logDependencies(options, result) {
-    if (options.depends) {
-      var depends = '';
-
-      for (var i = 0; i < result.imports.length; i++) {
-        depends += ''.concat(result.imports[i], ' ');
-      }
-
-      console.log(depends);
+    if (arg === '--compress' || arg === '-x') {
+      options.compress = true;
+      continue;
     }
-  };
-
-  var parseLessFile = function parseLessFile(e, data) {
-    if (e) {
-      console.error('lessc: '.concat(e.message));
-      process.exitCode = 1;
-      return;
+    const mathMatch = arg.match(/^--math=(.+)$/);
+    if (mathMatch) {
+      options.math = mathMatch[1];
+      continue;
     }
-
-    data = data.replace(/^\uFEFF/, '');
-    options.paths = [path.dirname(input)].concat(options.paths);
-    options.filename = input;
-
-    if (options.lint) {
-      options.sourceMap = false;
+    // URL rewriting (forwarded to the Less plugin). `--rewrite-urls` with no
+    // value is Less 4.x's `all`.
+    const rewriteUrlsMatch = arg.match(/^--rewrite-urls(?:=(.+))?$/);
+    if (rewriteUrlsMatch) {
+      options.rewriteUrls = rewriteUrlsMatch[1] ?? 'all';
+      continue;
     }
-
-    sourceMapOptions.sourceMapFileInline = sourceMapFileInline;
-
-    if (options.sourceMap) {
-      options.sourceMap = sourceMapOptions;
+    const rootpathMatch = arg.match(/^--rootpath=(.+)$/);
+    if (rootpathMatch) {
+      options.rootpath = rootpathMatch[1];
+      continue;
     }
-
-    less.logger.addListener({
-      info: function info(msg) {
-        if (verbose) {
-          console.log(msg);
-        }
-      },
-      warn: function warn(msg) {
-        // do not show warning if the silent option is used
-        if (!silent && !quiet) {
-          console.warn(msg);
-        }
-      },
-      error: function error(msg) {
-        if (!silent) {
-          console.error(msg);
-        }
-      }
-    });
-
-    less.render(data, options).then(function (result) {
-      if (!options.lint) {
-        writeOutput(output, result, function () {
-          writeSourceMapIfNeeded(result.map, function () {
-            logDependencies(options, result);
-          });
-        });
+    const urlArgsMatch = arg.match(/^--url-args=(.+)$/);
+    if (urlArgsMatch) {
+      options.urlArgs = urlArgsMatch[1];
+      continue;
+    }
+    // Source maps. The `--source-map-*` sub-flags are matched before the bare
+    // `--source-map[=file]` (their `$`-anchored patterns don't overlap, but the
+    // ordering documents intent). Each sub-flag also enables source maps.
+    if (arg === '--source-map-inline' || arg === '--source-map-map-inline') {
+      sourceMapEnabled = true;
+      sourceMapOptions.sourceMapFileInline = true;
+      continue;
+    }
+    if (arg === '--source-map-include-source') {
+      sourceMapEnabled = true;
+      sourceMapOptions.outputSourceFiles = true;
+      continue;
+    }
+    const smRootpathMatch = arg.match(/^--source-map-rootpath=(.+)$/);
+    if (smRootpathMatch) {
+      sourceMapEnabled = true;
+      sourceMapOptions.sourceMapRootpath = smRootpathMatch[1];
+      continue;
+    }
+    const smBasepathMatch = arg.match(/^--source-map-basepath=(.+)$/);
+    if (smBasepathMatch) {
+      sourceMapEnabled = true;
+      sourceMapOptions.sourceMapBasepath = smBasepathMatch[1];
+      continue;
+    }
+    const smUrlMatch = arg.match(/^--source-map-url=(.+)$/);
+    if (smUrlMatch) {
+      sourceMapEnabled = true;
+      sourceMapOptions.sourceMapURL = smUrlMatch[1];
+      continue;
+    }
+    const sourceMapMatch = arg.match(/^--source-map(?:=(.+))?$/);
+    if (sourceMapMatch) {
+      sourceMapEnabled = true;
+      if (sourceMapMatch[1]) {
+        sourceMapExplicitFile = sourceMapMatch[1];
       }
-    }, function (err) {
-      if (!options.silent) {
-        console.error(err.toString({
-          stylize: options.color && less.lesscHelper.stylize
-        }));
+      continue;
+    }
+    // Deprecated 4.x spellings (--strict-units, --strict-units=on|off, -su=on|off)
+    // set the deprecated `strictUnits` boolean; `createLessOptions` maps it to
+    // `unitMode` and warns during compile, after the logger listener is attached.
+    const strictUnitsMatch = arg.match(/^(?:--strict-units|-su)(?:=(on|off))?$/);
+    if (strictUnitsMatch) {
+      options.strictUnits = strictUnitsMatch[1] !== 'off';
+      continue;
+    }
+    const unitModeMatch = arg.match(/^--unit-mode=(.+)$/);
+    if (unitModeMatch) {
+      options.unitMode = unitModeMatch[1];
+      continue;
+    }
+    const optionName = arg.includes('=') ? arg.slice(0, arg.indexOf('=')) : arg;
+    if (unsupportedOptions.has(optionName)) {
+      failUnsupportedOption(optionName, unsupportedOptions.get(optionName));
+    }
+    if (arg === '-I' || arg === '--include-path') {
+      const match = arg.match(/^-I(.+)$/);
+      const paths = splitSearchPaths(match ? match[1] : args[++i]);
+      options.paths.push(...paths);
+      continue;
+    }
+    if (arg.startsWith('-I')) {
+      options.paths.push(...splitSearchPaths(arg.slice(2)));
+      continue;
+    }
+    const includeMatch = arg.match(/^--include-path=(.+)$/);
+    if (includeMatch) {
+      options.paths.push(...splitSearchPaths(includeMatch[1]));
+      continue;
+    }
+    if (arg === '--no-color') {
+      options.color = false;
+      continue;
+    }
+    if (arg === '-' || arg.endsWith('.less') || arg.endsWith('.css')) {
+      if (input === null) {
+        input = arg === '-' ? '-' : path.resolve(process.cwd(), arg);
+      } else if (output === null) {
+        output = path.resolve(process.cwd(), arg);
       }
-
-      process.exitCode = 1;
-    });
-  };
-
-  if (input != '-') {
-    fs.readFile(input, 'utf8', parseLessFile);
-  } else {
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
-    var buffer = '';
-    process.stdin.on('data', function (data) {
-      buffer += data;
-    });
-    process.stdin.on('end', function () {
-      parseLessFile(false, buffer);
-    });
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      failUnsupportedOption(arg, 'unknown flags are not supported');
+    }
   }
 }
 
-function processPluginQueue() {
-  var x = 0;
-
-  function pluginError(name) {
-    console.error('Unable to load plugin '.concat(name, ' please make sure that it is installed under or at the same level as less'));
-    process.exitCode = 1;
+// Assemble the `sourceMap` render option from the CLI source-map flags and
+// return the sidecar `.map` path to write (null when inlined or unset). The
+// engine writes the `sourceMappingURL` annotation into the CSS and returns
+// `result.map`; the CLI owns writing that map to disk, mirroring Less 4.x lessc.
+function resolveSourceMap() {
+  if (!sourceMapEnabled) {
+    return null;
   }
-
-  function pluginFinished(plugin) {
-    x++;
-    plugins.push(plugin);
-
-    if (x === queuePlugins.length) {
-      render();
+  let mapFilePath = null;
+  if (sourceMapOptions.sourceMapFileInline !== true) {
+    if (sourceMapExplicitFile) {
+      mapFilePath = path.resolve(process.cwd(), sourceMapExplicitFile);
+    } else if (output) {
+      mapFilePath = `${output}.map`;
+    } else {
+      // Writing CSS to stdout leaves nowhere for a sidecar; inline the map.
+      sourceMapOptions.sourceMapFileInline = true;
+    }
+  }
+  if (mapFilePath) {
+    // Annotation URL (unless --source-map-url set it) points at the map relative
+    // to the CSS output directory — so a map written to another directory still
+    // resolves (dist/app.css -> ../maps/app.map), and the same-dir common case
+    // stays a bare basename. With no output file (stdout) there is no directory
+    // to resolve against, so fall back to the basename.
+    if (sourceMapOptions.sourceMapURL === undefined) {
+      sourceMapOptions.sourceMapFilename = output
+        ? path.relative(path.dirname(output), mapFilePath).split(path.sep).join('/')
+        : path.basename(mapFilePath);
+    }
+    if (output) {
+      sourceMapOptions.sourceMapOutputFilename = path.basename(output);
     }
   }
+  options.sourceMap = sourceMapOptions;
+  return mapFilePath;
+}
 
-  queuePlugins.forEach(function (queue) {
-    var context = utils.clone(options);
-    pluginManager.Loader.loadPlugin(queue.name, process.cwd(), context, less.environment, fileManager).then(function (data) {
-      pluginFinished({
-        fileContent: data.contents,
-        filename: data.filename,
-        options: queue.options
-      });
-    }).catch(function () {
-      pluginError(queue.name);
-    });
-  });
-} // self executing function so we can return
+async function run() {
+  parseArgs();
 
+  if (!input) {
+    console.error('lessc: no input files');
+    console.error('');
+    printUsage();
+  }
 
-(function () {
-  args = args.filter(function (arg) {
-    var match;
-    match = arg.match(/^-I(.+)$/);
+  const mapFilePath = resolveSourceMap();
+
+  less.logger.addListener({
+    info(msg) {
+      if (verbose) console.log(msg);
+    },
+    warn(msg) {
+      if (!silent && !quiet) console.warn(renderLogMessage(msg));
+    },
+    error(msg) {
+      if (!silent) console.error(renderLogMessage(msg));
+    },
+  });
 
-    if (match) {
-      options.paths.push(match[1]);
-      return false;
+  try {
+    let result;
+    if (input === '-') {
+      const data = await new Promise((resolve, reject) => {
+        let buf = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', chunk => { buf += chunk; });
+        process.stdin.on('end', () => resolve(buf));
+        process.stdin.on('error', reject);
+      });
+      result = await less.render(data, { ...options, filename: 'input.less' });
+    } else {
+      options.filename = input;
+      options.paths = [path.dirname(input), ...options.paths];
+      result = await less.renderFile(input, options);
     }
 
-    match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=(.*))?$/i);
-
-    if (match) {
-      arg = match[1];
+    if (output) {
+      fs.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, result.css, 'utf8');
+      if (!silent) outputJessDiagnostics([], result.warnings || []);
+      if (!silent) console.log(`lessc: wrote ${output}`);
     } else {
-      return arg;
+      if (!silent) outputJessDiagnostics([], result.warnings || []);
+      process.stdout.write(result.css);
     }
 
-    switch (arg) {
-      case 'v':
-      case 'version':
-        console.log('lessc '.concat(less.version.join('.'), ' (Less Compiler) [JavaScript]'));
-        continueProcessing = false;
-        break;
-
-      case 'verbose':
-        options.verbose = verbose = true;
-        break;
-
-      case 's':
-      case 'silent':
-        options.silent = silent = true;
-        break;
-
-      case 'quiet':
-        options.quiet = quiet = true;
-        break;
-
-      case 'quiet-deprecations':
-        options.quietDeprecations = true;
-        break;
-
-      case 'l':
-      case 'lint':
-        options.lint = true;
-        break;
-
-      case 'strict-imports':
-        options.strictImports = true;
-        break;
-
-      case 'h':
-      case 'help':
-        printUsage();
-        break;
-
-      case 'x':
-      case 'compress':
-        options.compress = true;
-        break;
-
-      case 'insecure':
-        options.insecure = true;
-        break;
-
-      case 'M':
-      case 'depends':
-        options.depends = true;
-        break;
-
-      case 'max-line-len':
-        if (checkArgFunc(arg, match[2])) {
-          options.maxLineLen = parseInt(match[2], 10);
-
-          if (options.maxLineLen <= 0) {
-            options.maxLineLen = -1;
-          }
-        }
-
-        break;
-
-      case 'no-color':
-        options.color = false;
-        break;
-
-      case 'js':
-        options.javascriptEnabled = true;
-        pendingDeprecations.push('Warning: Inline JavaScript (--js) is deprecated and will be removed in Less 5.x. Use Less functions or custom plugins instead. (js-eval)');
-        break;
-
-      case 'no-js':
-        // eslint-disable-next-line max-len
-        console.error('The "--no-js" argument is deprecated, as inline JavaScript is disabled by default. Use "--js" to enable inline JavaScript (not recommended).');
-        break;
-
-      case 'include-path':
-        if (checkArgFunc(arg, match[2])) {
-          // ; supported on windows.
-          // : supported on windows and linux, excluding a drive letter like C:\ so C:\file:D:\file parses to 2
-          options.paths = match[2].split(os.type().match(/Windows/) ? /:(?!\\)|;/ : ':').map(function (p) {
-            if (p) {
-              return path.resolve(process.cwd(), p);
-            }
-          });
-        }
-
-        break;
-
-      case 'line-numbers':
-        if (checkArgFunc(arg, match[2])) {
-          options.dumpLineNumbers = match[2];
-          pendingDeprecations.push('Warning: The --line-numbers option is deprecated and will be removed in Less 5.x. Use source maps instead (--source-map). (dump-line-numbers)');
-        }
-
-        break;
-
-      case 'source-map':
-        options.sourceMap = true;
-
-        if (match[2]) {
-          sourceMapOptions.sourceMapFullFilename = match[2];
-        }
-
-        break;
-
-      case 'source-map-rootpath':
-        if (checkArgFunc(arg, match[2])) {
-          sourceMapOptions.sourceMapRootpath = match[2];
-        }
-
-        break;
-
-      case 'source-map-basepath':
-        if (checkArgFunc(arg, match[2])) {
-          sourceMapOptions.sourceMapBasepath = match[2];
-        }
-
-        break;
-
-      case 'source-map-inline':
-      case 'source-map-map-inline':
-        sourceMapFileInline = true;
-        options.sourceMap = true;
-        break;
-
-      case 'source-map-include-source':
-      case 'source-map-less-inline':
-        sourceMapOptions.outputSourceFiles = true;
-        break;
-
-      case 'source-map-url':
-        if (checkArgFunc(arg, match[2])) {
-          sourceMapOptions.sourceMapURL = match[2];
-        }
-
-        break;
-
-      case 'source-map-no-annotation':
-        sourceMapOptions.disableSourcemapAnnotation = true;
-        break;
-
-      case 'rp':
-      case 'rootpath':
-        if (checkArgFunc(arg, match[2])) {
-          options.rootpath = match[2].replace(/\\/g, '/');
-        }
-
-        break;
-
-      case 'ie-compat':
-        pendingDeprecations.push('Warning: The --ie-compat option is deprecated, as it has no effect on compilation.');
-        break;
-
-      case 'relative-urls':
-        pendingDeprecations.push('Warning: The --relative-urls option has been deprecated. Use --rewrite-urls=all.');
-        options.rewriteUrls = Constants.RewriteUrls.ALL;
-        break;
-
-      case 'ru':
-      case 'rewrite-urls':
-        var m = match[2];
-
-        if (m) {
-          if (m === 'local') {
-            options.rewriteUrls = Constants.RewriteUrls.LOCAL;
-          } else if (m === 'off') {
-            options.rewriteUrls = Constants.RewriteUrls.OFF;
-          } else if (m === 'all') {
-            options.rewriteUrls = Constants.RewriteUrls.ALL;
-          } else {
-            console.error('Unknown rewrite-urls argument '.concat(m));
-            continueProcessing = false;
-            process.exitCode = 1;
-          }
-        } else {
-          options.rewriteUrls = Constants.RewriteUrls.ALL;
-        }
-
-        break;
-
-      case 'sm':
-      case 'strict-math':
-        pendingDeprecations.push('Warning: The --strict-math option has been deprecated. Use --math=strict.');
-
-        if (checkArgFunc(arg, match[2])) {
-          if (checkBooleanArg(match[2])) {
-            options.math = Constants.Math.PARENS;
-          }
-        }
-
-        break;
-
-      case 'm':
-      case 'math': {
-        let m = match[2];
-        if (checkArgFunc(arg, m)) {
-          if (m === 'always') {
-            pendingDeprecations.push('Warning: --math=always is deprecated and will be removed in Less 5.x. Use --math=parens-division (default) or --math=parens. (math-always)');
-            options.math = Constants.Math.ALWAYS;
-          } else if (m === 'parens-division') {
-            options.math = Constants.Math.PARENS_DIVISION;
-          } else if (m === 'parens' || m === 'strict') {
-            options.math = Constants.Math.PARENS;
-          } else if (m === 'strict-legacy') {
-            pendingDeprecations.push('Warning: --math=strict-legacy has been removed. Defaulting to --math=strict.');
-            options.math = Constants.Math.PARENS;
-          }
-        }
-
-        break;
+    if (mapFilePath && result.map) {
+      fs.mkdirSync(path.dirname(mapFilePath), { recursive: true });
+      fs.writeFileSync(mapFilePath, result.map, 'utf8');
+      if (!silent) console.log(`lessc: wrote ${mapFilePath}`);
+    }
+  } catch (err) {
+    if (!silent) {
+      if (!outputJessError(err)) {
+        console.error(renderLogMessage(err.toString?.() || err.message));
       }
-      case 'su':
-      case 'strict-units':
-        if (checkArgFunc(arg, match[2])) {
-          options.strictUnits = checkBooleanArg(match[2]);
-        }
-
-        break;
-
-      case 'global-var':
-        if (checkArgFunc(arg, match[2])) {
-          if (!options.globalVars) {
-            options.globalVars = {};
-          }
-
-          parseVariableOption(match[2], options.globalVars);
-        }
-
-        break;
-
-      case 'modify-var':
-        if (checkArgFunc(arg, match[2])) {
-          if (!options.modifyVars) {
-            options.modifyVars = {};
-          }
-
-          parseVariableOption(match[2], options.modifyVars);
-        }
-
-        break;
-
-      case 'url-args':
-        if (checkArgFunc(arg, match[2])) {
-          options.urlArgs = match[2];
-        }
-
-        break;
-
-      case 'plugin':
-        var splitupArg = match[2].match(/^([^=]+)(=(.*))?/);
-        var name = splitupArg[1];
-        var pluginOptions = splitupArg[3];
-        queuePlugins.push({
-          name: name,
-          options: pluginOptions
-        });
-        break;
-
-      case 'disable-plugin-rule':
-        options.disablePluginRule = true;
-        break;
-
-      default:
-        queuePlugins.push({
-          name: arg,
-          options: match[2],
-          default: true
-        });
-        break;
     }
-  });
-
-  // Flush queued deprecation warnings (respects --silent, --quiet, --quiet-deprecations)
-  if (!silent && !quiet && !options.quietDeprecations) {
-    pendingDeprecations.forEach(function (msg) {
-      console.warn(msg);
-    });
+    process.exitCode = 1;
   }
+}
 
-  if (queuePlugins.length > 0) {
-    processPluginQueue();
-  } else {
-    render();
-  }
-})();
+run();