Index: imaps-frontend/node_modules/flat/test/test.js
===================================================================
--- imaps-frontend/node_modules/flat/test/test.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
+++ imaps-frontend/node_modules/flat/test/test.js	(revision 79a03170cdde4e801d12257ee86723774970427b)
@@ -0,0 +1,643 @@
+/* globals suite test */
+
+const assert = require('assert')
+const path = require('path')
+const { exec } = require('child_process')
+const pkg = require('../package.json')
+const flat = require('../index')
+
+const flatten = flat.flatten
+const unflatten = flat.unflatten
+
+const primitives = {
+  String: 'good morning',
+  Number: 1234.99,
+  Boolean: true,
+  Date: new Date(),
+  null: null,
+  undefined: undefined
+}
+
+suite('Flatten Primitives', function () {
+  Object.keys(primitives).forEach(function (key) {
+    const value = primitives[key]
+
+    test(key, function () {
+      assert.deepStrictEqual(flatten({
+        hello: {
+          world: value
+        }
+      }), {
+        'hello.world': value
+      })
+    })
+  })
+})
+
+suite('Unflatten Primitives', function () {
+  Object.keys(primitives).forEach(function (key) {
+    const value = primitives[key]
+
+    test(key, function () {
+      assert.deepStrictEqual(unflatten({
+        'hello.world': value
+      }), {
+        hello: {
+          world: value
+        }
+      })
+    })
+  })
+})
+
+suite('Flatten', function () {
+  test('Nested once', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        world: 'good morning'
+      }
+    }), {
+      'hello.world': 'good morning'
+    })
+  })
+
+  test('Nested twice', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      }
+    }), {
+      'hello.world.again': 'good morning'
+    })
+  })
+
+  test('Multiple Keys', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        lorem: {
+          ipsum: 'again',
+          dolor: 'sit'
+        }
+      },
+      world: {
+        lorem: {
+          ipsum: 'again',
+          dolor: 'sit'
+        }
+      }
+    }), {
+      'hello.lorem.ipsum': 'again',
+      'hello.lorem.dolor': 'sit',
+      'world.lorem.ipsum': 'again',
+      'world.lorem.dolor': 'sit'
+    })
+  })
+
+  test('Custom Delimiter', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      }
+    }, {
+      delimiter: ':'
+    }), {
+      'hello:world:again': 'good morning'
+    })
+  })
+
+  test('Empty Objects', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        empty: {
+          nested: {}
+        }
+      }
+    }), {
+      'hello.empty.nested': {}
+    })
+  })
+
+  if (typeof Buffer !== 'undefined') {
+    test('Buffer', function () {
+      assert.deepStrictEqual(flatten({
+        hello: {
+          empty: {
+            nested: Buffer.from('test')
+          }
+        }
+      }), {
+        'hello.empty.nested': Buffer.from('test')
+      })
+    })
+  }
+
+  if (typeof Uint8Array !== 'undefined') {
+    test('typed arrays', function () {
+      assert.deepStrictEqual(flatten({
+        hello: {
+          empty: {
+            nested: new Uint8Array([1, 2, 3, 4])
+          }
+        }
+      }), {
+        'hello.empty.nested': new Uint8Array([1, 2, 3, 4])
+      })
+    })
+  }
+
+  test('Custom Depth', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      },
+      lorem: {
+        ipsum: {
+          dolor: 'good evening'
+        }
+      }
+    }, {
+      maxDepth: 2
+    }), {
+      'hello.world': {
+        again: 'good morning'
+      },
+      'lorem.ipsum': {
+        dolor: 'good evening'
+      }
+    })
+  })
+
+  test('Transformed Keys', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      },
+      lorem: {
+        ipsum: {
+          dolor: 'good evening'
+        }
+      }
+    }, {
+      transformKey: function (key) {
+        return '__' + key + '__'
+      }
+    }), {
+      '__hello__.__world__.__again__': 'good morning',
+      '__lorem__.__ipsum__.__dolor__': 'good evening'
+    })
+  })
+
+  test('Should keep number in the left when object', function () {
+    assert.deepStrictEqual(flatten({
+      hello: {
+        '0200': 'world',
+        '0500': 'darkness my old friend'
+      }
+    }), {
+      'hello.0200': 'world',
+      'hello.0500': 'darkness my old friend'
+    })
+  })
+})
+
+suite('Unflatten', function () {
+  test('Nested once', function () {
+    assert.deepStrictEqual({
+      hello: {
+        world: 'good morning'
+      }
+    }, unflatten({
+      'hello.world': 'good morning'
+    }))
+  })
+
+  test('Nested twice', function () {
+    assert.deepStrictEqual({
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      }
+    }, unflatten({
+      'hello.world.again': 'good morning'
+    }))
+  })
+
+  test('Multiple Keys', function () {
+    assert.deepStrictEqual({
+      hello: {
+        lorem: {
+          ipsum: 'again',
+          dolor: 'sit'
+        }
+      },
+      world: {
+        greet: 'hello',
+        lorem: {
+          ipsum: 'again',
+          dolor: 'sit'
+        }
+      }
+    }, unflatten({
+      'hello.lorem.ipsum': 'again',
+      'hello.lorem.dolor': 'sit',
+      'world.lorem.ipsum': 'again',
+      'world.lorem.dolor': 'sit',
+      world: { greet: 'hello' }
+    }))
+  })
+
+  test('nested objects do not clobber each other when a.b inserted before a', function () {
+    const x = {}
+    x['foo.bar'] = { t: 123 }
+    x.foo = { p: 333 }
+    assert.deepStrictEqual(unflatten(x), {
+      foo: {
+        bar: {
+          t: 123
+        },
+        p: 333
+      }
+    })
+  })
+
+  test('Custom Delimiter', function () {
+    assert.deepStrictEqual({
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      }
+    }, unflatten({
+      'hello world again': 'good morning'
+    }, {
+      delimiter: ' '
+    }))
+  })
+
+  test('Overwrite', function () {
+    assert.deepStrictEqual({
+      travis: {
+        build: {
+          dir: '/home/travis/build/kvz/environmental'
+        }
+      }
+    }, unflatten({
+      travis: 'true',
+      travis_build_dir: '/home/travis/build/kvz/environmental'
+    }, {
+      delimiter: '_',
+      overwrite: true
+    }))
+  })
+
+  test('Transformed Keys', function () {
+    assert.deepStrictEqual(unflatten({
+      '__hello__.__world__.__again__': 'good morning',
+      '__lorem__.__ipsum__.__dolor__': 'good evening'
+    }, {
+      transformKey: function (key) {
+        return key.substring(2, key.length - 2)
+      }
+    }), {
+      hello: {
+        world: {
+          again: 'good morning'
+        }
+      },
+      lorem: {
+        ipsum: {
+          dolor: 'good evening'
+        }
+      }
+    })
+  })
+
+  test('Messy', function () {
+    assert.deepStrictEqual({
+      hello: { world: 'again' },
+      lorem: { ipsum: 'another' },
+      good: {
+        morning: {
+          hash: {
+            key: {
+              nested: {
+                deep: {
+                  and: {
+                    even: {
+                      deeper: { still: 'hello' }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          again: { testing: { this: 'out' } }
+        }
+      }
+    }, unflatten({
+      'hello.world': 'again',
+      'lorem.ipsum': 'another',
+      'good.morning': {
+        'hash.key': {
+          'nested.deep': {
+            'and.even.deeper.still': 'hello'
+          }
+        }
+      },
+      'good.morning.again': {
+        'testing.this': 'out'
+      }
+    }))
+  })
+
+  suite('Overwrite + non-object values in key positions', function () {
+    test('non-object keys + overwrite should be overwritten', function () {
+      assert.deepStrictEqual(flat.unflatten({ a: null, 'a.b': 'c' }, { overwrite: true }), { a: { b: 'c' } })
+      assert.deepStrictEqual(flat.unflatten({ a: 0, 'a.b': 'c' }, { overwrite: true }), { a: { b: 'c' } })
+      assert.deepStrictEqual(flat.unflatten({ a: 1, 'a.b': 'c' }, { overwrite: true }), { a: { b: 'c' } })
+      assert.deepStrictEqual(flat.unflatten({ a: '', 'a.b': 'c' }, { overwrite: true }), { a: { b: 'c' } })
+    })
+
+    test('overwrite value should not affect undefined keys', function () {
+      assert.deepStrictEqual(flat.unflatten({ a: undefined, 'a.b': 'c' }, { overwrite: true }), { a: { b: 'c' } })
+      assert.deepStrictEqual(flat.unflatten({ a: undefined, 'a.b': 'c' }, { overwrite: false }), { a: { b: 'c' } })
+    })
+
+    test('if no overwrite, should ignore nested values under non-object key', function () {
+      assert.deepStrictEqual(flat.unflatten({ a: null, 'a.b': 'c' }), { a: null })
+      assert.deepStrictEqual(flat.unflatten({ a: 0, 'a.b': 'c' }), { a: 0 })
+      assert.deepStrictEqual(flat.unflatten({ a: 1, 'a.b': 'c' }), { a: 1 })
+      assert.deepStrictEqual(flat.unflatten({ a: '', 'a.b': 'c' }), { a: '' })
+    })
+  })
+
+  suite('.safe', function () {
+    test('Should protect arrays when true', function () {
+      assert.deepStrictEqual(flatten({
+        hello: [
+          { world: { again: 'foo' } },
+          { lorem: 'ipsum' }
+        ],
+        another: {
+          nested: [{ array: { too: 'deep' } }]
+        },
+        lorem: {
+          ipsum: 'whoop'
+        }
+      }, {
+        safe: true
+      }), {
+        hello: [
+          { world: { again: 'foo' } },
+          { lorem: 'ipsum' }
+        ],
+        'lorem.ipsum': 'whoop',
+        'another.nested': [{ array: { too: 'deep' } }]
+      })
+    })
+
+    test('Should not protect arrays when false', function () {
+      assert.deepStrictEqual(flatten({
+        hello: [
+          { world: { again: 'foo' } },
+          { lorem: 'ipsum' }
+        ]
+      }, {
+        safe: false
+      }), {
+        'hello.0.world.again': 'foo',
+        'hello.1.lorem': 'ipsum'
+      })
+    })
+
+    test('Empty objects should not be removed', function () {
+      assert.deepStrictEqual(unflatten({
+        foo: [],
+        bar: {}
+      }), { foo: [], bar: {} })
+    })
+  })
+
+  suite('.object', function () {
+    test('Should create object instead of array when true', function () {
+      const unflattened = unflatten({
+        'hello.you.0': 'ipsum',
+        'hello.you.1': 'lorem',
+        'hello.other.world': 'foo'
+      }, {
+        object: true
+      })
+      assert.deepStrictEqual({
+        hello: {
+          you: {
+            0: 'ipsum',
+            1: 'lorem'
+          },
+          other: { world: 'foo' }
+        }
+      }, unflattened)
+      assert(!Array.isArray(unflattened.hello.you))
+    })
+
+    test('Should create object instead of array when nested', function () {
+      const unflattened = unflatten({
+        hello: {
+          'you.0': 'ipsum',
+          'you.1': 'lorem',
+          'other.world': 'foo'
+        }
+      }, {
+        object: true
+      })
+      assert.deepStrictEqual({
+        hello: {
+          you: {
+            0: 'ipsum',
+            1: 'lorem'
+          },
+          other: { world: 'foo' }
+        }
+      }, unflattened)
+      assert(!Array.isArray(unflattened.hello.you))
+    })
+
+    test('Should keep the zero in the left when object is true', function () {
+      const unflattened = unflatten({
+        'hello.0200': 'world',
+        'hello.0500': 'darkness my old friend'
+      }, {
+        object: true
+      })
+
+      assert.deepStrictEqual({
+        hello: {
+          '0200': 'world',
+          '0500': 'darkness my old friend'
+        }
+      }, unflattened)
+    })
+
+    test('Should not create object when false', function () {
+      const unflattened = unflatten({
+        'hello.you.0': 'ipsum',
+        'hello.you.1': 'lorem',
+        'hello.other.world': 'foo'
+      }, {
+        object: false
+      })
+      assert.deepStrictEqual({
+        hello: {
+          you: ['ipsum', 'lorem'],
+          other: { world: 'foo' }
+        }
+      }, unflattened)
+      assert(Array.isArray(unflattened.hello.you))
+    })
+  })
+
+  if (typeof Buffer !== 'undefined') {
+    test('Buffer', function () {
+      assert.deepStrictEqual(unflatten({
+        'hello.empty.nested': Buffer.from('test')
+      }), {
+        hello: {
+          empty: {
+            nested: Buffer.from('test')
+          }
+        }
+      })
+    })
+  }
+
+  if (typeof Uint8Array !== 'undefined') {
+    test('typed arrays', function () {
+      assert.deepStrictEqual(unflatten({
+        'hello.empty.nested': new Uint8Array([1, 2, 3, 4])
+      }), {
+        hello: {
+          empty: {
+            nested: new Uint8Array([1, 2, 3, 4])
+          }
+        }
+      })
+    })
+  }
+
+  test('should not pollute prototype', function () {
+    unflatten({
+      '__proto__.polluted': true
+    })
+    unflatten({
+      'prefix.__proto__.polluted': true
+    })
+    unflatten({
+      'prefix.0.__proto__.polluted': true
+    })
+
+    assert.notStrictEqual({}.polluted, true)
+  })
+})
+
+suite('Arrays', function () {
+  test('Should be able to flatten arrays properly', function () {
+    assert.deepStrictEqual({
+      'a.0': 'foo',
+      'a.1': 'bar'
+    }, flatten({
+      a: ['foo', 'bar']
+    }))
+  })
+
+  test('Should be able to revert and reverse array serialization via unflatten', function () {
+    assert.deepStrictEqual({
+      a: ['foo', 'bar']
+    }, unflatten({
+      'a.0': 'foo',
+      'a.1': 'bar'
+    }))
+  })
+
+  test('Array typed objects should be restored by unflatten', function () {
+    assert.strictEqual(
+      Object.prototype.toString.call(['foo', 'bar'])
+      , Object.prototype.toString.call(unflatten({
+        'a.0': 'foo',
+        'a.1': 'bar'
+      }).a)
+    )
+  })
+
+  test('Do not include keys with numbers inside them', function () {
+    assert.deepStrictEqual(unflatten({
+      '1key.2_key': 'ok'
+    }), {
+      '1key': {
+        '2_key': 'ok'
+      }
+    })
+  })
+})
+
+suite('Order of Keys', function () {
+  test('Order of keys should not be changed after round trip flatten/unflatten', function () {
+    const obj = {
+      b: 1,
+      abc: {
+        c: [{
+          d: 1,
+          bca: 1,
+          a: 1
+        }]
+      },
+      a: 1
+    }
+    const result = unflatten(
+      flatten(obj)
+    )
+
+    assert.deepStrictEqual(Object.keys(obj), Object.keys(result))
+    assert.deepStrictEqual(Object.keys(obj.abc), Object.keys(result.abc))
+    assert.deepStrictEqual(Object.keys(obj.abc.c[0]), Object.keys(result.abc.c[0]))
+  })
+})
+
+suite('CLI', function () {
+  test('can take filename', function (done) {
+    const cli = path.resolve(__dirname, '..', pkg.bin)
+    const pkgJSON = path.resolve(__dirname, '..', 'package.json')
+    exec(`${cli} ${pkgJSON}`, (err, stdout, stderr) => {
+      assert.ifError(err)
+      assert.strictEqual(stdout.trim(), JSON.stringify(flatten(pkg), null, 2))
+      done()
+    })
+  })
+
+  test('exits with usage if no file', function (done) {
+    const cli = path.resolve(__dirname, '..', pkg.bin)
+    const pkgJSON = path.resolve(__dirname, '..', 'package.json')
+    exec(`${cli} ${pkgJSON}`, (err, stdout, stderr) => {
+      assert.ifError(err)
+      assert.strictEqual(stdout.trim(), JSON.stringify(flatten(pkg), null, 2))
+      done()
+    })
+  })
+
+  test('can take piped file', function (done) {
+    const cli = path.resolve(__dirname, '..', pkg.bin)
+    const pkgJSON = path.resolve(__dirname, '..', 'package.json')
+    exec(`cat ${pkgJSON} | ${cli}`, (err, stdout, stderr) => {
+      assert.ifError(err)
+      assert.strictEqual(stdout.trim(), JSON.stringify(flatten(pkg), null, 2))
+      done()
+    })
+  })
+})
