@walkthru-earth/objex-utils 0.1.0 → 1.1.0

package/dist/index.cjs

@@ -1,6 +1,26 @@
 'use strict';
 
 var apacheArrow = require('apache-arrow');
+var YAML = require('yaml');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var YAML__default = /*#__PURE__*/_interopDefault(YAML);
+
+// ../../src/lib/constants.ts
+var STORAGE_KEYS = {
+  SETTINGS: "obstore-explore-settings",
+  CONNECTIONS: "obstore-explore-connections",
+  QUERY_HISTORY: "obstore-explore-query-history"
+};
+var WGS84_CODES = /* @__PURE__ */ new Set([4326, 4979]);
+var DEFAULT_TARGET_CRS = "EPSG:4326";
+var DUCKDB_INIT_TIMEOUT_MS = 3e4;
+var MAX_QUERY_HISTORY_ENTRIES = 200;
+var SQL_PREVIEW_LENGTH = 120;
+var VIEWER_DIR_EXTENSIONS = /* @__PURE__ */ new Set(["zarr", "zr3"]);
+var LAYER_HUE_MULTIPLIER = 137;
+var COPY_FEEDBACK_MS = 2e3;
 
 // ../../src/lib/file-icons/index.ts
 var DEFAULT_INFO = {
@@ -1000,6 +1020,11 @@ var EXTENSIONS = {
   }
 };
 function getFileTypeInfo(extension, isDir = false) {
+  if (isDir && extension) {
+    const ext2 = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
+    const found = EXTENSIONS[ext2];
+    if (found) return found;
+  }
   if (isDir) return FOLDER_INFO;
   const ext = extension.startsWith(".") ? extension.toLowerCase() : `.${extension.toLowerCase()}`;
   return EXTENSIONS[ext] ?? DEFAULT_INFO;
@@ -1039,6 +1064,304 @@ var QueryCancelledError = class extends Error {
   }
 };
 
