@nshiab/simple-data-analysis 5.21.1 → 6.0.0

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/extractLatLon.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function extractLatLon(simpleTable: SimpleTable, column: string, latColumn: string, lonColumn: string): void;
+//# sourceMappingURL=extractLatLon.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/extractLatLon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractLatLon.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/extractLatLon.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,aAAa,CACnC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,QAiBlB"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/extractLatLon.js

@@ -0,0 +1,16 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import assertNewColumns from "../helpers/assertNewColumns.js";
+import queueOp from "../helpers/queueOp.js";
+export default function extractLatLon(simpleTable, column, latColumn, lonColumn) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "extractLatLon()",
+        parameters: { column, latColumn, lonColumn },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            assertNewColumns(types, [latColumn, lonColumn], "extractLatLon()");
+            return `SELECT *, CAST(ST_Y(${quoteIdentifier(column)}) AS DOUBLE) AS ${quoteIdentifier(latColumn)}, CAST(ST_X(${quoteIdentifier(column)}) AS DOUBLE) AS ${quoteIdentifier(lonColumn)} FROM ${input}`;
+        },
+    });
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fill.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fill(simpleTable: SimpleTable, columns: string | string[], options?: {
+    by?: string | string[];
+    interpolate?: boolean;
+    interpolateBy?: string;
+}): void;
+//# sourceMappingURL=fill.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fill.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fill.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,IAAI,CAC1B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,OAAO,GAAE;IACP,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACnB,QAmBP"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fill.js

@@ -0,0 +1,57 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import stringToArray from "../helpers/stringToArray.js";
+export default function fill(simpleTable, columns, options = {}) {
+    // This validation doesn't need the database, so it stays at call time.
+    if (options.interpolateBy && options.interpolate === false) {
+        throw new Error(`interpolate cannot be false when interpolateBy is set.`);
+    }
+    // The fill order is based on rowid, which only exists on the materialized
+    // table: it executes as a barrier.
+    columns = Array.isArray(columns) ? [...columns] : columns;
+    options = structuredClone(options);
+    queueOp(simpleTable, {
+        kind: "barrier",
+        method: "fill()",
+        parameters: { columns, options },
+        execute: () => executeFill(simpleTable, columns, options),
+    });
+}
+async function executeFill(simpleTable, columns, options) {
+    const by = options.by ? stringToArray(options.by) : [];
+    const cols = stringToArray(columns);
+    const excludeList = cols.map((col) => `${quoteIdentifier(col)}`).join(", ");
+    let selectList;
+    if (options.interpolate || options.interpolateBy) {
+        // Use interpolateBy for the window function's ORDER BY (correct
+        // interpolation math), but always order the final output by rowid to
+        // preserve input row order.
+        const windowOrder = options.interpolateBy
+            ? `${quoteIdentifier(options.interpolateBy)}`
+            : "rowid";
+        const overClause = by.length > 0
+            ? `(PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")})`
+            : `()`;
+        selectList = cols
+            .map((col) => `fill(${quoteIdentifier(col)} ORDER BY ${windowOrder}) OVER ${overClause} as ${quoteIdentifier(col)}`)
+            .join(", ");
+    }
+    else if (by.length > 0) {
+        const partition = `PARTITION BY ${by.map((d) => `${quoteIdentifier(d)}`).join(", ")}`;
+        selectList = cols
+            .map((col) => `COALESCE(${quoteIdentifier(col)}, LAG(${quoteIdentifier(col)} IGNORE NULLS) OVER(${partition} ORDER BY rowid)) as ${quoteIdentifier(col)}`)
+            .join(", ");
+    }
+    else {
+        selectList = cols
+            .map((col) => `COALESCE(${quoteIdentifier(col)}, LAG(${quoteIdentifier(col)} IGNORE NULLS) OVER(ORDER BY rowid)) as ${quoteIdentifier(col)}`)
+            .join(", ");
+    }
+    await queryDB(simpleTable, `CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT * EXCLUDE(${excludeList}), ${selectList} FROM ${quoteIdentifier(simpleTable.name)} ORDER BY rowid;`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "fill()",
+        parameters: { columns, ...options },
+    }));
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fillHoles.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fillHoles(simpleTable: SimpleTable, column?: string): void;
+//# sourceMappingURL=fillHoles.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fillHoles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillHoles.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fillHoles.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,QAkBhB"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fillHoles.js

