DavyKoravand
commented
6 years ago Const is introduced in ES6, in 2015. UglifyJS supports ES5. Use 'Babel' to compile your code to ES5 first.
Closed RossComputerGuy closed 5 years ago
DavyKoravand
commented
6 years ago Const is introduced in ES6, in 2015. UglifyJS supports ES5. Use 'Babel' to compile your code to ES5 first.
fabiosantoscode
commented
6 years ago Or use terser to minify. It supports ES6 and therefore const.
Bug report or feature request?
Uglify version (
uglifyjs -V) 3.4.9JavaScript input
}()); // /
*/ function UInt64(value) { this.value = new BigInteger(value); this.value.twos(64); var arr32 = new Int32Array(new Uint8Array(this.toArray()).buffer); this.low = arr32[0]; this.high = arr32[1]; } /**
*/ UInt64.compare = function (a, b) { return a.value.compare(b.value); }; /**
*/ UInt64.hi = function (num) { return num.high; }; /**
*/ UInt64.lo = function (num) { return num.low; }; /**
*/ UInt64.join = function (high, low) { var result = new UInt64(0); var arr8 = new Uint8Array(new Int32Array([low, high]).buffer); result.value.fromArray(arr8); result.low = low; result.high = high; return result; }; /**
*/ UInt64.prototype.toString = function (radix) { if (radix === void 0) { radix = 10; } return this.value.toString(radix); }; /**
/ UInt64.prototype.toArray = function (endian) { if (endian === void 0) { endian = 'le'; } return this.value.toArray(endian, 8); }; return UInt64; }()); // /*/
var Int64 = (function () {
/**
*/ function Int64(value) { this.value = new BigInteger(value); var arr32 = new Int32Array(new Uint8Array(this.toArray()).buffer); this.low = arr32[0]; this.high = arr32[1]; } /**
*/ Int64.compare = function (a, b) { return a.value.compare(b.value); }; /**
*/ Int64.hi = function (num) { return num.high; }; /**
*/ Int64.lo = function (num) { return num.low; }; /**
*/ Int64.join = function (high, low) { var result = new Int64(0); var arr8 = new Uint8Array(new Int32Array([low, high]).buffer); result.value.fromArray(arr8); if (high < 0) { result.value.negative = 1; result.value.twos(64); result.value.negative = 1; } result.low = low; result.high = high; return result; }; /**
*/ Int64.prototype.toString = function (radix) { if (radix === void 0) { radix = 10; } return this.value.toString(radix); }; /**
/ Int64.prototype.toArray = function (endian) { if (endian === void 0) { endian = 'le'; } var c = this.value.clone(); c.twos(64); return c.toArray(endian, 8); }; return Int64; }()); // var exports = { BigInteger: BigInteger, UInt64: UInt64, Int64: Int64, }; / istanbul ignore next */ if (typeof define === 'function') { if (define.amd || define.cmd) { define(function() { return exports; }); } } else if (typeof module !== 'undefined' && module.exports) { module.exports = exports; } else { window[exportName] = exports; } })('jints'); },{}],13:[function(require,module,exports){ // shim for using process in browser var process = module.exports = {};
// cached from whatever global is present so that test runners that stub it // don't break things. But we need to wrap it in a try catch in case it is // wrapped in strict mode code which doesn't define any globals. It's inside a // function because try/catches deoptimize in certain engines.
var cachedSetTimeout; var cachedClearTimeout;
function defaultSetTimout() { throw new Error('setTimeout has not been defined'); } function defaultClearTimeout () { throw new Error('clearTimeout has not been defined'); } (function () { try { if (typeof setTimeout === 'function') { cachedSetTimeout = setTimeout; } else { cachedSetTimeout = defaultSetTimout; } } catch (e) { cachedSetTimeout = defaultSetTimout; } try { if (typeof clearTimeout === 'function') { cachedClearTimeout = clearTimeout; } else { cachedClearTimeout = defaultClearTimeout; } } catch (e) { cachedClearTimeout = defaultClearTimeout; } } ()) function runTimeout(fun) { if (cachedSetTimeout === setTimeout) { //normal enviroments in sane situations return setTimeout(fun, 0); } // if setTimeout wasn't available but was latter defined if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { cachedSetTimeout = setTimeout; return setTimeout(fun, 0); } try { // when when somebody has screwed with setTimeout but no I.E. maddness return cachedSetTimeout(fun, 0); } catch(e){ try { // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally return cachedSetTimeout.call(null, fun, 0); } catch(e){ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error return cachedSetTimeout.call(this, fun, 0); } }
} function runClearTimeout(marker) { if (cachedClearTimeout === clearTimeout) { //normal enviroments in sane situations return clearTimeout(marker); } // if clearTimeout wasn't available but was latter defined if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { cachedClearTimeout = clearTimeout; return clearTimeout(marker); } try { // when when somebody has screwed with setTimeout but no I.E. maddness return cachedClearTimeout(marker); } catch (e){ try { // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally return cachedClearTimeout.call(null, marker); } catch (e){ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. // Some versions of I.E. have different rules for clearTimeout vs setTimeout return cachedClearTimeout.call(this, marker); } }
} var queue = []; var draining = false; var currentQueue; var queueIndex = -1;
function cleanUpNextTick() { if (!draining || !currentQueue) { return; } draining = false; if (currentQueue.length) { queue = currentQueue.concat(queue); } else { queueIndex = -1; } if (queue.length) { drainQueue(); } }
function drainQueue() { if (draining) { return; } var timeout = runTimeout(cleanUpNextTick); draining = true;
}
process.nextTick = function (fun) { var args = new Array(arguments.length - 1); if (arguments.length > 1) { for (var i = 1; i < arguments.length; i++) { args[i - 1] = arguments[i]; } } queue.push(new Item(fun, args)); if (queue.length === 1 && !draining) { runTimeout(drainQueue); } };
// v8 likes predictible objects function Item(fun, array) { this.fun = fun; this.array = array; } Item.prototype.run = function () { this.fun.apply(null, this.array); }; process.title = 'browser'; process.browser = true; process.env = {}; process.argv = []; process.version = ''; // empty string to avoid regexp issues process.versions = {};
function noop() {}
process.on = noop; process.addListener = noop; process.once = noop; process.off = noop; process.removeListener = noop; process.removeAllListeners = noop; process.emit = noop; process.prependListener = noop; process.prependOnceListener = noop;
process.listeners = function (name) { return [] }
process.binding = function (name) { throw new Error('process.binding is not supported'); };
process.cwd = function () { return '/' }; process.chdir = function (dir) { throw new Error('process.chdir is not supported'); }; process.umask = function() { return 0; };
},{}],14:[function(require,module,exports){ var indexOf = function (xs, item) { if (xs.indexOf) return xs.indexOf(item); else for (var i = 0; i < xs.length; i++) { if (xs[i] === item) return i; } return -1; }; var Object_keys = function (obj) { if (Object.keys) return Object.keys(obj) else { var res = []; for (var key in obj) res.push(key) return res; } };
var forEach = function (xs, fn) { if (xs.forEach) return xs.forEach(fn) else for (var i = 0; i < xs.length; i++) { fn(xs[i], i, xs); } };
var defineProp = (function() { try { Object.defineProperty({}, '_', {}); return function(obj, name, value) { Object.defineProperty(obj, name, { writable: true, enumerable: false, configurable: true, value: value }) }; } catch(e) { return function(obj, name, value) { obj[name] = value; }; } }());
var globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function', 'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError', 'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError', 'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape', 'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'];
function Context() {} Context.prototype = {};
var Script = exports.Script = function NodeScript (code) { if (!(this instanceof Script)) return new Script(code); this.code = code; };
Script.prototype.runInContext = function (context) { if (!(context instanceof Context)) { throw new TypeError("needs a 'context' argument."); }
};
Script.prototype.runInThisContext = function () { return eval(this.code); // maybe... };
Script.prototype.runInNewContext = function (context) { var ctx = Script.createContext(context); var res = this.runInContext(ctx);
};
forEach(Object_keys(Script.prototype), function (name) { exports[name] = Script[name] = function (code) { var s = Script(code); return s[name].apply(s, [].slice.call(arguments, 1)); }; });
exports.isContext = function (context) { return context instanceof Context; };
exports.createScript = function (code) { return exports.Script(code); };
exports.createContext = Script.createContext = function (context) { var copy = new Context(); if(typeof context === 'object') { forEach(Object_keys(context), function (key) { copy[key] = context[key]; }); } return copy; };
},{}],15:[function(require,module,exports){ const jints = require("jints");
function decode64bits(buff,size) { if(typeof(size) != "number") size = 1; return new jints.UInt64(buff).toArray(); //return _.float64("value").unpack(buff); }
function encode64bits(i,size) { if(typeof(size) != "number") size = 1; return new jints.UInt64(i).toArray(); //return _.float64("value",size).pack(i); }
module.exports = { decode64bits: decode64bits, encode64bits: encode64bits };
},{"jints":12}],16:[function(require,module,exports){ const assert = require("assert").ok;
const MAILBOX_BASE = 0x10000000; const MAILBOX_SIZE = 0x00000009; const MAILBOX_END = MAILBOX_BASE+MAILBOX_SIZE;
class Mailbox { constructor() { this.devices = []; this.devIndex = 0; this.dataIndex = 0; } destroy() { for(var dev of this.devices) { if(dev.destroy) dev.destroy(dev,this); } } isValidDeviceIndex(i) { return i >= 0 && this.devices.length > i; } reset(vm) { vm.mmap(MAILBOX_BASE,MAILBOX_END,i => { switch(i) { case 0: return this.devices.length; case 1: return this.devIndex; case 2: return this.dataIndex; case 3: if(this.isValidDeviceIndex(this.devIndex)) { if(this.devices[this.devIndex].read) return this.devices[this.devIndex].read(this.devices[this.devIndex],this.dataIndex); } else return 0xFFFF; case 4: if(this.isValidDeviceIndex(this.devIndex)) return this.devices[this.devIndex].hdr.vendorID; else return 0xFFFF; case 5: if(this.isValidDeviceIndex(this.devIndex)) return this.devices[this.devIndex].hdr.deviceID; else return 0xFFFF; case 6: if(this.isValidDeviceIndex(this.devIndex)) return this.devices[this.devIndex].hdr.rev; else return 0xFFFF; case 7: if(this.isValidDeviceIndex(this.devIndex)) return this.devices[this.devIndex].hdr.type; else return 0xFFFF; case 8: if(this.isValidDeviceIndex(this.devIndex)) return this.devices[this.devIndex].hdr.classCode; else return 0xFFFF; case 9: if(this.isValidDeviceIndex(this.devIndex)) return this.devices[this.devIndex].hdr.subclass; else return 0xFFFF; } return 0; },(i,v) => { switch(i) { case 1: this.devIndex = v; break; case 2: this.dataIndex = v; break; case 3: if(this.isValidDeviceIndex(this.devIndex)) { if(this.devices[this.devIndex].write) return this.devices[this.devIndex].write(this.devices[this.devIndex],this.dataIndex,v); } else return 0xFFFF; } }); for(var dev of this.devices) { if(dev.reset) dev.reset(dev,vm); } } cycle(vm) { for(var dev of this.devices) { if(dev.cycle) dev.cycle(dev,vm); } } addDevice(dev) { assert(typeof(dev) == "object","dev is not an object"); assert(typeof(dev.hdr) == "object","dev.hdr is not an object"); assert(typeof(dev.hdr.vendorID) == "number","dev.hdr.vendorID is not a number"); assert(typeof(dev.hdr.deviceID) == "number","dev.hdr.deviceID is not a number"); assert(typeof(dev.hdr.rev) == "number","dev.hdr.rev is not a number"); assert(typeof(dev.hdr.type) == "number","dev.hdr.type is not a number"); assert(typeof(dev.hdr.classCode) == "number","dev.hdr.classCode is not a number"); assert(typeof(dev.hdr.subclass) == "number","dev.hdr.subclass is not a number"); assert(typeof(dev.name) == "string","dev.name is not a string");
} module.exports = Mailbox;
},{"assert":3}],17:[function(require,module,exports){ const RTC_BASE = 0x1000000A; const RTC_SIZE = 0x00000007; const RTC_END = RTC_BASE+RTC_SIZE;
Date.prototype.stdTimezoneOffset = function () { var jan = new Date(this.getFullYear(),0,1); var jul = new Date(this.getFullYear(),6,1); return Math.max(jan.getTimezoneOffset(),jul.getTimezoneOffset()); }
Date.prototype.isDstObserved = function () { return this.getTimezoneOffset() < this.stdTimezoneOffset(); }
class RTC { constructor() { this.timers = []; } destroy() {} reset(vm) { vm.mmap(RTC_BASE,RTC_END,i => { switch(i) { case 0: return new Date().getSeconds(); case 1: return new Date().getMinutes(); case 2: return new Date().getHours(); case 3: return new Date().getDate(); case 4: return new Date().getMonth(); case 5: return new Date().getFullYear(); case 6: return new Date().isDstObserved();
} module.exports = RTC;
},{}],18:[function(require,module,exports){ (function (Buffer){ const EventEmitter = require("events");
const UART_BASE = 0x10000012; const UART_SIZE = 0x00000003; const UART_END = UART_BASE+UART_SIZE;
class UART extends EventEmitter { constructor() { super();
} module.exports = UART;
}).call(this,require("buffer").Buffer) },{"buffer":9,"events":10}],19:[function(require,module,exports){ (function (Buffer){ const EventEmitter = require("events"); const fs = require("fs"); const jints = require("jints"); const Mailbox = require("./hardware/mailbox"); const RTC = require("./hardware/rtc"); const UART = require("./hardware/uart");
const CPU_REG_FLAG_INTR = (1 << 0);
const CPU_INT = { "STACK_OVERFLOW": 0, "FAULT": 1, "BADADDR": 2, "DIVBYZERO": 3, "BADINSTR": 4, "TIMER": 5 };
const IO_RAM_BASE = 0xA0000000; const IO_RAM_SIZE = 0x40000000; const IO_RAM_END = IO_RAM_BASE+IO_RAM_SIZE;
function setupRegisters() { return { flags: new Float64Array(1), tmp: new Float64Array(1), sp: new Float64Array(1), ip: new Float64Array(1), pc: new Float64Array(1), cycle: new Float64Array(1), data: new Float64Array(10), index: new Float64Array(10), addr: new Float64Array(10), ptr: new Float64Array(10) }; }
class VirtualMachine extends EventEmitter { constructor(opts = {}) { super(); this.cpu = { regs: setupRegisters(), iregs: setupRegisters(),
}
module.exports = VirtualMachine;
}).call(this,require("buffer").Buffer) },{"./hardware/mailbox":16,"./hardware/rtc":17,"./hardware/uart":18,"buffer":9,"events":10,"fs":8,"jints":12}]},{},[2]);
Parse error at ./dist/sa.js:3,0 const fs = require("fs"); ^ ERROR: Unexpected token: keyword (const) at JS_Parse_Error.get (eval at (/home/spaceboyross/SherwoodArch/src/package/node_modules/uglify-js/tools/node.js:20:1), :71:23)
at fatal (/home/spaceboyross/SherwoodArch/src/package/node_modules/uglify-js/bin/uglifyjs:291:52)
at run (/home/spaceboyross/SherwoodArch/src/package/node_modules/uglify-js/bin/uglifyjs:235:9)
at Object. (/home/spaceboyross/SherwoodArch/src/package/node_modules/uglify-js/bin/uglifyjs:160:5)
at Module._compile (module.js:569:30)
at Object.Module._extensions..js (module.js:580:10)
at Module.load (module.js:503:32)
at tryModuleLoad (module.js:466:12)
at Function.Module._load (module.js:458:3)
at Function.Module.runMain (module.js:605:10)