standard

bench/basic.js

@@ -1,14 +1,14 @@
-var random = require('crypto').randomBytes
+const random = require('crypto').randomBytes
 
-var b64 = require('../')
-var data = random(1e6).toString('base64')
-var start = Date.now()
-var raw = b64.toByteArray(data)
-var middle1 = Date.now()
+const b64 = require('../')
+let data = random(1e6).toString('base64')
+const start = Date.now()
+const raw = b64.toByteArray(data)
+const middle1 = Date.now()
 data = b64.fromByteArray(raw)
-var middle2 = Date.now()
-var len = b64.byteLength(data)
-var end = Date.now()
+const middle2 = Date.now()
+const len = b64.byteLength(data)
+const end = Date.now()
 
 console.log(
   'decode ms, decode ops/ms, encode ms, encode ops/ms, length ms, length ops/ms'

bench/bench.js

@@ -1,20 +1,20 @@
-var base64 = require('../')
-var benchmark = require('benchmark')
+const base64 = require('../')
+const benchmark = require('benchmark')
 
-var suite = new benchmark.Suite()
-var random = require('crypto').randomBytes
-var data = random(1e6).toString('base64')
-var raw = base64.toByteArray(data)
+const suite = new benchmark.Suite()
+const random = require('crypto').randomBytes
+const data = random(1e6).toString('base64')
+const raw = base64.toByteArray(data)
 
 suite
   .add('base64.toByteArray() (decode)', function () {
-    var raw2 = base64.toByteArray(data) // eslint-disable-line no-unused-vars
+    const raw2 = base64.toByteArray(data) // eslint-disable-line no-unused-vars
   })
   .add('base64.fromByteArray() (encode)', function () {
-    var data2 = base64.fromByteArray(raw) // eslint-disable-line no-unused-vars
+    const data2 = base64.fromByteArray(raw) // eslint-disable-line no-unused-vars
   })
   .add('base64.byteLength() (encode)', function () {
-    var len = base64.byteLength(data) // eslint-disable-line no-unused-vars
+    const len = base64.byteLength(data) // eslint-disable-line no-unused-vars
   })
   .on('error', function (event) {
     console.error(event.target.error.stack)

index.js

@@ -4,12 +4,12 @@ exports.byteLength = byteLength
 exports.toByteArray = toByteArray
 exports.fromByteArray = fromByteArray
 
-var lookup = []
-var revLookup = []
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+const lookup = []
+const revLookup = []
+const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
 
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-for (var i = 0, len = code.length; i < len; ++i) {
+const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (let i = 0, len = code.length; i < len; ++i) {
   lookup[i] = code[i]
   revLookup[code.charCodeAt(i)] = i
 }
@@ -20,18 +20,18 @@ revLookup['-'.charCodeAt(0)] = 62
 revLookup['_'.charCodeAt(0)] = 63
 
 function getLens (b64) {
-  var len = b64.length
+  const len = b64.length
 
   if (len % 4 > 0) {
     throw new Error('Invalid string. Length must be a multiple of 4')
   }
 
   // Trim off extra bytes after placeholder bytes are found
   // See: https://github.com/beatgammit/base64-js/issues/42
-  var validLen = b64.indexOf('=')
+  let validLen = b64.indexOf('=')
   if (validLen === -1) validLen = len
 
-  var placeHoldersLen = validLen === len
+  const placeHoldersLen = validLen === len
     ? 0
     : 4 - (validLen % 4)
 
@@ -40,9 +40,9 @@ function getLens (b64) {
 
 // base64 is 4/3 + up to two characters of the original data
 function byteLength (b64) {
-  var lens = getLens(b64)
-  var validLen = lens[0]
-  var placeHoldersLen = lens[1]
+  const lens = getLens(b64)
+  const validLen = lens[0]
+  const placeHoldersLen = lens[1]
   return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
 }
 
@@ -51,21 +51,21 @@ function _byteLength (b64, validLen, placeHoldersLen) {
 }
 
 function toByteArray (b64) {
-  var tmp
-  var lens = getLens(b64)
-  var validLen = lens[0]
-  var placeHoldersLen = lens[1]
+  let tmp
+  const lens = getLens(b64)
+  const validLen = lens[0]
+  const placeHoldersLen = lens[1]
 
-  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+  const arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
 
-  var curByte = 0
+  let curByte = 0
 
   // if there are placeholders, only get up to the last complete 4 chars
-  var len = placeHoldersLen > 0
+  const len = placeHoldersLen > 0
     ? validLen - 4
     : validLen
 
-  var i
+  let i
   for (i = 0; i < len; i += 4) {
     tmp =
       (revLookup[b64.charCodeAt(i)] << 18) |
@@ -104,9 +104,9 @@ function tripletToBase64 (num) {
 }
 
 function encodeChunk (uint8, start, end) {
-  var tmp
-  var output = []
-  for (var i = start; i < end; i += 3) {
+  let tmp
+  const output = []
+  for (let i = start; i < end; i += 3) {
     tmp =
       ((uint8[i] << 16) & 0xFF0000) +
       ((uint8[i + 1] << 8) & 0xFF00) +
@@ -117,14 +117,14 @@ function encodeChunk (uint8, start, end) {
 }
 
 function fromByteArray (uint8) {
-  var tmp
-  var len = uint8.length
-  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
-  var parts = []
-  var maxChunkLength = 16383 // must be multiple of 3
+  let tmp
+  const len = uint8.length
+  const extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+  const parts = []
+  const maxChunkLength = 16383 // must be multiple of 3
 
   // go through the array every three bytes, we'll deal with trailing stuff later
-  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+  for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
     parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
   }
 

test/big-data.js

@@ -1,9 +1,9 @@
-var test = require('tape')
-var b64 = require('../')
+const test = require('tape')
+const b64 = require('../')
 
 test('convert big data to base64', function (t) {
-  var b64str, arr, i, length
-  var big = new Uint8Array(64 * 1024 * 1024)
+  let b64str, arr, i, length
+  const big = new Uint8Array(64 * 1024 * 1024)
   for (i = 0, length = big.length; i < length; ++i) {
     big[i] = i % 256
   }
@@ -15,8 +15,8 @@ test('convert big data to base64', function (t) {
 })
 
 function equal (a, b) {
-  var i
-  var length = a.length
+  let i
+  const length = a.length
   if (length !== b.length) return false
   for (i = 0; i < length; ++i) {
     if (a[i] !== b[i]) return false

test/convert.js

@@ -1,6 +1,6 @@
-var test = require('tape')
-var b64 = require('../')
-var checks = [
+const test = require('tape')
+const b64 = require('../')
+const checks = [
   'a',
   'aa',
   'aaa',
@@ -15,8 +15,8 @@ var checks = [
 test('convert to base64 and back', function (t) {
   t.plan(checks.length * 2)
 
-  for (var i = 0; i < checks.length; i++) {
-    var check = checks[i]
+  for (let i = 0; i < checks.length; i++) {
+    const check = checks[i]
     var b64Str, arr, str
 
     b64Str = b64.fromByteArray(map(check, function (char) { return char.charCodeAt(0) }))
@@ -29,7 +29,7 @@ test('convert to base64 and back', function (t) {
   }
 })
 
-var data = [
+const data = [
   [[0, 0, 0], 'AAAA'],
   [[0, 0, 1], 'AAAB'],
   [[0, 1, -1], 'AAH/'],
@@ -38,30 +38,30 @@ var data = [
 ]
 
 test('convert known data to string', function (t) {
-  for (var i = 0; i < data.length; i++) {
-    var bytes = data[i][0]
-    var expected = data[i][1]
-    var actual = b64.fromByteArray(bytes)
+  for (let i = 0; i < data.length; i++) {
+    const bytes = data[i][0]
+    const expected = data[i][1]
+    const actual = b64.fromByteArray(bytes)
     t.equal(actual, expected, 'Ensure that ' + bytes + ' serialise to ' + expected)
   }
   t.end()
 })
 
 test('convert known data from string', function (t) {
-  for (var i = 0; i < data.length; i++) {
-    var expected = data[i][0]
-    var string = data[i][1]
-    var actual = b64.toByteArray(string)
+  for (let i = 0; i < data.length; i++) {
+    const expected = data[i][0]
+    const string = data[i][1]
+    const actual = b64.toByteArray(string)
     t.ok(equal(actual, expected), 'Ensure that ' + string + ' deserialise to ' + expected)
-    var length = b64.byteLength(string)
+    const length = b64.byteLength(string)
     t.equal(length, expected.length, 'Ensure that ' + string + ' has byte lentgh of ' + expected.length)
   }
   t.end()
 })
 
 function equal (a, b) {
-  var i
-  var length = a.length
+  let i
+  const length = a.length
   if (length !== b.length) return false
   for (i = 0; i < length; ++i) {
     if ((a[i] & 0xFF) !== (b[i] & 0xFF)) return false
@@ -70,10 +70,10 @@ function equal (a, b) {
 }
 
 function map (arr, callback) {
-  var res = []
-  var kValue, mappedValue
+  const res = []
+  let kValue, mappedValue
 
-  for (var k = 0, len = arr.length; k < len; k++) {
+  for (let k = 0, len = arr.length; k < len; k++) {
     if ((typeof arr === 'string' && !!arr.charAt(k))) {
       kValue = arr.charAt(k)
       mappedValue = callback(kValue, k, arr)

test/corrupt.js

@@ -1,9 +1,9 @@
-var test = require('tape')
-var b64 = require('../')
+const test = require('tape')
+const b64 = require('../')
 
 test('padding bytes found inside base64 string', function (t) {
   // See https://github.com/beatgammit/base64-js/issues/42
-  var str = 'SQ==QU0='
+  const str = 'SQ==QU0='
   t.deepEqual(b64.toByteArray(str), new Uint8Array([73]))
   t.equal(b64.byteLength(str), 1)
   t.end()

test/url-safe.js

@@ -1,11 +1,11 @@
-var test = require('tape')
-var b64 = require('../')
+const test = require('tape')
+const b64 = require('../')
 
 test('decode url-safe style base64 strings', function (t) {
-  var expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff]
+  const expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff]
 
-  var str = '//++/++/++//'
-  var actual = b64.toByteArray(str)
+  let str = '//++/++/++//'
+  let actual = b64.toByteArray(str)
   for (var i = 0; i < actual.length; i++) {
     t.equal(actual[i], expected[i])
   }