@@ -0,0 +1,19 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function fillHoles(simpleTable, column) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "fillHoles()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                findGeoColumnFromSchema(types, "fillHoles()", simpleTable.name);
+            // Like the previous UPDATE-based implementation, the result is always
+            // stored in the "geom" column, and the assignment cast keeps its type.
+            return `SELECT * REPLACE (ST_MakePolygon(ST_ExteriorRing(${quoteIdentifier(col)}))${types["geom"] ? `::${types["geom"]}` : ""} AS "geom") FROM ${input}`;
+        },
+    });
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/filter.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function filter(simpleTable: SimpleTable, conditions: string): void;
+//# sourceMappingURL=filter.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,QAcnB"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/filter.js

@@ -0,0 +1,14 @@
+import queueOp from "../helpers/queueOp.js";
+export default function filter(simpleTable, conditions) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "filter()",
+        parameters: { conditions },
+        needsSchema: false,
+        rawSQL: [conditions],
+        preservesSchema: true,
+        buildSelect: (input) => `SELECT *
+        FROM ${input}
+        WHERE ${conditions}`,
+    });
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/firstChars.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function firstChars(simpleTable: SimpleTable, column: string, count: number): void;
+//# sourceMappingURL=firstChars.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/firstChars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firstChars.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/firstChars.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,QAYd"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/firstChars.js

@@ -0,0 +1,11 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import queueOp from "../helpers/queueOp.js";
+export default function firstChars(simpleTable, column, count) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "firstChars()",
+        parameters: { column, count },
+        needsSchema: false,
+        buildSelect: (input) => `SELECT * REPLACE (LEFT(${quoteIdentifier(column)}, ${count}) AS ${quoteIdentifier(column)}) FROM ${input}`,
+    });
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fixGeo.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fixGeo(simpleTable: SimpleTable, column?: string): void;
+//# sourceMappingURL=fixGeo.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fixGeo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixGeo.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fixGeo.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,QAqBhB"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fixGeo.js

@@ -0,0 +1,22 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function fixGeo(simpleTable, column) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "fixGeo()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        // The cast pins the geometry column back to its existing type, so the
+        // schema is unchanged.
+        preservesSchema: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                findGeoColumnFromSchema(types, "fixGeo()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            return `SELECT * REPLACE (ST_MakeValid(${quoteIdentifier(col)})::${types[col]} AS ${quoteIdentifier(col)}) FROM ${input}`;
+        },
+    });
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/flipCoordinates.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function flipCoordinates(simpleTable: SimpleTable, column?: string): void;
+//# sourceMappingURL=flipCoordinates.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/flipCoordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flipCoordinates.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/flipCoordinates.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,QAqBhB"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/flipCoordinates.js

