@nshiab/simple-data-analysis-core 1.0.0 → 2.0.0

package/script/helpers/writeGeoData.js

@@ -4,81 +4,168 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = writeGeoData;
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
 const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
 const createDirectory_js_1 = __importDefault(require("./createDirectory.js"));
 const getExtension_js_1 = __importDefault(require("./getExtension.js"));
 const hasGeometryColumn_js_1 = __importDefault(require("./hasGeometryColumn.js"));
 const queryDB_js_1 = __importDefault(require("./queryDB.js"));
-const writeGeoDataQuery_js_1 = __importDefault(require("../methods/writeGeoDataQuery.js"));
 const mergeOptions_js_1 = __importDefault(require("./mergeOptions.js"));
 const rewind_js_1 = __importDefault(require("./rewind.js"));
+const flushAllTables_js_1 = __importDefault(require("./flushAllTables.js"));
 const stringifyDates_js_1 = __importDefault(require("./stringifyDates.js"));
 const stringifyDatesInvert_js_1 = __importDefault(require("./stringifyDatesInvert.js"));
 const cleanPath_js_1 = __importDefault(require("./cleanPath.js"));
+const writeZip_js_1 = __importDefault(require("./writeZip.js"));
 async function writeGeoData(table, file, options = {}) {
-    (0, createDirectory_js_1.default)(file);
+    const compressedShapefileExtension = file.toLowerCase().endsWith(".shp.zip");
+    const fileExtension = compressedShapefileExtension
+        ? "shp"
+        : (0, getExtension_js_1.default)(file);
+    assertWriteGeoDataOptions(fileExtension, options);
     if (!(await (0, hasGeometryColumn_js_1.default)(table))) {
         throw new Error("Table contains no geometry columns. Use writeData() instead.");
     }
-    const fileExtension = (0, getExtension_js_1.default)(file);
+    (0, createDirectory_js_1.default)(file);
     if (fileExtension === "geojson" || fileExtension === "json") {
         let types;
+        let datesConverted = false;
         if (options.formatDates === true) {
             types = await table.getTypes();
             if (Object.values(types).includes("DATE") ||
                 Object.values(types).includes("TIMESTAMP")) {
                 await (0, stringifyDates_js_1.default)(table, types);
+                datesConverted = true;
             }
         }
-        if (typeof options.compression === "boolean") {
-            throw new Error("The compression option is not supported for writing GeoJSON files.");
-        }
-        await (0, queryDB_js_1.default)(table, (0, writeGeoDataQuery_js_1.default)(table.name, file, fileExtension, options), (0, mergeOptions_js_1.default)(table, {
-            table: table.name,
-            method: "writeGeoData()",
-            parameters: { file, options },
-        }));
-        if (options.metadata) {
-            const fileData = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
-            fileData.metadata = options.metadata;
-            (0, node_fs_1.writeFileSync)(file, JSON.stringify(fileData));
-        }
-        if (options.rewind) {
-            const fileData = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
-            const fileRewinded = (0, rewind_js_1.default)(fileData);
-            (0, node_fs_1.writeFileSync)(file, JSON.stringify(fileRewinded));
+        try {
+            await (0, queryDB_js_1.default)(table, writeGeoDataQuery(table.name, file, fileExtension, options), (0, mergeOptions_js_1.default)(table, {
+                table: table.name,
+                method: "writeGeoData()",
+                parameters: { file, options },
+            }));
+            if (options.metadata) {
+                const fileData = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
+                fileData.metadata = options.metadata;
+                (0, node_fs_1.writeFileSync)(file, JSON.stringify(fileData));
+            }
+            if (options.rewind) {
+                const fileData = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
+                const fileRewinded = (0, rewind_js_1.default)(fileData);
+                (0, node_fs_1.writeFileSync)(file, JSON.stringify(fileRewinded));
+            }
         }
-        if (types && (Object.values(types).includes("DATE") ||
-            Object.values(types).includes("TIMESTAMP"))) {
-            await (0, stringifyDatesInvert_js_1.default)(table, types);
+        finally {
+            if (datesConverted && types) {
+                await (0, stringifyDatesInvert_js_1.default)(table, types);
+                // stringifyDatesInvert queues sync builder operations restoring the
+                // date columns. writeGeoData is an observer, so it must leave no
+                // queued work behind.
+                await (0, flushAllTables_js_1.default)(table.sdb);
+            }
         }
     }
     else if (fileExtension === "shp") {
-        if (typeof options.precision === "number" ||
-            typeof options.compression === "boolean" ||
-            typeof options.rewind === "boolean" ||
-            options.metadata ||
-            options.formatDates === true) {
-            throw new Error("The following options are not supported for writing SHAPEFILE files: precision, compression, rewind, metadata, and formatDates.");
+        if (compressedShapefileExtension) {
+            const shapefile = file.slice(0, -".zip".length);
+            await writeCompressedShapefile(table, shapefile, file, file, options);
+        }
+        else {
+            await writeShapefile(table, file, file, options);
         }
-        await (0, queryDB_js_1.default)(table, (0, writeGeoDataQuery_js_1.default)(table.name, file, fileExtension, options), (0, mergeOptions_js_1.default)(table, {
+    }
+    else if (fileExtension === "geoparquet") {
+        await (0, queryDB_js_1.default)(table, `COPY ${(0, quoteIdentifier_js_1.default)(table.name)} TO '${(0, cleanPath_js_1.default)(file)}' WITH (FORMAT PARQUET${options.compression === true ? ", COMPRESSION 'zstd'" : ""});`, (0, mergeOptions_js_1.default)(table, {
             table: table.name,
             method: "writeGeoData()",
             parameters: { file, options },
         }));
     }
-    else if (fileExtension === "geoparquet") {
-        if (typeof options.precision === "number") {
-            throw new Error("The precision option is not supported for writing PARQUET files. Use the .reducePrecision() method.");
+}
+function assertWriteGeoDataOptions(fileExtension, options) {
+    if (!["geojson", "json", "shp", "geoparquet"].includes(fileExtension)) {
+        throw new Error(`writeGeoData() does not support the extension ${JSON.stringify(fileExtension)}. Use .geojson, .json, .shp, .shp.zip, or .geoparquet.`);
+    }
+    if ((fileExtension === "geojson" || fileExtension === "json") &&
+        typeof options.compression === "boolean") {
+        throw new Error("writeGeoData() compression is not supported for GeoJSON files.");
+    }
+    if (fileExtension === "shp" && typeof options.compression === "boolean") {
+        throw new Error("writeGeoData() compression is not supported for Shapefiles. Use a .shp.zip file extension instead.");
+    }
+    if (fileExtension === "shp" &&
+        (typeof options.precision === "number" ||
+            typeof options.rewind === "boolean" ||
+            options.metadata !== undefined ||
+            options.formatDates === true)) {
+        throw new Error("writeGeoData() precision, rewind, metadata, and formatDates are not supported for Shapefiles.");
+    }
+    if (fileExtension === "geoparquet" && typeof options.precision === "number") {
+        throw new Error("writeGeoData() precision is not supported for GeoParquet files. Use reducePrecision() first.");
+    }
+    if (fileExtension === "geoparquet" && typeof options.rewind === "boolean") {
+        throw new Error("writeGeoData() rewind is not supported for GeoParquet files.");
+    }
+}
+async function writeCompressedShapefile(table, shapefile, archive, requestedFile, options) {
+    const temporaryDirectory = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_path_1.dirname)(archive), `.${(0, node_path_1.basename)(shapefile)}-`));
+    const temporaryShapefile = (0, node_path_1.join)(temporaryDirectory, (0, node_path_1.basename)(shapefile));
+    const temporaryArchive = `${temporaryShapefile}.zip`;
+    let outcome;
+    try {
+        await writeShapefile(table, temporaryShapefile, requestedFile, options);
+        const inputs = (0, node_fs_1.readdirSync)(temporaryDirectory, { withFileTypes: true })
+            .filter((entry) => entry.isFile())
+            .sort((first, second) => first.name.localeCompare(second.name))
+            .map((entry) => ({
+            file: (0, node_path_1.join)(temporaryDirectory, entry.name),
+            name: entry.name,
+        }));
+        await (0, writeZip_js_1.default)(temporaryArchive, inputs);
+        (0, node_fs_1.renameSync)(temporaryArchive, archive);
+        outcome = { success: true };
+    }
+    catch (error) {
+        outcome = { success: false, error };
+    }
+    try {
+        (0, node_fs_1.rmSync)(temporaryDirectory, { recursive: true, force: true });
+    }
+    catch (cleanupError) {
+        if (!outcome.success) {
+            throw new AggregateError([outcome.error, cleanupError], "Writing and cleaning up the compressed Shapefile both failed.", { cause: outcome.error });
         }
-        if (typeof options.rewind === "boolean") {
-            throw new Error("The rewind option is not supported for writing PARQUET files.");
+        throw cleanupError;
+    }
+    if (!outcome.success) {
+        throw outcome.error;
+    }
+}
+async function writeShapefile(table, outputFile, requestedFile, options) {
+    await (0, queryDB_js_1.default)(table, writeGeoDataQuery(table.name, outputFile, "shp"), (0, mergeOptions_js_1.default)(table, {
+        table: table.name,
+        method: "writeGeoData()",
+        parameters: { file: requestedFile, options },
+    }));
+}
+function writeGeoDataQuery(table, file, fileExtension, options = {}) {
+    if (fileExtension === "geojson" || fileExtension === "json") {
+        const layerOptions = [];
+        if (typeof options.precision === "number") {
+            layerOptions.push(`COORDINATE_PRECISION=${options.precision}`);
         }
-        await (0, queryDB_js_1.default)(table, `COPY "${table.name}" TO '${(0, cleanPath_js_1.default)(file)}' WITH (FORMAT PARQUET${options.compression === true ? ", COMPRESSION 'zstd'" : ""});`, (0, mergeOptions_js_1.default)(table, {
-            table: table.name,
-            method: "writeGeoData()",
-            parameters: { file, options },
-        }));
+        layerOptions.push(`RFC7946=YES`);
+        return `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; COPY ${(0, quoteIdentifier_js_1.default)(table)} to '${(0, cleanPath_js_1.default)(file)}' WITH (FORMAT GDAL, DRIVER 'GeoJSON'${layerOptions.length > 0
+            ? `, LAYER_CREATION_OPTIONS ('WRITE_NAME=NO', ${layerOptions.map((d) => `'${d}'`).join(", ")})`
+            : ""})`;
+    }
+    else if (fileExtension === "shp") {
+        // DuckDB only finalizes the main file when a GDAL driver creates a
+        // multi-file dataset, leaving Shapefile sidecars under the tmp_ prefix.
+        // Remove USE_TMP_FILE false once the upstream fix is released:
+        // https://github.com/duckdb/duckdb-spatial/issues/859
+        return `INSTALL spatial; LOAD spatial; SET geometry_always_xy = true; COPY ${(0, quoteIdentifier_js_1.default)(table)} TO '${(0, cleanPath_js_1.default)(file)}' WITH (FORMAT GDAL, DRIVER 'ESRI Shapefile', LAYER_CREATION_OPTIONS 'ENCODING=UTF-8', USE_TMP_FILE false)`;
     }
     else {
         throw new Error(`Unknown extension ${fileExtension}`);

package/script/helpers/writeZip.d.ts

@@ -0,0 +1,15 @@
+type ZipInput = {
+    file: string;
+    name?: string;
+};
+/**
+ * Writes files to a ZIP archive using streaming DEFLATE compression.
+ *
+ * The implementation intentionally supports ZIP32 archives only. Shapefile
+ * components are conventionally limited to 2 GB, but the combined archive can
+ * still exceed ZIP32 limits; those cases fail explicitly instead of producing
+ * a corrupt archive.
+ */
+export default function writeZip(archive: string, inputs: ZipInput[]): Promise<void>;
+export {};
+//# sourceMappingURL=writeZip.d.ts.map

package/script/helpers/writeZip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeZip.d.ts","sourceRoot":"","sources":["../../src/helpers/writeZip.ts"],"names":[],"mappings":"AAkBA,KAAK,QAAQ,GAAG;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAsDF;;;;;;;GAOG;AACH,wBAA8B,QAAQ,CACpC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,QAAQ,EAAE,GACjB,OAAO,CAAC,IAAI,CAAC,CAiHf"}

package/script/helpers/writeZip.js

@@ -0,0 +1,293 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ChecksumTransform_crc32, _FileHandleWritable_fileHandle;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = writeZip;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const zlib = __importStar(require("node:zlib"));
+const node_zlib_1 = require("node:zlib");
+const maximumZip32Value = 0xffff_fffe;
+const maximumZip32Entries = 0xfffe;
+const utf8WithDataDescriptor = 0x0808;
+const crc32Table = createCrc32Table();
+class ChecksumTransform extends node_stream_1.Transform {
+    constructor() {
+        super(...arguments);
+        _ChecksumTransform_crc32.set(this, 0);
+        Object.defineProperty(this, "size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    get crc32() {
+        return __classPrivateFieldGet(this, _ChecksumTransform_crc32, "f");
+    }
+    _transform(chunk, _encoding, callback) {
+        __classPrivateFieldSet(this, _ChecksumTransform_crc32, updateCrc32(chunk, __classPrivateFieldGet(this, _ChecksumTransform_crc32, "f")), "f");
+        this.size += chunk.byteLength;
+        callback(null, chunk);
+    }
+}
+_ChecksumTransform_crc32 = new WeakMap();
+class FileHandleWritable extends node_stream_1.Writable {
+    constructor(fileHandle, options) {
+        super(options);
+        Object.defineProperty(this, "bytesWritten", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        _FileHandleWritable_fileHandle.set(this, void 0);
+        __classPrivateFieldSet(this, _FileHandleWritable_fileHandle, fileHandle, "f");
+    }
+    _write(chunk, _encoding, callback) {
+        writeAll(__classPrivateFieldGet(this, _FileHandleWritable_fileHandle, "f"), chunk).then(() => {
+            this.bytesWritten += chunk.byteLength;
+            callback();
+        }).catch((error) => {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+}
+_FileHandleWritable_fileHandle = new WeakMap();
+/**
+ * Writes files to a ZIP archive using streaming DEFLATE compression.
+ *
+ * The implementation intentionally supports ZIP32 archives only. Shapefile
+ * components are conventionally limited to 2 GB, but the combined archive can
+ * still exceed ZIP32 limits; those cases fail explicitly instead of producing
+ * a corrupt archive.
+ */
+async function writeZip(archive, inputs) {
+    if (inputs.length > maximumZip32Entries) {
+        throw new Error(`ZIP archives support at most ${maximumZip32Entries} files.`);
+    }
+    const fileHandle = await (0, promises_1.open)(archive, "w");
+    const entries = [];
+    let offset = 0;
+    let operationError;
+    try {
+        for (const input of inputs) {
+            const fileStats = await (0, promises_1.stat)(input.file);
+            if (!fileStats.isFile()) {
+                throw new Error(`ZIP input is not a file: ${JSON.stringify(input.file)}`);
+            }
+            assertZip32Value(fileStats.size, "uncompressed file size");
+            const name = encodeZipName(input.name ?? (0, node_path_1.basename)(input.file));
+            const { modificationTime, modificationDate } = encodeDosDateTime(fileStats.mtime);
+            const localHeaderOffset = offset;
+            const localHeader = createLocalHeader(name, modificationTime, modificationDate);
+            await writeAll(fileHandle, localHeader);
+            offset += localHeader.byteLength;
+            const checksum = new ChecksumTransform();
+            const output = new FileHandleWritable(fileHandle);
+            await (0, promises_2.pipeline)((0, node_fs_1.createReadStream)(input.file), checksum, (0, node_zlib_1.createDeflateRaw)({ level: node_zlib_1.constants.Z_BEST_SPEED }), output);
+            assertZip32Value(output.bytesWritten, "compressed file size");
+            const descriptor = createDataDescriptor(checksum.crc32, output.bytesWritten, checksum.size);
+            await writeAll(fileHandle, descriptor);
+            offset += output.bytesWritten + descriptor.byteLength;
+            entries.push({
+                name,
+                crc32: checksum.crc32,
+                compressedSize: output.bytesWritten,
+                uncompressedSize: checksum.size,
+                localHeaderOffset,
+                modificationTime,
+                modificationDate,
+            });
+        }
+        const centralDirectoryOffset = offset;
+        for (const entry of entries) {
+            assertZip32Value(entry.localHeaderOffset, "local header offset");
+            const centralHeader = createCentralDirectoryHeader(entry);
+            await writeAll(fileHandle, centralHeader);
+            offset += centralHeader.byteLength;
+        }
+        const centralDirectorySize = offset - centralDirectoryOffset;
+        assertZip32Value(centralDirectoryOffset, "central directory offset");
+        assertZip32Value(centralDirectorySize, "central directory size");
+        await writeAll(fileHandle, createEndOfCentralDirectory(entries.length, centralDirectorySize, centralDirectoryOffset));
+    }
+    catch (error) {
+        operationError = error;
+    }
+    try {
+        await fileHandle.close();
+    }
+    catch (closeError) {
+        if (operationError !== undefined) {
+            operationError = new AggregateError([operationError, closeError], "Writing and closing the ZIP archive both failed.", { cause: operationError });
+        }
+        else {
+            operationError = closeError;
+        }
+    }
+    if (operationError !== undefined) {
+        try {
+            await (0, promises_1.rm)(archive, { force: true });
+        }
+        catch (cleanupError) {
+            throw new AggregateError([operationError, cleanupError], "Writing and cleaning up the ZIP archive both failed.", { cause: operationError });
+        }
+        throw operationError;
+    }
+}
+function createCrc32Table() {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < table.length; index++) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit++) {
+            value = (value & 1) === 1 ? 0xedb8_8320 ^ (value >>> 1) : value >>> 1;
+        }
+        table[index] = value >>> 0;
+    }
+    return table;
+}
+function updateCrc32(data, previous) {
+    if (typeof zlib.crc32 === "function") {
+        return zlib.crc32(data, previous);
+    }
+    let value = (previous ^ 0xffff_ffff) >>> 0;
+    for (const byte of data) {
+        value = crc32Table[(value ^ byte) & 0xff] ^ (value >>> 8);
+    }
+    return (value ^ 0xffff_ffff) >>> 0;
+}
+function encodeZipName(name) {
+    const normalizedName = name.replaceAll("\\", "/");
+    if (normalizedName === "" || normalizedName.startsWith("/") ||
+        normalizedName.split("/").includes("..")) {
+        throw new Error(`Invalid ZIP entry name: ${JSON.stringify(name)}`);
+    }
+    const encoded = new TextEncoder().encode(normalizedName);
+    if (encoded.byteLength > 0xffff) {
+        throw new Error(`ZIP entry name is too long: ${JSON.stringify(name)}`);
+    }
+    return encoded;
+}
+function encodeDosDateTime(date) {
+    const year = Math.min(2107, Math.max(1980, date.getFullYear()));
+    return {
+        modificationTime: (date.getHours() << 11) |
+            (date.getMinutes() << 5) |
+            Math.floor(date.getSeconds() / 2),
+        modificationDate: ((year - 1980) << 9) |
+            ((date.getMonth() + 1) << 5) |
+            date.getDate(),
+    };
+}
+function createLocalHeader(name, modificationTime, modificationDate) {
+    const header = new Uint8Array(30 + name.byteLength);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, 0x0403_4b50, true);
+    view.setUint16(4, 20, true);
+    view.setUint16(6, utf8WithDataDescriptor, true);
+    view.setUint16(8, 8, true);
+    view.setUint16(10, modificationTime, true);
+    view.setUint16(12, modificationDate, true);
+    view.setUint16(26, name.byteLength, true);
+    header.set(name, 30);
+    return header;
+}
+function createDataDescriptor(crc32, compressedSize, uncompressedSize) {
+    const descriptor = new Uint8Array(16);
+    const view = new DataView(descriptor.buffer);
+    view.setUint32(0, 0x0807_4b50, true);
+    view.setUint32(4, crc32, true);
+    view.setUint32(8, compressedSize, true);
+    view.setUint32(12, uncompressedSize, true);
+    return descriptor;
+}
+function createCentralDirectoryHeader(entry) {
+    const header = new Uint8Array(46 + entry.name.byteLength);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, 0x0201_4b50, true);
+    view.setUint16(4, 20, true);
+    view.setUint16(6, 20, true);
+    view.setUint16(8, utf8WithDataDescriptor, true);
+    view.setUint16(10, 8, true);
+    view.setUint16(12, entry.modificationTime, true);
+    view.setUint16(14, entry.modificationDate, true);
+    view.setUint32(16, entry.crc32, true);
+    view.setUint32(20, entry.compressedSize, true);
+    view.setUint32(24, entry.uncompressedSize, true);
+    view.setUint16(28, entry.name.byteLength, true);
+    view.setUint32(42, entry.localHeaderOffset, true);
+    header.set(entry.name, 46);
+    return header;
+}
+function createEndOfCentralDirectory(entryCount, centralDirectorySize, centralDirectoryOffset) {
+    const end = new Uint8Array(22);
+    const view = new DataView(end.buffer);
+    view.setUint32(0, 0x0605_4b50, true);
+    view.setUint16(8, entryCount, true);
+    view.setUint16(10, entryCount, true);
+    view.setUint32(12, centralDirectorySize, true);
+    view.setUint32(16, centralDirectoryOffset, true);
+    return end;
+}
+function assertZip32Value(value, label) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximumZip32Value) {
+        throw new Error(`Cannot create ZIP archive: ${label} exceeds the 4 GB ZIP32 limit.`);
+    }
+}
+async function writeAll(fileHandle, data) {
+    let offset = 0;
+    while (offset < data.byteLength) {
+        const { bytesWritten } = await fileHandle.write(data.subarray(offset));
+        if (bytesWritten === 0) {
+            throw new Error("Could not write to ZIP archive.");
+        }
+        offset += bytesWritten;
+    }
+}

package/script/index.d.ts

@@ -10,7 +10,7 @@
  *
  * To install the library with Node.js, use:
  * ```bash
- * npx jsr add @nshiab/simple-data-analysis-core
+ * npm i @nshiab/simple-data-analysis-core
  * ```
  *
  * To start, create a SimpleDB instance and then a SimpleTable from this instance:
@@ -18,14 +18,18 @@
  * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
  *
  * const sdb = new SimpleDB();
- * const table = sdb.newTable("myTable"); // This returns a SimpleTable instance
- * await table.loadData("path/to/your/data.csv");
+ * const table = await sdb
+ *   .newTable("myTable")
+ *   .loadData("path/to/your/data.csv")
+ *   .log();
  *
  * // You can now perform various data analysis operations on the table.
  *
- * await sdb.done(); // Ensure to call done when you're finished.
+ * await sdb.close(); // Ensure to close the database when you're finished.
  * ```
  */
+import "./_dnt.polyfills.js";
 export { default as SimpleDB } from "./class/SimpleDB.js";
 export { default as SimpleTable } from "./class/SimpleTable.js";
+export { default as SDAError } from "./class/SDAError.js";
 //# sourceMappingURL=index.d.ts.map

package/script/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,qBAAqB,CAAC;AAG7B,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,qBAAqB,CAAC"}

package/script/index.js

@@ -1,4 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDAError = exports.SimpleTable = exports.SimpleDB = void 0;
 /**
  * @module
  *
@@ -11,7 +16,7 @@
  *
  * To install the library with Node.js, use:
  * ```bash
- * npx jsr add @nshiab/simple-data-analysis-core
+ * npm i @nshiab/simple-data-analysis-core
  * ```
  *
  * To start, create a SimpleDB instance and then a SimpleTable from this instance:
@@ -19,20 +24,20 @@
  * import { SimpleDB } from "@nshiab/simple-data-analysis-core";
  *
  * const sdb = new SimpleDB();
- * const table = sdb.newTable("myTable"); // This returns a SimpleTable instance
- * await table.loadData("path/to/your/data.csv");
+ * const table = await sdb
+ *   .newTable("myTable")
+ *   .loadData("path/to/your/data.csv")
+ *   .log();
  *
  * // You can now perform various data analysis operations on the table.
  *
- * await sdb.done(); // Ensure to call done when you're finished.
+ * await sdb.close(); // Ensure to close the database when you're finished.
  * ```
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleTable = exports.SimpleDB = void 0;
+require("./_dnt.polyfills.js");
 var SimpleDB_js_1 = require("./class/SimpleDB.js");
 Object.defineProperty(exports, "SimpleDB", { enumerable: true, get: function () { return __importDefault(SimpleDB_js_1).default; } });
 var SimpleTable_js_1 = require("./class/SimpleTable.js");
 Object.defineProperty(exports, "SimpleTable", { enumerable: true, get: function () { return __importDefault(SimpleTable_js_1).default; } });
+var SDAError_js_1 = require("./class/SDAError.js");
+Object.defineProperty(exports, "SDAError", { enumerable: true, get: function () { return __importDefault(SDAError_js_1).default; } });

package/script/methods/accumulate.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function accumulate(simpleTable: SimpleTable, column: string, newColumn: string, options?: {
+    by?: string | string[];
+}): void;
+//# sourceMappingURL=accumulate.d.ts.map

package/script/methods/accumulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accumulate.d.ts","sourceRoot":"","sources":["../../src/methods/accumulate.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACnB,QA8BP"}