+// ../../src/lib/storage/providers.ts
+var PROVIDERS = {
+  s3: {
+    label: "AWS S3",
+    description: "Amazon S3 or any S3-compatible service",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "us-east-1",
+    endpointTemplate: null,
+    regions: [
+      { code: "us-east-1", label: "US East (N. Virginia)" },
+      { code: "us-east-2", label: "US East (Ohio)" },
+      { code: "us-west-1", label: "US West (N. California)" },
+      { code: "us-west-2", label: "US West (Oregon)" },
+      { code: "eu-west-1", label: "EU (Ireland)" },
+      { code: "eu-west-2", label: "EU (London)" },
+      { code: "eu-west-3", label: "EU (Paris)" },
+      { code: "eu-central-1", label: "EU (Frankfurt)" },
+      { code: "eu-central-2", label: "EU (Zurich)" },
+      { code: "eu-north-1", label: "EU (Stockholm)" },
+      { code: "eu-south-1", label: "EU (Milan)" },
+      { code: "eu-south-2", label: "EU (Spain)" },
+      { code: "ap-northeast-1", label: "Asia Pacific (Tokyo)" },
+      { code: "ap-northeast-2", label: "Asia Pacific (Seoul)" },
+      { code: "ap-northeast-3", label: "Asia Pacific (Osaka)" },
+      { code: "ap-southeast-1", label: "Asia Pacific (Singapore)" },
+      { code: "ap-southeast-2", label: "Asia Pacific (Sydney)" },
+      { code: "ap-southeast-3", label: "Asia Pacific (Jakarta)" },
+      { code: "ap-south-1", label: "Asia Pacific (Mumbai)" },
+      { code: "ap-south-2", label: "Asia Pacific (Hyderabad)" },
+      { code: "ap-east-1", label: "Asia Pacific (Hong Kong)" },
+      { code: "sa-east-1", label: "South America (S\xE3o Paulo)" },
+      { code: "ca-central-1", label: "Canada (Central)" },
+      { code: "ca-west-1", label: "Canada (Calgary)" },
+      { code: "me-south-1", label: "Middle East (Bahrain)" },
+      { code: "me-central-1", label: "Middle East (UAE)" },
+      { code: "af-south-1", label: "Africa (Cape Town)" },
+      { code: "il-central-1", label: "Israel (Tel Aviv)" }
+    ],
+    endpointPlaceholder: "Leave empty for AWS, or enter custom S3 endpoint",
+    schemes: ["s3", "s3a", "s3n", "aws"]
+  },
+  gcs: {
+    label: "Google Cloud",
+    description: "Google Cloud Storage",
+    authMethod: "sigv4",
+    needsRegion: false,
+    needsEndpoint: false,
+    defaultRegion: "auto",
+    endpointTemplate: "https://storage.googleapis.com",
+    regions: [],
+    endpointPlaceholder: "https://storage.googleapis.com",
+    schemes: ["gs", "gcs"]
+  },
+  r2: {
+    label: "Cloudflare R2",
+    description: "Cloudflare R2 Storage",
+    authMethod: "sigv4",
+    needsRegion: false,
+    needsEndpoint: true,
+    defaultRegion: "auto",
+    endpointTemplate: null,
+    regions: [],
+    endpointPlaceholder: "https://<account-id>.r2.cloudflarestorage.com",
+    schemes: ["r2"]
+  },
+  azure: {
+    label: "Azure",
+    description: "Azure Blob Storage",
+    authMethod: "sas-token",
+    needsRegion: false,
+    needsEndpoint: true,
+    defaultRegion: "",
+    endpointTemplate: null,
+    regions: [],
+    bucketLabel: "Container",
+    endpointPlaceholder: "https://<account>.blob.core.windows.net",
+    schemes: ["azure", "az", "abfs", "abfss", "wasbs", "adl"]
+  },
+  minio: {
+    label: "MinIO",
+    description: "Self-hosted MinIO or S3-compatible",
+    authMethod: "sigv4",
+    needsRegion: false,
+    needsEndpoint: true,
+    defaultRegion: "us-east-1",
+    endpointTemplate: null,
+    regions: [],
+    endpointPlaceholder: "https://minio.example.com or http://localhost:9000",
+    schemes: []
+  },
+  storj: {
+    label: "Storj",
+    description: "Storj Decentralized Cloud",
+    authMethod: "sigv4",
+    needsRegion: false,
+    needsEndpoint: false,
+    defaultRegion: "us1",
+    endpointTemplate: "https://gateway.storjshare.io",
+    regions: [
+      { code: "us1", label: "US1" },
+      { code: "eu1", label: "EU1" },
+      { code: "ap1", label: "AP1" }
+    ],
+    endpointPlaceholder: "https://gateway.storjshare.io",
+    schemes: ["storj", "sj"]
+  },
+  b2: {
+    label: "Backblaze B2",
+    description: "Backblaze B2 Cloud Storage",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "us-west-004",
+    endpointTemplate: "https://s3.{region}.backblazeb2.com",
+    regions: [
+      { code: "us-west-000", label: "US West (Sacramento)" },
+      { code: "us-west-001", label: "US West (Stockton)" },
+      { code: "us-west-002", label: "US West (Phoenix)" },
+      { code: "us-west-004", label: "US West" },
+      { code: "us-east-005", label: "US East (Reston)" },
+      { code: "eu-central-003", label: "EU Central (Amsterdam)" },
+      { code: "ca-central-001", label: "Canada (Toronto)" }
+    ],
+    endpointPlaceholder: "https://s3.us-west-004.backblazeb2.com",
+    schemes: []
+  },
+  digitalocean: {
+    label: "DigitalOcean",
+    description: "DigitalOcean Spaces",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "nyc3",
+    endpointTemplate: "https://{region}.digitaloceanspaces.com",
+    regions: [
+      { code: "nyc3", label: "New York 3" },
+      { code: "sfo3", label: "San Francisco 3" },
+      { code: "ams3", label: "Amsterdam 3" },
+      { code: "sgp1", label: "Singapore 1" },
+      { code: "lon1", label: "London 1" },
+      { code: "fra1", label: "Frankfurt 1" },
+      { code: "tor1", label: "Toronto 1" },
+      { code: "blr1", label: "Bangalore 1" },
+      { code: "syd1", label: "Sydney 1" }
+    ],
+    endpointPlaceholder: "https://nyc3.digitaloceanspaces.com",
+    schemes: []
+  },
+  wasabi: {
+    label: "Wasabi",
+    description: "Wasabi Hot Cloud Storage",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "us-east-1",
+    endpointTemplate: "https://s3.{region}.wasabisys.com",
+    regions: [
+      { code: "us-east-1", label: "US East 1 (Virginia)" },
+      { code: "us-east-2", label: "US East 2 (Virginia)" },
+      { code: "us-central-1", label: "US Central 1 (Texas)" },
+      { code: "us-west-1", label: "US West 1 (Oregon)" },
+      { code: "eu-central-1", label: "EU Central 1 (Amsterdam)" },
+      { code: "eu-central-2", label: "EU Central 2 (Frankfurt)" },
+      { code: "eu-west-1", label: "EU West 1 (London)" },
+      { code: "eu-west-2", label: "EU West 2 (Paris)" },
+      { code: "ap-northeast-1", label: "AP Northeast 1 (Tokyo)" },
+      { code: "ap-northeast-2", label: "AP Northeast 2 (Osaka)" },
+      { code: "ap-southeast-1", label: "AP Southeast 1 (Singapore)" },
+      { code: "ap-southeast-2", label: "AP Southeast 2 (Sydney)" },
+      { code: "ca-central-1", label: "Canada (Toronto)" }
+    ],
+    endpointPlaceholder: "https://s3.us-east-1.wasabisys.com",
+    schemes: []
+  },
+  contabo: {
+    label: "Contabo",
+    description: "Contabo Object Storage",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "eu2",
+    endpointTemplate: "https://{region}.contabostorage.com",
+    regions: [
+      { code: "eu2", label: "European Union" },
+      { code: "usc1", label: "US Central" },
+      { code: "sin1", label: "Singapore" }
+    ],
+    endpointPlaceholder: "https://eu2.contabostorage.com",
+    schemes: []
+  },
+  hetzner: {
+    label: "Hetzner",
+    description: "Hetzner Object Storage",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "fsn1",
+    endpointTemplate: "https://{region}.your-objectstorage.com",
+    regions: [
+      { code: "fsn1", label: "Falkenstein, DE" },
+      { code: "nbg1", label: "Nuremberg, DE" },
+      { code: "hel1", label: "Helsinki, FI" }
+    ],
+    endpointPlaceholder: "https://fsn1.your-objectstorage.com",
+    schemes: []
+  },
+  linode: {
+    label: "Linode / Akamai",
+    description: "Akamai / Linode Object Storage",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "us-east-1",
+    endpointTemplate: "https://{region}.linodeobjects.com",
+    regions: [
+      { code: "us-east-1", label: "Newark, NJ" },
+      { code: "us-southeast-1", label: "Atlanta, GA" },
+      { code: "us-ord-1", label: "Chicago, IL" },
+      { code: "us-iad-1", label: "Washington, DC" },
+      { code: "us-lax-1", label: "Los Angeles, CA" },
+      { code: "us-sea-1", label: "Seattle, WA" },
+      { code: "us-mia-1", label: "Miami, FL" },
+      { code: "eu-central-1", label: "Frankfurt, DE" },
+      { code: "nl-ams-1", label: "Amsterdam, NL" },
+      { code: "gb-lon-1", label: "London, UK" },
+      { code: "fr-par-1", label: "Paris, FR" },
+      { code: "ap-south-1", label: "Singapore" },
+      { code: "jp-osa-1", label: "Osaka, JP" },
+      { code: "au-mel-1", label: "Melbourne, AU" },
+      { code: "br-gru-1", label: "S\xE3o Paulo, BR" },
+      { code: "in-maa-1", label: "Chennai, IN" },
+      { code: "id-cgk-1", label: "Jakarta, ID" },
+      { code: "it-mil-1", label: "Milan, IT" },
+      { code: "se-sto-1", label: "Stockholm, SE" }
+    ],
+    endpointPlaceholder: "https://us-east-1.linodeobjects.com",
+    schemes: []
+  },
+  ovhcloud: {
+    label: "OVHcloud",
+    description: "OVHcloud Object Storage",
+    authMethod: "sigv4",
+    needsRegion: true,
+    needsEndpoint: false,
+    defaultRegion: "gra",
+    endpointTemplate: "https://s3.{region}.io.cloud.ovh.net",
+    regions: [
+      { code: "gra", label: "Gravelines, FR" },
+      { code: "sbg", label: "Strasbourg, FR" },
+      { code: "bhs", label: "Beauharnois, CA" },
+      { code: "de", label: "Frankfurt, DE" },
+      { code: "uk", label: "London, UK" },
+      { code: "waw", label: "Warsaw, PL" }
+    ],
+    endpointPlaceholder: "https://s3.gra.io.cloud.ovh.net",
+    schemes: []
+  }
+};
+var PROVIDER_IDS = [
+  "s3",
+  "gcs",
+  "r2",
+  "azure",
+  "b2",
+  "digitalocean",
+  "wasabi",
+  "storj",
+  "hetzner",
+  "contabo",
+  "linode",
+  "ovhcloud",
+  "minio"
+];
+function getProvider(id) {
+  return PROVIDERS[id] ?? PROVIDERS.s3;
+}
+function buildEndpointFromTemplate(id, region) {
+  const def = PROVIDERS[id];
+  if (!def?.endpointTemplate) return "";
+  return def.endpointTemplate.replace("{region}", region);
+}
+function buildProviderBaseUrl(provider, endpoint, bucket, region) {
+  if (endpoint) {
+    return `${endpoint.replace(/\/$/, "")}/${bucket}`;
+  }
+  const def = PROVIDERS[provider];
+  if (def?.endpointTemplate) {
+    const resolved = def.endpointTemplate.replace("{region}", region || def.defaultRegion);
+    return `${resolved}/${bucket}`;
+  }
+  return `https://s3.${region || "us-east-1"}.amazonaws.com/${bucket}`;
+}
+function isGcsProvider(provider, endpoint) {
+  return provider === "gcs" || !!endpoint && /storage\.googleapis\.com/i.test(endpoint);
+}
+
 // ../../src/lib/storage/url-adapter.ts
 var UrlAdapter = class {
   supportsWrite = false;
@@ -1084,6 +1407,38 @@ var UrlAdapter = class {
   }
 };
 
