Modernize and run eslint on tools/lz4-compress.js. NFC

package.json

@@ -14,6 +14,6 @@
     "wasm2c": "1.0.0"
   },
   "scripts": {
-    "lint": "eslint src/parseTools.js tools/acorn-optimizer.js"
+    "lint": "eslint src/parseTools.js tools/acorn-optimizer.js tools/lz4-compress.js"
   }
 }

tools/lz4-compress.js

@@ -1,157 +1,60 @@
+#!/usr/bin/env node
 // Copyright 2015 The Emscripten Authors.  All rights reserved.
 // Emscripten is available under two separate licenses, the MIT license and the
 // University of Illinois/NCSA Open Source License.  Both these licenses can be
 // found in the LICENSE file.
 
-// *** Environment setup code ***
-var arguments_ = [];
-var debug = false;
+const fs = require('fs');
+const path = require('path');
 
-var ENVIRONMENT_IS_NODE = typeof process === 'object';
-var ENVIRONMENT_IS_WEB = typeof window === 'object';
-var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
-var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+const arguments_ = process['argv'].slice(2);
+const debug = false;
 
-if (ENVIRONMENT_IS_NODE) {
-  // Expose functionality in the same simple way that the shells work
-  // Note that we pollute the global namespace here, otherwise we break in node
-  print = function(x) {
-    process['stdout'].write(x + '\n');
-  };
-  printErr = function(x) {
-    process['stderr'].write(x + '\n');
-  };
-
-  var nodeFS = require('fs');
-  var nodePath = require('path');
-
-  if (!nodeFS.existsSync) {
-    nodeFS.existsSync = function(path) {
-      try {
-        return !!nodeFS.readFileSync(path);
-      } catch(e) {
-        return false;
-      }
-    }
-  }
-
-  function find(filename) {
-    var prefixes = [nodePath.join(__dirname, '..', 'src'), process.cwd()];
-    for (var i = 0; i < prefixes.length; ++i) {
-      var combined = nodePath.join(prefixes[i], filename);
-      if (nodeFS.existsSync(combined)) {
-        return combined;
-      }
-    }
-    return filename;
-  }
-
-  read = function(filename, binary) {
-    filename = nodePath['normalize'](filename);
-    var ret = nodeFS['readFileSync'](filename);
-    // The path is absolute if the normalized version is the same as the resolved.
-    if (!ret && filename != nodePath['resolve'](filename)) {
-      filename = path.join(__dirname, '..', 'src', filename);
-      ret = nodeFS['readFileSync'](filename);
-    }
-    if (ret && !binary) ret = ret.toString();
-    return ret;
-  };
-
-  readBinary = function(filename) { return read(filename, true) };
-
-  load = function(f) {
-    globalEval(read(f));
-  };
-
-  arguments_ = process['argv'].slice(2);
-
-} else if (ENVIRONMENT_IS_SHELL) {
-  // Polyfill over SpiderMonkey/V8 differences
-  if (!this['read']) {
-    this['read'] = function(f) { snarf(f) };
-  }
-
-  if (typeof scriptArgs != 'undefined') {
-    arguments_ = scriptArgs;
-  } else if (typeof arguments != 'undefined') {
-    arguments_ = arguments;
-  }
-
-} else if (ENVIRONMENT_IS_WEB) {
-  this['print'] = printErr = function(x) {
-    console.log(x);
-  };
-
-  this['read'] = function(url) {
-    var xhr = new XMLHttpRequest();
-    xhr.open('GET', url, false);
-    xhr.send(null);
-    return xhr.responseText;
-  };
-
-  if (this['arguments']) {
-    arguments_ = arguments;
-  }
-} else if (ENVIRONMENT_IS_WORKER) {
-  // We can do very little here...
-
-  this['load'] = importScripts;
-
-} else {
-  throw 'Unknown runtime environment. Where are we?';
+function print(x) {
+  process['stdout'].write(x + '\n');
 }
 
-function globalEval(x) {
-  eval.call(null, x);
+function printErr(x) {
+  process['stderr'].write(x + '\n');
 }
 
-if (typeof load === 'undefined' && typeof read != 'undefined') {
-  this['load'] = function(f) {
-    globalEval(read(f));
-  };
+function read(filename, binary) {
+  filename = path['normalize'](filename);
+  let ret = fs['readFileSync'](filename);
+  if (ret && !binary) ret = ret.toString();
+  return ret;
 }
 
-if (typeof printErr === 'undefined') {
-  this['printErr'] = function(){};
+function readBinary(filename) {
+  return read(filename, true);
 }
 
-if (typeof print === 'undefined') {
-  this['print'] = printErr;
+function globalEval(x) {
+  eval.call(null, x);
 }
 
-assert = function(x, message) {
-  if (!x) throw 'assertion failed: ' + message + ' : ' + new Error().stack;
+function load(f) {
+  globalEval(read(f));
 }
 
-if (!Math['imul'] || Math['imul'](0xffffffff, 5) !== -5) Math['imul'] = function imul(a, b) {
-  var ah  = a >>> 16;
-  var al = a & 0xffff;
-  var bh  = b >>> 16;
-  var bl = b & 0xffff;
-  return (al*bl + ((ah*bl + al*bh) << 16))|0;
+assert = function(x, message) {
+  if (!x) throw new Errror(message);
 };
 
+// Redirect console.log message from MiniLZ4 to stderr since stdout is
+// where we return the decompressed data.
 console.log = printErr;
 
-// *** Environment setup code ***
-
-var lz4 = arguments_[0];
-var input = arguments_[1];
-var output = arguments_[2];
+const lz4 = arguments_[0];
+const input = arguments_[1];
+const output = arguments_[2];
 
 load(lz4);
 
-var data = readBinary(input);
-if (!(data instanceof ArrayBuffer)) {
-  printErr('converting to ArrayBuffer');
-  data = new Uint8Array(data).buffer;
-}
-
-var start = Date.now();
-var compressedData = MiniLZ4.compressPackage(data);
-nodeFS['writeFileSync'](output, Buffer.from(compressedData['data']));
+const data = new Uint8Array(readBinary(input)).buffer;
+const start = Date.now();
+const compressedData = MiniLZ4.compressPackage(data);
+fs.writeFileSync(output, Buffer.from(compressedData['data']));
 compressedData['data'] = null;
 printErr('compressed in ' + (Date.now() - start) + ' ms');
 print(JSON.stringify(compressedData));
-