@loaders.gl/parquet 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/parquetjs/schema/shred.js

@@ -0,0 +1,225 @@
+"use strict";
+// Forked from https://github.com/kbajalc/parquets under MIT license (Copyright (c) 2017 ironSource Ltd.)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.materializeRecords = exports.shredRecord = exports.shredBuffer = exports.ParquetBuffer = void 0;
+const declare_1 = require("./declare");
+Object.defineProperty(exports, "ParquetBuffer", { enumerable: true, get: function () { return declare_1.ParquetBuffer; } });
+const Types = __importStar(require("./types"));
+function shredBuffer(schema) {
+    const columnData = {};
+    for (const field of schema.fieldList) {
+        columnData[field.key] = {
+            dlevels: [],
+            rlevels: [],
+            values: [],
+            pageHeaders: [],
+            count: 0
+        };
+    }
+    return { rowCount: 0, columnData };
+}
+exports.shredBuffer = shredBuffer;
+/**
+ * 'Shred' a record into a list of <value, repetition_level, definition_level>
+ * tuples per column using the Google Dremel Algorithm..
+ *
+ * The buffer argument must point to an object into which the shredded record
+ * will be returned. You may re-use the buffer for repeated calls to this function
+ * to append to an existing buffer, as long as the schema is unchanged.
+ *
+ * The format in which the shredded records will be stored in the buffer is as
+ * follows:
+ *
+ *   buffer = {
+ *     columnData: [
+ *       'my_col': {
+ *          dlevels: [d1, d2, .. dN],
+ *          rlevels: [r1, r2, .. rN],
+ *          values: [v1, v2, .. vN],
+ *        }, ...
+ *      ],
+ *      rowCount: X,
+ *   }
+ */
+function shredRecord(schema, record, buffer) {
+    /* shred the record, this may raise an exception */
+    const data = shredBuffer(schema).columnData;
+    shredRecordFields(schema.fields, record, data, 0, 0);
+    /* if no error during shredding, add the shredded record to the buffer */
+    if (buffer.rowCount === 0) {
+        buffer.rowCount = 1;
+        buffer.columnData = data;
+        return;
+    }
+    buffer.rowCount += 1;
+    for (const field of schema.fieldList) {
+        Array.prototype.push.apply(buffer.columnData[field.key].rlevels, data[field.key].rlevels);
+        Array.prototype.push.apply(buffer.columnData[field.key].dlevels, data[field.key].dlevels);
+        Array.prototype.push.apply(buffer.columnData[field.key].values, data[field.key].values);
+        buffer.columnData[field.key].count += data[field.key].count;
+    }
+}
+exports.shredRecord = shredRecord;
+// eslint-disable-next-line max-statements, complexity
+function shredRecordFields(fields, record, data, rLevel, dLevel) {
+    for (const name in fields) {
+        const field = fields[name];
+        // fetch values
+        let values = [];
+        if (record &&
+            field.name in record &&
+            record[field.name] !== undefined &&
+            record[field.name] !== null) {
+            if (record[field.name].constructor === Array) {
+                values = record[field.name];
+            }
+            else {
+                values.push(record[field.name]);
+            }
+        }
+        // check values
+        if (values.length === 0 && Boolean(record) && field.repetitionType === 'REQUIRED') {
+            throw new Error(`missing required field: ${field.name}`);
+        }
+        if (values.length > 1 && field.repetitionType !== 'REPEATED') {
+            throw new Error(`too many values for field: ${field.name}`);
+        }
+        // push null
+        if (values.length === 0) {
+            if (field.isNested) {
+                shredRecordFields(field.fields, null, data, rLevel, dLevel);
+            }
+            else {
+                data[field.key].count += 1;
+                data[field.key].rlevels.push(rLevel);
+                data[field.key].dlevels.push(dLevel);
+            }
+            continue; // eslint-disable-line no-continue
+        }
+        // push values
+        for (let i = 0; i < values.length; i++) {
+            const rlvl = i === 0 ? rLevel : field.rLevelMax;
+            if (field.isNested) {
+                shredRecordFields(field.fields, values[i], data, rlvl, field.dLevelMax);
+            }
+            else {
+                data[field.key].count += 1;
+                data[field.key].rlevels.push(rlvl);
+                data[field.key].dlevels.push(field.dLevelMax);
+                data[field.key].values.push(Types.toPrimitive((field.originalType || field.primitiveType), values[i]));
+            }
+        }
+    }
+}
+/**
+ * 'Materialize' a list of <value, repetition_level, definition_level>
+ * tuples back to nested records (objects/arrays) using the Google Dremel
+ * Algorithm..
+ *
+ * The buffer argument must point to an object with the following structure (i.e.
+ * the same structure that is returned by shredRecords):
+ *
+ *   buffer = {
+ *     columnData: [
+ *       'my_col': {
+ *          dlevels: [d1, d2, .. dN],
+ *          rlevels: [r1, r2, .. rN],
+ *          values: [v1, v2, .. vN],
+ *        }, ...
+ *      ],
+ *      rowCount: X,
+ *   }
+ */
+function materializeRecords(schema, buffer) {
+    const records = [];
+    for (let i = 0; i < buffer.rowCount; i++)
+        records.push({});
+    for (const key in buffer.columnData) {
+        materializeColumn(schema, buffer, key, records);
+    }
+    return records;
+}
+exports.materializeRecords = materializeRecords;
+// eslint-disable-next-line max-statements, complexity
+function materializeColumn(schema, buffer, key, records) {
+    const data = buffer.columnData[key];
+    if (!data.count)
+        return;
+    const field = schema.findField(key);
+    const branch = schema.findFieldBranch(key);
+    // tslint:disable-next-line:prefer-array-literal
+    const rLevels = new Array(field.rLevelMax + 1).fill(0);
+    let vIndex = 0;
+    for (let i = 0; i < data.count; i++) {
+        const dLevel = data.dlevels[i];
+        const rLevel = data.rlevels[i];
+        rLevels[rLevel]++;
+        rLevels.fill(0, rLevel + 1);
+        let rIndex = 0;
+        let record = records[rLevels[rIndex++] - 1];
+        // Internal nodes
+        for (const step of branch) {
+            if (step === field)
+                break;
+            if (dLevel < step.dLevelMax)
+                break;
+            if (step.repetitionType === 'REPEATED') {
+                if (!(step.name in record)) {
+                    // eslint-disable max-depth
+                    record[step.name] = [];
+                }
+                const ix = rLevels[rIndex++];
+                while (record[step.name].length <= ix) {
+                    // eslint-disable max-depth
+                    record[step.name].push({});
+                }
+                record = record[step.name][ix];
+            }
+            else {
+                record[step.name] = record[step.name] || {};
+                record = record[step.name];
+            }
+        }
+        // Leaf node
+        if (dLevel === field.dLevelMax) {
+            const value = Types.fromPrimitive(
+            // @ts-ignore
+            field.originalType || field.primitiveType, data.values[vIndex], field);
+            vIndex++;
+            if (field.repetitionType === 'REPEATED') {
+                if (!(field.name in record)) {
+                    // eslint-disable max-depth
+                    record[field.name] = [];
+                }
+                const ix = rLevels[rIndex];
+                while (record[field.name].length <= ix) {
+                    // eslint-disable max-depth
+                    record[field.name].push(null);
+                }
+                record[field.name][ix] = value;
+            }
+            else {
+                record[field.name] = value;
+            }
+        }
+    }
+}