+// ../../src/lib/utils/cloud-url.ts
+var AWS_REGION_RE = /^(us|eu|ap|sa|ca|me|af|il)-(north|south|east|west|central|northeast|southeast|northwest|southwest)-\d+/;
+function getNativeScheme(provider) {
+  const def = PROVIDERS[provider];
+  if (def?.schemes.length) return def.schemes[0];
+  return "s3";
+}
+function safeDecodeURIComponent(s) {
+  try {
+    return decodeURIComponent(s);
+  } catch {
+    return s;
+  }
+}
+function resolveCloudUrl(url) {
+  const s3Match = url.match(/^s3[an]?:\/\/([^/]+)\/?(.*)$/);
+  if (s3Match) {
+    const [, bucket, key] = s3Match;
+    const regionMatch = bucket.match(AWS_REGION_RE);
+    const region = regionMatch ? regionMatch[0] : "us-east-1";
+    const base = buildProviderBaseUrl("s3", "", bucket, region);
+    return key ? `${base}/${key}` : base;
+  }
+  const gcsMatch = url.match(/^gcs?:\/\/([^/]+)\/?(.*)$/);
+  if (gcsMatch) {
+    const [, bucket, key] = gcsMatch;
+    const base = buildProviderBaseUrl("gcs", "", bucket, "");
+    return key ? `${base}/${key}` : base;
+  }
+  return url;
+}
+
 // ../../src/lib/utils/column-types.ts
 var NUMBER_TYPES = [
   "TINYINT",
@@ -1200,6 +1555,12 @@ function typeLabel(category) {
   return TYPE_LABELS[category];
 }
 
+// ../../src/lib/utils/error.ts
+function handleLoadError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") return null;
+  return err instanceof Error ? err.message : String(err);
+}
+
 // ../../src/lib/utils/format.ts
 function formatFileSize(bytes) {
   if (bytes < 0) return "0 B";
@@ -1235,6 +1596,81 @@ function getFileExtension(filename) {
   if (lastDot <= 0) return "";
   return filename.slice(lastDot).toLowerCase();
 }
+function jsonReplacerBigInt(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function formatValue(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") return JSON.stringify(value, jsonReplacerBigInt);
+  return String(value);
+}
+
+// ../../src/lib/utils/export.ts
+function formatCellValue(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") return JSON.stringify(value, jsonReplacerBigInt);
+  return String(value);
+}
+function escapeCsvField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function serializeToCsv(columns, rows) {
+  const header = columns.map(escapeCsvField).join(",");
+  const body = rows.map((row) => columns.map((col) => escapeCsvField(formatCellValue(row[col]))).join(",")).join("\n");
+  return `${header}
+${body}`;
+}
+function serializeToJson(columns, rows) {
+  const data = rows.map((row) => {
+    const obj = {};
+    for (const col of columns) {
+      const val = row[col];
+      if (val instanceof Date) {
+        obj[col] = val.toISOString();
+      } else {
+        obj[col] = val ?? null;
+      }
+    }
+    return obj;
+  });
+  return JSON.stringify(data, jsonReplacerBigInt, 2);
+}
+
+// ../../src/lib/utils/file-sort.ts
+function sortFileEntries(entries, config) {
+  const sorted = [...entries];
+  const dir = config.direction === "asc" ? 1 : -1;
+  sorted.sort((a, b) => {
+    if (a.is_dir && !b.is_dir) return -1;
+    if (!a.is_dir && b.is_dir) return 1;
+    switch (config.field) {
+      case "name":
+        return dir * a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+      case "size":
+        return dir * (a.size - b.size);
+      case "modified":
+        return dir * (a.modified - b.modified);
+      case "extension":
+        return dir * a.extension.localeCompare(b.extension, void 0, { sensitivity: "base" });
+      default:
+        return 0;
+    }
+  });
+  return sorted;
+}
+function toggleSortField(current, field) {
+  if (current.field === field) {
+    return { field, direction: current.direction === "asc" ? "desc" : "asc" };
+  }
+  return { field, direction: "asc" };
+}
 function normalizeGeomType(raw) {
   const s = raw.toUpperCase().replace(/\s+/g, "");
   if (s === "POINT") return "point";
@@ -1836,8 +2272,78 @@ function generateHexDump(data, bytesPerRow = 16) {
   return rows;
 }
 
+// ../../src/lib/utils/local-storage.ts
+function loadFromStorage(key, defaultValue) {
+  if (typeof window === "undefined") return defaultValue;
+  try {
+    const raw = localStorage.getItem(key);
+    if (raw) return JSON.parse(raw);
+  } catch {
+  }
+  return defaultValue;
+}
+function persistToStorage(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+function parseMarkdownDocument(markdown) {
+  let frontmatter = {};
+  let content = markdown;
+  const fmMatch = markdown.match(/^---\n([\s\S]*?)\n---\n/);
+  if (fmMatch) {
+    try {
+      frontmatter = YAML__default.default.parse(fmMatch[1]) || {};
+    } catch {
+    }
+    content = markdown.slice(fmMatch[0].length);
+  }
+  const sqlBlocks = [];
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const match = line.match(/^```sql\s+(\w[\w-]*)\s*$/);
+    if (match) {
+      const name = match[1];
+      const startLine = i;
+      const sqlLines = [];
+      i++;
+      while (i < lines.length && lines[i] !== "```") {
+        sqlLines.push(lines[i]);
+        i++;
+      }
+      sqlBlocks.push({
+        name,
+        sql: sqlLines.join("\n"),
+        startLine,
+        endLine: i
+      });
+    }
+    i++;
+  }
+  return { frontmatter, content, sqlBlocks };
+}
+function interpolateTemplates(text, queryResults) {
+  return text.replace(/\{(\w+)\.rows\[(\d+)\]\.(\w+)\}/g, (match, queryName, rowIdx, colName) => {
+    const rows = queryResults.get(queryName);
+    if (!rows) return match;
+    const row = rows[parseInt(rowIdx, 10)];
+    if (!row) return match;
+    const value = row[colName];
+    return value !== void 0 ? String(value) : match;
+  });
+}
+function markSqlBlocks(content) {
+  return content.replace(
+    /```sql\s+(\w[\w-]*)\s*\n([\s\S]*?)```/g,
+    (_, name) => `<div data-sql-block="${name}"></div>`
+  );
+}
+
 // ../../src/lib/utils/parquet-metadata.ts
-var WGS84_CODES = /* @__PURE__ */ new Set([4326, 4979]);
 function mapParquetType(col) {
   const lt = col.logical_type;
   if (lt) {
@@ -1978,24 +2484,18 @@ function extractBounds(geo) {
 }
 
 // ../../src/lib/utils/storage-url.ts
-var SCHEME_MAP = {
-  "s3://": { provider: "s3", strip: 5 },
-  "s3a://": { provider: "s3", strip: 6 },
-  "s3n://": { provider: "s3", strip: 6 },
-  "aws://": { provider: "s3", strip: 6 },
-  "r2://": { provider: "r2", strip: 5 },
-  "gs://": { provider: "gcs", strip: 5 },
-  "gcs://": { provider: "gcs", strip: 6 },
-  "azure://": { provider: "azure", strip: 8 },
-  "az://": { provider: "azure", strip: 5 },
-  "abfs://": { provider: "azure", strip: 7 },
-  "abfss://": { provider: "azure", strip: 8 },
-  "wasbs://": { provider: "azure", strip: 8 },
-  "adl://": { provider: "azure", strip: 6 },
-  "storj://": { provider: "storj", strip: 8 },
-  "sj://": { provider: "storj", strip: 5 },
-  "swift://": { provider: "unknown", strip: 8 }
-};
+function buildSchemeMap() {
+  const map = {};
+  for (const [id, def] of Object.entries(PROVIDERS)) {
+    for (const scheme of def.schemes) {
+      const key = `${scheme}://`;
+      map[key] = { provider: id, strip: key.length };
+    }
+  }
+  map["swift://"] = { provider: "unknown", strip: 8 };
+  return map;
+}
+var SCHEME_MAP = buildSchemeMap();
 function defaultResult(defaults) {
   return {
     bucket: "",
@@ -2100,7 +2600,7 @@ function parseStorageUrl(input, defaults = {}) {
           bucket: doVhost[1],
           region: doVhost[2],
           endpoint: `${url.protocol}//${doVhost[2]}.digitaloceanspaces.com`,
-          provider: "s3",
+          provider: "digitalocean",
           prefix: pathParts.join("/")
         };
       }
@@ -2110,7 +2610,7 @@ function parseStorageUrl(input, defaults = {}) {
           bucket: pathParts[0],
           region: doPath[1],
           endpoint: `${url.protocol}//${url.host}`,
-          provider: "s3",
+          provider: "digitalocean",
           prefix: pathParts.slice(1).join("/")
         };
       }
@@ -2120,7 +2620,7 @@ function parseStorageUrl(input, defaults = {}) {
           bucket: pathParts[0],
           region: wasabiMatch[1],
           endpoint: `${url.protocol}//${url.host}`,
-          provider: "s3",
+          provider: "wasabi",
           prefix: pathParts.slice(1).join("/")
         };
       }
@@ -2130,7 +2630,7 @@ function parseStorageUrl(input, defaults = {}) {
           bucket: b2S3[1],
           region: b2S3[2],
           endpoint: `${url.protocol}//s3.${b2S3[2]}.backblazeb2.com`,
-          provider: "s3",
+          provider: "b2",
           prefix: pathParts.join("/")
         };
       }
@@ -2140,7 +2640,7 @@ function parseStorageUrl(input, defaults = {}) {
           bucket: pathParts[1],
           region: defaults.region || "us-west-000",
           endpoint: `${url.protocol}//${url.host}`,
-          provider: "s3",
+          provider: "b2",
           prefix: pathParts.slice(2).join("/")
         };
       }
@@ -2173,6 +2673,56 @@ function parseStorageUrl(input, defaults = {}) {
           prefix: pathParts.slice(1).join("/")
         };
       }
