@gscdump/lakehouse 1.4.0 → 1.4.2

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/s3.mjs

@@ -0,0 +1,91 @@
+import { ByteWriter } from "../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/bytewriter.mjs";
+import "../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+import { signRequest } from "./sigv4.mjs";
+function s3SignedResolver({ accessKeyId, secretAccessKey, sessionToken, region, endpoint, pathStyle = false }) {
+	const ep = endpoint ? new URL(endpoint.replace(/\/$/, "") + "/") : void 0;
+	function toHttps(url) {
+		if (!url.startsWith("s3://") && !url.startsWith("s3a://")) return url;
+		const rest = url.slice(url.indexOf("://") + 3);
+		const slash = rest.indexOf("/");
+		if (slash === -1) throw new Error(`invalid S3 URL: ${url}`);
+		const bucket = rest.slice(0, slash);
+		const key = rest.slice(slash + 1);
+		if (ep) {
+			if (pathStyle) return `${ep.origin}${ep.pathname}${bucket}/${key}`;
+			return `${ep.protocol}//${bucket}.${ep.host}/${key}`;
+		}
+		if (region && region !== "us-east-1" && region !== "auto") return `https://${bucket}.s3.${region}.amazonaws.com/${key}`;
+		return `https://${bucket}.s3.amazonaws.com/${key}`;
+	}
+	function signRequest$1(method, url, body, extra = {}) {
+		return signRequest(method, url, body, {
+			accessKeyId,
+			secretAccessKey,
+			sessionToken,
+			region,
+			service: "s3",
+			extraHeaders: extra
+		});
+	}
+	return {
+		async reader(path, byteLength) {
+			const url = toHttps(path);
+			let len = byteLength;
+			if (len === void 0) {
+				const headers = await signRequest$1("HEAD", url);
+				const res = await fetch(url, {
+					method: "HEAD",
+					headers
+				});
+				if (!res.ok) throw new Error(`HEAD ${path}: ${res.status} ${res.statusText}`);
+				len = Number(res.headers.get("content-length"));
+				if (!Number.isFinite(len)) throw new Error(`HEAD ${path}: missing Content-Length`);
+			}
+			const fileLength = len;
+			return {
+				byteLength: fileLength,
+				async slice(start, end) {
+					const range = `bytes=${start}-${(end ?? fileLength) - 1}`;
+					const headers = await signRequest$1("GET", url, void 0, { range });
+					const res = await fetch(url, {
+						method: "GET",
+						headers
+					});
+					if (!res.ok) throw new Error(`GET ${path} ${range}: ${res.status} ${res.statusText}`);
+					return await res.arrayBuffer();
+				}
+			};
+		},
+		writer(path, options) {
+			const w = new ByteWriter();
+			w.finish = async function() {
+				const url = toHttps(path);
+				const body = w.getBytes().slice();
+				const extra = {};
+				if (options?.ifNoneMatch) extra["if-none-match"] = options.ifNoneMatch;
+				const headers = await signRequest$1("PUT", url, body, extra);
+				const res = await fetch(url, {
+					method: "PUT",
+					headers,
+					body
+				});
+				if (!res.ok) {
+					const err = /* @__PURE__ */ new Error(`PUT ${path}: ${res.status} ${res.statusText}`);
+					err.status = res.status;
+					throw err;
+				}
+			};
+			return w;
+		},
+		async deleter(path) {
+			const url = toHttps(path);
+			const headers = await signRequest$1("DELETE", url);
+			const res = await fetch(url, {
+				method: "DELETE",
+				headers
+			});
+			if (!res.ok && res.status !== 404) throw new Error(`DELETE ${path}: ${res.status} ${res.statusText}`);
+		}
+	};
+}
+export { s3SignedResolver };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/schema.mjs

