amqplib 0.10.9 → 1.0.1

package/bin/generate-defs.js

@@ -1,41 +1,34 @@
-var FS = require('fs');
-var format = require('util').format;
+const format = require('node:util').format;
 
-var defs = require('./amqp-rabbitmq-0.9.1.json');
+const defs = require('./amqp-rabbitmq-0.9.1.json');
 
-var FRAME_OVERHEAD = 8; // type + channel + size + frame-end
+const FRAME_OVERHEAD = 8; // type + channel + size + frame-end
 
-var METHOD_OVERHEAD = FRAME_OVERHEAD + 4;
+const METHOD_OVERHEAD = FRAME_OVERHEAD + 4;
 // F_O + classId + methodId
 
-var PROPERTIES_OVERHEAD = FRAME_OVERHEAD + 4 + 8 + 2;
+const PROPERTIES_OVERHEAD = FRAME_OVERHEAD + 4 + 8 + 2;
 // F_O + classId + weight + content size + flags
 
+const out = process.stdout;
 
-var out = process.stdout;
-
-function printf() {
-  out.write(format.apply(format, arguments), 'utf8');
+function printf(...args) {
+  out.write(format.apply(format, args), 'utf8');
 }
 
-function nl() { out.write('\n'); }
-function println() { printf.apply(printf, arguments); nl(); }
-
-function isEmptyObject(val) {
-  return (val != null && typeof val === 'object' &&
-          Object.keys(val).length === 0);
+function nl() {
+  out.write('\n');
 }
-
-function stringifyValue(val) {
-  return (isEmptyObject(val)) ? 'EMPTY_OBJECT' :
-    JSON.stringify(val);
+function println(...args) {
+  printf.apply(printf, args);
+  nl();
 }
 
-var constants = {};
-var constant_strs = {};
+const constants = {};
+const constant_strs = {};
 
-for (var i = 0, len = defs.constants.length; i < len; i++) {
-  var cdef = defs.constants[i];
+for (let i = 0, len = defs.constants.length; i < len; i++) {
+  const cdef = defs.constants[i];
   constants[constantName(cdef)] = cdef.value;
   constant_strs[cdef.value] = cdef.name;
 }
@@ -49,7 +42,7 @@ function methodName(clazz, method) {
 }
 
 function propertyName(dashed) {
-  var parts = dashed.split('-');
+  const parts = dashed.split('-');
   return parts[0] + parts.slice(1).map(initial).join('');
 }
 
@@ -58,26 +51,26 @@ function initial(part) {
 }
 
 function argument(a) {
-  var type = a.type || domains[a.domain];
-  var friendlyName = propertyName(a.name);
-  return {type: type, name: friendlyName, default: a['default-value']};
+  const type = a.type || domains[a.domain];
+  const friendlyName = propertyName(a.name);
+  return { type: type, name: friendlyName, default: a['default-value'] };
 }
 
-var domains = {};
-for (var i=0, len = defs.domains.length; i < len; i++) {
-  var dom = defs.domains[i];
+const domains = {};
+for (let i = 0, len = defs.domains.length; i < len; i++) {
+  const dom = defs.domains[i];
   domains[dom[0]] = dom[1];
 }
 
-var methods = {};
-var propertieses = {};
+const methods = {};
+const propertieses = {};
 
-for (var i = 0, len = defs.classes.length; i < len; i++) {
-  var clazz = defs.classes[i];
-  for (var j = 0, num = clazz.methods.length; j < num; j++) {
-    var method = clazz.methods[j];
-    var name = methodName(clazz, method);
-    var info = 'methodInfo' + name;
+for (let i = 0, len = defs.classes.length; i < len; i++) {
+  const clazz = defs.classes[i];
+  for (let j = 0, num = clazz.methods.length; j < num; j++) {
+    const method = clazz.methods[j];
+    const name = methodName(clazz, method);
+    const info = `methodInfo${name}`;
 
     methods[name] = {
       id: methodId(clazz, method),
@@ -87,20 +80,20 @@ for (var i = 0, len = defs.classes.length; i < len; i++) {
       clazz: clazz.name,
       args: method['arguments'].map(argument),
       isReply: method.answer,
-      encoder: 'encode' + name,
-      decoder: 'decode' + name,
-      info: info
+      encoder: `encode${name}`,
+      decoder: `decode${name}`,
+      info: info,
     };
   }
   if (clazz.properties && clazz.properties.length > 0) {
-    var name = propertiesName(clazz);
-    var props = clazz.properties;
+    const name = propertiesName(clazz);
+    const props = clazz.properties;
     propertieses[name] = {
       id: clazz.id,
       name: name,
-      encoder: 'encode' + name,
-      decoder: 'decode' + name,
-      info: 'propertiesInfo' + name,
+      encoder: `encode${name}`,
+      decoder: `decode${name}`,
+      info: `propertiesInfo${name}`,
       args: props.map(argument),
     };
   }
@@ -109,14 +102,16 @@ for (var i = 0, len = defs.classes.length; i < len; i++) {
 // OK let's get emitting
 
 println(
-'/** @preserve This file is generated by the script\n',
-'* ../bin/generate-defs.js, which is not in general included in a\n',
-'* distribution, but is available in the source repository e.g. at\n',
-'* https://github.com/amqp-node/amqplib/\n',
-'*/');
-
-println("'use strict';"); nl();
-nl()
+  '/** @preserve This file is generated by the script\n',
+  '* ../bin/generate-defs.js, which is not in general included in a\n',
+  '* distribution, but is available in the source repository e.g. at\n',
+  '* https://github.com/amqp-node/amqplib/\n',
+  '*/',
+);
+
+println("'use strict';");
+nl();
+nl();
 println('var codec = require("./codec");');
 println('var ints = require("buffer-more-ints");');
 println('var encodeTable = codec.encodeTable;');
@@ -126,77 +121,81 @@ nl();
 println('var SCRATCH = Buffer.alloc(65536);');
 println('var EMPTY_OBJECT = Object.freeze({});');
 
-println('module.exports.constants = %s',
-        JSON.stringify(constants));
+println('module.exports.constants = %s', JSON.stringify(constants));
 nl();
-println('module.exports.constant_strs = %s',
-        JSON.stringify(constant_strs));
+println('module.exports.constant_strs = %s', JSON.stringify(constant_strs));
 nl();
 println('module.exports.FRAME_OVERHEAD = %d;', FRAME_OVERHEAD);
 nl();
 
 println('module.exports.decode = function(id, buf) {');
 println('switch (id) {');
-for (var m in methods) {
-  var method = methods[m];
+for (const m in methods) {
+  const method = methods[m];
   println('case %d: return %s(buf);', method.id, method.decoder);
 }
-for (var p in propertieses) {
-  var props = propertieses[p];
-  println('case %d: return %s(buf);', props.id,  props.decoder);
+for (const p in propertieses) {
+  const props = propertieses[p];
+  println('case %d: return %s(buf);', props.id, props.decoder);
 }
 println('default: throw new Error("Unknown class/method ID");');
-println('}}'); nl();
+println('}}');
+nl();
 
-println('module.exports.encodeMethod =',
-        'function(id, channel, fields) {');
+println('module.exports.encodeMethod =', 'function(id, channel, fields) {');
 println('switch (id) {');
-for (var m in methods) {
-  var method = methods[m];
-  println('case %d: return %s(channel, fields);',
-          method.id, method.encoder);
+for (const m in methods) {
+  const method = methods[m];
+  println('case %d: return %s(channel, fields);', method.id, method.encoder);
 }
 println('default: throw new Error("Unknown class/method ID");');
-println('}}'); nl();
+println('}}');
+nl();
 
-println('module.exports.encodeProperties ='
-        , 'function(id, channel, size, fields) {');
+println('module.exports.encodeProperties =', 'function(id, channel, size, fields) {');
 println('switch (id) {');
-for (var p in propertieses) {
-  var props = propertieses[p];
-  println('case %d: return %s(channel, size, fields);',
-          props.id, props.encoder);
+for (const p in propertieses) {
+  const props = propertieses[p];
+  println('case %d: return %s(channel, size, fields);', props.id, props.encoder);
 }
 println('default: throw new Error("Unknown class/properties ID");');
-println('}}'); nl();
+println('}}');
+nl();
 
 println('module.exports.info = function(id) {');
 println('switch(id) {');
-for (var m in methods) {
-  var method = methods[m];
+for (const m in methods) {
+  const method = methods[m];
   println('case %d: return %s; ', method.id, method.info);
 }
-for (var p in propertieses) {
-  var properties = propertieses[p];
+for (const p in propertieses) {
+  const properties = propertieses[p];
   println('case %d: return %s', properties.id, properties.info);
 }
 println('default: throw new Error("Unknown class/method ID");');
-println('}}'); nl();
+println('}}');
+nl();
 
-for (var m in methods) {
-  var method = methods[m];
+for (const m in methods) {
+  const method = methods[m];
   println('module.exports.%s = %d;', m, method.id);
-  decoderFn(method); nl();
-  encoderFn(method); nl();
-  infoObj(method); nl();
+  decoderFn(method);
+  nl();
+  encoderFn(method);
+  nl();
+  infoObj(method);
+  nl();
 }
 
-for (var p in propertieses) {
-  var properties = propertieses[p];
+for (const p in propertieses) {
+  const properties = propertieses[p];
   println('module.exports.%s = %d;', p, properties.id);
-  encodePropsFn(properties); nl();
-  decodePropsFn(properties); nl();
-  infoObj(properties); nl();
+  encodePropsFn(properties);
+  nl();
+  decodePropsFn(properties);
+  nl();
+  infoObj(properties);
+  nl();
 }
 
 function methodId(clazz, method) {
@@ -204,46 +203,55 @@ function methodId(clazz, method) {
 }
 
 function propertiesName(clazz) {
-  return initial(clazz.name) + 'Properties';
+  return `${initial(clazz.name)}Properties`;
 }
 
 function valTypeTest(arg) {
   switch (arg.type) {
-  // everything is booleany
-  case 'bit':       return 'true'
-  case 'octet':
-  case 'short':
-  case 'long':
-  case 'longlong':
-  case 'timestamp': return "typeof val === 'number' && !isNaN(val)";
-  case 'shortstr':  return "typeof val === 'string' &&" +
-      " Buffer.byteLength(val) < 256";
-  case 'longstr':   return "Buffer.isBuffer(val)";
-  case 'table':     return "typeof val === 'object'";
+    // everything is booleany
+    case 'bit':
+      return 'true';
+    case 'octet':
+    case 'short':
+    case 'long':
+    case 'longlong':
+    case 'timestamp':
+      return "typeof val === 'number' && !isNaN(val)";
+    case 'shortstr':
+      return "typeof val === 'string' &&" + ' Buffer.byteLength(val) < 256';
+    case 'longstr':
+      return 'Buffer.isBuffer(val)';
+    case 'table':
+      return "typeof val === 'object'";
   }
 }
 
 function typeDesc(t) {
   switch (t) {
-  case 'bit':       return 'booleany';
-  case 'octet':
-  case 'short':
-  case 'long':
-  case 'longlong':
-  case 'timestamp': return "a number (but not NaN)";
-  case 'shortstr':  return "a string (up to 255 chars)";
-  case 'longstr':   return "a Buffer";
-  case 'table':     return "an object";
+    case 'bit':
+      return 'booleany';
+    case 'octet':
+    case 'short':
+    case 'long':
+    case 'longlong':
+    case 'timestamp':
+      return 'a number (but not NaN)';
+    case 'shortstr':
+      return 'a string (up to 255 chars)';
+    case 'longstr':
+      return 'a Buffer';
+    case 'table':
+      return 'an object';
   }
 }
 
 function defaultValueRepr(arg) {
   switch (arg.type) {
-  case 'longstr':
-    return format("Buffer.from(%s)", JSON.stringify(arg.default));
-  default:
-    // assumes no tables as defaults
-    return JSON.stringify(arg.default);
+    case 'longstr':
+      return format('Buffer.from(%s)', JSON.stringify(arg.default));
+    default:
+      // assumes no tables as defaults
+      return JSON.stringify(arg.default);
   }
 }
 
@@ -254,7 +262,7 @@ function assignArg(a) {
 
 function assignOrDefault(a) {
   println("val = fields['%s'];", a.name);
-  println("if (val === undefined) val = %s;", defaultValueRepr(a));
+  println('if (val === undefined) val = %s;', defaultValueRepr(a));
 }
 
 // Emit code for assigning an argument value to `val`, checking that
@@ -265,15 +273,13 @@ function checkAssignArg(a) {
   println('if (val === undefined) {');
   if (a.default !== undefined) {
     println('val = %s;', defaultValueRepr(a));
-  }
-  else {
+  } else {
     println('throw new Error("Missing value for mandatory field \'%s\'");', a.name);
   }
   println('}'); // undefined test
   println('else if (!(%s)) {', valTypeTest(a));
   println('throw new TypeError(');
-  println('"Field \'%s\' is the wrong type; must be %s");',
-          a.name, typeDesc(a.type));
+  println('"Field \'%s\' is the wrong type; must be %s");', a.name, typeDesc(a.type));
   println('}'); // type test
 }
 
@@ -285,30 +291,28 @@ function checkAssignArg(a) {
 // another buffer before returning. `scratchOffset`, `val`, `len` are
 // expected to have been declared.
 function assignTable(a) {
-  var varname = tableVar(a);
-  println(
-    "len = encodeTable(SCRATCH, val, scratchOffset);");
+  const varname = tableVar(a);
+  println('len = encodeTable(SCRATCH, val, scratchOffset);');
   println('var %s = SCRATCH.slice(scratchOffset, scratchOffset + len);', varname);
   println('scratchOffset += len;');
 }
 
 function tableVar(a) {
-  return a.name + '_encoded';
+  return `${a.name}_encoded`;
 }
 
 function stringLenVar(a) {
-  return a.name + '_len';
+  return `${a.name}_len`;
 }
 
 function assignStringLen(a) {
-  var v = stringLenVar(a);
+  const v = stringLenVar(a);
   // Assumes the value or default is in val
   println("var %s = Buffer.byteLength(val, 'utf8');", v);
 }
 
-
 function encoderFn(method) {
-  var args = method['args'];
+  const args = method['args'];
   println('function %s(channel, fields) {', method.encoder);
   println('var offset = 0, val = null, bits = 0, varyingSize = 0;');
   println('var len, scratchOffset = 0;');
@@ -319,50 +323,57 @@ function encoderFn(method) {
   // either 1. contribute to the fixed size; or 2. emit code to
   // calculate the size (and possibly the encoded value, in the case
   // of tables).
-  var fixedSize = METHOD_OVERHEAD;
+  let fixedSize = METHOD_OVERHEAD;
 
-  var bitsInARow = 0;
+  let bitsInARow = 0;
 
-  for (var i=0, len = args.length; i < len; i++) {
-    var arg = args[i];
+  for (let i = 0, len = args.length; i < len; i++) {
+    const arg = args[i];
 
-    if (arg.type != 'bit') bitsInARow = 0;
+    if (arg.type !== 'bit') bitsInARow = 0;
 
     switch (arg.type) {
-    // varying size
-    case 'shortstr':
-      checkAssignArg(arg);
-      assignStringLen(arg);
-      println("varyingSize += %s;", stringLenVar(arg));
-      fixedSize += 1;
-      break;
-    case 'longstr':
-      checkAssignArg(arg);
-      println("varyingSize += val.length;");
-      fixedSize += 4;
-      break;
-    case 'table':
-      // For a table we have to encode the table before we can see its
-      // length.
-      checkAssignArg(arg);
-      assignTable(arg);
-      println('varyingSize += %s.length;', tableVar(arg));
-      break;
-
-    // fixed size
-    case 'octet': fixedSize += 1; break;
-    case 'short': fixedSize += 2; break;
-    case 'long': fixedSize += 4; break;
-    case 'longlong': //fall through
-    case 'timestamp':
-      fixedSize += 8; break;
-    case 'bit':
-      bitsInARow ++;
-      // open a fresh pack o' bits
-      if (bitsInARow === 1) fixedSize += 1;
-      // just used a pack; reset
-      else if (bitsInARow === 8) bitsInARow = 0;
-      break;
+      // varying size
+      case 'shortstr':
+        checkAssignArg(arg);
+        assignStringLen(arg);
+        println('varyingSize += %s;', stringLenVar(arg));
+        fixedSize += 1;
+        break;
+      case 'longstr':
+        checkAssignArg(arg);
+        println('varyingSize += val.length;');
+        fixedSize += 4;
+        break;
+      case 'table':
+        // For a table we have to encode the table before we can see its
+        // length.
+        checkAssignArg(arg);
+        assignTable(arg);
+        println('varyingSize += %s.length;', tableVar(arg));
+        break;
+
+      // fixed size
+      case 'octet':
+        fixedSize += 1;
+        break;
+      case 'short':
+        fixedSize += 2;
+        break;
+      case 'long':
+        fixedSize += 4;
+        break;
+      case 'longlong': //fall through
+      case 'timestamp':
+        fixedSize += 8;
+        break;
+      case 'bit':
+        bitsInARow++;
+        // open a fresh pack o' bits
+        if (bitsInARow === 1) fixedSize += 1;
+        // just used a pack; reset
+        else if (bitsInARow === 8) bitsInARow = 0;
+        break;
     }
   }
 
@@ -376,58 +387,58 @@ function encoderFn(method) {
 
   bitsInARow = 0;
 
-  for (var i = 0, len = args.length; i < len; i++) {
-    var a = args[i];
+  for (let i = 0, len = args.length; i < len; i++) {
+    const a = args[i];
 
     // Flush any collected bits before doing a new field
-    if (a.type != 'bit' && bitsInARow > 0) {
+    if (a.type !== 'bit' && bitsInARow > 0) {
       bitsInARow = 0;
       println('buffer[offset] = bits; offset++; bits = 0;');
     }
 
     switch (a.type) {
-    case 'octet':
-      checkAssignArg(a);
-      println('buffer.writeUInt8(val, offset); offset++;');
-      break;
-    case 'short':
-      checkAssignArg(a);
-      println('buffer.writeUInt16BE(val, offset); offset += 2;');
-      break;
-    case 'long':
-      checkAssignArg(a);
-      println('buffer.writeUInt32BE(val, offset); offset += 4;');
-      break;
-    case 'longlong':
-    case 'timestamp':
-      checkAssignArg(a);
-      println('ints.writeUInt64BE(buffer, val, offset); offset += 8;');
-      break;
-    case 'bit':
-      checkAssignArg(a);
-      println('if (val) bits += %d;', 1 << bitsInARow);
-      if (bitsInARow === 7) { // I don't think this ever happens, but whatever
-        println('buffer[offset] = bits; offset++; bits = 0;');
-        bitsInARow = 0;
-      }
-      else bitsInARow++;
-      break;
-    case 'shortstr':
-      assignOrDefault(a);
-      println('buffer[offset] = %s; offset++;', stringLenVar(a));
-      println('buffer.write(val, offset, "utf8"); offset += %s;',
-              stringLenVar(a));
-      break;
-    case 'longstr':
-      assignOrDefault(a);
-      println('len = val.length;');
-      println('buffer.writeUInt32BE(len, offset); offset += 4;');
-      println('val.copy(buffer, offset); offset += len;');
-      break;
-    case 'table':
-      println('offset += %s.copy(buffer, offset);', tableVar(a));
-      break;
-    default: throw new Error("Unexpected argument type: " + a.type);
+      case 'octet':
+        checkAssignArg(a);
+        println('buffer.writeUInt8(val, offset); offset++;');
+        break;
+      case 'short':
+        checkAssignArg(a);
+        println('buffer.writeUInt16BE(val, offset); offset += 2;');
+        break;
+      case 'long':
+        checkAssignArg(a);
+        println('buffer.writeUInt32BE(val, offset); offset += 4;');
+        break;
+      case 'longlong':
+      case 'timestamp':
+        checkAssignArg(a);
+        println('ints.writeUInt64BE(buffer, val, offset); offset += 8;');
+        break;
+      case 'bit':
+        checkAssignArg(a);
+        println('if (val) bits += %d;', 1 << bitsInARow);
+        if (bitsInARow === 7) {
+          // I don't think this ever happens, but whatever
+          println('buffer[offset] = bits; offset++; bits = 0;');
+          bitsInARow = 0;
+        } else bitsInARow++;
+        break;
+      case 'shortstr':
+        assignOrDefault(a);
+        println('buffer[offset] = %s; offset++;', stringLenVar(a));
+        println('buffer.write(val, offset, "utf8"); offset += %s;', stringLenVar(a));
+        break;
+      case 'longstr':
+        assignOrDefault(a);
+        println('len = val.length;');
+        println('buffer.writeUInt32BE(len, offset); offset += 4;');
+        println('val.copy(buffer, offset); offset += len;');
+        break;
+      case 'table':
+        println('offset += %s.copy(buffer, offset);', tableVar(a));
+        break;
+      default:
+        throw new Error(`Unexpected argument type: ${a.type}`);
     }
   }
 
@@ -446,70 +457,70 @@ function encoderFn(method) {
 
 function fieldsDecl(args) {
   println('var fields = {');
-  for (var i=0, num=args.length; i < num; i++) {
+  for (let i = 0, num = args.length; i < num; i++) {
     println('%s: undefined,', args[i].name);
   }
   println('};');
 }
 
 function decoderFn(method) {
-  var args = method.args;
+  const args = method.args;
   println('function %s(buffer) {', method.decoder);
   println('var offset = 0, val, len;');
   fieldsDecl(args);
 
-  var bitsInARow = 0;
+  let bitsInARow = 0;
 
-  for (var i=0, num=args.length; i < num; i++) {
-    var a = args[i];
-    var field = "fields['" + a.name + "']";
+  for (let i = 0, num = args.length; i < num; i++) {
+    const a = args[i];
+    const field = `fields['${a.name}']`;
 
     // Flush any collected bits before doing a new field
-    if (a.type != 'bit' && bitsInARow > 0) {
+    if (a.type !== 'bit' && bitsInARow > 0) {
       bitsInARow = 0;
       println('offset++;');
     }
 
     switch (a.type) {
-    case 'octet':
-      println('val = buffer[offset]; offset++;');
-      break;
-    case 'short':
-      println('val = buffer.readUInt16BE(offset); offset += 2;');
-      break;
-    case 'long':
-      println('val = buffer.readUInt32BE(offset); offset += 4;');
-      break;
-    case 'longlong':
-    case 'timestamp':
-      println('val = ints.readUInt64BE(buffer, offset); offset += 8;');
-      break;
-    case 'bit':
-      var bit = 1 << bitsInARow;
-      println('val = !!(buffer[offset] & %d);', bit);
-      if (bitsInARow === 7) {
-        println('offset++;');
-        bitsInARow = 0;
+      case 'octet':
+        println('val = buffer[offset]; offset++;');
+        break;
+      case 'short':
+        println('val = buffer.readUInt16BE(offset); offset += 2;');
+        break;
+      case 'long':
+        println('val = buffer.readUInt32BE(offset); offset += 4;');
+        break;
+      case 'longlong':
+      case 'timestamp':
+        println('val = ints.readUInt64BE(buffer, offset); offset += 8;');
+        break;
+      case 'bit': {
+        const bit = 1 << bitsInARow;
+        println('val = !!(buffer[offset] & %d);', bit);
+        if (bitsInARow === 7) {
+          println('offset++;');
+          bitsInARow = 0;
+        } else bitsInARow++;
+        break;
       }
-      else bitsInARow++;
-      break;
-    case 'longstr':
-      println('len = buffer.readUInt32BE(offset); offset += 4;');
-      println('val = buffer.subarray(offset, offset + len);');
-      println('offset += len;');
-      break;
-    case 'shortstr':
-      println('len = buffer.readUInt8(offset); offset++;');
-      println('val = buffer.toString("utf8", offset, offset + len);');
-      println('offset += len;');
-      break;
-    case 'table':
-      println('len = buffer.readUInt32BE(offset); offset += 4;');
-      println('val = decodeFields(buffer.subarray(offset, offset + len));');
-      println('offset += len;');
-      break;
-    default:
-      throw new TypeError("Unexpected type in argument list: " + a.type);
+      case 'longstr':
+        println('len = buffer.readUInt32BE(offset); offset += 4;');
+        println('val = buffer.subarray(offset, offset + len);');
+        println('offset += len;');
+        break;
+      case 'shortstr':
+        println('len = buffer.readUInt8(offset); offset++;');
+        println('val = buffer.toString("utf8", offset, offset + len);');
+        println('offset += len;');
+        break;
+      case 'table':
+        println('len = buffer.readUInt32BE(offset); offset += 4;');
+        println('val = decodeFields(buffer.subarray(offset, offset + len));');
+        println('offset += len;');
+        break;
+      default:
+        throw new TypeError(`Unexpected type in argument list: ${a.type}`);
     }
     println('%s = val;', field);
   }
@@ -518,13 +529,8 @@ function decoderFn(method) {
 }
 
 function infoObj(thing) {
-  var info = JSON.stringify({id: thing.id,
-                             classId: thing.clazzId,
-                             methodId: thing.methodId,
-                             name: thing.name,
-                             args: thing.args});
-  println('var %s = module.exports.%s = %s;',
-          thing.info, thing.info, info);
+  const info = JSON.stringify({ id: thing.id, classId: thing.clazzId, methodId: thing.methodId, name: thing.name, args: thing.args });
+  println('var %s = module.exports.%s = %s;', thing.info, thing.info, info);
 }
 
 // The flags are laid out in groups of fifteen in a short (high to
@@ -546,47 +552,53 @@ function encodePropsFn(props) {
   println('var offset = 0, flags = 0, val, len;');
   println('var scratchOffset = 0, varyingSize = 0;');
 
-  var fixedSize = PROPERTIES_OVERHEAD;
+  const fixedSize = PROPERTIES_OVERHEAD;
 
-  var args = props.args;
+  const args = props.args;
 
   function incVarying(by) {
-    println("varyingSize += %d;", by);
+    println('varyingSize += %d;', by);
   }
 
-  for (var i=0, num=args.length; i < num; i++) {
-    var p = args[i];
+  for (let i = 0, num = args.length; i < num; i++) {
+    const p = args[i];
 
     assignArg(p);
-    println("if (val != undefined) {");
+    println('if (val != undefined) {');
 
-    println("if (%s) {", valTypeTest(p));
+    println('if (%s) {', valTypeTest(p));
     switch (p.type) {
-    case 'shortstr':
-      assignStringLen(p);
-      incVarying(1);
-      println('varyingSize += %s;', stringLenVar(p));
-      break;
-    case 'longstr':
-      incVarying(4);
-      println('varyingSize += val.length;');
-      break;
-    case 'table':
-      assignTable(p);
-      println('varyingSize += %s.length;', tableVar(p));
-      break;
-    case 'octet': incVarying(1); break;
-    case 'short': incVarying(2); break;
-    case 'long': incVarying(4); break;
-    case 'longlong': // fall through
-    case 'timestamp':
-      incVarying(8); break;
+      case 'shortstr':
+        assignStringLen(p);
+        incVarying(1);
+        println('varyingSize += %s;', stringLenVar(p));
+        break;
+      case 'longstr':
+        incVarying(4);
+        println('varyingSize += val.length;');
+        break;
+      case 'table':
+        assignTable(p);
+        println('varyingSize += %s.length;', tableVar(p));
+        break;
+      case 'octet':
+        incVarying(1);
+        break;
+      case 'short':
+        incVarying(2);
+        break;
+      case 'long':
+        incVarying(4);
+        break;
+      case 'longlong': // fall through
+      case 'timestamp':
+        incVarying(8);
+        break;
       // no case for bit, as they are accounted for in the flags
     }
     println('} else {');
     println('throw new TypeError(');
-    println('"Field \'%s\' is the wrong type; must be %s");',
-            p.name, typeDesc(p.type));
+    println('"Field \'%s\' is the wrong type; must be %s");', p.name, typeDesc(p.type));
     println('}');
     println('}');
   }
@@ -606,48 +618,50 @@ function encodePropsFn(props) {
   // we'll write the flags later too
   println('offset = 21;');
 
-  for (var i=0, num=args.length; i < num; i++) {
-    var p = args[i];
-    var flag = flagAt(i);
+  for (let i = 0, num = args.length; i < num; i++) {
+    const p = args[i];
+    const flag = flagAt(i);
 
     assignArg(p);
-    println("if (val != undefined) {");
-    if (p.type === 'bit') { // which none of them are ..
+    println('if (val != undefined) {');
+    if (p.type === 'bit') {
+      // which none of them are ..
       println('if (val) flags += %d;', flag);
-    }
-    else {
+    } else {
       println('flags += %d;', flag);
       // %%% FIXME only slightly different to the method args encoding
       switch (p.type) {
-      case 'octet':
-        println('buffer.writeUInt8(val, offset); offset++;');
-        break;
-      case 'short':
-        println('buffer.writeUInt16BE(val, offset); offset += 2;');
-        break;
-      case 'long':
-        println('buffer.writeUInt32BE(val, offset); offset += 4;');
-        break;
-      case 'longlong':
-      case 'timestamp':
-        println('ints.writeUInt64BE(buffer, val, offset);');
-        println('offset += 8;');
-        break;
-      case 'shortstr':
-        var v = stringLenVar(p);
-        println('buffer[offset] = %s; offset++;', v);
-        println("buffer.write(val, offset, 'utf8');");
-        println("offset += %s;", v);
-        break;
-      case 'longstr':
-        println('buffer.writeUInt32BE(val.length, offset);');
-        println('offset += 4;');
-        println('offset += val.copy(buffer, offset);');
-        break;
-      case 'table':
-        println('offset += %s.copy(buffer, offset);', tableVar(p));
-        break;
-      default: throw new Error("Unexpected argument type: " + p.type);
+        case 'octet':
+          println('buffer.writeUInt8(val, offset); offset++;');
+          break;
+        case 'short':
+          println('buffer.writeUInt16BE(val, offset); offset += 2;');
+          break;
+        case 'long':
+          println('buffer.writeUInt32BE(val, offset); offset += 4;');
+          break;
+        case 'longlong':
+        case 'timestamp':
+          println('ints.writeUInt64BE(buffer, val, offset);');
+          println('offset += 8;');
+          break;
+        case 'shortstr': {
+          const v = stringLenVar(p);
+          println('buffer[offset] = %s; offset++;', v);
+          println("buffer.write(val, offset, 'utf8');");
+          println('offset += %s;', v);
+          break;
+        }
+        case 'longstr':
+          println('buffer.writeUInt32BE(val.length, offset);');
+          println('offset += 4;');
+          println('offset += val.copy(buffer, offset);');
+          break;
+        case 'table':
+          println('offset += %s.copy(buffer, offset);', tableVar(p));
+          break;
+        default:
+          throw new Error(`Unexpected argument type: ${p.type}`);
       }
     }
     println('}'); // != undefined
@@ -662,7 +676,7 @@ function encodePropsFn(props) {
 }
 
 function decodePropsFn(props) {
-  var args = props.args;
+  const args = props.args;
 
   println('function %s(buffer) {', props.decoder);
   println('var flags, offset = 2, val, len;');
@@ -672,46 +686,45 @@ function decodePropsFn(props) {
 
   fieldsDecl(args);
 
-  for (var i=0, num=args.length; i < num; i++) {
-    var p = argument(args[i]);
-    var field = "fields['" + p.name + "']";
+  for (let i = 0, num = args.length; i < num; i++) {
+    const p = argument(args[i]);
+    const field = `fields['${p.name}']`;
 
     println('if (flags & %d) {', flagAt(i));
     if (p.type === 'bit') {
       println('%d = true;', field);
-    }
-    else {
+    } else {
       switch (p.type) {
-      case 'octet':
-        println('val = buffer[offset]; offset++;');
-        break;
-      case 'short':
-        println('val = buffer.readUInt16BE(offset); offset += 2;');
-        break;
-      case 'long':
-        println('val = buffer.readUInt32BE(offset); offset += 4;');
-        break;
-      case 'longlong':
-      case 'timestamp':
-        println('val = ints.readUInt64BE(buffer, offset); offset += 8;');
-        break;
-      case 'longstr':
-        println('len = buffer.readUInt32BE(offset); offset += 4;');
-        println('val = buffer.subarray(offset, offset + len);');
-        println('offset += len;');
-        break;
-      case 'shortstr':
-        println('len = buffer.readUInt8(offset); offset++;');
-        println('val = buffer.toString("utf8", offset, offset + len);');
-        println('offset += len;');
-        break;
-      case 'table':
-        println('len = buffer.readUInt32BE(offset); offset += 4;');
-        println('val = decodeFields(buffer.subarray(offset, offset + len));');
-        println('offset += len;');
-        break;
-      default:
-        throw new TypeError("Unexpected type in argument list: " + p.type);
+        case 'octet':
+          println('val = buffer[offset]; offset++;');
+          break;
+        case 'short':
+          println('val = buffer.readUInt16BE(offset); offset += 2;');
+          break;
+        case 'long':
+          println('val = buffer.readUInt32BE(offset); offset += 4;');
+          break;
+        case 'longlong':
+        case 'timestamp':
+          println('val = ints.readUInt64BE(buffer, offset); offset += 8;');
+          break;
+        case 'longstr':
+          println('len = buffer.readUInt32BE(offset); offset += 4;');
+          println('val = buffer.subarray(offset, offset + len);');
+          println('offset += len;');
+          break;
+        case 'shortstr':
+          println('len = buffer.readUInt8(offset); offset++;');
+          println('val = buffer.toString("utf8", offset, offset + len);');
+          println('offset += len;');
+          break;
+        case 'table':
+          println('len = buffer.readUInt32BE(offset); offset += 4;');
+          println('val = decodeFields(buffer.subarray(offset, offset + len));');
+          println('offset += len;');
+          break;
+        default:
+          throw new TypeError(`Unexpected type in argument list: ${p.type}`);
       }
       println('%s = val;', field);
     }