package/dist/parquetjs/schema/types.d.ts

@@ -17,3 +17,4 @@ export declare function toPrimitive(type: ParquetType, value: any, field?: Parqu
  * the native representation
  */
 export declare function fromPrimitive(type: ParquetType, value: any, field?: ParquetField): any;
+//# sourceMappingURL=types.d.ts.map

package/dist/parquetjs/schema/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/parquetjs/schema/types.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAC,MAAM,WAAW,CAAC;AAEjF,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,QAAQ,CAAC;IACtB,aAAa,CAAC,EAAE,QAAQ,CAAC;CAC1B;AAED,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,WAAW,EAAE,cAAc,CAuJrE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,YAAY,OAM9E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,YAAY,OAUhF"}

package/dist/parquetjs/schema/types.js

@@ -0,0 +1,418 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromPrimitive = exports.toPrimitive = exports.PARQUET_LOGICAL_TYPES = void 0;
+// Forked from https://github.com/kbajalc/parquets under MIT license (Copyright (c) 2017 ironSource Ltd.)
+/* eslint-disable camelcase */
+const bson_1 = __importDefault(require("bson"));
+exports.PARQUET_LOGICAL_TYPES = {
+    BOOLEAN: {
+        primitiveType: 'BOOLEAN',
+        toPrimitive: toPrimitive_BOOLEAN,
+        fromPrimitive: fromPrimitive_BOOLEAN
+    },
+    INT32: {
+        primitiveType: 'INT32',
+        toPrimitive: toPrimitive_INT32
+    },
+    INT64: {
+        primitiveType: 'INT64',
+        toPrimitive: toPrimitive_INT64
+    },
+    INT96: {
+        primitiveType: 'INT96',
+        toPrimitive: toPrimitive_INT96
+    },
+    FLOAT: {
+        primitiveType: 'FLOAT',
+        toPrimitive: toPrimitive_FLOAT
+    },
+    DOUBLE: {
+        primitiveType: 'DOUBLE',
+        toPrimitive: toPrimitive_DOUBLE
+    },
+    BYTE_ARRAY: {
+        primitiveType: 'BYTE_ARRAY',
+        toPrimitive: toPrimitive_BYTE_ARRAY
+    },
+    FIXED_LEN_BYTE_ARRAY: {
+        primitiveType: 'FIXED_LEN_BYTE_ARRAY',
+        toPrimitive: toPrimitive_BYTE_ARRAY
+    },
+    UTF8: {
+        primitiveType: 'BYTE_ARRAY',
+        originalType: 'UTF8',
+        toPrimitive: toPrimitive_UTF8,
+        fromPrimitive: fromPrimitive_UTF8
+    },
+    TIME_MILLIS: {
+        primitiveType: 'INT32',
+        originalType: 'TIME_MILLIS',
+        toPrimitive: toPrimitive_TIME_MILLIS
+    },
+    TIME_MICROS: {
+        primitiveType: 'INT64',
+        originalType: 'TIME_MICROS',
+        toPrimitive: toPrimitive_TIME_MICROS
+    },
+    DATE: {
+        primitiveType: 'INT32',
+        originalType: 'DATE',
+        toPrimitive: toPrimitive_DATE,
+        fromPrimitive: fromPrimitive_DATE
+    },
+    TIMESTAMP_MILLIS: {
+        primitiveType: 'INT64',
+        originalType: 'TIMESTAMP_MILLIS',
+        toPrimitive: toPrimitive_TIMESTAMP_MILLIS,
+        fromPrimitive: fromPrimitive_TIMESTAMP_MILLIS
+    },
+    TIMESTAMP_MICROS: {
+        primitiveType: 'INT64',
+        originalType: 'TIMESTAMP_MICROS',
+        toPrimitive: toPrimitive_TIMESTAMP_MICROS,
+        fromPrimitive: fromPrimitive_TIMESTAMP_MICROS
+    },
+    UINT_8: {
+        primitiveType: 'INT32',
+        originalType: 'UINT_8',
+        toPrimitive: toPrimitive_UINT8
+    },
+    UINT_16: {
+        primitiveType: 'INT32',
+        originalType: 'UINT_16',
+        toPrimitive: toPrimitive_UINT16
+    },
+    UINT_32: {
+        primitiveType: 'INT32',
+        originalType: 'UINT_32',
+        toPrimitive: toPrimitive_UINT32
+    },
+    UINT_64: {
+        primitiveType: 'INT64',
+        originalType: 'UINT_64',
+        toPrimitive: toPrimitive_UINT64
+    },
+    INT_8: {
+        primitiveType: 'INT32',
+        originalType: 'INT_8',
+        toPrimitive: toPrimitive_INT8
+    },
+    INT_16: {
+        primitiveType: 'INT32',
+        originalType: 'INT_16',
+        toPrimitive: toPrimitive_INT16
+    },
+    INT_32: {
+        primitiveType: 'INT32',
+        originalType: 'INT_32',
+        toPrimitive: toPrimitive_INT32
+    },
+    INT_64: {
+        primitiveType: 'INT64',
+        originalType: 'INT_64',
+        toPrimitive: toPrimitive_INT64
+    },
+    JSON: {
+        primitiveType: 'BYTE_ARRAY',
+        originalType: 'JSON',
+        toPrimitive: toPrimitive_JSON,
+        fromPrimitive: fromPrimitive_JSON
+    },
+    BSON: {
+        primitiveType: 'BYTE_ARRAY',
+        originalType: 'BSON',
+        toPrimitive: toPrimitive_BSON,
+        fromPrimitive: fromPrimitive_BSON
+    },
+    INTERVAL: {
+        primitiveType: 'FIXED_LEN_BYTE_ARRAY',
+        originalType: 'INTERVAL',
+        typeLength: 12,
+        toPrimitive: toPrimitive_INTERVAL,
+        fromPrimitive: fromPrimitive_INTERVAL
+    },
+    DECIMAL_INT32: {
+        primitiveType: 'INT32',
+        originalType: 'DECIMAL_INT32',
+        toPrimitive: decimalToPrimitive_INT32,
+        fromPrimitive: decimalFromPrimitive_INT
+    },
+    DECIMAL_INT64: {
+        primitiveType: 'INT64',
+        originalType: 'DECIMAL_INT64',
+        toPrimitive: decimalToPrimitive_INT64,
+        fromPrimitive: decimalFromPrimitive_INT
+    },
+    DECIMAL_BYTE_ARRAY: {
+        primitiveType: 'BYTE_ARRAY',
+        originalType: 'DECIMAL_BYTE_ARRAY',
+        toPrimitive: decimalToPrimitive_BYTE_ARRAY,
+        fromPrimitive: decimalFromPrimitive_BYTE_ARRAY
+    },
+    DECIMAL_FIXED_LEN_BYTE_ARRAY: {
+        primitiveType: 'FIXED_LEN_BYTE_ARRAY',
+        originalType: 'DECIMAL_FIXED_LEN_BYTE_ARRAY',
+        toPrimitive: decimalToPrimitive_BYTE_ARRAY,
+        fromPrimitive: decimalFromPrimitive_BYTE_ARRAY
+    }
+};
+/**
+ * Convert a value from it's native representation to the internal/underlying
+ * primitive type
+ */
+function toPrimitive(type, value, field) {
+    if (!(type in exports.PARQUET_LOGICAL_TYPES)) {
+        throw new Error(`invalid type: ${type}`);
+    }
+    return exports.PARQUET_LOGICAL_TYPES[type].toPrimitive(value, field);
+}
+exports.toPrimitive = toPrimitive;
+/**
+ * Convert a value from it's internal/underlying primitive representation to
+ * the native representation
+ */
+function fromPrimitive(type, value, field) {
+    if (!(type in exports.PARQUET_LOGICAL_TYPES)) {
+        throw new Error(`invalid type: ${type}`);
+    }
+    if ('fromPrimitive' in exports.PARQUET_LOGICAL_TYPES[type]) {
+        return exports.PARQUET_LOGICAL_TYPES[type].fromPrimitive?.(value, field);
+        // tslint:disable-next-line:no-else-after-return
+    }
+    return value;
+}
+exports.fromPrimitive = fromPrimitive;
+function toPrimitive_BOOLEAN(value) {
+    return Boolean(value);
+}
+function fromPrimitive_BOOLEAN(value) {
+    return Boolean(value);
+}
+function toPrimitive_FLOAT(value) {
+    const v = parseFloat(value);
+    if (isNaN(v)) {
+        throw new Error(`invalid value for FLOAT: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_DOUBLE(value) {
+    const v = parseFloat(value);
+    if (isNaN(v)) {
+        throw new Error(`invalid value for DOUBLE: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_INT8(value) {
+    const v = parseInt(value, 10);
+    if (v < -0x80 || v > 0x7f || isNaN(v)) {
+        throw new Error(`invalid value for INT8: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_UINT8(value) {
+    const v = parseInt(value, 10);
+    if (v < 0 || v > 0xff || isNaN(v)) {
+        throw new Error(`invalid value for UINT8: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_INT16(value) {
+    const v = parseInt(value, 10);
+    if (v < -0x8000 || v > 0x7fff || isNaN(v)) {
+        throw new Error(`invalid value for INT16: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_UINT16(value) {
+    const v = parseInt(value, 10);
+    if (v < 0 || v > 0xffff || isNaN(v)) {
+        throw new Error(`invalid value for UINT16: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_INT32(value) {
+    const v = parseInt(value, 10);
+    if (v < -0x80000000 || v > 0x7fffffff || isNaN(v)) {
+        throw new Error(`invalid value for INT32: ${value}`);
+    }
+    return v;
+}
+function decimalToPrimitive_INT32(value, field) {
+    const primitiveValue = value * 10 ** (field.scale || 0);
+    const v = Math.round(((primitiveValue * 10 ** -field.presision) % 1) * 10 ** field.presision);
+    if (v < -0x80000000 || v > 0x7fffffff || isNaN(v)) {
+        throw new Error(`invalid value for INT32: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_UINT32(value) {
+    const v = parseInt(value, 10);
+    if (v < 0 || v > 0xffffffffffff || isNaN(v)) {
+        throw new Error(`invalid value for UINT32: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_INT64(value) {
+    const v = parseInt(value, 10);
+    if (isNaN(v)) {
+        throw new Error(`invalid value for INT64: ${value}`);
+    }
+    return v;
+}
+function decimalToPrimitive_INT64(value, field) {
+    const primitiveValue = value * 10 ** (field.scale || 0);
+    const v = Math.round(((primitiveValue * 10 ** -field.presision) % 1) * 10 ** field.presision);
+    if (isNaN(v)) {
+        throw new Error(`invalid value for INT64: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_UINT64(value) {
+    const v = parseInt(value, 10);
+    if (v < 0 || isNaN(v)) {
+        throw new Error(`invalid value for UINT64: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_INT96(value) {
+    const v = parseInt(value, 10);
+    if (isNaN(v)) {
+        throw new Error(`invalid value for INT96: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_BYTE_ARRAY(value) {
+    return Buffer.from(value);
+}
+function decimalToPrimitive_BYTE_ARRAY(value) {
+    // TBD
+    return Buffer.from(value);
+}
+function toPrimitive_UTF8(value) {
+    return Buffer.from(value, 'utf8');
+}
+function fromPrimitive_UTF8(value) {
+    return value.toString();
+}
+function toPrimitive_JSON(value) {
+    return Buffer.from(JSON.stringify(value));
+}
+function fromPrimitive_JSON(value) {
+    return JSON.parse(value);
+}
+function toPrimitive_BSON(value) {
+    return Buffer.from(bson_1.default.serialize(value));
+}
+function fromPrimitive_BSON(value) {
+    return bson_1.default.deserialize(value);
+}
+function toPrimitive_TIME_MILLIS(value) {
+    const v = parseInt(value, 10);
+    if (v < 0 || v > 0xffffffffffffffff || isNaN(v)) {
+        throw new Error(`invalid value for TIME_MILLIS: ${value}`);
+    }
+    return v;
+}
+function toPrimitive_TIME_MICROS(value) {
+    const v = parseInt(value, 10);
+    if (v < 0 || isNaN(v)) {
+        throw new Error(`invalid value for TIME_MICROS: ${value}`);
+    }
+    return v;
+}
+const kMillisPerDay = 86400000;
+function toPrimitive_DATE(value) {
+    /* convert from date */
+    if (value instanceof Date) {
+        return value.getTime() / kMillisPerDay;
+    }
+    /* convert from integer */
+    {
+        const v = parseInt(value, 10);
+        if (v < 0 || isNaN(v)) {
+            throw new Error(`invalid value for DATE: ${value}`);
+        }
+        return v;
+    }
+}
+function fromPrimitive_DATE(value) {
+    return new Date(value * kMillisPerDay);
+}
+function toPrimitive_TIMESTAMP_MILLIS(value) {
+    /* convert from date */
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    /* convert from integer */
+    {
+        const v = parseInt(value, 10);
+        if (v < 0 || isNaN(v)) {
+            throw new Error(`invalid value for TIMESTAMP_MILLIS: ${value}`);
+        }
+        return v;
+    }
+}
+function fromPrimitive_TIMESTAMP_MILLIS(value) {
+    return new Date(value);
+}
+function toPrimitive_TIMESTAMP_MICROS(value) {
+    /* convert from date */
+    if (value instanceof Date) {
+        return value.getTime() * 1000;
+    }
+    /* convert from integer */
+    {
+        const v = parseInt(value, 10);
+        if (v < 0 || isNaN(v)) {
+            throw new Error(`invalid value for TIMESTAMP_MICROS: ${value}`);
+        }
+        return v;
+    }
+}
+function fromPrimitive_TIMESTAMP_MICROS(value) {
+    return new Date(value / 1000);
+}
+function toPrimitive_INTERVAL(value) {
+    if (!value.months || !value.days || !value.milliseconds) {
+        throw new Error('value for INTERVAL must be object { months: ..., days: ..., milliseconds: ... }');
+    }
+    const buf = Buffer.alloc(12);
+    buf.writeUInt32LE(value.months, 0);
+    buf.writeUInt32LE(value.days, 4);
+    buf.writeUInt32LE(value.milliseconds, 8);
+    return buf;
+}
+function fromPrimitive_INTERVAL(value) {
+    const buf = Buffer.from(value);
+    const months = buf.readUInt32LE(0);
+    const days = buf.readUInt32LE(4);
+    const millis = buf.readUInt32LE(8);
+    return { months, days, milliseconds: millis };
+}
+function decimalFromPrimitive_INT(value, field) {
+    const presisionInt = Math.round(((value * 10 ** -field.presision) % 1) * 10 ** field.presision);
+    return presisionInt * 10 ** -(field.scale || 0);
+}
+function decimalFromPrimitive_BYTE_ARRAY(value, field) {
+    let number = 0;
+    if (value.length <= 4) {
+        // Bytewise operators faster. Use them if it is possible
+        for (let i = 0; i < value.length; i++) {
+            // `value.length - i - 1` bytes have reverse order (big-endian)
+            const component = value[i] << (8 * (value.length - i - 1));
+            number += component;
+        }
+    }
+    else {
+        for (let i = 0; i < value.length; i++) {
+            // `value.length - i - 1` bytes have reverse order (big-endian)
+            const component = value[i] * 2 ** (8 * (value.length - 1 - i));
+            number += component;
+        }
+    }
+    const presisionInt = Math.round(((number * 10 ** -field.presision) % 1) * 10 ** field.presision);
+    return presisionInt * 10 ** -(field.scale || 0);
+}

package/dist/parquetjs/utils/buffer-utils.d.ts

@@ -7,3 +7,4 @@ export declare function toArrayBuffer(buffer: Buffer): ArrayBuffer;
  * Convert (copy) ArrayBuffer to Buffer
  */
 export declare function toBuffer(arrayBuffer: ArrayBuffer): Buffer;
+//# sourceMappingURL=buffer-utils.d.ts.map

package/dist/parquetjs/utils/buffer-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-utils.d.ts","sourceRoot":"","sources":["../../../src/parquetjs/utils/buffer-utils.ts"],"names":[],"mappings":";AAAA;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAOzD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAEzD"}

package/dist/parquetjs/utils/buffer-utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBuffer = exports.toArrayBuffer = void 0;
+/**
+ * Convert Buffer to ArrayBuffer
+ */
+function toArrayBuffer(buffer) {
+    // TODO - per docs we should just be able to call buffer.buffer, but there are issues
+    if (Buffer.isBuffer(buffer)) {
+        const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
+        return typedArray.slice().buffer;
+    }
+    return buffer;
+}
+exports.toArrayBuffer = toArrayBuffer;
+/**
+ * Convert (copy) ArrayBuffer to Buffer
+ */
+function toBuffer(arrayBuffer) {
+    return Buffer.from(arrayBuffer);
+}
+exports.toBuffer = toBuffer;

package/dist/parquetjs/utils/file-utils.d.ts

@@ -10,10 +10,7 @@ export interface WriteStreamOptions {
     autoClose?: boolean;
     start?: number;
 }
-export declare function fopen(filePath: string): Promise<number>;
-export declare function fstat(filePath: string): Promise<fs.Stats>;
-export declare function fread(fd: number, position: number, length: number): Promise<Buffer>;
-export declare function fclose(fd: number): Promise<void>;
 export declare function oswrite(os: Writable, buf: Buffer): Promise<void>;
 export declare function osclose(os: Writable): Promise<void>;
 export declare function osopen(path: string, opts?: WriteStreamOptions): Promise<fs.WriteStream>;
+//# sourceMappingURL=file-utils.d.ts.map

package/dist/parquetjs/utils/file-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../../src/parquetjs/utils/file-utils.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAEhC,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAEtC;AACD,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhE;AAED,wBAAgB,OAAO,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAUnD;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,CAMvF"}