Merge branch '2.3' of git@github.com:mixxxdj/mixxx.git

1 files changed, 816 insertions, 817 deletions

diff --git a/res/controllers/common-hid-packet-parser.js b/res/controllers/common-hid-packet-parser.js
index ace9ad57d9..6a47697dec 100644
--- a/res/controllers/common-hid-packet-parser.js
+++ b/res/controllers/common-hid-packet-parser.js
@@ -1,112 +1,114 @@
+/* global controller */
+
 /** Common HID script debugging function. Just to get logging with 'HID' prefix. */
-HIDDebug = function(message) {
-    print("HID " + message)
-}
+var HIDDebug = function(message) {
+    print("HID " + message);
+};
 
 /** HID Bit Vector Class
  *
  * Collection of bits in one parsed packet field. These objects are
  * created by HIDPacket addControl and addOutput and should not be
  * created manually. */
-HIDBitVector = function() {
-    this.size = 0
-    this.bits = {}
-}
+var HIDBitVector = function() {
+    this.size = 0;
+    this.bits = {};
+};
 
 /** Return bit offset based on bitmask */
 HIDBitVector.prototype.getOffset = function(bitmask) {
     for (var i = 0; i < 32; i++)
-        if ((1 & bitmask >> i) != 0)
-            return i
-    return 0
-}
+        if ((1 & bitmask >> i) !== 0)
+            return i;
+    return 0;
+};
 
 /** Add a control bitmask to the HIDBitVector */
 HIDBitVector.prototype.addBitMask = function(group, name, bitmask) {
-    var bit = {}
-    bit.type = "button"
-    bit.packet = undefined
-    bit.id = group + "." + name
-    bit.group = group
-    bit.name = name
-    bit.mapped_group = undefined
-    bit.mapped_name = undefined
-    bit.bitmask = bitmask
-    bit.bitmask = bitmask
-    bit.bit_offset = this.getOffset(bitmask)
-    bit.callback = undefined
-    bit.value = undefined
-    bit.auto_repeat = undefined
-    bit.auto_repeat_interval = undefined
-    this.bits[bit.id] = bit
-}
+    var bit = {};
+    bit.type = "button";
+    bit.packet = undefined;
+    bit.id = group + "." + name;
+    bit.group = group;
+    bit.name = name;
+    bit.mapped_group = undefined;
+    bit.mapped_name = undefined;
+    bit.bitmask = bitmask;
+    bit.bitmask = bitmask;
+    bit.bit_offset = this.getOffset(bitmask);
+    bit.callback = undefined;
+    bit.value = undefined;
+    bit.auto_repeat = undefined;
+    bit.auto_repeat_interval = undefined;
+    this.bits[bit.id] = bit;
+};
 
 /** Add a Output control bitmask to the HIDBitVector */
 HIDBitVector.prototype.addOutputMask = function(group, name, bitmask) {
-    var bit = {}
-    bit.type = "output"
-    bit.packet = undefined
-    bit.id = group + "." + name
-    bit.group = group
-    bit.name = name
-    bit.mapped_group = undefined
-    bit.mapped_name = undefined
-    bit.bitmask = bitmask
-    bit.bit_offset = this.getOffset(bitmask)
-    bit.callback = undefined
-    bit.value = undefined
-    bit.toggle = undefined
-    this.bits[bit.id] = bit
-}
+    var bit = {};
+    bit.type = "output";
+    bit.packet = undefined;
+    bit.id = group + "." + name;
+    bit.group = group;
+    bit.name = name;
+    bit.mapped_group = undefined;
+    bit.mapped_name = undefined;
+    bit.bitmask = bitmask;
+    bit.bit_offset = this.getOffset(bitmask);
+    bit.callback = undefined;
+    bit.value = undefined;
+    bit.toggle = undefined;
+    this.bits[bit.id] = bit;
+};
 
 /** HID Modifiers object
  *
  * Wraps all defined modifiers to one object with uniform API.
  * Don't call directly, this is available as HIDController.modifiers */