@@ -0,0 +1,76 @@
+function validateSchemaForVersion(schema, formatVersion) {
+	for (const field of schema.fields) validateFieldForVersion(field, formatVersion, field.name);
+}
+function maxFieldId(fields = []) {
+	let max = 0;
+	for (const field of fields) {
+		if (max < field.id) max = field.id;
+		const nested = maxNestedFieldId(field.type);
+		if (max < nested) max = nested;
+	}
+	return max;
+}
+function maxNestedFieldId(type) {
+	if (typeof type === "string") return 0;
+	if (type.type === "list") {
+		const elementId = type["element-id"] ?? 0;
+		return Math.max(elementId, maxNestedFieldId(type.element));
+	}
+	if (type.type === "map") {
+		const keyId = type["key-id"] ?? 0;
+		const valueId = type["value-id"] ?? 0;
+		return Math.max(keyId, valueId, maxNestedFieldId(type.key), maxNestedFieldId(type.value));
+	}
+	if (type.type === "struct") return maxFieldId(type.fields);
+	return 0;
+}
+const MAX_USER_FIELD_ID = 2147483447;
+function validateFieldForVersion(field, formatVersion, path) {
+	if (typeof field.id === "number" && field.id > MAX_USER_FIELD_ID) throw new Error(`field id ${field.id} is in the reserved range (> ${MAX_USER_FIELD_ID}) (field: ${path})`);
+	if (formatVersion < 3) {
+		checkTypeForV2(field.type, path);
+		if (field["initial-default"] !== void 0) throw new Error(`initial-default requires format-version 3 (field: ${path})`);
+		if (field["write-default"] !== void 0) throw new Error(`write-default requires format-version 3 (field: ${path})`);
+	} else checkV3Default(field, path);
+	checkNestedFieldsForVersion(field.type, formatVersion, path);
+}
+function checkTypeForV2(type, path) {
+	if (typeof type === "string") {
+		if (type === "unknown" || type === "variant" || type === "timestamp_ns" || type === "timestamptz_ns" || type === "geometry" || type.startsWith("geometry(") || type === "geography" || type.startsWith("geography(")) throw new Error(`type ${type} requires format-version 3 (field: ${path})`);
+		return;
+	}
+	if (type.type === "struct") for (const f of type.fields) checkTypeForV2(f.type, `${path}.${f.name}`);
+	else if (type.type === "list") checkTypeForV2(type.element, `${path}.element`);
+	else if (type.type === "map") {
+		checkTypeForV2(type.key, `${path}.key`);
+		checkTypeForV2(type.value, `${path}.value`);
+	}
+}
+function checkV3Default(field, path) {
+	const type = typeName(field.type);
+	if (!requiresNullDefault(type)) return;
+	for (const key of ["initial-default", "write-default"]) if (field[key] != null) throw new Error(`${key} for field ${path} of type ${type} must default to null`);
+}
+function checkNestedFieldsForVersion(type, formatVersion, path) {
+	if (typeof type === "string") return;
+	if (type.type === "struct") for (const f of type.fields) validateFieldForVersion(f, formatVersion, `${path}.${f.name}`);
+	else if (type.type === "list") {
+		checkReservedFieldId(type["element-id"], `${path}.element`);
+		checkNestedFieldsForVersion(type.element, formatVersion, `${path}.element`);
+	} else if (type.type === "map") {
+		checkReservedFieldId(type["key-id"], `${path}.key`);
+		checkReservedFieldId(type["value-id"], `${path}.value`);
+		checkNestedFieldsForVersion(type.key, formatVersion, `${path}.key`);
+		checkNestedFieldsForVersion(type.value, formatVersion, `${path}.value`);
+	}
+}
+function checkReservedFieldId(id, path) {
+	if (typeof id === "number" && id > MAX_USER_FIELD_ID) throw new Error(`field id ${id} is in the reserved range (> ${MAX_USER_FIELD_ID}) (field: ${path})`);
+}
+function typeName(type) {
+	return typeof type === "string" ? type : type.type;
+}
+function requiresNullDefault(type) {
+	return type === "unknown" || type === "variant" || type === "geometry" || type.startsWith("geometry(") || type === "geography" || type.startsWith("geography(");
+}
+export { maxFieldId, typeName, validateSchemaForVersion };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/sigv4.mjs

