@gscdump/lakehouse 1.4.0 → 1.4.1

package/dist/index.mjs

@@ -1,363 +1,7 @@
 import { bigintJsonReplacer, coerceBigIntToNumber, encodeJsonBigintSafe, stringifyBigintSafe } from "./bigint.mjs";
-import { icebergCreateTable } from "./_chunks/libs/icebird.mjs";
-import { ICEBERG_TYPE_MAP, buildManifestPartitionFilter, cacheGet, cachePut, catalogCacheScope, connectIcebergCatalog, dropIcebergTables, ensureIcebergNamespace, icebergAppendBatchesRetrying, icebergAppendRetrying, invalidateSnapshotRef, listIcebergTables, resolveIcebergDataFiles } from "./_chunks/catalog.mjs";
+import { cacheGet, cachePut } from "./catalog-cache.mjs";
+import { buildManifestPartitionFilter } from "./partition-prune.mjs";
+import { ICEBERG_TYPE_MAP, catalogCacheScope, connectIcebergCatalog, dropIcebergTables, ensureIcebergNamespace, invalidateSnapshotRef, listIcebergTables, resolveIcebergDataFiles } from "./catalog.mjs";
+import { defineIcebergDataset, deriveTableSpec, toIcebergDayCount } from "./dataset.mjs";
 import { DEFAULT_PARTITION_KEY_ENCODING } from "./schema.mjs";