@@ -0,0 +1,22 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumnFromSchema from "../helpers/findGeoColumnFromSchema.js";
+import queueOp from "../helpers/queueOp.js";
+export default function flipCoordinates(simpleTable, column) {
+    queueOp(simpleTable, {
+        kind: "fusable",
+        method: "flipCoordinates()",
+        parameters: { column },
+        needsSchema: true,
+        needsSpatial: true,
+        // The cast pins the geometry column back to its existing type, so the
+        // schema is unchanged.
+        preservesSchema: true,
+        buildSelect: (input, types) => {
+            const col = column ??
+                findGeoColumnFromSchema(types, "flipCoordinates()", simpleTable.name);
+            // The schema type carries the projection (e.g. GEOMETRY('EPSG:4326')),
+            // so the cast keeps it on the new geometries.
+            return `SELECT * REPLACE (ST_FlipCoordinates(${quoteIdentifier(col)})::${types[col]} AS ${quoteIdentifier(col)}) FROM ${input}`;
+        },
+    });
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyClean.d.ts

@@ -0,0 +1,7 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fuzzyClean(table: SimpleTable, column: string, newColumn: string, threshold: number, options?: {
+    method?: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio";
+    strategy?: "mostCommon" | "longestString" | "shortestString" | "mostCentral" | "maxScore";
+    prefilterPrefixLength?: number;
+}): void;
+//# sourceMappingURL=fuzzyClean.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyClean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzyClean.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyClean.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,QAAQ,CAAC,EACL,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,UAAU,CAAC;IACf,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,GACL,IAAI,CAYN"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyClean.js

@@ -0,0 +1,213 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import buildFuzzyMatchSql from "../helpers/buildFuzzyMatchSql.js";
+export default function fuzzyClean(table, column, newColumn, threshold, options = {}) {
+    // The clustering runs in JS over the fuzzy pairs read from the table, so
+    // fuzzyClean can't be expressed as a single SELECT over its input: it
+    // executes as a barrier.
+    options = structuredClone(options);
+    queueOp(table, {
+        kind: "barrier",
+        method: "fuzzyClean()",
+        parameters: { column, newColumn, threshold, options },
+        execute: () => executeFuzzyClean(table, column, newColumn, threshold, options),
+    });
+}
+async function executeFuzzyClean(table, column, newColumn, threshold, options = {}) {
+    const method = options.method ?? "ratio";
+    const strategy = options.strategy ?? "mostCommon";
+    const { scoreExpression, condition } = buildFuzzyMatchSql("a.value", "b.value", method, threshold, { prefilterPrefixLength: options.prefilterPrefixLength });
+    // Compute fuzzy pairs and embed counts for both sides. Only values that
+    // appear in at least one pair above the threshold can be normalized —
+    // singletons need no processing at all.
+    const pairsData = await queryDB(table, `INSTALL rapidfuzz FROM community; LOAD rapidfuzz;
+     WITH uniques AS (
+       SELECT ${quoteIdentifier(column)} AS value, COUNT(*) AS cnt
+       FROM ${quoteIdentifier(table.name)}
+       WHERE ${quoteIdentifier(column)} IS NOT NULL
+       GROUP BY ${quoteIdentifier(column)}
+     )
+     SELECT
+       a.value AS left_value,
+       b.value AS right_value,
+       a.cnt   AS left_cnt,
+       b.cnt   AS right_cnt,
+       ${scoreExpression} AS score
+     FROM uniques a
+     JOIN uniques b
+       ON ${condition}
+       AND a.value < b.value`, mergeOptions(table, {
+        table: table.name,
+        method: "fuzzyClean()",
+        parameters: { column, newColumn, threshold, options },
+        returnData: true,
+    }));
+    const pairs = pairsData ?? [];
+    if (pairs.length === 0) {
+        if (newColumn !== column) {
+            await queryDB(table, `ALTER TABLE ${quoteIdentifier(table.name)} ADD ${quoteIdentifier(newColumn)} VARCHAR;
+         UPDATE ${quoteIdentifier(table.name)}
+           SET ${quoteIdentifier(newColumn)} = ${quoteIdentifier(column)};`, mergeOptions(table, {
+                table: table.name,
+                method: "fuzzyClean()",
+                parameters: { column, newColumn, threshold, options },
+            }));
+        }
+        return;
+    }
+    // Build count map from the pairs — no separate query needed.
+    const countMap = new Map();
+    for (const { left_value, left_cnt, right_value, right_cnt } of pairs) {
+        countMap.set(left_value, Number(left_cnt));
+        countMap.set(right_value, Number(right_cnt));
+    }
+    // Union-Find — only over values that actually participate in a pair.
+    const parent = new Map();
+    const find = (x) => {
+        if (!parent.has(x))
+            parent.set(x, x);
+        if (parent.get(x) !== x)
+            parent.set(x, find(parent.get(x)));
+        return parent.get(x);
+    };
+    const union = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            parent.set(ra, rb);
+    };
+    for (const v of countMap.keys())
+        find(v);
+    for (const { left_value, right_value } of pairs) {
+        union(left_value, right_value);
+    }
+    // Group values by their cluster root.
+    const clusters = new Map();
+    for (const v of countMap.keys()) {
+        const root = find(v);
+        if (!clusters.has(root))
+            clusters.set(root, []);
+        clusters.get(root).push(v);
+    }
+    // Pick the canonical value for each cluster.
+    const replacement = new Map();
+    for (const members of clusters.values()) {
+        if (members.length === 1)
+            continue; // All pairs are already canonical — skip.
+        // Score sums and per-member max scores are computed lazily — only when
+        // actually needed as a primary criterion or tie-breaker.
+        //
+        // scoreSum: total similarity to all other cluster members (used by
+        //   "mostCentral" as primary, and as tie-breaker for all strategies).
+        // scoreMax: highest single pairwise score (used by "maxScore" as primary).
+        let scoreSum = null;
+        const getScoreSum = () => {
+            if (scoreSum === null) {
+                scoreSum = new Map(members.map((m) => [m, 0]));
+                for (const { left_value, right_value, score } of pairs) {
+                    if (scoreSum.has(left_value) && scoreSum.has(right_value)) {
+                        scoreSum.set(left_value, (scoreSum.get(left_value) ?? 0) + score);
+                        scoreSum.set(right_value, (scoreSum.get(right_value) ?? 0) + score);
+                    }
+                }
+            }
+            return scoreSum;
+        };
+        let scoreMax = null;
+        const getScoreMax = () => {
+            if (scoreMax === null) {
+                scoreMax = new Map(members.map((m) => [m, 0]));
+                for (const { left_value, right_value, score } of pairs) {
+                    if (scoreMax.has(left_value) && scoreMax.has(right_value)) {
+                        scoreMax.set(left_value, Math.max(scoreMax.get(left_value) ?? 0, score));
+                        scoreMax.set(right_value, Math.max(scoreMax.get(right_value) ?? 0, score));
+                    }
+                }
+            }
+            return scoreMax;
+        };
+        // Sum-based comparator: highest total similarity, then alphabetical.
+        const byScore = (a, b) => {
+            const sum = getScoreSum();
+            const sa = sum.get(a) ?? 0;
+            const sb = sum.get(b) ?? 0;
+            if (sa !== sb)
+                return sa > sb ? a : b;
+            return a <= b ? a : b; // alphabetical tie-break
+        };
+        // Max-based comparator: highest single-pair score, then sum, then alphabetical.
+        const byMaxScore = (a, b) => {
+            const mx = getScoreMax();
+            const ma = mx.get(a) ?? 0;
+            const mb = mx.get(b) ?? 0;
+            if (ma !== mb)
+                return ma > mb ? a : b;
+            return byScore(a, b); // sum then alphabetical tie-break
+        };
+        let canonical;
+        if (strategy === "longestString") {
+            canonical = members.reduce((a, b) => {
+                if (a.length !== b.length)
+                    return a.length > b.length ? a : b;
+                return byScore(a, b);
+            });
+        }
+        else if (strategy === "shortestString") {
+            canonical = members.reduce((a, b) => {
+                if (a.length !== b.length)
+                    return a.length < b.length ? a : b;
+                return byScore(a, b);
+            });
+        }
+        else if (strategy === "mostCommon") {
+            canonical = members.reduce((a, b) => {
+                const ca = countMap.get(a) ?? 0;
+                const cb = countMap.get(b) ?? 0;
+                if (ca !== cb)
+                    return ca > cb ? a : b;
+                return byScore(a, b);
+            });
+        }
+        else if (strategy === "mostCentral") {
+            // Most central string — highest total similarity to all other cluster members.
+            canonical = members.reduce((a, b) => byScore(a, b));
+        }
+        else {
+            // "maxScore": the string participating in the single highest-scoring pair.
+            canonical = members.reduce((a, b) => byMaxScore(a, b));
+        }
+        for (const m of members) {
+            if (m !== canonical)
+                replacement.set(m, canonical);
+        }
+    }
+    if (replacement.size === 0)
+        return;
+    // Use a VALUES-based CTE for the UPDATE so DuckDB can use a hash join
+    // instead of evaluating a potentially huge CASE WHEN expression.
+    const replacementEntries = [...replacement.entries()];
+    const valuesList = replacementEntries.map(() => "(?, ?)").join(",\n     ");
+    const values = replacementEntries.flatMap(([from, to]) => [from, to]);
+    const query = newColumn !== column
+        ? `ALTER TABLE ${quoteIdentifier(table.name)} ADD ${quoteIdentifier(newColumn)} VARCHAR;
+       UPDATE ${quoteIdentifier(table.name)}
+         SET ${quoteIdentifier(newColumn)} = ${quoteIdentifier(column)};
+       WITH mapping(original, canonical) AS (VALUES ${valuesList})
+       UPDATE ${quoteIdentifier(table.name)}
+         SET ${quoteIdentifier(newColumn)} = m.canonical
+         FROM mapping m
+         WHERE ${quoteIdentifier(table.name)}.${quoteIdentifier(newColumn)} = m.original`
+        : `WITH mapping(original, canonical) AS (VALUES ${valuesList})
+       UPDATE ${quoteIdentifier(table.name)}
+         SET ${quoteIdentifier(column)} = m.canonical
+         FROM mapping m
+         WHERE ${quoteIdentifier(table.name)}.${quoteIdentifier(column)} = m.original`;
+    await queryDB(table, query, mergeOptions(table, {
+        table: table.name,
+        method: "fuzzyClean()",
+        parameters: { column, newColumn, options },
+        values,
+    }));
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyJoin.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function fuzzyJoin(leftTable: SimpleTable, rightTable: SimpleTable, leftColumn: string, rightColumn: string, threshold: number, options?: {
+    method?: "ratio" | "partial_ratio" | "token_sort_ratio" | "token_set_ratio";
+    similarityColumn?: string;
+    outputTable?: string | boolean;
+    prefilterPrefixLength?: number;
+}): SimpleTable;
+//# sourceMappingURL=fuzzyJoin.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyJoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuzzyJoin.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyJoin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAUvD,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,SAAS,EAAE,WAAW,EACtB,UAAU,EAAE,WAAW,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IACP,MAAM,CAAC,EACH,OAAO,GACP,eAAe,GACf,kBAAkB,GAClB,iBAAiB,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,GACL,WAAW,CAyCb"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/fuzzyJoin.js

@@ -0,0 +1,93 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import getIdenticalColumns from "../helpers/getIdenticalColumns.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+import queueOp from "../helpers/queueOp.js";
+import assertSameDatabase from "../helpers/assertSameDatabase.js";
+import buildFuzzyMatchSql from "../helpers/buildFuzzyMatchSql.js";
+export default function fuzzyJoin(leftTable, rightTable, leftColumn, rightColumn, threshold, options = {}) {
+    assertSameDatabase(leftTable.sdb, [rightTable], "fuzzyJoin()");
+    options = structuredClone(options);
+    // This validation doesn't need the database, so it stays at call time.
+    if (leftColumn === rightColumn) {
+        throw new Error(`The leftColumn and rightColumn have the same name ${quoteIdentifier(leftColumn)}. Rename one of them before doing the fuzzy join.`);
+    }
+    // The output table instance is created at call time so it can be returned
+    // synchronously and chained on right away.
+    const outputTable = typeof options.outputTable === "string"
+        ? leftTable.sdb.newTable(options.outputTable)
+        : leftTable;
+    queueOp(outputTable, {
+        kind: "barrier",
+        method: "fuzzyJoin()",
+        parameters: {
+            leftColumn,
+            rightColumn,
+            rightTable: rightTable.name,
+            threshold,
+            options,
+        },
+        execute: () => executeFuzzyJoin(leftTable, rightTable, outputTable, leftColumn, rightColumn, threshold, options),
+    });
+    return outputTable;
+}
+async function executeFuzzyJoin(leftTable, rightTable, outputTable, leftColumn, rightColumn, threshold, options) {
+    const leftCols = await leftTable.getColumns();
+    const rightCols = await rightTable.getColumns();
+    const identicalColumns = getIdenticalColumns(leftCols, rightCols);
+    // Any column shared between both tables — other than rightColumn (whose
+    // potential _1 duplicate we clean up) — would produce ambiguous output.
+    const identicalColumnsForError = identicalColumns.filter((d) => d !== rightColumn);
+    if (identicalColumnsForError.length > 0) {
+        if (identicalColumnsForError.length === 1) {
+            throw new Error(`The tables have columns with identical names. Rename or remove "${identicalColumnsForError[0]}" in one of the two tables before doing the fuzzy join.`);
+        }
+        else {
+            throw new Error(`The tables have columns with identical names. Rename or remove ${identicalColumnsForError.map((d) => `${quoteIdentifier(d)}`).join(", ")} in one of the two tables before doing the fuzzy join.`);
+        }
+    }
+    const method = options.method ?? "ratio";
+    const similarityColumn = options.similarityColumn;
+    // The right table's copy of a column shared with the left table (only
+    // rightColumn can be shared, checked above) is excluded from the SELECT
+    // directly, instead of dropping its _1 duplicate with a rewrite after the
+    // join.
+    const rightSelect = rightCols
+        .filter((d) => !leftCols.includes(d))
+        .map((d) => `${quoteIdentifier(rightTable.name)}.${quoteIdentifier(d)}`)
+        .join(", ");
+    const sql = `INSTALL rapidfuzz FROM community; LOAD rapidfuzz;\n` +
+        fuzzyJoinQuery(leftTable.name, leftColumn, rightTable.name, rightColumn, method, threshold, outputTable.name, similarityColumn, rightSelect, options.prefilterPrefixLength);
+    await queryDB(leftTable, sql, mergeOptions(leftTable, {
+        table: outputTable.name,
+        method: "fuzzyJoin()",
+        parameters: {
+            leftColumn,
+            rightColumn,
+            rightTable: rightTable.name,
+            threshold,
+            options,
+        },
+    }));
+}
+function fuzzyJoinQuery(leftTable, leftColumn, rightTable, rightColumn, method, threshold, outputTable, similarityColumn, rightSelect, prefilterPrefixLength) {
+    const leftExpression = `${quoteIdentifier(leftTable)}.${quoteIdentifier(leftColumn)}`;
+    const rightExpression = `${quoteIdentifier(rightTable)}.${quoteIdentifier(rightColumn)}`;
+    const { scoreExpression, condition } = buildFuzzyMatchSql(leftExpression, rightExpression, method, threshold, { decimals: 2, prefilterPrefixLength });
+    if (similarityColumn) {
+        return `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable)} AS
+SELECT * EXCLUDE ("_sda_score"), "_sda_score" AS ${quoteIdentifier(similarityColumn)}
+FROM (
+  SELECT ${quoteIdentifier(leftTable)}.*, ${rightSelect}, ${scoreExpression} AS "_sda_score"
+  FROM ${quoteIdentifier(leftTable)} LEFT JOIN ${quoteIdentifier(rightTable)} ON ${condition}
+) _sda
+ORDER BY ${quoteIdentifier(leftColumn)}, "_sda_score" DESC;\n`;
+    }
+    return `CREATE OR REPLACE TABLE ${quoteIdentifier(outputTable)} AS
+SELECT *
+FROM (
+  SELECT ${quoteIdentifier(leftTable)}.*, ${rightSelect}
+  FROM ${quoteIdentifier(leftTable)} LEFT JOIN ${quoteIdentifier(rightTable)} ON ${condition}
+) _sda
+ORDER BY ${quoteIdentifier(leftColumn)}, ${quoteIdentifier(rightColumn)};\n`;
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBottom.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getBottom(simpleTable: SimpleTable, count: number, options?: {
+    originalOrder?: boolean;
+    conditions?: string;
+}): Promise<{
+    [key: string]: unknown;
+}[]>;
+//# sourceMappingURL=getBottom.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBottom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBottom.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBottom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,SAAS,CACrC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CAChB;;KA6BP"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBottom.js

@@ -0,0 +1,23 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getBottom(simpleTable, count, options = {}) {
+    const queryResult = await queryDB(simpleTable, `WITH "numberedRowsForGetBottom" AS (
+                SELECT *, row_number() OVER () as "rowNumberForGetBottom" FROM ${quoteIdentifier(simpleTable.name)}${options.conditions ? ` WHERE ${options.conditions}` : ""}
+            )
+            SELECT * FROM "numberedRowsForGetBottom" ORDER BY "rowNumberForGetBottom" DESC LIMIT ${count};`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        returnData: true,
+        method: "getBottom()",
+        parameters: { count, options },
+    }));
+    if (!queryResult) {
+        throw new Error("The query did not return a result.");
+    }
+    const rowsRaw = queryResult.map((d) => {
+        delete d.rowNumberForGetBottom;
+        return d;
+    });
+    const rows = options.originalOrder ? rowsRaw.reverse() : rowsRaw;
+    return rows;
+}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBoundingBox.d.ts