@@ -0,0 +1,70 @@
+const enc = new TextEncoder();
+async function signRequest(method, url, body, { accessKeyId, secretAccessKey, sessionToken, region, service, extraHeaders = {} }) {
+	const u = new URL(url);
+	const xAmzDate = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]|\.\d{3}/g, "");
+	const dStamp = xAmzDate.slice(0, 8);
+	const payloadHash = body !== void 0 ? await sha256hex(body) : await sha256hex("");
+	const lc = {};
+	for (const [k, v] of Object.entries(extraHeaders)) lc[k.toLowerCase()] = String(v);
+	lc["host"] = u.host;
+	lc["x-amz-date"] = xAmzDate;
+	lc["x-amz-content-sha256"] = payloadHash;
+	if (sessionToken) lc["x-amz-security-token"] = sessionToken;
+	const sortedKeys = Object.keys(lc).sort();
+	const canonicalHeaders = sortedKeys.map((k) => `${k}:${lc[k].trim().replace(/\s+/g, " ")}\n`).join("");
+	const signedHeaders = sortedKeys.join(";");
+	const doubleEncodePath = service !== "s3";
+	const canonicalRequest = [
+		method,
+		u.pathname.split("/").map((seg) => doubleEncodePath ? encodeRfc3986(seg) : encodeRfc3986(decodeURIComponent(seg))).join("/"),
+		[...u.searchParams.entries()].sort((a, b) => {
+			if (a[0] !== b[0]) return a[0] < b[0] ? -1 : 1;
+			return a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0;
+		}).map(([k, v]) => `${encodeRfc3986(k)}=${encodeRfc3986(v)}`).join("&"),
+		canonicalHeaders,
+		signedHeaders,
+		payloadHash
+	].join("\n");
+	const credentialScope = `${dStamp}/${region}/${service}/aws4_request`;
+	const stringToSign = [
+		"AWS4-HMAC-SHA256",
+		xAmzDate,
+		credentialScope,
+		await sha256hex(canonicalRequest)
+	].join("\n");
+	const signature = bytesToHex(await hmac(await deriveSigningKey(secretAccessKey, dStamp, region, service), stringToSign));
+	const out = {};
+	for (const [k, v] of Object.entries(lc)) {
+		if (k === "host") continue;
+		out[k] = v;
+	}
+	out["Authorization"] = `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+	return out;
+}
+async function sha256hex(data) {
+	const bytes = typeof data === "string" ? enc.encode(data) : data;
+	const hash = await crypto.subtle.digest("SHA-256", bytes);
+	return bytesToHex(new Uint8Array(hash));
+}
+async function hmac(key, data) {
+	const keyBytes = typeof key === "string" ? enc.encode(key) : key;
+	const dataBytes = typeof data === "string" ? enc.encode(data) : data;
+	const cryptoKey = await crypto.subtle.importKey("raw", keyBytes, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const sig = await crypto.subtle.sign("HMAC", cryptoKey, dataBytes);
+	return new Uint8Array(sig);
+}
+async function deriveSigningKey(secret, dateStamp, region, service) {
+	return await hmac(await hmac(await hmac(await hmac(`AWS4${secret}`, dateStamp), region), service), "aws4_request");
+}
+function encodeRfc3986(str) {
+	return encodeURIComponent(str).replace(/[!*'()]/g, (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase());
+}
+function bytesToHex(bytes) {
+	let s = "";
+	for (const b of bytes) s += b.toString(16).padStart(2, "0");
+	return s;
+}
+export { signRequest };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/sql/icebergDataSource.mjs

@@ -0,0 +1,8 @@
+import "../fetch.mjs";
+import "../manifest.mjs";
+import "../metadata.mjs";
+import "../read.mjs";
+import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";
+import "../prune.mjs";
+import "./whereFilter.mjs";
+export {};

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/sql/icebergQuery.mjs

@@ -0,0 +1,5 @@
+import "../fetch.mjs";
+import "../catalog/loadTable.mjs";
+import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";
+import "./icebergDataSource.mjs";
+export {};

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/sql/whereFilter.mjs

@@ -0,0 +1 @@
+export {};

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/types.d.mts

@@ -0,0 +1,255 @@
+import { AsyncBuffer } from "../../../../hyparquet@1.26.2/node_modules/hyparquet/types/index.mjs";
+import "../../../../hyparquet@1.26.2/node_modules/hyparquet/types/node.mjs";
+import { Writer } from "../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/index.mjs";
+import "../../../../hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/node.mjs";
+interface WriterOptions {
+  /**
+   * If `'*'`, the writer must create the object only if it does not already
+   * exist (S3 conditional write: `If-None-Match: *`). On collision the
+   * underlying `finish()` rejects with an error whose `status` is 412 (or 409
+   * on some providers). The HTTP/S3 `urlResolver` translates this to the
+   * `If-None-Match` header. Other resolvers may honor or ignore it.
+   */
+  ifNoneMatch?: '*';
+}
+interface Resolver {
+  reader: (path: string, byteLength?: number) => AsyncBuffer | Promise<AsyncBuffer>;
+  writer?: (path: string, options?: WriterOptions) => Writer;
+  deleter?: (path: string) => Promise<void>;
+}
+type Lister = (path: string) => Promise<string[]>;
+/** Catalogs */
+interface RestCatalogContext {
+  type: 'rest';
+  url: string;
+  prefix: string;
+  defaults: Record<string, string>;
+  overrides: Record<string, string>;
+  requestInit?: RequestInit;
+  /** Optional per-request auth hook (e.g. SigV4 signing). Called after merging requestInit. */
+  signRequest?: (url: string, init?: RequestInit) => Promise<RequestInit>;
+}
+interface FileCatalog {
+  type: 'file';
+  resolver: Resolver;
+  lister?: Lister;
+  /**
+   * Opt in to S3-safe metadata commits: every `vN.metadata.json` (the
+   * initial create and every subsequent commit) is written with
+   * `If-None-Match: *` and `version-hint.text` is best-effort. High-level
+   * write functions retry on 412/409 by reloading the latest metadata and
+   * re-staging. `icebergCreateTable` and `icebergTransaction` do not retry.
+   * Default false preserves backwards-compatible (overwrite) behavior.
+   */
+  conditionalCommits?: boolean;
+}
+type Catalog = RestCatalogContext | FileCatalog;
+interface TableIdentifier {
+  namespace: string[];
+  name: string;
+}
+interface LoadTableResponse {
+  metadataLocation?: string;
+  metadata: TableMetadata;
+  config: Record<string, string>;
+}
+interface TableMetadata {
+  'format-version': number;
+  'table-uuid': string;
+  location: string;
+  'last-sequence-number': number; // missing in V1, required in V2+
+  'last-updated-ms': number;
+  'last-column-id': number;
+  'current-schema-id': number; // optional in V1, required in V2+
+  schemas: Schema[]; // optional in V1, required in V2+
+  'default-spec-id': number; // optional in V1, required in V2+
+  'partition-specs': PartitionSpec[]; // optional in V1, required in V2+
+  'last-partition-id': number; // optional in V1, required in V2+
+  properties?: Record<string, string>;
+  'current-snapshot-id'?: number | bigint;
+  snapshots?: Snapshot[];
+  'snapshot-log'?: SnapshotLog[];
+  'metadata-log'?: MetadataLog[];
+  'sort-orders': SortOrder[]; // optional in V1, required in V2+
+  'default-sort-order-id': number; // optional in V1, required in V2+
+  refs?: Record<string, SnapshotRef>;
+  statistics?: TableStatistics[];
+  'partition-statistics'?: PartitionStatistics[];
+  'next-row-id'?: number | bigint; // required in V3
+  'encryption-keys'?: EncryptionKey[]; // V3
+}
+interface Schema {
+  type: 'struct';
+  'schema-id': number;
+  'identifier-field-ids'?: number[];
+  fields: Field[];
+}
+interface Field {
+  id: number;
+  name: string;
+  required: boolean;
+  type: IcebergType;
+  doc?: string;
+  'initial-default'?: any;
+  'write-default'?: any;
+}
+type IcebergType = 'unknown' | 'boolean' | 'int' | 'long' | 'float' | 'double' | 'date' | 'time' | 'timestamp' | 'timestamptz' | 'timestamp_ns' | 'timestamptz_ns' | 'string' | 'uuid' | `fixed[${number}]` | 'binary' | `decimal(${number},${number})` | `decimal(${number}, ${number})` | 'variant' | 'geometry' | `geometry(${string})` | 'geography' | `geography(${string})` | IcebergNestedType;
+type IcebergNestedType = Schema | {
+  type: 'list';
+  'element-id': number;
+  'element-required': boolean;
+  element: IcebergType;
+} | {
+  type: 'map';
+  'key-id': number;
+  key: IcebergType;
+  'value-id': number;
+  'value-required': boolean;
+  value: IcebergType;
+};
+interface PartitionSpec {
+  'spec-id': number;
+  fields: PartitionField[];
+}
+interface PartitionField {
+  'source-id'?: number;
+  'source-ids'?: number[];
+  'field-id': number;
+  name: string;
+  transform: PartitionTransform;
+}
+type PartitionTransform = 'identity' | `bucket[${number}]` | `truncate[${number}]` | 'year' | 'month' | 'day' | 'hour' | 'void' | string;
+interface PartitionStatistics {
+  'snapshot-id': bigint;
+  'statistics-path': string;
+  'file-size-in-bytes': bigint;
+}
+interface SortOrder {
+  'order-id': number;
+  'fields': SortField[];
+}
+interface SortField {
+  transform: string;
+  'source-id'?: number;
+  'source-ids'?: number[]; // V3
+  'direction': 'asc' | 'desc';
+  'null-order': 'nulls-first' | 'nulls-last';
+}
+interface Snapshot {
+  'snapshot-id': number | bigint;
+  'parent-snapshot-id'?: number | bigint;
+  'sequence-number': number;
+  'timestamp-ms': number;
+  'manifest-list': string;
+  manifests?: Manifest[];
+  summary: {
+    // spec: "value of these fields should be of string type"
+    operation: string;
+    // 'spark.app.id'?: string
+    'added-data-files'?: string;
+    'added-records'?: string;
+    'deleted-data-files'?: string;
+    'deleted-records'?: string;
+    'removed-files-size'?: string;
+    'added-delete-files'?: string;
+    'removed-delete-files'?: string;
+    'added-position-deletes'?: string;
+    'removed-position-deletes'?: string;
+    'added-equality-deletes'?: string;
+    'removed-equality-deletes'?: string;
+    'added-dvs'?: string;
+    'removed-dvs'?: string;
+    'added-files-size'?: string;
+    'changed-partition-count'?: string;
+    'total-records'?: string;
+    'total-files-size'?: string;
+    'total-data-files'?: string;
+    'total-delete-files'?: string;
+    'total-position-deletes'?: string;
+    'total-equality-deletes'?: string;
+  };
+  'schema-id'?: number;
+  'first-row-id'?: number; // V3
+  'added-rows'?: number; // V3
+  'key-id'?: string; // V3
+}
+interface TableStatistics {
+  'snapshot-id': number | bigint;
+  'statistics-path': string;
+  'file-size-in-bytes': bigint;
+  'file-footer-size-in-bytes': bigint;
+}
+interface SnapshotLog {
+  'timestamp-ms': number;
+  'snapshot-id': number | bigint;
+}
+interface SnapshotRef {
+  'snapshot-id': number | bigint;
+  type: 'branch' | 'tag';
+  'min-snapshots-to-keep'?: number;
+  'max-snapshot-age-ms'?: number;
+  'max-ref-age-ms'?: number;
+}
+interface EncryptionKey {
+  'key-id': string;
+  'key-metadata': string;
+}
+interface MetadataLog {
+  'timestamp-ms': number;
+  'metadata-file': string;
+}
+interface Manifest {
+  manifest_path: string;
+  manifest_length: bigint;
+  partition_spec_id: number;
+  content: 0 | 1; // 0=data, 1=deletes
+  sequence_number?: bigint;
+  min_sequence_number?: bigint;
+  added_snapshot_id: bigint;
+  added_files_count: number;
+  existing_files_count: number;
+  deleted_files_count: number;
+  added_rows_count: bigint;
+  existing_rows_count: bigint;
+  deleted_rows_count: bigint;
+  partitions?: FieldSummary[];
+  // key_metadata?: unknown
+  first_row_id?: bigint | number;
+}
+interface ManifestEntry {
+  status: 0 | 1 | 2; // 0=existing, 1=added, 2=deleted
+  snapshot_id?: bigint;
+  sequence_number?: bigint;
+  file_sequence_number?: bigint;
+  partition_spec_id?: number;
+  data_file: DataFile;
+}
+interface FieldSummary {
+  contains_null: boolean;
+  contains_nan?: boolean | null;
+  lower_bound?: Uint8Array | null;
+  upper_bound?: Uint8Array | null;
+}
+interface DataFile {
+  content: 0 | 1 | 2; // 0=data, 1=position_delete, 2=equality_delete
+  file_path: string;
+  file_format: 'avro' | 'orc' | 'parquet' | 'puffin';
+  partition: Record<string, unknown>; // keyed by partition-field name in Avro
+  record_count: bigint;
+  file_size_in_bytes: bigint;
+  column_sizes?: Record<number, bigint>;
+  value_counts?: Record<number, bigint>;
+  null_value_counts?: Record<number, bigint>;
+  nan_value_counts?: Record<number, bigint>;
+  lower_bounds?: Record<number, unknown>;
+  upper_bounds?: Record<number, unknown>;
+  // key_metadata?: string
+  split_offsets?: bigint[];
+  equality_ids?: number[];
+  sort_order_id?: number;
+  first_row_id?: bigint | number;
+  referenced_data_file?: string;
+  content_offset?: bigint;
+  content_size_in_bytes?: bigint;
+}
+export { Catalog, DataFile, Field, FileCatalog, IcebergNestedType, IcebergType, Lister, LoadTableResponse, Manifest, ManifestEntry, PartitionSpec, PartitionTransform, Resolver, RestCatalogContext, Schema, Snapshot, SnapshotRef, SortOrder, TableIdentifier, TableMetadata, WriterOptions };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/utils.mjs

@@ -0,0 +1,45 @@
+function sanitize(name) {
+	let result = "";
+	for (let i = 0; i < name.length; i++) {
+		const ch = name.charAt(i);
+		const isLetter = /^[A-Za-z]$/.test(ch);
+		const isDigit = /^[0-9]$/.test(ch);
+		if (i === 0) if (isLetter || ch === "_") result += ch;
+		else result += isDigit ? "_" + ch : "_x" + ch.charCodeAt(0).toString(16).toUpperCase();
+		else if (isLetter || isDigit || ch === "_") result += ch;
+		else result += "_x" + ch.charCodeAt(0).toString(16).toUpperCase();
+	}
+	return result;
+}
+function equalityMatch(row, deletePredicate, columnNamesById) {
+	for (const key of Object.keys(deletePredicate)) {
+		const columnName = columnNamesById ? columnNamesById[Number(key)] : key;
+		if (columnName === "file_path" || columnName === "pos") continue;
+		if (!columnName) return false;
+		if (!valuesEqual(row[columnName], deletePredicate[key])) return false;
+	}
+	return true;
+}
+function valuesEqual(a, b) {
+	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (a instanceof Uint8Array && b instanceof Uint8Array) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+		return true;
+	}
+	return a === b;
+}
+function bytesToHex(bytes) {
+	let hex = "";
+	for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
+	return hex;
+}
+function uuid4() {
+	if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+export { bytesToHex, equalityMatch, sanitize, uuid4, valuesEqual };