@nshiab/simple-data-analysis-core 2.1.12 → 2.1.14

package/esm/helpers/extractZipEntryToFile.js

@@ -1,226 +0,0 @@
-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_crc;
-import { createReadStream, createWriteStream } from "node:fs";
-import { open, rm, stat } from "node:fs/promises";
-import { Transform } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { createInflateRaw } from "node:zlib";
-/*
- * Adapted from the ZIP reader in @nshiab/journalism-web-scraping. This
- * version streams the selected entry to disk so complete StatCan tables do
- * not need to be buffered in JavaScript memory.
- */
-const END_OF_CENTRAL_DIRECTORY = 0x0605_4b50;
-const CENTRAL_DIRECTORY_ENTRY = 0x0201_4b50;
-const LOCAL_FILE_HEADER = 0x0403_4b50;
-const MAX_COMMENT_LENGTH = 0xffff;
-const MAX_END_RECORD_LENGTH = 22 + MAX_COMMENT_LENGTH;
-const CRC_TABLE = createCrcTable();
-class ChecksumTransform extends Transform {
-    constructor() {
-        super(...arguments);
-        _ChecksumTransform_crc.set(this, 0xffff_ffff);
-        Object.defineProperty(this, "size", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-    }
-    get crc32() {
-        return (__classPrivateFieldGet(this, _ChecksumTransform_crc, "f") ^ 0xffff_ffff) >>> 0;
-    }
-    _transform(chunk, _encoding, callback) {
-        for (const byte of chunk) {
-            __classPrivateFieldSet(this, _ChecksumTransform_crc, CRC_TABLE[(__classPrivateFieldGet(this, _ChecksumTransform_crc, "f") ^ byte) & 0xff] ^ (__classPrivateFieldGet(this, _ChecksumTransform_crc, "f") >>> 8), "f");
-        }
-        this.size += chunk.byteLength;
-        callback(null, chunk);
-    }
-}
-_ChecksumTransform_crc = new WeakMap();
-/** Extracts one entry from a non-ZIP64, single-disk ZIP without buffering it. */
-export default async function extractZipEntryToFile(archive, wantedName, output) {
-    const entry = await findZipEntry(archive, wantedName);
-    if (entry === undefined) {
-        throw new Error(`No ${wantedName} in the zipped file.`);
-    }
-    if (entry.compressionMethod !== 0 && entry.compressionMethod !== 8) {
-        throw new Error(`ZIP entry ${wantedName} uses unsupported compression method ${entry.compressionMethod}.`);
-    }
-    const file = await open(archive, "r");
-    let operationError;
-    try {
-        const localHeader = new Uint8Array(30);
-        await readExactly(file, localHeader, entry.localHeaderOffset);
-        const view = new DataView(localHeader.buffer);
-        assertSignature(view, 0, LOCAL_FILE_HEADER, "local file header");
-        const fileNameLength = view.getUint16(26, true);
-        const extraLength = view.getUint16(28, true);
-        const dataOffset = entry.localHeaderOffset + 30 + fileNameLength +
-            extraLength;
-        const checksum = new ChecksumTransform();
-        const source = createReadStream(archive, {
-            start: dataOffset,
-            end: dataOffset + entry.compressedSize - 1,
-        });
-        const streams = entry.compressionMethod === 8
-            ? [
-                source,
-                createInflateRaw(),
-                checksum,
-                createWriteStream(output, {
-                    flags: "wx",
-                }),
-            ]
-            : [source, checksum, createWriteStream(output, { flags: "wx" })];
-        await pipeline(streams);
-        if (checksum.size !== entry.uncompressedSize) {
-            throw new Error(`ZIP entry ${wantedName} has an invalid size.`);
-        }
-        if (checksum.crc32 !== entry.expectedCrc) {
-            throw new Error(`ZIP entry ${wantedName} failed its CRC check.`);
-        }
-    }
-    catch (error) {
-        operationError = error;
-    }
-    try {
-        await file.close();
-    }
-    catch (closeError) {
-        operationError = operationError === undefined
-            ? closeError
-            : new AggregateError([operationError, closeError], "Extracting and closing the ZIP archive both failed.", { cause: operationError });
-    }
-    if (operationError !== undefined) {
-        try {
-            await rm(output, { force: true });
-        }
-        catch (cleanupError) {
-            throw new AggregateError([operationError, cleanupError], "Extracting and cleaning up the ZIP entry both failed.", { cause: operationError });
-        }
-        throw operationError;
-    }
-}
-async function findZipEntry(archive, wantedName) {
-    const file = await open(archive, "r");
-    try {
-        const size = (await stat(archive)).size;
-        const tailLength = Math.min(size, MAX_END_RECORD_LENGTH);
-        const tail = new Uint8Array(tailLength);
-        await readExactly(file, tail, size - tailLength);
-        const tailView = new DataView(tail.buffer);
-        const endOffset = findEndOfCentralDirectory(tailView);
-        const diskNumber = tailView.getUint16(endOffset + 4, true);
-        const centralDirectoryDisk = tailView.getUint16(endOffset + 6, true);
-        const entriesOnDisk = tailView.getUint16(endOffset + 8, true);
-        const entryCount = tailView.getUint16(endOffset + 10, true);
-        const centralDirectorySize = tailView.getUint32(endOffset + 12, true);
-        const centralDirectoryOffset = tailView.getUint32(endOffset + 16, true);
-        if (diskNumber !== 0 || centralDirectoryDisk !== 0 ||
-            entriesOnDisk !== entryCount) {
-            throw new Error("Multi-disk ZIP archives are not supported.");
-        }
-        if (entryCount === 0xffff || centralDirectorySize === 0xffff_ffff ||
-            centralDirectoryOffset === 0xffff_ffff) {
-            throw new Error("ZIP64 archives are not supported.");
-        }
-        if (centralDirectoryOffset + centralDirectorySize > size) {
-            throw new Error("Invalid ZIP archive: truncated central directory.");
-        }
-        const centralDirectory = new Uint8Array(centralDirectorySize);
-        await readExactly(file, centralDirectory, centralDirectoryOffset);
-        const view = new DataView(centralDirectory.buffer);
-        let offset = 0;
-        for (let index = 0; index < entryCount; index++) {
-            assertSignature(view, offset, CENTRAL_DIRECTORY_ENTRY, "central directory");
-            assertRange(centralDirectory, offset, 46, "central directory entry");
-            const flags = view.getUint16(offset + 8, true);
-            const compressionMethod = view.getUint16(offset + 10, true);
-            const expectedCrc = view.getUint32(offset + 16, true);
-            const compressedSize = view.getUint32(offset + 20, true);
-            const uncompressedSize = view.getUint32(offset + 24, true);
-            const fileNameLength = view.getUint16(offset + 28, true);
-            const extraLength = view.getUint16(offset + 30, true);
-            const commentLength = view.getUint16(offset + 32, true);
-            const localHeaderOffset = view.getUint32(offset + 42, true);
-            const entryLength = 46 + fileNameLength + extraLength + commentLength;
-            assertRange(centralDirectory, offset, entryLength, "central directory entry");
-            const name = new TextDecoder().decode(centralDirectory.subarray(offset + 46, offset + 46 + fileNameLength));
-            if (name === wantedName) {
-                if ((flags & 1) !== 0) {
-                    throw new Error(`ZIP entry ${wantedName} is encrypted.`);
-                }
-                if (compressedSize === 0xffff_ffff ||
-                    uncompressedSize === 0xffff_ffff ||
-                    localHeaderOffset === 0xffff_ffff) {
-                    throw new Error("ZIP64 archives are not supported.");
-                }
-                return {
-                    compressionMethod,
-                    compressedSize,
-                    uncompressedSize,
-                    expectedCrc,
-                    localHeaderOffset,
-                };
-            }
-            offset += entryLength;
-        }
-        return undefined;
-    }
-    finally {
-        await file.close();
-    }
-}
-async function readExactly(file, buffer, position) {
-    let offset = 0;
-    while (offset < buffer.byteLength) {
-        const { bytesRead } = await file.read(buffer, offset, buffer.byteLength - offset, position + offset);
-        if (bytesRead === 0) {
-            throw new Error("Invalid ZIP archive: unexpected end of file.");
-        }
-        offset += bytesRead;
-    }
-}
-function findEndOfCentralDirectory(view) {
-    for (let offset = view.byteLength - 22; offset >= 0; offset--) {
-        if (view.getUint32(offset, true) === END_OF_CENTRAL_DIRECTORY &&
-            offset + 22 + view.getUint16(offset + 20, true) === view.byteLength) {
-            return offset;
-        }
-    }
-    throw new Error("Invalid ZIP archive: end of central directory not found.");
-}
-function assertSignature(view, offset, expected, description) {
-    if (offset < 0 || offset + 4 > view.byteLength) {
-        throw new Error(`Invalid ZIP archive: truncated ${description}.`);
-    }
-    if (view.getUint32(offset, true) !== expected) {
-        throw new Error(`Invalid ZIP archive: malformed ${description}.`);
-    }
-}
-function assertRange(data, offset, length, description) {
-    if (offset < 0 || length < 0 || offset + length > data.byteLength) {
-        throw new Error(`Invalid ZIP archive: truncated ${description}.`);
-    }
-}
-function createCrcTable() {
-    return Uint32Array.from({ length: 256 }, (_, index) => {
-        let value = index;
-        for (let bit = 0; bit < 8; bit++) {
-            value = (value >>> 1) ^ (0xedb8_8320 & -(value & 1));
-        }
-        return value >>> 0;
-    });
-}

package/esm/helpers/factorCovariance.d.ts

@@ -1,17 +0,0 @@
-export type CovarianceFactor = {
-    dimensions: number;
-    covariance: Float64Array;
-    scales: Float64Array;
-    cholesky: Float64Array;
-    reciprocalCondition: number;
-};
-/** Factors a sample covariance matrix for stable repeated linear solves. */
-export declare function factorCovariance(covarianceInput: ArrayLike<number>, dimensions: number): CovarianceFactor;
-/** Solves covariance * x = rightHandSide through the scaled Cholesky factor. */
-export declare function solveCovariance(factor: CovarianceFactor, rightHandSide: ArrayLike<number>): Float64Array;
-/**
- * Returns the lower-triangular transform whose squared norm is Mahalanobis
- * squared distance. This inverts only the Cholesky factor, never covariance.
- */
-export declare function covarianceWhitening(factor: CovarianceFactor): Float64Array;
-//# sourceMappingURL=factorCovariance.d.ts.map

package/esm/helpers/factorCovariance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"factorCovariance.d.ts","sourceRoot":"","sources":["../../src/helpers/factorCovariance.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,YAAY,CAAC;IACzB,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,YAAY,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAkGF,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,SAAS,CAAC,MAAM,CAAC,EAClC,UAAU,EAAE,MAAM,GACjB,gBAAgB,CAoGlB;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAC7B,MAAM,EAAE,gBAAgB,EACxB,aAAa,EAAE,SAAS,CAAC,MAAM,CAAC,GAC/B,YAAY,CAsBd;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,gBAAgB,GACvB,YAAY,CA2Bd"}

package/esm/helpers/factorCovariance.js

@@ -1,189 +0,0 @@
-const instabilityMultiplier = 64;
-function singularCovariance(reason) {
-    return new Error(`Covariance is singular or numerically unstable (${reason}). Constant columns, linearly dependent features, or too few observations are common causes. Remove redundant features or provide more observations.`);
-}
-function scaleCovarianceEntry(value, leftScale, rightScale) {
-    // Divide by the larger scale first. For a valid covariance, Cauchy-Schwarz
-    // bounds |value| by their product, so this avoids intermediate overflow when
-    // two otherwise equivalent features use radically different units.
-    return leftScale >= rightScale
-        ? value / leftScale / rightScale
-        : value / rightScale / leftScale;
-}
-function solveCorrelation(cholesky, dimensions, rightHandSide) {
-    const solution = new Float64Array(dimensions);
-    for (let row = 0; row < dimensions; row++) {
-        let value = rightHandSide[row];
-        for (let column = 0; column < row; column++) {
-            value -= cholesky[row * dimensions + column] * solution[column];
-        }
-        solution[row] = value / cholesky[row * dimensions + row];
-    }
-    for (let row = dimensions - 1; row >= 0; row--) {
-        let value = solution[row];
-        for (let column = row + 1; column < dimensions; column++) {
-            value -= cholesky[column * dimensions + row] * solution[column];
-        }
-        solution[row] = value / cholesky[row * dimensions + row];
-    }
-    return solution;
-}
-// Hager's estimator avoids forming the inverse merely to decide whether the
-// correlation-scaled covariance is safe to solve. Scaling first makes this
-// rank decision invariant to a change of units in any feature.
-function estimateInverseOneNorm(cholesky, dimensions) {
-    let vector = new Float64Array(dimensions).fill(1 / dimensions);
-    let estimate = 0;
-    let previousIndex = -1;
-    for (let iteration = 0; iteration < 8; iteration++) {
-        const solved = solveCorrelation(cholesky, dimensions, vector);
-        estimate = Math.max(estimate, solved.reduce((sum, value) => sum + Math.abs(value), 0));
-        const signs = solved.map((value) => value < 0 ? -1 : 1);
-        const dual = solveCorrelation(cholesky, dimensions, signs);
-        let index = 0;
-        for (let i = 1; i < dimensions; i++) {
-            if (Math.abs(dual[i]) > Math.abs(dual[index]))
-                index = i;
-        }
-        const directional = dual.reduce((sum, value, i) => sum + value * vector[i], 0);
-        if (Math.abs(dual[index]) <= directional || index === previousIndex)
-            break;
-        vector = new Float64Array(dimensions);
-        vector[index] = 1;
-        previousIndex = index;
-    }
-    // The all-positive initial vector can be an eigenvector that causes Hager's
-    // iteration to stop at the *smallest* inverse eigenvalue (for example an
-    // equicorrelation matrix). Higham's alternating, increasing-magnitude probe
-    // prevents that failure; normalize by its 1-norm to retain a lower estimate.
-    // Reference: https://www.netlib.org/lapack/double/dlacon.f (final stage).
-    const alternating = Float64Array.from({ length: dimensions }, (_, i) => (i % 2 === 0 ? 1 : -1) * (1 + i / Math.max(1, dimensions - 1)));
-    const alternatingNorm = alternating.reduce((sum, value) => sum + Math.abs(value), 0);
-    const solved = solveCorrelation(cholesky, dimensions, alternating);
-    estimate = Math.max(estimate, solved.reduce((sum, value) => sum + Math.abs(value), 0) / alternatingNorm);
-    return estimate;
-}
-/** Factors a sample covariance matrix for stable repeated linear solves. */
-export function factorCovariance(covarianceInput, dimensions) {
-    if (!Number.isSafeInteger(dimensions) || dimensions < 1) {
-        throw new Error("Covariance dimensions must be a positive safe integer.");
-    }
-    if (covarianceInput.length !== dimensions * dimensions) {
-        throw new Error(`Expected ${dimensions * dimensions} covariance values, received ${covarianceInput.length}.`);
-    }
-    const covariance = Float64Array.from(covarianceInput);
-    const scales = new Float64Array(dimensions);
-    for (let dimension = 0; dimension < dimensions; dimension++) {
-        const variance = covariance[dimension * dimensions + dimension];
-        if (!Number.isFinite(variance) || variance <= 0) {
-            throw singularCovariance(`feature ${dimension + 1} has non-positive or non-finite sample variance`);
-        }
-        scales[dimension] = Math.sqrt(variance);
-    }
-    const correlation = new Float64Array(dimensions * dimensions);
-    let correlationOneNorm = 0;
-    for (let column = 0; column < dimensions; column++) {
-        let columnSum = 0;
-        for (let row = 0; row < dimensions; row++) {
-            const left = covariance[row * dimensions + column];
-            const right = covariance[column * dimensions + row];
-            if (!Number.isFinite(left) || !Number.isFinite(right)) {
-                throw singularCovariance("the sample covariance contains non-finite values");
-            }
-            const value = row === column ? 1 : scaleCovarianceEntry(left, scales[row], scales[column]) / 2 + scaleCovarianceEntry(right, scales[row], scales[column]) / 2;
-            if (!Number.isFinite(value)) {
-                throw singularCovariance("correlation scaling produced a non-finite value");
-            }
-            correlation[row * dimensions + column] = value;
-            columnSum += Math.abs(value);
-        }
-        correlationOneNorm = Math.max(correlationOneNorm, columnSum);
-    }
-    const cholesky = new Float64Array(dimensions * dimensions);
-    for (let row = 0; row < dimensions; row++) {
-        for (let column = 0; column <= row; column++) {
-            let value = correlation[row * dimensions + column];
-            for (let k = 0; k < column; k++) {
-                value -= cholesky[row * dimensions + k] *
-                    cholesky[column * dimensions + k];
-            }
-            if (row === column) {
-                if (!Number.isFinite(value) || value <= 0) {
-                    throw singularCovariance(`correlation-scaled Cholesky pivot ${row + 1} is not positive`);
-                }
-                cholesky[row * dimensions + column] = Math.sqrt(value);
-            }
-            else {
-                cholesky[row * dimensions + column] = value /
-                    cholesky[column * dimensions + column];
-            }
-        }
-    }
-    const inverseOneNorm = estimateInverseOneNorm(cholesky, dimensions);
-    const reciprocalCondition = 1 / (correlationOneNorm * inverseOneNorm);
-    // This is the usual dimension-scaled floating-point rank tolerance, with a
-    // modest safety factor for covariance aggregation and subsequent row solves.
-    const tolerance = instabilityMultiplier * dimensions * Number.EPSILON;
-    if (!Number.isFinite(reciprocalCondition) || reciprocalCondition <= tolerance) {
-        throw singularCovariance(`estimated reciprocal condition ${reciprocalCondition} is at or below ${tolerance}`);
-    }
-    return {
-        dimensions,
-        covariance,
-        scales,
-        cholesky,
-        reciprocalCondition,
-    };
-}
-/** Solves covariance * x = rightHandSide through the scaled Cholesky factor. */
-export function solveCovariance(factor, rightHandSide) {
-    const { dimensions, scales, cholesky } = factor;
-    if (rightHandSide.length !== dimensions) {
-        throw new Error(`Expected a right-hand side with ${dimensions} values, received ${rightHandSide.length}.`);
-    }
-    const scaled = new Float64Array(dimensions);
-    for (let i = 0; i < dimensions; i++) {
-        if (!Number.isFinite(rightHandSide[i])) {
-            throw new Error("The covariance solve requires finite values.");
-        }
-        scaled[i] = rightHandSide[i] / scales[i];
-    }
-    const solution = solveCorrelation(cholesky, dimensions, scaled);
-    for (let i = 0; i < dimensions; i++) {
-        solution[i] /= scales[i];
-        if (!Number.isFinite(solution[i])) {
-            throw singularCovariance("the linear solve produced a non-finite value");
-        }
-    }
-    return solution;
-}
-/**
- * Returns the lower-triangular transform whose squared norm is Mahalanobis
- * squared distance. This inverts only the Cholesky factor, never covariance.
- */
-export function covarianceWhitening(factor) {
-    const { dimensions, scales, cholesky } = factor;
-    const whitening = new Float64Array(dimensions * dimensions);
-    // Invert the triangular correlation factor first, then apply feature units.
-    // Keeping units out of the recurrence avoids repeated underflow/rounding of
-    // the same coefficient, and visits only the nonzero triangle.
-    for (let column = 0; column < dimensions; column++) {
-        for (let row = column; row < dimensions; row++) {
-            let value = row === column ? 1 : 0;
-            for (let k = column; k < row; k++) {
-                value -= cholesky[row * dimensions + k] *
-                    whitening[k * dimensions + column];
-            }
-            whitening[row * dimensions + column] = value /
-                cholesky[row * dimensions + row];
-        }
-        for (let row = column; row < dimensions; row++) {
-            const index = row * dimensions + column;
-            whitening[index] /= scales[column];
-            if (!Number.isFinite(whitening[index])) {
-                throw singularCovariance("the whitening transform produced a non-finite value");
-            }
-        }
-    }
-    return whitening;
-}

package/esm/helpers/fileCache.d.ts

@@ -1,15 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-export declare function createFileCacheId(prefix: string, identity: unknown): string;
-export default function fileCache(table: SimpleTable, options: {
-    directory: string;
-    enabled: boolean;
-    extension: string;
-    formatVersion: string;
-    id: string;
-    method: string;
-    ttl?: number;
-    load: (file: string) => Promise<void>;
-    compute: () => Promise<void>;
-    write: (file: string) => Promise<void>;
-}): Promise<void>;
-//# sourceMappingURL=fileCache.d.ts.map

package/esm/helpers/fileCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fileCache.d.ts","sourceRoot":"","sources":["../../src/helpers/fileCache.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAiBvD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,CAK3E;AAED,wBAA8B,SAAS,CACrC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE;IACP,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,GACA,OAAO,CAAC,IAAI,CAAC,CAef"}

package/esm/helpers/fileCache.js

@@ -1,128 +0,0 @@
-import crypto from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { cacheEntryExpired, cacheLoadMessage, cacheTtlMessage, } from "./cacheDiagnostics.js";
-import prettyDuration from "./prettyDuration.js";
-export function createFileCacheId(prefix, identity) {
-    const hash = crypto.createHash("sha256")
-        .update(JSON.stringify(identity))
-        .digest("hex");
-    return `${prefix}.${hash}`;
-}
-export default async function fileCache(table, options) {
-    if (!options.enabled) {
-        logFileCacheDisabled(table, options.method);
-    }
-    else if (await loadFileCache(table, options)) {
-        return;
-    }
-    const start = Date.now();
-    await options.compute();
-    if (options.enabled) {
-        await writeFileCache(table, {
-            ...options,
-            duration: Date.now() - start,
-        });
-    }
-}
-async function loadFileCache(table, options) {
-    const sourcesFile = `${options.directory}/sources.json`;
-    const sources = readFileCacheSources(sourcesFile);
-    const source = sources[options.id];
-    const now = Date.now();
-    if (table.sdb.cacheVerbose) {
-        console.log(`\n${options.method} cache for ${table.name}`);
-    }
-    if (source === undefined) {
-        logCacheMiss(table, "No matching cache entry exists.");
-        return false;
-    }
-    if (source.formatVersion !== options.formatVersion) {
-        logCacheMiss(table, "The cache format changed.");
-        return false;
-    }
-    if (source.file === null || !existsSync(source.file)) {
-        logCacheMiss(table, "The cached file is missing.");
-        return false;
-    }
-    if (options.ttl !== undefined &&
-        cacheEntryExpired(source.creation, options.ttl, now)) {
-        table.sdb.cacheVerbose &&
-            console.log(`Cache entry is stale.\n${cacheTtlMessage(source.creation, options.ttl, now, true)}\nFetching fresh data and refreshing the cache entry.`);
-        return false;
-    }
-    if (table.sdb.cacheVerbose) {
-        console.log("Cache hit.");
-        if (options.ttl !== undefined) {
-            console.log(cacheTtlMessage(source.creation, options.ttl, now, false));
-        }
-    }
-    const start = Date.now();
-    try {
-        await options.load(source.file);
-    }
-    catch {
-        rmSync(source.file, { force: true });
-        delete sources[options.id];
-        writeFileCacheSources(options.directory, sourcesFile, sources);
-        table.sdb.cacheVerbose &&
-            console.log("Could not load cached data. Fetching fresh data...");
-        return false;
-    }
-    const end = Date.now();
-    if (table.sdb.cacheVerbose) {
-        console.log(`${cacheLoadMessage(start, end, source.duration)}\n`);
-        if (source.duration !== undefined) {
-            table.sdb.cacheTimeSaved += source.duration - (end - start);
-        }
-    }
-    return true;
-}
-async function writeFileCache(table, options) {
-    mkdirSync(options.directory, { recursive: true });
-    const file = `${options.directory}/${options.id}.${options.extension}`;
-    const temporaryFile = `${file}.${crypto.randomUUID()}.tmp.${options.extension}`;
-    table.sdb.cacheVerbose &&
-        console.log(`Computations done in ${prettyDuration(0, { end: options.duration })}.`);
-    const start = Date.now();
-    try {
-        await options.write(temporaryFile);
-        rmSync(file, { force: true });
-        renameSync(temporaryFile, file);
-    }
-    catch (error) {
-        rmSync(temporaryFile, { force: true });
-        throw error;
-    }
-    const end = Date.now();
-    const sourcesFile = `${options.directory}/sources.json`;
-    const sources = readFileCacheSources(sourcesFile);
-    sources[options.id] = {
-        file,
-        creation: Date.now(),
-        duration: options.duration,
-        formatVersion: options.formatVersion,
-    };
-    writeFileCacheSources(options.directory, sourcesFile, sources);
-    if (table.sdb.cacheVerbose) {
-        console.log(`Wrote in cache in ${prettyDuration(start, { end })}.\n`);
-        table.sdb.cacheTimeWriting += end - start;
-    }
-}
-function logFileCacheDisabled(table, method) {
-    table.sdb.cacheVerbose &&
-        console.log(`\n${method} cache for ${table.name}\nCache disabled.\nFetching fresh data without storing a cache entry.`);
-}
-function logCacheMiss(table, reason) {
-    table.sdb.cacheVerbose &&
-        console.log(`Cache miss.\n${reason}\nFetching fresh data and storing a new cache entry.`);
-}
-function readFileCacheSources(sourcesFile) {
-    if (!existsSync(sourcesFile)) {
-        return {};
-    }
-    return JSON.parse(readFileSync(sourcesFile, "utf-8"));
-}
-function writeFileCacheSources(directory, sourcesFile, sources) {
-    mkdirSync(directory, { recursive: true });
-    writeFileSync(sourcesFile, JSON.stringify(sources));
-}

package/esm/helpers/findGeoColumn.d.ts

@@ -1,17 +0,0 @@
-import type SimpleTable from "../class/SimpleTable.js";
-/**
- * Returns the only geometry column in a table.
- *
- * @example
- * ```ts
- * const column = await findGeoColumn(table, "getGeoData()");
- * ```
- *
- * @param simpleTable - The table to inspect.
- *
- * @param method - The SDA method requesting a geometry column.
- *
- * @returns A promise resolving to the name of the only geometry column.
- */
-export default function findGeoColumn(simpleTable: SimpleTable, method: string): Promise<string>;
-//# sourceMappingURL=findGeoColumn.d.ts.map

package/esm/helpers/findGeoColumn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"findGeoColumn.d.ts","sourceRoot":"","sources":["../../src/helpers/findGeoColumn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;;;;;;;;;;;GAaG;AACH,wBAA8B,aAAa,CACzC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAMjB"}

package/esm/helpers/findGeoColumn.js

@@ -1,18 +0,0 @@
-import findGeoColumnFromSchema from "./findGeoColumnFromSchema.js";
-/**
- * Returns the only geometry column in a table.
- *
- * @example
- * ```ts
- * const column = await findGeoColumn(table, "getGeoData()");
- * ```
- *
- * @param simpleTable - The table to inspect.
- *
- * @param method - The SDA method requesting a geometry column.
- *
- * @returns A promise resolving to the name of the only geometry column.
- */
-export default async function findGeoColumn(simpleTable, method) {
-    return findGeoColumnFromSchema(await simpleTable.getTypes(), method, simpleTable.name);
-}

package/esm/helpers/findGeoColumnFromSchema.d.ts

@@ -1,23 +0,0 @@
-import type { TableSchema } from "./pendingOps.js";
-/**
- * Returns the only geometry column in a table schema.
- *
- * @example
- * ```ts
- * const column = findGeoColumnFromSchema(
- *   { geom: "GEOMETRY('EPSG:4326')" },
- *   "area()",
- *   "places",
- * );
- * ```
- *
- * @param types - The table schema to inspect.
- *
- * @param method - The SDA method requesting a geometry column.
- *
- * @param tableName - The name of the table represented by the schema.
- *
- * @returns The name of the only geometry column.
- */
-export default function findGeoColumnFromSchema(types: TableSchema, method: string, tableName: string): string;
-//# sourceMappingURL=findGeoColumnFromSchema.d.ts.map

package/esm/helpers/findGeoColumnFromSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"findGeoColumnFromSchema.d.ts","sourceRoot":"","sources":["../../src/helpers/findGeoColumnFromSchema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,MAAM,CAoBR"}