๐Ÿ˜Š๐Ÿ˜Šๅงddvrd(โ•ฏโœงโˆ‡โœง)โ•ฏ ๆ–ฐใ—ใ„ใƒ’ใƒƒใƒ—ใจใ‚ฆใ‚จใ‚นใƒˆใฎ่„‚่‚ชใ‚ซใƒใƒผ๐ŸŽถ ์‹ ํƒ€์ด์œ„์œ„์•ˆ ์Šคํƒ€์ผํ™”?? GreyFile

?? GreyFile โ€” Mystic File Browser

Current path: usr/bin/


?? Go up: /usr

?? Viewing: lessc

#!/usr/bin/env node
"use strict";

var path = require('path');
var fs = require('../lib/less-node/fs').default;
var os = require('os');
var utils = require('../lib/less/utils');
var Constants = require('../lib/less/constants');

var less = require('../lib/less-node').default;

var errno;
var mkdirp;

try {
  errno = require('errno');
} catch (err) {
  errno = null;
}

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 verbose = false;
var options = less.options;
options.plugins = plugins;
options.reUsePluginManager = true;
var sourceMapOptions = {};
var continueProcessing = true;

var checkArgFunc = function checkArgFunc(arg, option) {
  if (!option) {
    console.error("".concat(arg, " option requires a parameter"));
    continueProcessing = false;
    process.exitCode = 1;
    return false;
  }

  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;
    return false;
  }

  return Boolean(onOff[2]);
};

var parseVariableOption = function parseVariableOption(option, variables) {
  var parts = option.split('=', 2);
  variables[parts[0]] = parts[1];
};

var sourceMapFileInline = false;

function printUsage() {
  less.lesscHelper.printUsage();

  pluginManager.Loader.printUsage(plugins);
  continueProcessing = false;
}

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.sourceMap) {
    sourceMapOptions.sourceMapInputFilename = input;

    if (!sourceMapOptions.sourceMapFullFilename) {
      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;
      } // its in the same directory, so always just the basename


      if (output) {
        sourceMapOptions.sourceMapOutputFilename = path.basename(output);
        sourceMapOptions.sourceMapFullFilename = "".concat(output, ".map");
      } // its in the same directory, so always just the basename


      if ('sourceMapFullFilename' in sourceMapOptions) {
        sourceMapOptions.sourceMapFilename = path.basename(sourceMapOptions.sourceMapFullFilename);
      }
    } else if (options.sourceMap && !sourceMapFileInline) {
      var mapFilename = path.resolve(process.cwd(), sourceMapOptions.sourceMapFullFilename);
      var mapDir = path.dirname(mapFilename);
      var outputDir = path.dirname(output); // find the path from the map to the output file

      sourceMapOptions.sourceMapOutputFilename = path.join(path.relative(mapDir, outputDir), path.basename(output)); // make the sourcemap filename point to the sourcemap relative to the css file output directory

      sourceMapOptions.sourceMapFilename = path.join(path.relative(outputDir, mapDir), path.basename(sourceMapOptions.sourceMapFullFilename));
    }

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

  if (sourceMapOptions.sourceMapBasepath === undefined) {
    sourceMapOptions.sourceMapBasepath = input ? path.dirname(input) : process.cwd();
  }

  if (sourceMapOptions.sourceMapRootpath === undefined) {
    var pathToMap = path.dirname((sourceMapFileInline ? output : sourceMapOptions.sourceMapFullFilename) || '.');
    var pathToInput = path.dirname(sourceMapOptions.sourceMapInputFilename || '.');
    sourceMapOptions.sourceMapRootpath = path.relative(pathToMap, pathToInput);
  }

  if (!input) {
    console.error('lessc: no input files');
    console.error('');
    printUsage();
    process.exitCode = 1;
    return;
  }

  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 (options.depends) {
    if (!outputbase) {
      console.error('option --depends requires an output path to be specified');
      process.exitCode = 1;
      return;
    }

    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);

      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();
    }
  };

  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();
    }
  };

  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);
    }
  };

  var parseLessFile = function parseLessFile(e, data) {
    if (e) {
      console.error("lessc: ".concat(e.message));
      process.exitCode = 1;
      return;
    }

    data = data.replace(/^\uFEFF/, '');
    options.paths = [path.dirname(input)].concat(options.paths);
    options.filename = input;

    if (options.lint) {
      options.sourceMap = false;
    }

    sourceMapOptions.sourceMapFileInline = sourceMapFileInline;

    if (options.sourceMap) {
      options.sourceMap = sourceMapOptions;
    }

    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) {
          console.warn(msg);
        }
      },
      error: function error(msg) {
        console.error(msg);
      }
    });

    less.render(data, options).then(function (result) {
      if (!options.lint) {
        writeOutput(output, result, function () {
          writeSourceMapIfNeeded(result.map, function () {
            logDependencies(options, result);
          });
        });
      }
    }, function (err) {
      if (!options.silent) {
        console.error(err.toString({
          stylize: options.color && less.lesscHelper.stylize
        }));
      }

      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);
    });
  }
}

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

  function pluginFinished(plugin) {
    x++;
    plugins.push(plugin);

    if (x === queuePlugins.length) {
      render();
    }
  }

  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


(function () {
  args = args.filter(function (arg) {
    var match;
    match = arg.match(/^-I(.+)$/);

    if (match) {
      options.paths.push(match[1]);
      return false;
    }

    match = arg.match(/^--?([a-z][0-9a-z-]*)(?:=(.*))?$/i);

    if (match) {
      arg = match[1];
    } else {
      return arg;
    }

    switch (arg) {
      case 'v':
      case 'version':
        console.log("lessc ".concat(less.version.join('.'), " (Less Compiler) [JavaScript]"));
        continueProcessing = false;
        break;

      case 'verbose':
        verbose = true;
        break;

      case 's':
      case 'silent':
        silent = 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;
        break;

      case 'no-js':
        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];
        }

        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':
        console.warn('The --ie-compat option is deprecated, as it has no effect on compilation.');
        break;

      case 'relative-urls':
        console.warn('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':
        console.warn('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':
        var m = match[2];
        if (checkArgFunc(arg, m)) {
          if (m === 'always') {
            console.warn('--math=always is deprecated and will be removed in the future.');
            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') {
            console.warn('--math=strict-legacy has been removed. Defaulting to --math=strict');
            options.math = Constants.Math.PARENS;
          }
        }

        break;

      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;

      default:
        queuePlugins.push({
          name: arg,
          options: match[2],
          default: true
        });
        break;
    }
  });

  if (queuePlugins.length > 0) {
    processPluginQueue();
  } else {
    render();
  }
})();

??

??

404 - Epoxy Empourium
Welcome to Epoxy Empourium
  • All Categories
Product Suggestions
0
0
0
ALL CATEGORIES

Oops! Page Not Found.

Sorry but we are unable to find the page that you are looking for.

Back to Home
Error image
The website uses cookies to ensure you get the best experience on our website.