@@ -0,0 +1,3 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function getBoundingBox(simpleTable: SimpleTable, column?: string): Promise<[number, number, number, number]>;
+//# sourceMappingURL=getBoundingBox.d.ts.map

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBoundingBox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBoundingBox.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBoundingBox.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,cAAc,CAC1C,WAAW,EAAE,WAAW,EACxB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAkB3C"}

package/esm/deps/jsr.io/@nshiab/simple-data-analysis-core/2.0.2/src/methods/getBoundingBox.js

@@ -0,0 +1,19 @@
+import quoteIdentifier from "../helpers/quoteIdentifier.js";
+import findGeoColumn from "../helpers/findGeoColumn.js";
+import mergeOptions from "../helpers/mergeOptions.js";
+import queryDB from "../helpers/queryDB.js";
+export default async function getBoundingBox(simpleTable, column) {
+    const col = column ?? (await findGeoColumn(simpleTable, "getBoundingBox()"));
+    const result = (await queryDB(simpleTable, `SELECT
+                MIN(ST_YMin(${quoteIdentifier(col)})) AS minX,
+                MIN(ST_XMin(${quoteIdentifier(col)})) AS minY,
+                MAX(ST_YMax(${quoteIdentifier(col)})) AS maxX,
+                MAX(ST_XMax(${quoteIdentifier(col)})) AS maxY,
+            from ${quoteIdentifier(simpleTable.name)};`, mergeOptions(simpleTable, {
+        table: simpleTable.name,
+        method: "getBoundingBox()",
+        parameters: { column },
+        returnData: true,
+    })));
+    return [result[0].minY, result[0].minX, result[0].maxY, result[0].maxX];
+}