@loaders.gl/parquet 3.0.13 → 3.0.14

package/dist/es5/parquetjs/writer.js

@@ -2,11 +2,29 @@
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 
+var _typeof = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ParquetTransformer = exports.ParquetEnvelopeWriter = exports.ParquetWriter = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _stream = require("stream");
@@ -23,33 +41,30 @@ var Util = _interopRequireWildcard(require("./util"));
 
 var _nodeInt = _interopRequireDefault(require("node-int64"));
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const PARQUET_MAGIC = 'PAR1';
-const PARQUET_VERSION = 1;
-const PARQUET_DEFAULT_PAGE_SIZE = 8192;
-const PARQUET_DEFAULT_ROW_GROUP_SIZE = 4096;
-const PARQUET_RDLVL_TYPE = 'INT32';
-const PARQUET_RDLVL_ENCODING = 'RLE';
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
-class ParquetWriter {
-  static async openFile(schema, path, opts) {
-    const outputStream = await Util.osopen(path, opts);
-    return ParquetWriter.openStream(schema, outputStream, opts);
-  }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
-  static async openStream(schema, outputStream, opts) {
-    if (!opts) {
-      opts = {};
-    }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-    const envelopeWriter = await ParquetEnvelopeWriter.openStream(schema, outputStream, opts);
-    return new ParquetWriter(schema, envelopeWriter, opts);
-  }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var PARQUET_MAGIC = 'PAR1';
+var PARQUET_VERSION = 1;
+var PARQUET_DEFAULT_PAGE_SIZE = 8192;
+var PARQUET_DEFAULT_ROW_GROUP_SIZE = 4096;
+var PARQUET_RDLVL_TYPE = 'INT32';
+var PARQUET_RDLVL_ENCODING = 'RLE';
 
-  constructor(schema, envelopeWriter, opts) {
+var ParquetWriter = function () {
+  function ParquetWriter(schema, envelopeWriter, opts) {
+    (0, _classCallCheck2.default)(this, ParquetWriter);
     (0, _defineProperty2.default)(this, "schema", void 0);
     (0, _defineProperty2.default)(this, "envelopeWriter", void 0);
     (0, _defineProperty2.default)(this, "rowBuffer", void 0);
@@ -71,61 +86,178 @@ class ParquetWriter {
     }
   }
 
-  async appendRow(row) {
-    if (this.closed) {
-      throw new Error('writer was closed');
+  (0, _createClass2.default)(ParquetWriter, [{
+    key: "appendRow",
+    value: function () {
+      var _appendRow = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(row) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!this.closed) {
+                  _context.next = 2;
+                  break;
+                }
+
+                throw new Error('writer was closed');
+
+              case 2:
+                Shred.shredRecord(this.schema, row, this.rowBuffer);
+
+                if (this.rowBuffer.rowCount >= this.rowGroupSize) {
+                  this.rowBuffer = {};
+                }
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function appendRow(_x) {
+        return _appendRow.apply(this, arguments);
+      }
+
+      return appendRow;
+    }()
+  }, {
+    key: "close",
+    value: function () {
+      var _close = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(callback) {
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!this.closed) {
+                  _context2.next = 2;
+                  break;
+                }
+
+                throw new Error('writer was closed');
+
+              case 2:
+                this.closed = true;
+
+                if (this.rowBuffer.rowCount > 0 || this.rowBuffer.rowCount >= this.rowGroupSize) {
+                  this.rowBuffer = {};
+                }
+
+                _context2.next = 6;
+                return this.envelopeWriter.writeFooter(this.userMetadata);
+
+              case 6:
+                _context2.next = 8;
+                return this.envelopeWriter.close();
+
+              case 8:
+                if (callback) {
+                  callback();
+                }
+
+              case 9:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+
+      function close(_x2) {
+        return _close.apply(this, arguments);
+      }
+
+      return close;
+    }()
+  }, {
+    key: "setMetadata",
+    value: function setMetadata(key, value) {
+      this.userMetadata[String(key)] = String(value);
     }
-
-    Shred.shredRecord(this.schema, row, this.rowBuffer);
-
-    if (this.rowBuffer.rowCount >= this.rowGroupSize) {
-      this.rowBuffer = {};
+  }, {
+    key: "setRowGroupSize",
+    value: function setRowGroupSize(cnt) {
+      this.rowGroupSize = cnt;
     }
-  }
-
-  async close(callback) {
-    if (this.closed) {
-      throw new Error('writer was closed');
+  }, {
+    key: "setPageSize",
+    value: function setPageSize(cnt) {
+      this.envelopeWriter.setPageSize(cnt);
     }
-
-    this.closed = true;
-
-    if (this.rowBuffer.rowCount > 0 || this.rowBuffer.rowCount >= this.rowGroupSize) {
-      this.rowBuffer = {};
-    }
-
-    await this.envelopeWriter.writeFooter(this.userMetadata);
-    await this.envelopeWriter.close();
-
-    if (callback) {
-      callback();
-    }
-  }
-
-  setMetadata(key, value) {
-    this.userMetadata[String(key)] = String(value);
-  }
-
-  setRowGroupSize(cnt) {
-    this.rowGroupSize = cnt;
-  }
-
-  setPageSize(cnt) {
-    this.envelopeWriter.setPageSize(cnt);
-  }
-
-}
+  }], [{
+    key: "openFile",
+    value: function () {
+      var _openFile = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(schema, path, opts) {
+        var outputStream;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return Util.osopen(path, opts);
+
+              case 2:
+                outputStream = _context3.sent;
+                return _context3.abrupt("return", ParquetWriter.openStream(schema, outputStream, opts));
+
+              case 4:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      function openFile(_x3, _x4, _x5) {
+        return _openFile.apply(this, arguments);
+      }
+
+      return openFile;
+    }()
+  }, {
+    key: "openStream",
+    value: function () {
+      var _openStream = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(schema, outputStream, opts) {
+        var envelopeWriter;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                if (!opts) {
+                  opts = {};
+                }
+
+                _context4.next = 3;
+                return ParquetEnvelopeWriter.openStream(schema, outputStream, opts);
+
+              case 3:
+                envelopeWriter = _context4.sent;
+                return _context4.abrupt("return", new ParquetWriter(schema, envelopeWriter, opts));
+
+              case 5:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+
+      function openStream(_x6, _x7, _x8) {
+        return _openStream.apply(this, arguments);
+      }
+
+      return openStream;
+    }()
+  }]);
+  return ParquetWriter;
+}();
 
 exports.ParquetWriter = ParquetWriter;
 
-class ParquetEnvelopeWriter {
-  static async openStream(schema, outputStream, opts) {
-    const writeFn = Util.oswrite.bind(undefined, outputStream);
-    const closeFn = Util.osclose.bind(undefined, outputStream);
-    return new ParquetEnvelopeWriter(schema, writeFn, closeFn, 0, opts);
-  }
-
-  constructor(schema, writeFn, closeFn, fileOffset, opts) {
+var ParquetEnvelopeWriter = function () {
+  function ParquetEnvelopeWriter(schema, writeFn, closeFn, fileOffset, opts) {
+    (0, _classCallCheck2.default)(this, ParquetEnvelopeWriter);
     (0, _defineProperty2.default)(this, "schema", void 0);
     (0, _defineProperty2.default)(this, "write", void 0);
     (0, _defineProperty2.default)(this, "close", void 0);
@@ -144,72 +276,186 @@ class ParquetEnvelopeWriter {
     this.useDataPageV2 = 'useDataPageV2' in opts ? Boolean(opts.useDataPageV2) : false;
   }
 
-  writeSection(buf) {
-    this.offset += buf.length;
-    return this.write(buf);
-  }
-
-  writeHeader() {
-    return this.writeSection(Buffer.from(PARQUET_MAGIC));
-  }
-
-  async writeRowGroup(records) {
-    const rgroup = encodeRowGroup(this.schema, records, {
-      baseOffset: this.offset,
-      pageSize: this.pageSize,
-      useDataPageV2: this.useDataPageV2
-    });
-    this.rowCount += records.rowCount;
-    this.rowGroups.push(rgroup.metadata);
-    return this.writeSection(rgroup.body);
-  }
-
-  writeFooter(userMetadata) {
-    if (!userMetadata) {
-      userMetadata = {};
+  (0, _createClass2.default)(ParquetEnvelopeWriter, [{
+    key: "writeSection",
+    value: function writeSection(buf) {
+      this.offset += buf.length;
+      return this.write(buf);
+    }
+  }, {
+    key: "writeHeader",
+    value: function writeHeader() {
+      return this.writeSection(Buffer.from(PARQUET_MAGIC));
     }
+  }, {
+    key: "writeRowGroup",
+    value: function () {
+      var _writeRowGroup = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee5(records) {
+        var rgroup;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                rgroup = encodeRowGroup(this.schema, records, {
+                  baseOffset: this.offset,
+                  pageSize: this.pageSize,
+                  useDataPageV2: this.useDataPageV2
+                });
+                this.rowCount += records.rowCount;
+                this.rowGroups.push(rgroup.metadata);
+                return _context5.abrupt("return", this.writeSection(rgroup.body));
+
+              case 4:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+
+      function writeRowGroup(_x9) {
+        return _writeRowGroup.apply(this, arguments);
+      }
+
+      return writeRowGroup;
+    }()
+  }, {
+    key: "writeFooter",
+    value: function writeFooter(userMetadata) {
+      if (!userMetadata) {
+        userMetadata = {};
+      }
+
+      return this.writeSection(encodeFooter(this.schema, this.rowCount, this.rowGroups, userMetadata));
+    }
+  }, {
+    key: "setPageSize",
+    value: function setPageSize(cnt) {
+      this.pageSize = cnt;
+    }
+  }], [{
+    key: "openStream",
+    value: function () {
+      var _openStream2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee6(schema, outputStream, opts) {
+        var writeFn, closeFn;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) {
+            switch (_context6.prev = _context6.next) {
+              case 0:
+                writeFn = Util.oswrite.bind(undefined, outputStream);
+                closeFn = Util.osclose.bind(undefined, outputStream);
+                return _context6.abrupt("return", new ParquetEnvelopeWriter(schema, writeFn, closeFn, 0, opts));
+
+              case 3:
+              case "end":
+                return _context6.stop();
+            }
+          }
+        }, _callee6);
+      }));
+
+      function openStream(_x10, _x11, _x12) {
+        return _openStream2.apply(this, arguments);
+      }
+
+      return openStream;
+    }()
+  }]);
+  return ParquetEnvelopeWriter;
+}();
 
-    return this.writeSection(encodeFooter(this.schema, this.rowCount, this.rowGroups, userMetadata));
-  }
+exports.ParquetEnvelopeWriter = ParquetEnvelopeWriter;
 
-  setPageSize(cnt) {
-    this.pageSize = cnt;
-  }
+var ParquetTransformer = function (_Transform) {
+  (0, _inherits2.default)(ParquetTransformer, _Transform);
 
-}
+  var _super = _createSuper(ParquetTransformer);
 
-exports.ParquetEnvelopeWriter = ParquetEnvelopeWriter;
+  function ParquetTransformer(schema) {
+    var _this;
 
-class ParquetTransformer extends _stream.Transform {
-  constructor(schema, opts = {}) {
-    super({
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2.default)(this, ParquetTransformer);
+    _this = _super.call(this, {
       objectMode: true
     });
-    (0, _defineProperty2.default)(this, "writer", void 0);
-
-    const writeProxy = function (t) {
-      return async function (b) {
-        t.push(b);
-      };
-    }(this);
-
-    this.writer = new ParquetWriter(schema, new ParquetEnvelopeWriter(schema, writeProxy, async () => {}, 0, opts), opts);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "writer", void 0);
+
+    var writeProxy = function (t) {
+      return function () {
+        var _ref = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee7(b) {
+          return _regenerator.default.wrap(function _callee7$(_context7) {
+            while (1) {
+              switch (_context7.prev = _context7.next) {
+                case 0:
+                  t.push(b);
+
+                case 1:
+                case "end":
+                  return _context7.stop();
+              }
+            }
+          }, _callee7);
+        }));
+
+        return function (_x13) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+    }((0, _assertThisInitialized2.default)(_this));
+
+    _this.writer = new ParquetWriter(schema, new ParquetEnvelopeWriter(schema, writeProxy, (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee8() {
+      return _regenerator.default.wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8);
+    })), 0, opts), opts);
+    return _this;
   }
 
-  _transform(row, encoding, callback) {
-    if (row) {
-      return this.writer.appendRow(row).then(callback);
-    }
-
-    callback();
-    return Promise.resolve();
-  }
-
-  async _flush(callback) {
-    await this.writer.close(callback);
-  }
+  (0, _createClass2.default)(ParquetTransformer, [{
+    key: "_transform",
+    value: function _transform(row, encoding, callback) {
+      if (row) {
+        return this.writer.appendRow(row).then(callback);
+      }
 
-}
+      callback();
+      return Promise.resolve();
+    }
+  }, {
+    key: "_flush",
+    value: function () {
+      var _flush2 = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee9(callback) {
+        return _regenerator.default.wrap(function _callee9$(_context9) {
+          while (1) {
+            switch (_context9.prev = _context9.next) {
+              case 0:
+                _context9.next = 2;
+                return this.writer.close(callback);
+
+              case 2:
+              case "end":
+                return _context9.stop();
+            }
+          }
+        }, _callee9, this);
+      }));
+
+      function _flush(_x14) {
+        return _flush2.apply(this, arguments);
+      }
+
+      return _flush;
+    }()
+  }]);
+  return ParquetTransformer;
+}(_stream.Transform);
 
 exports.ParquetTransformer = ParquetTransformer;
 