-HIDModifierList = function() {
-    this.modifiers = Object()
-    this.callbacks = Object()
-}
+var HIDModifierList = function() {
+    this.modifiers = Object();
+    this.callbacks = Object();
+};
 
 /** Add a new modifier to controller. */
 HIDModifierList.prototype.add = function(name) {
     if (name in this.modifiers) {
-        HIDDebug("Modifier already defined: " + name)
-        return
+        HIDDebug("Modifier already defined: " + name);
+        return;
     }
-    this.modifiers[name] = undefined
-}
+    this.modifiers[name] = undefined;
+};
 
 /** Set modifier value */
 HIDModifierList.prototype.set = function(name, value) {
-    if ((!name in this.modifiers)) {
-        HIDDebug("Unknown modifier: " + name)
-        return
+    if (!(name in this.modifiers)) {
+        HIDDebug("Unknown modifier: " + name);
+        return;
     }
-    this.modifiers[name] = value
+    this.modifiers[name] = value;
     if (name in this.callbacks) {
-        var callback = this.callbacks[name]
-        callback(value)
+        var callback = this.callbacks[name];
+        callback(value);
     }
-}
+};
 
 /** Get modifier value */
 HIDModifierList.prototype.get = function(name) {
     if (!(name in this.modifiers)) {
-        HIDDebug("Unknown modifier: " + name)
-        return false
+        HIDDebug("Unknown modifier: " + name);
+        return false;
     }
-    return this.modifiers[name]
-}
+    return this.modifiers[name];
+};
 
 /** Set modifier callback (update function after modifier state changes) */
 HIDModifierList.prototype.setCallback = function(name, callback) {
-    if ((!name in this.modifiers)) {
+    if (!(name in this.modifiers)) {
         HIDDebug("Unknown modifier: " + name);
-        return
+        return;
     }
-    this.callbacks[name] = callback
-}
+    this.callbacks[name] = callback;
+};
 
 /**
  * HID Packet object
@@ -122,70 +124,70 @@ HIDModifierList.prototype.setCallback = function(name, callback) {
  * @param header   (optional) list of bytes to match from beginning
  *          of packet. Do NOT put the report ID in this; use
  *          the reportId parameter instead. */