+      const contaboMatch = host.match(/^([a-z0-9]+)\.contabostorage\.com$/);
+      if (contaboMatch && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: contaboMatch[1],
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "contabo",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      const hetznerMatch = host.match(/^([a-z0-9]+)\.your-objectstorage\.com$/);
+      if (hetznerMatch && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: hetznerMatch[1],
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "hetzner",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      const linodeVhost = host.match(/^(.+)\.([a-z0-9-]+)\.linodeobjects\.com$/);
+      if (linodeVhost) {
+        return {
+          bucket: linodeVhost[1],
+          region: linodeVhost[2],
+          endpoint: `${url.protocol}//${linodeVhost[2]}.linodeobjects.com`,
+          provider: "linode",
+          prefix: pathParts.join("/")
+        };
+      }
+      const linodePath = host.match(/^([a-z0-9-]+)\.linodeobjects\.com$/);
+      if (linodePath && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: linodePath[1],
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "linode",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
+      const ovhMatch = host.match(/^s3\.([a-z0-9-]+)\.io\.cloud\.ovh\.(?:net|us)$/);
+      if (ovhMatch && pathParts.length > 0) {
+        return {
+          bucket: pathParts[0],
+          region: ovhMatch[1],
+          endpoint: `${url.protocol}//${url.host}`,
+          provider: "ovhcloud",
+          prefix: pathParts.slice(1).join("/")
+        };
+      }
       const isMinioLike = host.includes("minio") || host === "localhost" || host === "127.0.0.1" || host.startsWith("192.168.") || host.startsWith("10.");
       if (isMinioLike && pathParts.length > 0) {
         return {
@@ -2509,12 +3059,26 @@ function isWKT(value) {
   return WKT_TYPES.some((t) => s.startsWith(t) || s.startsWith(`MULTI${t}`));
 }
 
+exports.COPY_FEEDBACK_MS = COPY_FEEDBACK_MS;
+exports.DEFAULT_TARGET_CRS = DEFAULT_TARGET_CRS;
+exports.DUCKDB_INIT_TIMEOUT_MS = DUCKDB_INIT_TIMEOUT_MS;
+exports.LAYER_HUE_MULTIPLIER = LAYER_HUE_MULTIPLIER;
+exports.MAX_QUERY_HISTORY_ENTRIES = MAX_QUERY_HISTORY_ENTRIES;
+exports.PROVIDERS = PROVIDERS;
+exports.PROVIDER_IDS = PROVIDER_IDS;
 exports.QueryCancelledError = QueryCancelledError;
+exports.SQL_PREVIEW_LENGTH = SQL_PREVIEW_LENGTH;
+exports.STORAGE_KEYS = STORAGE_KEYS;
 exports.UrlAdapter = UrlAdapter;
+exports.VIEWER_DIR_EXTENSIONS = VIEWER_DIR_EXTENSIONS;
+exports.WGS84_CODES = WGS84_CODES;
 exports.buildDuckDbSource = buildDuckDbSource;
+exports.buildEndpointFromTemplate = buildEndpointFromTemplate;
 exports.buildGeoArrowTables = buildGeoArrowTables;
+exports.buildProviderBaseUrl = buildProviderBaseUrl;
 exports.classifyType = classifyType;
 exports.describeParseResult = describeParseResult;
+exports.escapeCsvField = escapeCsvField;
 exports.extractBounds = extractBounds;
 exports.extractEpsgFromGeoMeta = extractEpsgFromGeoMeta;
 exports.extractGeometryTypes = extractGeometryTypes;
@@ -2522,20 +3086,37 @@ exports.findGeoColumn = findGeoColumn;
 exports.findGeoColumnFromRows = findGeoColumnFromRows;
 exports.formatDate = formatDate;
 exports.formatFileSize = formatFileSize;
+exports.formatValue = formatValue;
 exports.generateHexDump = generateHexDump;
 exports.getDuckDbReadFn = getDuckDbReadFn;
 exports.getFileExtension = getFileExtension;
 exports.getFileTypeInfo = getFileTypeInfo;
 exports.getMimeType = getMimeType;
+exports.getNativeScheme = getNativeScheme;
+exports.getProvider = getProvider;
 exports.getViewerKind = getViewerKind;
+exports.handleLoadError = handleLoadError;
+exports.interpolateTemplates = interpolateTemplates;
 exports.isCloudNativeFormat = isCloudNativeFormat;
+exports.isGcsProvider = isGcsProvider;
 exports.isQueryable = isQueryable;
+exports.jsonReplacerBigInt = jsonReplacerBigInt;
+exports.loadFromStorage = loadFromStorage;
 exports.looksLikeUrl = looksLikeUrl;
+exports.markSqlBlocks = markSqlBlocks;
 exports.normalizeGeomType = normalizeGeomType;
+exports.parseMarkdownDocument = parseMarkdownDocument;
 exports.parseStorageUrl = parseStorageUrl;
 exports.parseWKB = parseWKB;
+exports.persistToStorage = persistToStorage;
 exports.readParquetMetadata = readParquetMetadata;
+exports.resolveCloudUrl = resolveCloudUrl;
+exports.safeDecodeURIComponent = safeDecodeURIComponent;
+exports.serializeToCsv = serializeToCsv;
+exports.serializeToJson = serializeToJson;
+exports.sortFileEntries = sortFileEntries;
 exports.toBinary = toBinary;
+exports.toggleSortField = toggleSortField;
 exports.typeBadgeClass = typeBadgeClass;
 exports.typeColor = typeColor;
 exports.typeLabel = typeLabel;