@@ -222,7 +468,7 @@ function encodeValues(type, encoding, values, opts) {
 }
 
 function encodeDataPage(column, data) {
-  let rLevelsBuf = Buffer.alloc(0);
+  var rLevelsBuf = Buffer.alloc(0);
 
   if (column.rLevelMax > 0) {
     rLevelsBuf = encodeValues(PARQUET_RDLVL_TYPE, PARQUET_RDLVL_ENCODING, data.rlevels, {
@@ -230,7 +476,7 @@ function encodeDataPage(column, data) {
     });
   }
 
-  let dLevelsBuf = Buffer.alloc(0);
+  var dLevelsBuf = Buffer.alloc(0);
 
   if (column.dLevelMax > 0) {
     dLevelsBuf = encodeValues(PARQUET_RDLVL_TYPE, PARQUET_RDLVL_ENCODING, data.dlevels, {
@@ -238,13 +484,13 @@ function encodeDataPage(column, data) {
     });
   }
 
-  const valuesBuf = encodeValues(column.primitiveType, column.encoding, data.values, {
+  var valuesBuf = encodeValues(column.primitiveType, column.encoding, data.values, {
     typeLength: column.typeLength,
     bitWidth: column.typeLength
   });
-  const dataBuf = Buffer.concat([rLevelsBuf, dLevelsBuf, valuesBuf]);
-  const compressedBuf = Compression.deflate(column.compression, dataBuf);
-  const header = new _parquetThrift.PageHeader({
+  var dataBuf = Buffer.concat([rLevelsBuf, dLevelsBuf, valuesBuf]);
+  var compressedBuf = Compression.deflate(column.compression, dataBuf);
+  var header = new _parquetThrift.PageHeader({
     type: _parquetThrift.PageType.DATA_PAGE,
     data_page_header: new _parquetThrift.DataPageHeader({
       num_values: data.count,
@@ -255,22 +501,22 @@ function encodeDataPage(column, data) {
     uncompressed_page_size: dataBuf.length,
     compressed_page_size: compressedBuf.length
   });
-  const headerBuf = Util.serializeThrift(header);
-  const page = Buffer.concat([headerBuf, compressedBuf]);
+  var headerBuf = Util.serializeThrift(header);
+  var page = Buffer.concat([headerBuf, compressedBuf]);
   return {
-    header,
+    header: header,
     headerSize: headerBuf.length,
-    page
+    page: page
   };
 }
 
 function encodeDataPageV2(column, data, rowCount) {
-  const valuesBuf = encodeValues(column.primitiveType, column.encoding, data.values, {
+  var valuesBuf = encodeValues(column.primitiveType, column.encoding, data.values, {
     typeLength: column.typeLength,
     bitWidth: column.typeLength
   });
-  const compressedBuf = Compression.deflate(column.compression, valuesBuf);
-  let rLevelsBuf = Buffer.alloc(0);
+  var compressedBuf = Compression.deflate(column.compression, valuesBuf);
+  var rLevelsBuf = Buffer.alloc(0);
 
   if (column.rLevelMax > 0) {
     rLevelsBuf = encodeValues(PARQUET_RDLVL_TYPE, PARQUET_RDLVL_ENCODING, data.rlevels, {
@@ -279,7 +525,7 @@ function encodeDataPageV2(column, data, rowCount) {
     });
   }
 
-  let dLevelsBuf = Buffer.alloc(0);
+  var dLevelsBuf = Buffer.alloc(0);
 
   if (column.dLevelMax > 0) {
     dLevelsBuf = encodeValues(PARQUET_RDLVL_TYPE, PARQUET_RDLVL_ENCODING, data.dlevels, {
@@ -288,7 +534,7 @@ function encodeDataPageV2(column, data, rowCount) {
     });
   }
 
-  const header = new _parquetThrift.PageHeader({
+  var header = new _parquetThrift.PageHeader({
     type: _parquetThrift.PageType.DATA_PAGE_V2,
     data_page_header_v2: new _parquetThrift.DataPageHeaderV2({
       num_values: data.count,
@@ -302,23 +548,23 @@ function encodeDataPageV2(column, data, rowCount) {
     uncompressed_page_size: rLevelsBuf.length + dLevelsBuf.length + valuesBuf.length,
     compressed_page_size: rLevelsBuf.length + dLevelsBuf.length + compressedBuf.length
   });
-  const headerBuf = Util.serializeThrift(header);
-  const page = Buffer.concat([headerBuf, rLevelsBuf, dLevelsBuf, compressedBuf]);
+  var headerBuf = Util.serializeThrift(header);
+  var page = Buffer.concat([headerBuf, rLevelsBuf, dLevelsBuf, compressedBuf]);
   return {
-    header,
+    header: header,
     headerSize: headerBuf.length,
-    page
+    page: page
   };
 }
 
 function encodeColumnChunk(column, buffer, offset, opts) {
-  const data = buffer.columnData[column.path.join()];
-  const baseOffset = (opts.baseOffset || 0) + offset;
-  let pageBuf;
-  let total_uncompressed_size = 0;
-  let total_compressed_size = 0;
+  var data = buffer.columnData[column.path.join()];
+  var baseOffset = (opts.baseOffset || 0) + offset;
+  var pageBuf;
+  var total_uncompressed_size = 0;
+  var total_compressed_size = 0;
   {
-    let result;
+    var result;
 
     if (opts.useDataPageV2) {
       result = encodeDataPageV2(column, data, buffer.rowCount);
@@ -330,58 +576,69 @@ function encodeColumnChunk(column, buffer, offset, opts) {
     total_uncompressed_size += result.header.uncompressed_page_size + result.headerSize;
     total_compressed_size += result.header.compressed_page_size + result.headerSize;
   }
-  const metadata = new _parquetThrift.ColumnMetaData({
+  var metadata = new _parquetThrift.ColumnMetaData({
     path_in_schema: column.path,
     num_values: data.count,
     data_page_offset: baseOffset,
     encodings: [],
-    total_uncompressed_size,
-    total_compressed_size,
+    total_uncompressed_size: total_uncompressed_size,
+    total_compressed_size: total_compressed_size,
     type: _parquetThrift.Type[column.primitiveType],
     codec: _parquetThrift.CompressionCodec[column.compression]
   });
   metadata.encodings.push(_parquetThrift.Encoding[PARQUET_RDLVL_ENCODING]);
   metadata.encodings.push(_parquetThrift.Encoding[column.encoding]);
-  const metadataOffset = baseOffset + pageBuf.length;
-  const body = Buffer.concat([pageBuf, Util.serializeThrift(metadata)]);
+  var metadataOffset = baseOffset + pageBuf.length;
+  var body = Buffer.concat([pageBuf, Util.serializeThrift(metadata)]);
   return {
-    body,
-    metadata,
-    metadataOffset
+    body: body,
+    metadata: metadata,
+    metadataOffset: metadataOffset
   };
 }
 
 function encodeRowGroup(schema, data, opts) {
-  const metadata = new _parquetThrift.RowGroup({
+  var metadata = new _parquetThrift.RowGroup({
     num_rows: data.rowCount,
     columns: [],
     total_byte_size: 0
   });
-  let body = Buffer.alloc(0);
-
-  for (const field of schema.fieldList) {
-    if (field.isNested) {
-      continue;
+  var body = Buffer.alloc(0);
+
+  var _iterator = _createForOfIteratorHelper(schema.fieldList),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var field = _step.value;
+
+      if (field.isNested) {
+        continue;
+      }
+
+      var cchunkData = encodeColumnChunk(field, data, body.length, opts);
+      var cchunk = new _parquetThrift.ColumnChunk({
+        file_offset: cchunkData.metadataOffset,
+        meta_data: cchunkData.metadata
+      });
+      metadata.columns.push(cchunk);
+      metadata.total_byte_size = new _nodeInt.default(Number(metadata.total_byte_size) + cchunkData.body.length);
+      body = Buffer.concat([body, cchunkData.body]);
     }
-
-    const cchunkData = encodeColumnChunk(field, data, body.length, opts);
-    const cchunk = new _parquetThrift.ColumnChunk({
-      file_offset: cchunkData.metadataOffset,
-      meta_data: cchunkData.metadata
-    });
-    metadata.columns.push(cchunk);
-    metadata.total_byte_size = new _nodeInt.default(Number(metadata.total_byte_size) + cchunkData.body.length);
-    body = Buffer.concat([body, cchunkData.body]);
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
   return {
-    body,
-    metadata
+    body: body,
+    metadata: metadata
   };
 }
 
 function encodeFooter(schema, rowCount, rowGroups, userMetadata) {
-  const metadata = new _parquetThrift.FileMetaData({
+  var metadata = new _parquetThrift.FileMetaData({
     version: PARQUET_VERSION,
     created_by: 'parquets',
     num_rows: rowCount,
@@ -390,47 +647,57 @@ function encodeFooter(schema, rowCount, rowGroups, userMetadata) {
     key_value_metadata: []
   });
 
-  for (const key in userMetadata) {
+  for (var key in userMetadata) {
     var _metadata$key_value_m, _metadata$key_value_m2;
 
-    const kv = new _parquetThrift.KeyValue({
-      key,
+    var kv = new _parquetThrift.KeyValue({
+      key: key,
       value: userMetadata[key]
     });
     (_metadata$key_value_m = metadata.key_value_metadata) === null || _metadata$key_value_m === void 0 ? void 0 : (_metadata$key_value_m2 = _metadata$key_value_m.push) === null || _metadata$key_value_m2 === void 0 ? void 0 : _metadata$key_value_m2.call(_metadata$key_value_m, kv);
   }
 
   {
-    const schemaRoot = new _parquetThrift.SchemaElement({
+    var schemaRoot = new _parquetThrift.SchemaElement({
       name: 'root',
       num_children: Object.keys(schema.fields).length
     });
     metadata.schema.push(schemaRoot);
   }
 
-  for (const field of schema.fieldList) {
-    const relt = _parquetThrift.FieldRepetitionType[field.repetitionType];
-    const schemaElem = new _parquetThrift.SchemaElement({
-      name: field.name,
-      repetition_type: relt
-    });
-
-    if (field.isNested) {
-      schemaElem.num_children = field.fieldCount;
-    } else {
-      schemaElem.type = _parquetThrift.Type[field.primitiveType];
-    }
-
-    if (field.originalType) {
-      schemaElem.converted_type = _parquetThrift.ConvertedType[field.originalType];
+  var _iterator2 = _createForOfIteratorHelper(schema.fieldList),
+      _step2;
+
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var field = _step2.value;
+      var relt = _parquetThrift.FieldRepetitionType[field.repetitionType];
+      var schemaElem = new _parquetThrift.SchemaElement({
+        name: field.name,
+        repetition_type: relt
+      });
+
+      if (field.isNested) {
+        schemaElem.num_children = field.fieldCount;
+      } else {
+        schemaElem.type = _parquetThrift.Type[field.primitiveType];
+      }
+
+      if (field.originalType) {
+        schemaElem.converted_type = _parquetThrift.ConvertedType[field.originalType];
+      }
+
+      schemaElem.type_length = field.typeLength;
+      metadata.schema.push(schemaElem);
     }
-
-    schemaElem.type_length = field.typeLength;
-    metadata.schema.push(schemaElem);
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
   }
 
-  const metadataEncoded = Util.serializeThrift(metadata);
-  const footerEncoded = Buffer.alloc(metadataEncoded.length + 8);
+  var metadataEncoded = Util.serializeThrift(metadata);
+  var footerEncoded = Buffer.alloc(metadataEncoded.length + 8);
   metadataEncoded.copy(footerEncoded);
   footerEncoded.writeUInt32LE(metadataEncoded.length, metadataEncoded.length);
   footerEncoded.write(PARQUET_MAGIC, metadataEncoded.length + 4);