-HIDPacket = function(name, reportId, callback, header) {
-    this.name = name
-    this.header = header
-    this.callback = callback
+var HIDPacket = function(name, reportId, callback, header) {
+    this.name = name;
+    this.header = header;
+    this.callback = callback;
 
-    this.reportId = 0
+    this.reportId = 0;
     if (reportId !== undefined) {
-        this.reportId = reportId
+        this.reportId = reportId;
     }
 
-    this.groups = {}
+    this.groups = {};
 
     // Size of various 'pack' values in bytes
-    this.packSizes = {b: 1, B: 1, h: 2, H: 2, i: 4, I: 4}
-    this.signedPackFormats = ["b", "h", "i"]
-}
+    this.packSizes = {b: 1, B: 1, h: 2, H: 2, i: 4, I: 4};
+    this.signedPackFormats = ["b", "h", "i"];
+};
 
 /** Pack a field value to the packet.
  * Can only pack bits and byte values, patches welcome. */
 HIDPacket.prototype.pack = function(data, field) {
-    var value
+    var value;
     if (!(field.pack in this.packSizes)) {
-        HIDDebug("ERROR parsing packed value: invalid pack format " + field.pack)
-        return
+        HIDDebug("ERROR parsing packed value: invalid pack format " + field.pack);
+        return;
     }
-    var bytes = this.packSizes[field.pack]
-    var signed = false
-    if (this.signedPackFormats.indexOf(field.pack) != -1)
-        signed = true
+    var bytes = this.packSizes[field.pack];
+    var signed = false;
+    if (this.signedPackFormats.indexOf(field.pack) !== -1)
+        signed = true;
 
-    if (field.type == "bitvector") {
+    if (field.type === "bitvector") {
         // TODO - fix multi byte bit vector outputs
         if (bytes > 1) {
-            HIDDebug("ERROR: packing multibyte bit vectors not yet supported")
-            return
+            HIDDebug("ERROR: packing multibyte bit vectors not yet supported");
+            return;
         }
-        for (bit_id in field.value.bits) {
-            var bit = field.value.bits[bit_id]
-            data[field.offset] = data[field.offset] | bit.value
+        for (var bit_id in field.value.bits) {
+            var bit = field.value.bits[bit_id];
+            data[field.offset] = data[field.offset] | bit.value;
         }
-        return
+        return;
     }
 
-    value = (field.value != undefined) ? field.value : 0
+    value = (field.value !== undefined) ? field.value : 0;
 
     if (value < field.min || value > field.max) {
-        HIDDebug("ERROR " + field.id + " packed value out of range: " + value)
-        return
+        HIDDebug("ERROR " + field.id + " packed value out of range: " + value);
+        return;
     }
 
     for (var byte_index = 0; byte_index < bytes; byte_index++) {
-        var index = field.offset + byte_index
+        var index = field.offset + byte_index;
         if (signed) {
             if (value >= 0) {
-                data[index] = (value >> (byte_index * 8)) & 255
+                data[index] = (value >> (byte_index * 8)) & 255;
             } else {
-                data[index] = 255 - ((-(value + 1) >> (byte_index * 8)) & 255)
+                data[index] = 255 - ((-(value + 1) >> (byte_index * 8)) & 255);
             }
         } else {
-            data[index] = (value >> (byte_index * 8)) & 255
+            data[index] = (value >> (byte_index * 8)) & 255;
         }
     }
 
-}
+};
 
 /** Parse and return field value matching the 'pack' field from field attributes.
  * Valid values are:
@@ -196,135 +198,135 @@ HIDPacket.prototype.pack = function(data, field) {
  *  i       signed integer
  *  I       unsigned integer */
 HIDPacket.prototype.unpack = function(data, field) {
-    var value = 0
+    var value = 0;
 
     if (!(field.pack in this.packSizes)) {
-        HIDDebug("ERROR parsing packed value: invalid pack format " + field.pack)
-        return
+        HIDDebug("ERROR parsing packed value: invalid pack format " + field.pack);
+        return;
     }
-    var bytes = this.packSizes[field.pack]
-    var signed = false
-    if (this.signedPackFormats.indexOf(field.pack) != -1)
-        signed = true
+    var bytes = this.packSizes[field.pack];
+    var signed = false;
+    if (this.signedPackFormats.indexOf(field.pack) !== -1)
+        signed = true;
 
-    for (field_byte = 0; field_byte < bytes; field_byte++) {
-        if (data[field.offset + field_byte] == 255 && field_byte == 4)
-            value += 0
+    for (var field_byte = 0; field_byte < bytes; field_byte++) {
+        if (data[field.offset + field_byte] === 255 && field_byte === 4)
+            value += 0;
         else
-            value += data[field.offset + field_byte] * Math.pow(2, (field_byte * 8))
+            value += data[field.offset + field_byte] * Math.pow(2, (field_byte * 8));
     }
     if (signed) {
-        var max_value = Math.pow(2, bytes * 8)
-        var split = max_value / 2 - 1
+        var max_value = Math.pow(2, bytes * 8);
+        var split = max_value / 2 - 1;
         if (value > split)
-            value = value - max_value
+            value = value - max_value;
     }
-    return value
-}
+    return value;
+};
 
 /** Find HID packet group matching name.
  * Create group if create is true */
 HIDPacket.prototype.getGroup = function(name, create) {
-    if (this.groups == undefined)
-        this.groups = {}
+    if (this.groups === undefined)
+        this.groups = {};
     if (name in this.groups)
-        return this.groups[name]
+        return this.groups[name];
     if (!create)
-        return undefined
-    this.groups[name] = {}
-    return this.groups[name]
-}
+        return undefined;
+    this.groups[name] = {};
+    return this.groups[name];
+};
 
 /** Lookup HID packet field matching given offset and pack type
  * Returns undefined if no patching field can be found. */
 HIDPacket.prototype.getFieldByOffset = function(offset, pack) {
     if (!(pack in this.packSizes)) {
-        HIDDebug("Unknown pack string " + pack)
-        return undefined
+        HIDDebug("Unknown pack string " + pack);
+        return undefined;
     }
-    var end_offset = offset + this.packSizes[pack]
-    var group
-    var field
+    var end_offset = offset + this.packSizes[pack];
+    var group;
+    var field;
     for (var group_name in this.groups) {
-        group = this.groups[group_name]
+        group = this.groups[group_name];
         for (var field_id in group) {
-            field = group[field_id]
+            field = group[field_id];
             // Same field offset
-            if (field.offset == offset)
-                return field
+            if (field.offset === offset)
+                return field;
             // 7-8 8-9
             // Offset for smaller packet inside multibyte field
             if (field.offset < offset && field.end_offset >= end_offset)
-                return field
+                return field;
             // Packet offset starts inside field, may overflow
             if (field.offset < offset && field.end_offset > offset)
-                return field
+                return field;
             // Packet start before field, ends or overflows field
             if (field.offset > offset && field.offset < end_offset)
-                return field
+                return field;
         }
     }
-    return undefined
-}
+    return undefined;
+};
 
 /** Return a field by group and name from the packet,
  * Returns undefined if field could not be found */
 HIDPacket.prototype.getField = function(group, name) {
-    var field_id = group + "." + name
+    var field_id = group + "." + name;
     if (!(group in this.groups)) {
-        HIDDebug("PACKET " + this.name + " group not found " + group)
-        return undefined
+        HIDDebug("PACKET " + this.name + " group not found " + group);
+        return undefined;
     }
 
-    var control_group = this.groups[group]
+    var control_group = this.groups[group];
     if (field_id in control_group)
-        return control_group[field_id]
+        return control_group[field_id];
 
     // Lookup for bit fields in bitvector matching field name
     for (var group_name in this.groups) {
-        var control_group = this.groups[group_name]
-        for (field_name in control_group) {
-            var field = control_group[field_name]
-            if (field == undefined || field.type != "bitvector")
-                continue
-            for (bit_name in field.value.bits) {
-                var bit = field.value.bits[bit_name]
-                if (bit.id == field_id) {
-                    return field
+        control_group = this.groups[group_name];
+        for (var field_name in control_group) {
+            var field = control_group[field_name];
+            if (field === undefined || field.type !== "bitvector")
+                continue;
+            for (var bit_name in field.value.bits) {
+                var bit = field.value.bits[bit_name];
+                if (bit.id === field_id) {
+                    return field;
                 }
             }
         }
     }
     // Field not found
-    return undefined
-}
+    return undefined;
+};
 
 /** Return reference to a bit in a bitvector field */
 HIDPacket.prototype.lookupBit = function(group, name) {
-    var field = this.getField(group, name)
-    if (field == undefined) {
-        HIDDebug("Bitvector match not found: " + group + "." + name)
-        return undefined
+    var field = this.getField(group, name);
+    if (field === undefined) {
+        HIDDebug("Bitvector match not found: " + group + "." + name);
+        return undefined;
     }
-    var bit_id = group + "." + name
-    for (bit_name in field.value.bits) {
-        var bit = field.value.bits[bit_name]
-        if (bit.id == bit_id)
-            return bit
+    var bit_id = group + "." + name;
+    for (var bit_name in field.value.bits) {
+        var bit = field.value.bits[bit_name];
+        if (bit.id === bit_id)
+            return bit;
     }
-    HIDDebug("BUG: bit not found after successful field lookup")
-    return undefined
-}
+    HIDDebug("BUG: bit not found after successful field lookup");
+    return undefined;
+};
 
 /** Remove a control registered. Normally not needed */
 HIDPacket.prototype.removeControl = function(group, name) {
-    var control_group = this.getGroup(group)
+    var control_group = this.getGroup(group);
     if (!(name in control_group)) {
-        HIDDebug("Field not in control group " + group + ": " + name)
-        return
+        HIDDebug("Field not in control group " + group + ": " + name);
+        return;
     }
-    delete control_group[name]
-}
+    delete control_group[name];
+};
 
 /** Register a numeric value to parse from input packet
  *
@@ -338,28 +340,28 @@ HIDPacket.prototype.removeControl = function(group, name) {
  * @param callback callback function for the control
  */
 HIDPacket.prototype.addControl = function(group, name, offset, pack, bitmask, isEncoder, callback) {
-    var control_group = this.getGroup(group, true)
-    var bitvector = undefined
-    if (control_group == undefined) {
-        HIDDebug("ERROR creating HID packet group " + group)
-        return
+    var control_group = this.getGroup(group, true);
+    var bitvector = undefined;
+    if (control_group === undefined) {
+        HIDDebug("ERROR creating HID packet group " + group);
+        return;
     }
     if (!(pack in this.packSizes)) {
-        HIDDebug("Unknown pack value " + pack)
-        return
+        HIDDebug("Unknown pack value " + pack);
+        return;
     }
 
-    var field = this.getFieldByOffset(offset, pack)
-    if (field != undefined) {
-        if (bitmask == undefined) {
-            HIDDebug("ERROR registering offset " + offset + " pack " + pack)
+    var field = this.getFieldByOffset(offset, pack);
+    if (field !== undefined) {
+        if (bitmask === undefined) {
+            HIDDebug("ERROR registering offset " + offset + " pack " + pack);
             HIDDebug(
                 "ERROR trying to overwrite non-bitmask control " + group + " " + name
-            )
-            return
+            );
+            return;
         }
-        bitvector = field.value
-        bitvector.addBitMask(group, name, bitmask)
+        bitvector = field.value;
+        bitvector.addBitMask(group, name, bitmask);
         if (callback !== undefined) {
             if (typeof callback !== "function") {
                 HIDDebug("ERROR callback provided for " + group + "." + name + " is not a function.");
@@ -367,64 +369,64 @@ HIDPacket.prototype.addControl = function(group, name, offset, pack, bitmask, is
             }
             this.setCallback(group, name, callback);
         }
-        return
-    }
-
-    field = {}
-    field.packet = undefined
-    field.id = group + "." + name
-    field.group = group
-    field.name = name
-    field.mapped_group = undefined
-    field.mapped_name = undefined
-    field.pack = pack
-    field.offset = offset
-    field.end_offset = offset + this.packSizes[field.pack]
-    field.bitmask = bitmask
-    field.isEncoder = isEncoder
-    field.callback = undefined
-    field.soft_takeover = false
-    field.ignored = false
-    field.auto_repeat = undefined
-    field.auto_repeat_interval = undefined
-
-    var packet_max_value = Math.pow(2, this.packSizes[field.pack] * 8)
-    if (this.signedPackFormats.indexOf(pack) != -1) {
-        field.min = 0 - (packet_max_value / 2) + 1
-        field.max = (packet_max_value / 2) - 1
+        return;
+    }
+
+    field = {};
+    field.packet = undefined;
+    field.id = group + "." + name;
+    field.group = group;
+    field.name = name;
+    field.mapped_group = undefined;
+    field.mapped_name = undefined;
+    field.pack = pack;
+    field.offset = offset;
+    field.end_offset = offset + this.packSizes[field.pack];
+    field.bitmask = bitmask;
+    field.isEncoder = isEncoder;
+    field.callback = undefined;
+    field.soft_takeover = false;
+    field.ignored = false;
+    field.auto_repeat = undefined;
+    field.auto_repeat_interval = undefined;
+
+    var packet_max_value = Math.pow(2, this.packSizes[field.pack] * 8);
+    if (this.signedPackFormats.indexOf(pack) !== -1) {
+        field.min = 0 - (packet_max_value / 2) + 1;
+        field.max = (packet_max_value / 2) - 1;
     } else {
-        field.min = 0
-        field.max = packet_max_value - 1
+        field.min = 0;
+        field.max = packet_max_value - 1;
     }
 
-    if (bitmask == undefined || bitmask == packet_max_value) {
-        field.type = "control"
-        field.value = undefined
-        field.delta = 0
-        field.mindelta = 0
+    if (bitmask === undefined || bitmask === packet_max_value) {
+        field.type = "control";
+        field.value = undefined;
+        field.delta = 0;
+        field.mindelta = 0;
     } else {
-        if (this.signedPackFormats.indexOf(pack) != -1) {
-            HIDDebug("ERROR registering bitvector: signed fields not supported")
-            return
+        if (this.signedPackFormats.indexOf(pack) !== -1) {
+            HIDDebug("ERROR registering bitvector: signed fields not supported");
+            return;
         }
         // Create a new bitvector field and add the bit to that
         // TODO - accept controls with bitmask < packet_max_value
-        field_name = "bitvector_" + offset
-        field.type = "bitvector"
-        field.name = field_name
-        field.id = group + "." + field_name
-        bitvector = new HIDBitVector(field.max)
-        bitvector.size = field.max
-        bitvector.addBitMask(group, name, bitmask)
-        field.value = bitvector
-        field.delta = undefined
-        field.soft_takeover = undefined
-        field.mindelta = undefined
+        var field_name = "bitvector_" + offset;
+        field.type = "bitvector";
+        field.name = field_name;
+        field.id = group + "." + field_name;
+        bitvector = new HIDBitVector(field.max);
+        bitvector.size = field.max;
+        bitvector.addBitMask(group, name, bitmask);
+        field.value = bitvector;
+        field.delta = undefined;
+        field.soft_takeover = undefined;
+        field.mindelta = undefined;
     }
 
     // Add the new field to the packet
-    control_group[field.id] = field
-    
+    control_group[field.id] = field;
+
     if (callback !== undefined) {
         if (typeof callback !== "function") {
             HIDDebug("ERROR callback provided for " + group + "." + name + " is not a function.");
@@ -432,7 +434,7 @@ HIDPacket.prototype.addControl = function(group, name, offset, pack, bitmask, is
         }
         this.setCallback(group, name, callback);
     }
-}
+};
 
 /** Register a Output control field or Output control bit to output packet
  * Output control field:
@@ -447,250 +449,250 @@ HIDPacket.prototype.addControl = function(group, name, offset, pack, bitmask, is
  *          (0 is automatically populated with the reportId)
  * @param pack control packing format for pack(), one of b/B, h/H, i/I */
 HIDPacket.prototype.addOutput = function(group, name, offset, pack, bitmask, callback) {
-    var control_group = this.getGroup(group, true)
-    var field
-    var bitvector = undefined
-    var field_id = group + "." + name
+    var control_group = this.getGroup(group, true);
+    var field;
+    var bitvector = undefined;
+    var field_id = group + "." + name;
 
-    if (control_group == undefined) {
-        return
+    if (control_group === undefined) {
+        return;
     }
     if (!(pack in this.packSizes)) {
-        HIDDebug("ERROR: unknown Output control pack value " + pack)
-        return
+        HIDDebug("ERROR: unknown Output control pack value " + pack);
+        return;
     }
 
     // Adjust offset by 1 because the reportId was previously considered part of the payload
     // but isn't anymore and we can't be bothered to adjust every single script manually
-    offset -= 1
+    offset -= 1;
 
     // Check if we are adding a Output bit to existing bitvector
-    field = this.getFieldByOffset(offset, pack)
-    if (field != undefined) {
-        if (bitmask == undefined) {
+    field = this.getFieldByOffset(offset, pack);
+    if (field !== undefined) {
+        if (bitmask === undefined) {
             HIDDebug(
                 "ERROR: overwrite non-bitmask control " + group + "." + name
-            )
-            return
+            );
+            return;
         }
-        bitvector = field.value
-        bitvector.addOutputMask(group, name, bitmask)
-        return
-    }
-
-    field = {}
-    field.id = field_id
-    field.group = group
-    field.name = name
-    field.mapped_group = undefined
-    field.mapped_name = undefined
-    field.pack = pack
-    field.offset = offset
-    field.end_offset = offset + this.packSizes[field.pack]
-    field.bitmask = bitmask
-    field.callback = callback
-    field.toggle = undefined
-
-    var packet_max_value = Math.pow(2, this.packSizes[field.pack] * 8)
-    if (this.signedPackFormats.indexOf(pack) != -1) {
-        field.min = 0 - (packet_max_value / 2) + 1
-        field.max = (packet_max_value / 2) - 1
+        bitvector = field.value;
+        bitvector.addOutputMask(group, name, bitmask);
+        return;
+    }
+
+    field = {};
+    field.id = field_id;
+    field.group = group;
+    field.name = name;
+    field.mapped_group = undefined;
+    field.mapped_name = undefined;
+    field.pack = pack;
+    field.offset = offset;
+    field.end_offset = offset + this.packSizes[field.pack];
+    field.bitmask = bitmask;
+    field.callback = callback;
+    field.toggle = undefined;
+
+    var packet_max_value = Math.pow(2, this.packSizes[field.pack] * 8);
+    if (this.signedPackFormats.indexOf(pack) !== -1) {
+        field.min = 0 - (packet_max_value / 2) + 1;
+        field.max = (packet_max_value / 2) - 1;
     } else {
-        field.min = 0
-        field.max = packet_max_value - 1
-    }
-    if (bitmask == undefined || bitmask == packet_max_value) {
-        field.type = "output"
-        field.value = undefined
-        field.delta = undefined
-        field.mindelta = undefined
+        field.min = 0;
+        field.max = packet_max_value - 1;
+    }
+    if (bitmask === undefined || bitmask === packet_max_value) {
+        field.type = "output";
+        field.value = undefined;
+        field.delta = undefined;
+        field.mindelta = undefined;
     } else {
         // Create new Output bitvector control field, add bit to it
         // rewrite name to use bitvector instead
-        field_name = "bitvector_" + offset
-        field.type = "bitvector"
-        field.id = group + "." + field_name
-        field.name = field_name
-        bitvector = new HIDBitVector()
-        bitvector.size = field.max
-        bitvector.addOutputMask(group, name, bitmask)
-        field.value = bitvector
-        field.delta = undefined
-        field.mindelta = undefined
+        var field_name = "bitvector_" + offset;
+        field.type = "bitvector";
+        field.id = group + "." + field_name;
+        field.name = field_name;
+        bitvector = new HIDBitVector();
+        bitvector.size = field.max;
+        bitvector.addOutputMask(group, name, bitmask);
+        field.value = bitvector;
+        field.delta = undefined;
+        field.mindelta = undefined;
     }
 
     // Add Output to HID packet
-    control_group[field.id] = field
-}
+    control_group[field.id] = field;
+};
 
 /** Register a callback to field or a bit vector bit.
  * Does not make sense for Output fields but you can do that. */
 HIDPacket.prototype.setCallback = function(group, name, callback) {
-    var field = this.getField(group, name)
-    var field_id = group + "." + name
-    if (callback == undefined) {
-        HIDDebug("Callback to add was undefined for " + field_id)
-        return
+    var field = this.getField(group, name);
+    var field_id = group + "." + name;
+    if (callback === undefined) {
+        HIDDebug("Callback to add was undefined for " + field_id);
+        return;
     }
-    if (field == undefined) {
+    if (field === undefined) {
         HIDDebug("setCallback: field for " + field_id + " not found"
-        )
-        return
+        );
+        return;
     }
-    if (field.type == "bitvector") {
+    if (field.type === "bitvector") {
         for (var bit_id in field.value.bits) {
-            var bit = field.value.bits[bit_id]
-            if (bit_id != field_id)
-                continue
-            bit.callback = callback
-            return
+            var bit = field.value.bits[bit_id];
+            if (bit_id !== field_id)
+                continue;
+            bit.callback = callback;
+            return;
         }
-        HIDDebug("ERROR: BIT NOT FOUND " + field_id)
+        HIDDebug("ERROR: BIT NOT FOUND " + field_id);
     } else {
-        field.callback = callback
+        field.callback = callback;
     }
-}
+};
 
 /** Set 'ignored' flag for field to given value (true or false)
  * If field is ignored, it is not reported in 'delta' objects. */
 HIDPacket.prototype.setIgnored = function(group, name, ignored) {
-    var field = this.getField(group, name)
-    if (field == undefined) {
-        HIDDebug("ERROR setting ignored flag for " + group + " " + name)
-        return
+    var field = this.getField(group, name);
+    if (field === undefined) {
+        HIDDebug("ERROR setting ignored flag for " + group + " " + name);
+        return;
     }
-    field.ignored = ignored
-}
+    field.ignored = ignored;
+};
 
 /** Adjust field's minimum delta value.
  * Input value changes smaller than this are not reported in delta */
 HIDPacket.prototype.setMinDelta = function(group, name, mindelta) {
-    field = this.getField(group, name)
-    if (field == undefined) {
-        HIDDebug("ERROR adjusting mindelta for " + group + " " + name)
-        return
+    var field = this.getField(group, name);
+    if (field === undefined) {
+        HIDDebug("ERROR adjusting mindelta for " + group + " " + name);
+        return;
     }
-    if (field.type == "bitvector") {
-        HIDDebug("ERROR setting mindelta for bitvector packet does not make sense")
-        return
+    if (field.type === "bitvector") {
+        HIDDebug("ERROR setting mindelta for bitvector packet does not make sense");
+        return;
     }
-    field.mindelta = mindelta
-}
+    field.mindelta = mindelta;
+};
 
 /** Parse bitvector field values, returning object with the named bits set.
  * Value must be a valid unsigned byte to parse, with enough bits.
  * Returns list of modified bits (delta) */
 HIDPacket.prototype.parseBitVector = function(field, value) {
-    var bits = {}
-    var bit
-    var new_value
+    var bits = {};
+    var bit;
+    var new_value;
     for (var bit_id in field.value.bits) {
-        bit = field.value.bits[bit_id]
-        new_value = (bit.bitmask & value) >> bit.bit_offset
-        if (bit.value != undefined && bit.value != new_value)
-            bits[bit_id] = bit
-        bit.value = new_value
+        bit = field.value.bits[bit_id];
+        new_value = (bit.bitmask & value) >> bit.bit_offset;
+        if (bit.value !== undefined && bit.value !== new_value)
+            bits[bit_id] = bit;
+        bit.value = new_value;
     }
-    return bits
-}
+    return bits;
+};
 
 /** Parse input packet fields from data.
  * Data is expected to be a Packet() received from HID device.
  * Returns list of changed fields with new value.
  * BitVectors are returned as bits you can iterate separately. */
 HIDPacket.prototype.parse = function(data) {
-    var field_changes = {}
-    var group
-    var group_name
-    var field
-    var field_id
+    var field_changes = {};
+    var group;
+    var group_name;
+    var field;
+    var field_id;
 
     for (group_name in this.groups) {
-        group = this.groups[group_name]
+        group = this.groups[group_name];
         for (field_id in group) {
-            field = group[field_id]
-            if (field == undefined)
-                continue
-
-            var value = this.unpack(data, field)
-            if (value == undefined) {
-                HIDDebug("Error parsing packet field value for " + field_id)
-                return
+            field = group[field_id];
+            if (field === undefined)
+                continue;
+
+            var value = this.unpack(data, field);
+            if (value === undefined) {
+                HIDDebug("Error parsing packet field value for " + field_id);
+                return;
             }
 
-            if (field.type == "bitvector") {
+            if (field.type === "bitvector") {
                 // Bitvector deltas are checked in parseBitVector
-                var changed_bits = this.parseBitVector(field, value)
+                var changed_bits = this.parseBitVector(field, value);
                 for (var bit_name in changed_bits)
-                    field_changes[bit_name] = changed_bits[bit_name]
-
-            } else if (field.type == "control") {
-                if (field.value == value && field.mindelta != undefined)
-                    continue
-                if (field.ignored || field.value == undefined) {
-                    field.value = value
-                    continue
+                    field_changes[bit_name] = changed_bits[bit_name];
+
+            } else if (field.type === "control") {
+                if (field.value === value && field.mindelta !== undefined)
+                    continue;
+                if (field.ignored || field.value === undefined) {
+                    field.value = value;
+                    continue;
                 }
-                var change
+                var change;
                 if (field.isEncoder) {
-                    if (field.value == field.max && value == field.min) {
-                        change = 1
-                        field.delta = 1
-                    } else if (value == field.max && field.value == field.min) {
-                        change = 1
-                        field.delta = -1
+                    if (field.value === field.max && value === field.min) {
+                        change = 1;
+                        field.delta = 1;
+                    } else if (value === field.max && field.value === field.min) {
+                        change = 1;
+                        field.delta = -1;
                     } else {
-                        change = 1
-                        field.delta = value - field.value
+                        change = 1;
+                        field.delta = value - field.value;
                     }
-                    field.value = value
+                    field.value = value;
                 } else {
-                    change = Math.abs(value - field.value)
-                    field.delta = value - field.value
+                    change = Math.abs(value - field.value);
+                    field.delta = value - field.value;
                 }
-                if (field.mindelta == undefined || change > field.mindelta) {
-                    field_changes[field.id] = field
-                    field.value = value
+                if (field.mindelta === undefined || change > field.mindelta) {
+                    field_changes[field.id] = field;
+                    field.value = value;
                 }
             }
         }
     }
-    return field_changes
-}
+    return field_changes;
+};
 
 /** Send this HID packet to device.
  * First the header bytes are copied to beginning of packet, then
  * field object values are packed to the HID packet according to the
  * field type. */
 HIDPacket.prototype.send = function(debug) {
-    var data = []
+    var data = [];
 
     if (this.header !== undefined) {
-        for (header_byte = 0; header_byte < this.header.length; header_byte++) {
-            data[header_byte] = this.header[header_byte]
+