-const INT32_MIN = -2147483648;
-const INT32_MAX = 2147483647;
-const DAY_MILLIS = 864e5;
-function identityColumnNames(identity) {
-	return identity.kind === "site-int" ? ["site_id"] : identity.columns.map((c) => c.name);
-}
-function identityEncodings(identity) {
-	const map = /* @__PURE__ */ new Map();
-	if (identity.kind === "site-int") map.set("site_id", (identity.encoding ?? "int") === "int" ? "int32" : "string");
-	else for (const c of identity.columns) map.set(c.name, c.encoding);
-	return map;
-}
-function identityColumnType(encoding) {
-	return encoding === "int32" ? "INT" : "STRING";
-}
-function deriveTableSpec(def) {
-	const encodings = identityEncodings(def.identity);
-	const idNames = identityColumnNames(def.identity);
-	const dimNames = def.dims ? Object.keys(def.dims) : [];
-	let fieldId = 1;
-	const columns = [];
-	for (const name of idNames) columns.push({
-		name,
-		type: identityColumnType(encodings.get(name)),
-		required: true,
-		fieldId: fieldId++
-	});
-	for (const name of dimNames) {
-		const enc = def.dims[name].boundEncoding;
-		columns.push({
-			name,
-			type: identityColumnType(enc),
-			required: true,
-			fieldId: fieldId++
-		});
-	}
-	for (const col of def.columns) columns.push({
-		name: col.name,
-		type: col.type,
-		required: col.required,
-		fieldId: fieldId++
-	});
-	return {
-		namespace: def.namespace,
-		table: def.table,
-		columns,
-		partitionSpec: def.partition,
-		naturalKey: def.naturalKey,
-		identityColumns: [
-			...idNames,
-			...dimNames,
-			...def.naturalKey
-		],
-		clusterKey: def.clusterKey
-	};
-}
-function icebergSchemaFromSpec(spec) {
-	return {
-		"type": "struct",
-		"schema-id": 0,
-		"fields": spec.columns.map((col) => ({
-			id: col.fieldId,
-			name: col.name,
-			required: col.required,
-			type: ICEBERG_TYPE_MAP[col.type]
-		}))
-	};
-}
-function icebergPartitionSpecFromSpec(spec) {
-	const fieldId = (name) => {
-		const col = spec.columns.find((c) => c.name === name);
-		if (!col) throw new Error(`lakehouse: table '${spec.table}' has no '${name}' column`);
-		return col.fieldId;
-	};
-	return {
-		"spec-id": 0,
-		"fields": spec.partitionSpec.map((p, i) => ({
-			"source-id": fieldId(p.sourceColumn),
-			"field-id": 1e3 + i,
-			"name": p.name,
-			"transform": p.transform
-		}))
-	};
-}
-function icebergSortOrderFromSpec(spec) {
-	if (!spec.clusterKey || spec.clusterKey.length === 0) return void 0;
-	const fieldId = (name) => {
-		const col = spec.columns.find((c) => c.name === name);
-		if (!col) throw new Error(`lakehouse: table '${spec.table}' has no '${name}' column`);
-		return col.fieldId;
-	};
-	return {
-		"order-id": 1,
-		"fields": spec.clusterKey.map((col) => ({
-			"source-id": fieldId(col),
-			"transform": "identity",
-			"direction": "asc",
-			"null-order": "nulls-last"
-		}))
-	};
-}
-function toIcebergDayCount(value) {
-	if (typeof value === "number") return value;
-	if (value instanceof Date) {
-		const ms = value.getTime();
-		if (Number.isNaN(ms)) throw new TypeError("toIcebergDayCount: invalid Date (NaN)");
-		return Math.floor(ms / DAY_MILLIS);
-	}
-	const ms = Date.parse(`${value}T00:00:00Z`);
-	if (Number.isNaN(ms)) throw new TypeError(`toIcebergDayCount: invalid date string '${value}'`);
-	return Math.floor(ms / DAY_MILLIS);
-}
-function asInt32(value) {
-	if (typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint") return null;
-	const n = Number(value);
-	if (!Number.isSafeInteger(n) || n < INT32_MIN || n > INT32_MAX) return null;
-	return n;
-}
-function buildRowProcessor(def, tableSpec) {
-	const idNames = identityColumnNames(def.identity);
-	const idEncodings = identityEncodings(def.identity);
-	const dimNames = def.dims ? Object.keys(def.dims) : [];
-	const identityColumns = tableSpec.identityColumns;
-	function guard(row) {
-		const out = {};
-		for (const name of idNames) {
-			const enc = idEncodings.get(name);
-			const raw = row[name];
-			if (enc === "int32") {
-				const n = asInt32(raw);
-				if (n === null) return null;
-				out[name] = n;
-			} else {
-				if (raw == null || raw === "") return null;
-				out[name] = String(raw);
-			}
-		}
-		for (const name of dimNames) out[name] = def.dims[name].toPartitionValue(String(row[name]));
-		for (const col of def.columns) {
-			const value = row[col.name];
-			out[col.name] = col.type === "LONG" ? typeof value === "number" ? BigInt(value) : value : coerceBigIntToNumber(value);
-		}
-		return out;
-	}
-	function dedupe(rows) {
-		if (rows.length < 2) return rows;
-		const seen = /* @__PURE__ */ new Map();
-		for (const rec of rows) {
-			let identity = "";
-			for (let index = 0; index < identityColumns.length; index++) {
-				if (index > 0) identity += "\0";
-				identity += `${rec[identityColumns[index]] ?? ""}`;
-			}
-			seen.set(identity, rec);
-		}
-		return seen.size === rows.length ? rows : [...seen.values()];
-	}
-	function sort(rows) {
-		const cols = def.clusterKey;
-		if (!cols || cols.length === 0 || rows.length < 2) return rows;
-		return rows.slice().sort((a, b) => {
-			for (const col of cols) {
-				const av = a[col];
-				const bv = b[col];
-				if (av === bv) continue;
-				if (av == null) return -1;
-				if (bv == null) return 1;
-				if (typeof av === "number" && typeof bv === "number") return av - bv;
-				const as = String(av);
-				const bs = String(bv);
-				if (as !== bs) return as < bs ? -1 : 1;
-			}
-			return 0;
-		});
-	}
-	return {
-		guard,
-		dedupe,
-		sort
-	};
-}
-function defineIcebergDataset(def) {
-	const tableSpec = deriveTableSpec(def);
-	const schema = icebergSchemaFromSpec(tableSpec);
-	const partitionSpecIcebird = icebergPartitionSpecFromSpec(tableSpec);
-	const sortOrder = icebergSortOrderFromSpec(tableSpec);
-	const { guard, dedupe, sort } = buildRowProcessor(def, tableSpec);
-	async function createTable(conn) {
-		const results = [];
-		await icebergCreateTable({
-			catalog: conn.catalog,
-			namespace: conn.namespace,
-			table: def.table,
-			schema,
-			partitionSpec: partitionSpecIcebird,
-			...sortOrder ? { sortOrder } : {}
-		}).then(() => results.push({
-			table: def.table,
-			ok: true
-		}), (e) => results.push({
-			table: def.table,
-			ok: false,
-			error: e instanceof Error ? e.message : String(e)
-		}));
-		return results;
-	}
-	function process(rows) {
-		const guarded = [];
-		let skipped = 0;
-		for (const row of rows) {
-			const rec = guard(row);
-			if (rec === null) skipped++;
-			else guarded.push(rec);
-		}
-		return {
-			records: sort(dedupe(guarded)),
-			skipped
-		};
-	}
-	async function appendRows(conn, rows, opts = {}) {
-		if (rows.length === 0) return {
-			accepted: 0,
-			skipped: 0
-		};
-		const { records, skipped } = process(rows);
-		if (records.length === 0) return {
-			accepted: 0,
-			skipped
-		};
-		await icebergAppendRetrying({
-			catalog: conn.catalog,
-			namespace: conn.namespace,
-			table: def.table,
-			resolver: conn.resolver,
-			records
-		}, opts.commitRetry);
-		return {
-			accepted: records.length,
-			skipped
-		};
-	}
-	async function appendBatches(conn, source, opts) {
-		let accepted = 0;
-		let skipped = 0;
-		const batchFactory = async function* () {
-			accepted = 0;
-			skipped = 0;
-			for await (const rows of source()) {
-				const prepared = process(rows);
-				accepted += prepared.records.length;
-				skipped += prepared.skipped;
-				if (prepared.records.length > 0) yield prepared.records;
-			}
-		};
-		const committed = await icebergAppendBatchesRetrying({
-			catalog: conn.catalog,
-			namespace: conn.namespace,
-			table: def.table,
-			resolver: conn.resolver,
-			batchFactory
-		}, {
-			...opts.commitRetry,
-			appendId: opts.appendId
-		});
-		return {
-			accepted,
-			skipped,
-			committed
-		};
-	}
-	function appendSink(opts) {
-		let buffer = [];
-		let connection;
-		function connect() {
-			connection ??= connectIcebergCatalog(opts.catalog, opts.connect).then(async (conn) => {
-				await ensureIcebergNamespace(conn);
-				return conn;
-			});
-			return connection;
-		}
-		return {
-			emit(rows) {
-				for (const r of rows) buffer.push(r);
-			},
-			async close() {
-				if (buffer.length === 0) return {
-					flushed: false,
-					accepted: 0,
-					skipped: 0
-				};
-				const rows = buffer;
-				buffer = [];
-				try {
-					const result = await appendRows(await connect(), rows, { commitRetry: opts.commitRetry });
-					if (result.accepted > 0 && opts.ledger) await opts.ledger.record();
-					return {
-						flushed: result.accepted > 0,
-						...result
-					};
-				} catch (error) {
-					return {
-						flushed: false,
-						accepted: 0,
-						skipped: 0,
-						error
-					};
-				}
-			}
-		};
-	}
-	function readerPredicate(identity, dims) {
-		const idNames = identityColumnNames(def.identity);
-		const idEncodings = identityEncodings(def.identity);
-		const matches = idNames.map((name) => ({
-			field: name,
-			value: idEncodings.get(name) === "int32" ? Number(identity) : identity,
-			encoding: idEncodings.get(name) === "int32" ? "int32" : "string"
-		}));
-		if (def.dims && dims) {
-			for (const [name, dim] of Object.entries(def.dims)) if (name in dims) matches.push({
-				field: name,
-				value: dim.toPartitionValue(dims[name]),
-				encoding: dim.boundEncoding
-			});
-		}
-		return matches;
-	}
-	function partitionBoundFilter(identity, months, dims) {
-		return buildManifestPartitionFilter(def.partition, readerPredicate(identity, dims), months);
-	}
-	async function resolveDataFiles(conn, identity, range, dims, opts = {}) {
-		return resolveIcebergDataFiles(conn, {
-			namespace: def.namespace,
-			table: def.table,
-			partitionSpec: def.partition,
-			matches: readerPredicate(identity, dims),
-			range,
-			cache: opts.cache,
-			clock: opts.clock,
-			profiler: opts.profiler
-		});
-	}
-	return {
-		def,
-		tableSpec,
-		icebergSchema: () => schema,
-		icebergPartitionSpec: () => partitionSpecIcebird,
-		icebergSortOrder: () => sortOrder,
-		createTable,
-		appendRows,
-		appendBatches,
-		prepareRows: process,
-		appendSink,
-		readerPredicate,
-		partitionBoundFilter,
-		resolveDataFiles
-	};
-}
 export { DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_TYPE_MAP, bigintJsonReplacer, buildManifestPartitionFilter, cacheGet, cachePut, catalogCacheScope, coerceBigIntToNumber, connectIcebergCatalog, defineIcebergDataset, deriveTableSpec, dropIcebergTables, encodeJsonBigintSafe, ensureIcebergNamespace, invalidateSnapshotRef, listIcebergTables, resolveIcebergDataFiles, stringifyBigintSafe, toIcebergDayCount };

package/dist/maintenance.d.mts

@@ -1,94 +1,3 @@
-import { IcebergConnection, isCommitRateLimited } from "./_chunks/catalog.mjs";
-/** One listed object under a data prefix. */
-interface SweepListedObject {
-  key: string;
-  uploaded: Date;
-}
-/** One page of a prefix listing. */
-interface SweepListPage {
-  objects: readonly SweepListedObject[];
-  truncated: boolean;
-  cursor?: string;
-}
-/**
- * Minimal storage client `sweepUncommittedOrphans` needs: list-by-prefix +
- * batch delete against the warehouse bucket. Deliberately NOT an S3 SDK
- * client shape — this interface is structurally satisfied by Cloudflare's
- * native `R2Bucket` Workers binding (`env.R2_ANALYTICS.list({ prefix })` /
- * `env.R2_ANALYTICS.delete(keys)`), so a caller running inside a Worker can
- * pass the binding straight through with no adapter. Any other
- * S3-compatible client can be wrapped to this shape.
- */
-interface SweepStorageClient {
-  list: (options: {
-    prefix: string;
-    cursor?: string;
-  }) => Promise<SweepListPage>;
-  delete: (keys: string[]) => Promise<void>;
-}
-interface SweepUncommittedOrphansOptions {
-  conn: IcebergConnection;
-  s3: SweepStorageClient;
-  /**
-   * Bare R2 bucket name backing `conn`'s warehouse. Every scanned table's
-   * `location` must resolve into this exact bucket; a table whose location
-   * points elsewhere is SKIPPED — never guessed at, never touched.
-   */
-  bucket: string;
-  /**
-   * Restrict the sweep to these tables; defaults to every table currently
-   * in `conn.namespace` (`conn` already carries the namespace scope, so
-   * there's no separate `namespace` field here).
-   */
-  tables?: readonly string[];
-  /** Only delete objects older than this many hours. Default 48. */
-  graceHours?: number;
-  /** Hard cap on deletions in one run. Default 500. */
-  maxDeletes?: number;
-  /** Compute the delete set but never call `s3.delete`. Default false. */
-  dryRun?: boolean;
-  /** Injectable clock (ms epoch). Defaults to `Date.now`. */
-  now?: () => number;
-  /** Maximum catalog/object-store reads held in flight. Default 4, max 32. */
-  ioConcurrency?: number;
-}
-interface SweepUncommittedOrphansResult {
-  /** Tables whose retained snapshots were successfully walked. */
-  scannedTables: string[];
-  /** Tables skipped because their `location` didn't resolve into `bucket` — never scanned, never touched. */
-  skippedTables: string[];
-  /** Count of live (referenced-by-some-retained-snapshot) files found across `scannedTables`. */
-  liveFileCount: number;
-  /** Objects under a scanned table's data prefix with no snapshot reference anywhere, past `graceHours`. */
-  candidateCount: number;
-  /** Keys deleted (or, under `dryRun`, that WOULD be deleted). */
-  deleted: string[];
-  dryRun: boolean;
-  /** True when `candidateCount` exceeded `maxDeletes` — remaining orphans are left for the next run. */
-  cappedAtLimit: boolean;
-  /** Set when the sweep did nothing because the table scope listed zero tables (fail-closed — see class docs). */
-  reason?: 'zero-tables';
-}
-/**
- * Sweep data files written under a table's `data/` prefix that were NEVER
- * referenced by any snapshot the catalog still retains — a crashed/partial
- * writer's leftovers. This is the one orphan class Cloudflare's own R2 Data
- * Catalog snapshot-expiration GC does not cover.
- *
- * HARD SAFETY:
- * - A listing failure (table load / manifest walk throwing) PROPAGATES.
- *   It is never caught and treated as "no live files" — that would make
- *   every real data file look orphaned. Callers must let this reject and
- *   must not proceed to delete on catch.
- * - Zero tables in scope is treated as "couldn't determine what's live",
- *   not "nothing to protect" — the sweep no-ops with `reason: 'zero-tables'`
- *   rather than listing/deleting anything.
- * - Deletions are capped at `maxDeletes` per run (default 500).
- * - `dryRun` computes the exact candidate set without ever calling `s3.delete`.
- * - Only ever lists/deletes keys under a scanned table's own
- *   `<table.location>/data/` prefix, and every candidate is re-checked to
- *   actually start with that prefix before being considered for deletion —
- *   never a bare bucket-root listing, never a key outside a data prefix.
- */
-declare function sweepUncommittedOrphans(opts: SweepUncommittedOrphansOptions): Promise<SweepUncommittedOrphansResult>;
+import { isCommitRateLimited } from "./catalog.mjs";
+import { SweepListPage, SweepListedObject, SweepStorageClient, SweepUncommittedOrphansOptions, SweepUncommittedOrphansResult, sweepUncommittedOrphans } from "./orphan-sweep.mjs";
 export { type SweepListPage, type SweepListedObject, type SweepStorageClient, type SweepUncommittedOrphansOptions, type SweepUncommittedOrphansResult, isCommitRateLimited, sweepUncommittedOrphans };

package/dist/maintenance.mjs

@@ -1,140 +1,3 @@
-import { icebergManifests, restCatalogListTables, restCatalogLoadTable } from "./_chunks/libs/icebird.mjs";
-import { isCommitRateLimited } from "./_chunks/catalog.mjs";
-const DEFAULT_GRACE_HOURS = 48;
-const DEFAULT_MAX_DELETES = 500;
-const DEFAULT_IO_CONCURRENCY = 4;
-const MAX_IO_CONCURRENCY = 32;
-const HOUR_MS = 3600 * 1e3;
-function createIoLimiter(requested) {
-	const concurrency = typeof requested === "number" && Number.isFinite(requested) ? Math.max(1, Math.min(MAX_IO_CONCURRENCY, Math.floor(requested))) : DEFAULT_IO_CONCURRENCY;
-	let active = 0;
-	const waiters = [];
-	return async (operation) => {
-		if (active >= concurrency) await new Promise((resolve) => waiters.push(resolve));
-		active++;
-		try {
-			return await operation();
-		} finally {
-			active--;
-			waiters.shift()?.();
-		}
-	};
-}
-async function settleOrThrow(promises) {
-	const settled = await Promise.allSettled(promises);
-	const failure = settled.find((result) => result.status === "rejected");
-	if (failure) throw failure.reason;
-	return settled.map((result) => result.value);
-}
-function splitBucketKey(filePath) {
-	if (!filePath.startsWith("s3://")) return null;
-	const rest = filePath.slice(5);
-	const slash = rest.indexOf("/");
-	if (slash < 0) return null;
-	return {
-		bucket: rest.slice(0, slash),
-		key: rest.slice(slash + 1)
-	};
-}
-async function scanTable(conn, table, bucket, io) {
-	const { metadata } = await io(() => restCatalogLoadTable(conn.catalog, {
-		namespace: conn.namespace,
-		table
-	}));
-	const location = splitBucketKey(String(metadata.location ?? ""));
-	if (!location || location.bucket !== bucket) return {
-		dataPrefix: null,
-		liveKeys: /* @__PURE__ */ new Set()
-	};
-	const dataPrefix = `${location.key.replace(/\/+$/, "")}/data/`;
-	const liveKeys = /* @__PURE__ */ new Set();
-	const manifestsBySnapshot = await settleOrThrow((metadata.snapshots ?? []).map((snapshot) => io(() => icebergManifests({
-		metadata,
-		resolver: conn.resolver,
-		snapshotId: snapshot["snapshot-id"]
-	}))));
-	for (const manifests of manifestsBySnapshot) for (const manifest of manifests) for (const entry of manifest.entries) {
-		if (entry.status === 2) continue;
-		const filePath = entry.data_file?.file_path;
-		if (!filePath) continue;
-		const parsed = splitBucketKey(filePath);
-		if (parsed && parsed.bucket === bucket) liveKeys.add(parsed.key);
-	}
-	return {
-		dataPrefix,
-		liveKeys
-	};
-}
-async function listAllUnderPrefix(s3, prefix, io) {
-	const out = [];
-	let cursor;
-	do {
-		const page = await io(() => s3.list({
-			prefix,
-			cursor
-		}));
-		out.push(...page.objects);
-		cursor = page.truncated ? page.cursor : void 0;
-	} while (cursor);
-	return out;
-}
-async function sweepUncommittedOrphans(opts) {
-	const { conn, s3, bucket } = opts;
-	const graceHours = opts.graceHours ?? DEFAULT_GRACE_HOURS;
-	const maxDeletes = opts.maxDeletes ?? DEFAULT_MAX_DELETES;
-	const dryRun = opts.dryRun ?? false;
-	const graceCutoff = (opts.now ?? Date.now)() - graceHours * HOUR_MS;
-	const io = createIoLimiter(opts.ioConcurrency);
-	const tables = opts.tables ?? (await io(() => restCatalogListTables(conn.catalog, { namespace: conn.namespace }))).map((t) => t.name);
-	if (tables.length === 0) return {
-		scannedTables: [],
-		skippedTables: [],
-		liveFileCount: 0,
-		candidateCount: 0,
-		deleted: [],
-		dryRun,
-		cappedAtLimit: false,
-		reason: "zero-tables"
-	};
-	const tableResults = await settleOrThrow(tables.map(async (table) => {
-		const { dataPrefix, liveKeys } = await scanTable(conn, table, bucket, io);
-		if (!dataPrefix) return {
-			table,
-			skipped: true,
-			liveFileCount: 0,
-			candidates: []
-		};
-		const listed = await listAllUnderPrefix(s3, dataPrefix, io);
-		const tableCandidates = [];
-		for (const obj of listed) {
-			if (!obj.key.startsWith(dataPrefix)) continue;
-			if (liveKeys.has(obj.key)) continue;
-			if (obj.uploaded.getTime() > graceCutoff) continue;
-			tableCandidates.push(obj);
-		}
-		return {
-			table,
-			skipped: false,
-			liveFileCount: liveKeys.size,
-			candidates: tableCandidates
-		};
-	}));
-	const scannedTables = tableResults.filter((result) => !result.skipped).map((result) => result.table);
-	const skippedTables = tableResults.filter((result) => result.skipped).map((result) => result.table);
-	const liveFileCount = tableResults.reduce((sum, result) => sum + result.liveFileCount, 0);
-	const candidates = tableResults.flatMap((result) => result.candidates);
-	const candidateCount = candidates.length;
-	const toDelete = candidates.slice(0, maxDeletes);
-	const cappedAtLimit = candidateCount > maxDeletes;
-	if (!dryRun && toDelete.length > 0) await s3.delete(toDelete.map((o) => o.key));
-	return {
-		scannedTables,
-		skippedTables,
-		liveFileCount,
-		candidateCount,
-		deleted: toDelete.map((o) => o.key),
-		dryRun,
-		cappedAtLimit
-	};
-}
+import { isCommitRateLimited } from "./catalog.mjs";
+import { sweepUncommittedOrphans } from "./orphan-sweep.mjs";
 export { isCommitRateLimited, sweepUncommittedOrphans };

package/dist/node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.d.mts

@@ -0,0 +1,2 @@
+import "../../../readdirp@5.0.0/node_modules/readdirp/index.mjs";
+import "./index.mjs";

package/dist/node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.d.mts

@@ -0,0 +1,2 @@
+import "../../../readdirp@5.0.0/node_modules/readdirp/index.mjs";
+import "./handler.mjs";

package/dist/node_modules/.pnpm/hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/brotli.bitreader.mjs

@@ -0,0 +1,88 @@
+const BROTLI_READ_SIZE = 4096;
+const BROTLI_IBUF_SIZE = 8224;
+const BROTLI_IBUF_MASK = 2 * BROTLI_READ_SIZE - 1;
+const kBitMask = new Uint32Array([
+	0,
+	1,
+	3,
+	7,
+	15,
+	31,
+	63,
+	127,
+	255,
+	511,
+	1023,
+	2047,
+	4095,
+	8191,
+	16383,
+	32767,
+	65535,
+	131071,
+	262143,
+	524287,
+	1048575,
+	2097151,
+	4194303,
+	8388607,
+	16777215
+]);
+function BrotliBitReader(input) {
+	this.buf_ = new Uint8Array(BROTLI_IBUF_SIZE);
+	this.input_ = input;
+	this.buf_ptr_ = 0;
+	this.val_ = 0;
+	this.pos_ = 0;
+	this.reset();
+}
+BrotliBitReader.READ_SIZE = BROTLI_READ_SIZE;
+BrotliBitReader.IBUF_MASK = BROTLI_IBUF_MASK;
+BrotliBitReader.prototype.reset = function() {
+	this.buf_ptr_ = 0;
+	this.val_ = 0;
+	this.pos_ = 0;
+	this.bit_pos_ = 0;
+	this.bit_end_pos_ = 0;
+	this.eos_ = 0;
+	this.readMoreInput();
+	for (let i = 0; i < 4; i++) {
+		this.val_ |= this.buf_[this.pos_] << 8 * i;
+		this.pos_++;
+	}
+	return this.bit_end_pos_ > 0;
+};
+BrotliBitReader.prototype.readMoreInput = function() {
+	if (this.bit_end_pos_ > 256) {} else if (this.eos_) {
+		if (this.bit_pos_ > this.bit_end_pos_) throw new Error("Unexpected end of input " + this.bit_pos_ + " " + this.bit_end_pos_);
+	} else {
+		const dst = this.buf_ptr_;
+		const bytes_read = this.input_.read(this.buf_, dst, BROTLI_READ_SIZE);
+		if (bytes_read < 0) throw new Error("Unexpected end of input");
+		if (bytes_read < BROTLI_READ_SIZE) {
+			this.eos_ = 1;
+			for (let p = 0; p < 32; p++) this.buf_[dst + bytes_read + p] = 0;
+		}
+		if (dst === 0) {
+			for (let p = 0; p < 32; p++) this.buf_[(BROTLI_READ_SIZE << 1) + p] = this.buf_[p];
+			this.buf_ptr_ = BROTLI_READ_SIZE;
+		} else this.buf_ptr_ = 0;
+		this.bit_end_pos_ += bytes_read << 3;
+	}
+};
+BrotliBitReader.prototype.fillBitWindow = function() {
+	while (this.bit_pos_ >= 8) {
+		this.val_ >>>= 8;
+		this.val_ |= this.buf_[this.pos_ & BROTLI_IBUF_MASK] << 24;
+		this.pos_++;
+		this.bit_pos_ = this.bit_pos_ - 8 >>> 0;
+		this.bit_end_pos_ = this.bit_end_pos_ - 8 >>> 0;
+	}
+};
+BrotliBitReader.prototype.readBits = function(n_bits) {
+	if (32 - this.bit_pos_ < n_bits) this.fillBitWindow();
+	const val = this.val_ >>> this.bit_pos_ & kBitMask[n_bits];
+	this.bit_pos_ += n_bits;
+	return val;
+};
+export { BrotliBitReader };