gaussian-splat-lite 1.2.2 → 1.3.0

package/dist/types/loaders/rad/RadSource.d.cts

@@ -1,78 +1,93 @@
-import { LoadingManager } from 'three';
-import { SplatFileResolver, SplatRequestOptions } from '../loadTypes.cjs';
-import { RadHeader } from './radFormat.cjs';
+import type { LoadingManager } from "three";
+import type { SplatFileResolver, SplatRequestOptions } from "../loadTypes.cjs";
+import type { RadHeader } from "./radFormat.cjs";
 export type RadSourceOptions = SplatRequestOptions & {
-    url?: string;
-    file?: Blob;
-    fileBytes?: Uint8Array | ArrayBuffer;
-    baseUrl?: string;
-    manager?: LoadingManager;
-    resolveFile?: SplatFileResolver;
-    /** Internal bridge for LoadingManager URL modifiers in a decode worker. */
-    resolveAsset?: (url: string) => Promise<string>;
-    onProgress?: (downloadedBytes: number) => void;
-    /** Validate ordinary metadata as soon as the full-response header arrives. */
-    validateHeader?: (bytes: Uint8Array) => void;
+  url?: string;
+  file?: Blob;
+  fileBytes?: Uint8Array | ArrayBuffer;
+  baseUrl?: string;
+  manager?: LoadingManager;
+  resolveFile?: SplatFileResolver;
+  /** Internal bridge for LoadingManager URL modifiers in a decode worker. */
+  resolveAsset?: (url: string) => Promise<string>;
+  onProgress?: (downloadedBytes: number) => void;
+  /** Validate ordinary metadata as soon as the full-response header arrives. */
+  validateHeader?: (bytes: Uint8Array) => void;
 };
 type Remote = {
-    url: string;
-    resolved?: string;
-    responseUrl?: string;
-    total?: number;
-    validator?: string;
-    validatorHeader?: "ETag" | "Last-Modified";
-    full?: Blob;
+  url: string;
+  resolved?: string;
+  responseUrl?: string;
+  total?: number;
+  validator?: string;
+  validatorHeader?: "ETag" | "Last-Modified";
+  full?: Blob;
 };
 /** Small response snapshot shared across a dataset's download workers. */
-export type RadResourceState = Pick<Remote, "responseUrl" | "total" | "validator" | "validatorHeader">;
+export type RadResourceState = Pick<
+  Remote,
+  "responseUrl" | "total" | "validator" | "validatorHeader"
+>;
 /** Resolved page input. Local inputs contain only the requested Blob slice. */
 export type RadReadRequest = {
-    input: string | Blob;
-    offset: number;
-    length: number;
-    wholeFile: boolean;
-    resourceUrl?: string;
-    state?: RadResourceState;
-    requestHeader?: Record<string, string>;
-    withCredentials?: boolean;
+  input: string | Blob;
+  offset: number;
+  length: number;
+  wholeFile: boolean;
+  resourceUrl?: string;
+  state?: RadResourceState;
+  requestHeader?: Record<string, string>;
+  withCredentials?: boolean;
 };
 /** Validated byte reads shared by ordinary RAD loading and paged loading. */
 export declare class RadSource {
-    readonly options: RadSourceOptions;
-    private readonly allowFullDownload;
-    readonly stats: {
-        downloadedBytes: number;
-        activeRequests: number;
-        cachedBytes: number;
-    };
-    private readonly controller;
-    private readonly remotes;
-    private readonly root;
-    private readonly origin?;
-    constructor(options: RadSourceOptions, allowFullDownload?: boolean);
-    get url(): string | undefined;
-    readHeader(signal?: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;
-    readChunk(header: RadHeader, index: number, signal?: AbortSignal): Promise<Uint8Array<ArrayBufferLike>>;
-    private chunkRead;
-    /** Resolve callbacks on their owning thread; workers read and validate bodies. */
-    prepareChunk(header: RadHeader, index: number, signal?: AbortSignal): Promise<RadReadRequest>;
-    /** Worker transport reuses all ordinary Range, size and encoding validation. */
-    static readPreparedChunk(request: RadReadRequest, signal: AbortSignal, onProgress?: (downloadedBytes: number) => void): Promise<{
-        bytes: Uint8Array<ArrayBufferLike>;
-        state: RadResourceState | undefined;
-    }>;
-    /** Reconcile parallel responses before publishing a decoded page. */
-    acceptChunkResponse(request: RadReadRequest, state?: RadResourceState): void;
-    private resourceState;
-    private remote;
-    private resolveRemote;
-    private requestController;
-    private read;
-    private readRemote;
-    private cacheFullResponse;
-    private readHeaderOnlyResponse;
-    private readResponse;
-    private progress;
-    dispose(): void;
+  readonly options: RadSourceOptions;
+  private readonly allowFullDownload;
+  readonly stats: {
+    downloadedBytes: number;
+    activeRequests: number;
+    cachedBytes: number;
+  };
+  private readonly controller;
+  private readonly remotes;
+  private readonly root;
+  private readonly origin?;
+  constructor(options: RadSourceOptions, allowFullDownload?: boolean);
+  get url(): string | undefined;
+  readHeader(signal?: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;
+  readChunk(
+    header: RadHeader,
+    index: number,
+    signal?: AbortSignal,
+  ): Promise<Uint8Array<ArrayBufferLike>>;
+  private chunkRead;
+  /** Resolve callbacks on their owning thread; workers read and validate bodies. */
+  prepareChunk(
+    header: RadHeader,
+    index: number,
+    signal?: AbortSignal,
+  ): Promise<RadReadRequest>;
+  /** Worker transport reuses all ordinary Range, size and encoding validation. */
+  static readPreparedChunk(
+    request: RadReadRequest,
+    signal: AbortSignal,
+    onProgress?: (downloadedBytes: number) => void,
+  ): Promise<{
+    bytes: Uint8Array<ArrayBufferLike>;
+    state: RadResourceState | undefined;
+  }>;
+  /** Reconcile parallel responses before publishing a decoded page. */
+  acceptChunkResponse(request: RadReadRequest, state?: RadResourceState): void;
+  private resourceState;
+  private remote;
+  private resolveRemote;
+  private requestController;
+  private read;
+  private readRemote;
+  private cacheFullResponse;
+  private readHeaderOnlyResponse;
+  private readResponse;
+  private progress;
+  dispose(): void;
 }
 export {};

package/dist/types/loaders/rad/RadSource.d.ts

@@ -1,78 +1,93 @@
-import { LoadingManager } from 'three';
-import { SplatFileResolver, SplatRequestOptions } from '../loadTypes';
-import { RadHeader } from './radFormat';
+import type { LoadingManager } from "three";
+import type { SplatFileResolver, SplatRequestOptions } from "../loadTypes.js";
+import type { RadHeader } from "./radFormat.js";
 export type RadSourceOptions = SplatRequestOptions & {
-    url?: string;
-    file?: Blob;
-    fileBytes?: Uint8Array | ArrayBuffer;
-    baseUrl?: string;
-    manager?: LoadingManager;
-    resolveFile?: SplatFileResolver;
-    /** Internal bridge for LoadingManager URL modifiers in a decode worker. */
-    resolveAsset?: (url: string) => Promise<string>;
-    onProgress?: (downloadedBytes: number) => void;
-    /** Validate ordinary metadata as soon as the full-response header arrives. */
-    validateHeader?: (bytes: Uint8Array) => void;
+  url?: string;
+  file?: Blob;
+  fileBytes?: Uint8Array | ArrayBuffer;
+  baseUrl?: string;
+  manager?: LoadingManager;
+  resolveFile?: SplatFileResolver;
+  /** Internal bridge for LoadingManager URL modifiers in a decode worker. */
+  resolveAsset?: (url: string) => Promise<string>;
+  onProgress?: (downloadedBytes: number) => void;
+  /** Validate ordinary metadata as soon as the full-response header arrives. */
+  validateHeader?: (bytes: Uint8Array) => void;
 };
 type Remote = {
-    url: string;
-    resolved?: string;
-    responseUrl?: string;
-    total?: number;
-    validator?: string;
-    validatorHeader?: "ETag" | "Last-Modified";
-    full?: Blob;
+  url: string;
+  resolved?: string;
+  responseUrl?: string;
+  total?: number;
+  validator?: string;
+  validatorHeader?: "ETag" | "Last-Modified";
+  full?: Blob;
 };
 /** Small response snapshot shared across a dataset's download workers. */
-export type RadResourceState = Pick<Remote, "responseUrl" | "total" | "validator" | "validatorHeader">;
+export type RadResourceState = Pick<
+  Remote,
+  "responseUrl" | "total" | "validator" | "validatorHeader"
+>;
 /** Resolved page input. Local inputs contain only the requested Blob slice. */
 export type RadReadRequest = {
-    input: string | Blob;
-    offset: number;
-    length: number;
-    wholeFile: boolean;
-    resourceUrl?: string;
-    state?: RadResourceState;
-    requestHeader?: Record<string, string>;
-    withCredentials?: boolean;
+  input: string | Blob;
+  offset: number;
+  length: number;
+  wholeFile: boolean;
+  resourceUrl?: string;
+  state?: RadResourceState;
+  requestHeader?: Record<string, string>;
+  withCredentials?: boolean;
 };
 /** Validated byte reads shared by ordinary RAD loading and paged loading. */
 export declare class RadSource {
-    readonly options: RadSourceOptions;
-    private readonly allowFullDownload;
-    readonly stats: {
-        downloadedBytes: number;
-        activeRequests: number;
-        cachedBytes: number;
-    };
-    private readonly controller;
-    private readonly remotes;
-    private readonly root;
-    private readonly origin?;
-    constructor(options: RadSourceOptions, allowFullDownload?: boolean);
-    get url(): string | undefined;
-    readHeader(signal?: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;
-    readChunk(header: RadHeader, index: number, signal?: AbortSignal): Promise<Uint8Array<ArrayBufferLike>>;
-    private chunkRead;
-    /** Resolve callbacks on their owning thread; workers read and validate bodies. */
-    prepareChunk(header: RadHeader, index: number, signal?: AbortSignal): Promise<RadReadRequest>;
-    /** Worker transport reuses all ordinary Range, size and encoding validation. */
-    static readPreparedChunk(request: RadReadRequest, signal: AbortSignal, onProgress?: (downloadedBytes: number) => void): Promise<{
-        bytes: Uint8Array<ArrayBufferLike>;
-        state: RadResourceState | undefined;
-    }>;
-    /** Reconcile parallel responses before publishing a decoded page. */
-    acceptChunkResponse(request: RadReadRequest, state?: RadResourceState): void;
-    private resourceState;
-    private remote;
-    private resolveRemote;
-    private requestController;
-    private read;
-    private readRemote;
-    private cacheFullResponse;
-    private readHeaderOnlyResponse;
-    private readResponse;
-    private progress;
-    dispose(): void;
+  readonly options: RadSourceOptions;
+  private readonly allowFullDownload;
+  readonly stats: {
+    downloadedBytes: number;
+    activeRequests: number;
+    cachedBytes: number;
+  };
+  private readonly controller;
+  private readonly remotes;
+  private readonly root;
+  private readonly origin?;
+  constructor(options: RadSourceOptions, allowFullDownload?: boolean);
+  get url(): string | undefined;
+  readHeader(signal?: AbortSignal): Promise<Uint8Array<ArrayBuffer>>;
+  readChunk(
+    header: RadHeader,
+    index: number,
+    signal?: AbortSignal,
+  ): Promise<Uint8Array<ArrayBufferLike>>;
+  private chunkRead;
+  /** Resolve callbacks on their owning thread; workers read and validate bodies. */
+  prepareChunk(
+    header: RadHeader,
+    index: number,
+    signal?: AbortSignal,
+  ): Promise<RadReadRequest>;
+  /** Worker transport reuses all ordinary Range, size and encoding validation. */
+  static readPreparedChunk(
+    request: RadReadRequest,
+    signal: AbortSignal,
+    onProgress?: (downloadedBytes: number) => void,
+  ): Promise<{
+    bytes: Uint8Array<ArrayBufferLike>;
+    state: RadResourceState | undefined;
+  }>;
+  /** Reconcile parallel responses before publishing a decoded page. */
+  acceptChunkResponse(request: RadReadRequest, state?: RadResourceState): void;
+  private resourceState;
+  private remote;
+  private resolveRemote;
+  private requestController;
+  private read;
+  private readRemote;
+  private cacheFullResponse;
+  private readHeaderOnlyResponse;
+  private readResponse;
+  private progress;
+  dispose(): void;
 }
 export {};

package/dist/types/loaders/rad/radFormat.d.cts

@@ -1,57 +1,62 @@
-import { ReorderedSplatResult, SplatResult } from '../../data/defines.cjs';
-import { PostDecodeSplatData } from '../postDecode/protocol.cjs';
+import type { ReorderedSplatResult, SplatResult } from "../../data/defines.cjs";
+import type { PostDecodeSplatData } from "../postDecode/protocol.cjs";
 export type RadChunkRange = {
-    offset: number;
-    bytes: number;
-    base?: number;
-    count?: number;
-    filename?: string;
+  offset: number;
+  bytes: number;
+  base?: number;
+  count?: number;
+  filename?: string;
 };
 /** Spark RAD version 1 directory. Child references use file-global indices. */
 export type RadMeta = {
-    version: number;
-    type: "gsplat";
-    count: number;
-    maxSh?: number;
-    lodTree?: boolean;
-    chunkSize?: number;
-    allChunkBytes: number;
-    chunks: RadChunkRange[];
-    shCodeCount?: number;
-    splatEncoding?: Record<string, unknown>;
-    comment?: string;
+  version: number;
+  type: "gsplat";
+  count: number;
+  maxSh?: number;
+  lodTree?: boolean;
+  chunkSize?: number;
+  allChunkBytes: number;
+  chunks: RadChunkRange[];
+  shCodeCount?: number;
+  splatEncoding?: Record<string, unknown>;
+  comment?: string;
 };
 export type RadHeader = {
-    meta: RadMeta;
-    chunksStart: number;
+  meta: RadMeta;
+  chunksStart: number;
 };
 export type RadChunkData = SplatResult & {
-    base: number;
-    childStart?: Uint32Array;
-    childCount?: Uint16Array;
-    lodRadii?: Float32Array;
+  base: number;
+  childStart?: Uint32Array;
+  childCount?: Uint16Array;
+  lodRadii?: Float32Array;
 };
 /** Render records for streaming; tree arrays are transferred to the LOD worker. */
 export type RadStreamChunk = Omit<ReorderedSplatResult, "sortCenters"> & {
-    /** Root-page radius used when its initial bounds collapse to one point. */
-    rootRadius?: number;
+  /** Root-page radius used when its initial bounds collapse to one point. */
+  rootRadius?: number;
 };
 export type RadDecodedChunk = PostDecodeSplatData & {
-    base: number;
-    childStart?: Uint32Array;
-    childCount?: Uint16Array;
-    lodRadii?: Float32Array;
+  base: number;
+  childStart?: Uint32Array;
+  childCount?: Uint16Array;
+  lodRadii?: Float32Array;
 };
 export declare function unpackRadChunk(decoded: RadDecodedChunk): RadChunkData;
 /** Without chunkSize, Spark treats the dataset as one chunk. */
-export declare function getRadChunkSpan(meta: RadMeta, index: number): {
-    base: number;
-    count: number;
+export declare function getRadChunkSpan(
+  meta: RadMeta,
+  index: number,
+): {
+  base: number;
+  count: number;
 };
 export declare function isRadPrefix(bytes: Uint8Array): boolean;
 export declare function getRadHeaderSize(prefix: Uint8Array): {
-    jsonLength: number;
-    headerLength: number;
+  jsonLength: number;
+  headerLength: number;
 };
 /** Validate the header as soon as a full-response fallback supplies it. */
-export declare function collectRadHeader(complete: (bytes: Uint8Array) => void): (bytes: Uint8Array) => void;
+export declare function collectRadHeader(
+  complete: (bytes: Uint8Array) => void,
+): (bytes: Uint8Array) => void;

package/dist/types/loaders/rad/radFormat.d.ts

@@ -1,57 +1,62 @@
-import { ReorderedSplatResult, SplatResult } from '../../data/defines';
-import { PostDecodeSplatData } from '../postDecode/protocol';
+import type { ReorderedSplatResult, SplatResult } from "../../data/defines.js";
+import type { PostDecodeSplatData } from "../postDecode/protocol.js";
 export type RadChunkRange = {
-    offset: number;
-    bytes: number;
-    base?: number;
-    count?: number;
-    filename?: string;
+  offset: number;
+  bytes: number;
+  base?: number;
+  count?: number;
+  filename?: string;
 };
 /** Spark RAD version 1 directory. Child references use file-global indices. */
 export type RadMeta = {
-    version: number;
-    type: "gsplat";
-    count: number;
-    maxSh?: number;
-    lodTree?: boolean;
-    chunkSize?: number;
-    allChunkBytes: number;
-    chunks: RadChunkRange[];
-    shCodeCount?: number;
-    splatEncoding?: Record<string, unknown>;
-    comment?: string;
+  version: number;
+  type: "gsplat";
+  count: number;
+  maxSh?: number;
+  lodTree?: boolean;
+  chunkSize?: number;
+  allChunkBytes: number;
+  chunks: RadChunkRange[];
+  shCodeCount?: number;
+  splatEncoding?: Record<string, unknown>;
+  comment?: string;
 };
 export type RadHeader = {
-    meta: RadMeta;
-    chunksStart: number;
+  meta: RadMeta;
+  chunksStart: number;
 };
 export type RadChunkData = SplatResult & {
-    base: number;
-    childStart?: Uint32Array;
-    childCount?: Uint16Array;
-    lodRadii?: Float32Array;
+  base: number;
+  childStart?: Uint32Array;
+  childCount?: Uint16Array;
+  lodRadii?: Float32Array;
 };
 /** Render records for streaming; tree arrays are transferred to the LOD worker. */
 export type RadStreamChunk = Omit<ReorderedSplatResult, "sortCenters"> & {
-    /** Root-page radius used when its initial bounds collapse to one point. */
-    rootRadius?: number;
+  /** Root-page radius used when its initial bounds collapse to one point. */
+  rootRadius?: number;
 };
 export type RadDecodedChunk = PostDecodeSplatData & {
-    base: number;
-    childStart?: Uint32Array;
-    childCount?: Uint16Array;
-    lodRadii?: Float32Array;
+  base: number;
+  childStart?: Uint32Array;
+  childCount?: Uint16Array;
+  lodRadii?: Float32Array;
 };
 export declare function unpackRadChunk(decoded: RadDecodedChunk): RadChunkData;
 /** Without chunkSize, Spark treats the dataset as one chunk. */
-export declare function getRadChunkSpan(meta: RadMeta, index: number): {
-    base: number;
-    count: number;
+export declare function getRadChunkSpan(
+  meta: RadMeta,
+  index: number,
+): {
+  base: number;
+  count: number;
 };
 export declare function isRadPrefix(bytes: Uint8Array): boolean;
 export declare function getRadHeaderSize(prefix: Uint8Array): {
-    jsonLength: number;
-    headerLength: number;
+  jsonLength: number;
+  headerLength: number;
 };
 /** Validate the header as soon as a full-response fallback supplies it. */
-export declare function collectRadHeader(complete: (bytes: Uint8Array) => void): (bytes: Uint8Array) => void;
+export declare function collectRadHeader(
+  complete: (bytes: Uint8Array) => void,
+): (bytes: Uint8Array) => void;

package/dist/types/loaders/rad.d.cts

@@ -1,8 +1,8 @@
-import { SplatSourceArgs as LoadRadArgs } from './loadTypes.cjs';
-import { PostDecodeSplatData } from './postDecode/protocol.cjs';
-export { isRadPrefix } from './rad/radFormat.cjs';
+import type { SplatSourceArgs as LoadRadArgs } from "./loadTypes.cjs";
+import type { PostDecodeSplatData } from "./postDecode/protocol.cjs";
+export { isRadPrefix } from "./rad/radFormat.cjs";
 type RadOutput = PostDecodeSplatData & {
-    sourceIds: Uint32Array;
+  sourceIds: Uint32Array;
 };
 /** Complete-file RAD decode with validated chunk coverage and LOD trees. */
 export declare function loadRad(args: LoadRadArgs): Promise<RadOutput>;

package/dist/types/loaders/rad.d.ts

@@ -1,8 +1,8 @@
-import { SplatSourceArgs as LoadRadArgs } from './loadTypes';
-import { PostDecodeSplatData } from './postDecode/protocol';
-export { isRadPrefix } from './rad/radFormat';
+import type { SplatSourceArgs as LoadRadArgs } from "./loadTypes.js";
+import type { PostDecodeSplatData } from "./postDecode/protocol.js";
+export { isRadPrefix } from "./rad/radFormat.js";
 type RadOutput = PostDecodeSplatData & {
-    sourceIds: Uint32Array;
+  sourceIds: Uint32Array;
 };
 /** Complete-file RAD decode with validated chunk coverage and LOD trees. */
 export declare function loadRad(args: LoadRadArgs): Promise<RadOutput>;

package/dist/types/loaders/sog/SogSource.d.cts

@@ -1,5 +1,15 @@
-import { SplatSourceArgs } from '../loadTypes.cjs';
-import { ByteSource as Source } from '../source.cjs';
-export declare function openSogSource(args: SplatSourceArgs, progress: (bytes: number, total?: number) => void, signal: AbortSignal): Promise<Source>;
+import type { SplatSourceArgs } from "../loadTypes.cjs";
+import type { ByteSource as Source } from "../source.cjs";
+export declare function openSogSource(
+  args: SplatSourceArgs,
+  progress: (bytes: number, total?: number) => void,
+  signal: AbortSignal,
+): Promise<Source>;
 /** Resolve and read an external property image; ZIP entries stay with the archive reader. */
-export declare function readSogAsset(name: string, args: SplatSourceArgs, sourceUrl: string | undefined, progress: (bytes: number) => void, signal: AbortSignal): Promise<Uint8Array[]>;
+export declare function readSogAsset(
+  name: string,
+  args: SplatSourceArgs,
+  sourceUrl: string | undefined,
+  progress: (bytes: number) => void,
+  signal: AbortSignal,
+): Promise<Uint8Array[]>;

package/dist/types/loaders/sog/SogSource.d.ts

@@ -1,5 +1,15 @@
-import { SplatSourceArgs } from '../loadTypes';
-import { ByteSource as Source } from '../source';
-export declare function openSogSource(args: SplatSourceArgs, progress: (bytes: number, total?: number) => void, signal: AbortSignal): Promise<Source>;
+import type { SplatSourceArgs } from "../loadTypes.js";
+import type { ByteSource as Source } from "../source.js";
+export declare function openSogSource(
+  args: SplatSourceArgs,
+  progress: (bytes: number, total?: number) => void,
+  signal: AbortSignal,
+): Promise<Source>;
 /** Resolve and read an external property image; ZIP entries stay with the archive reader. */
-export declare function readSogAsset(name: string, args: SplatSourceArgs, sourceUrl: string | undefined, progress: (bytes: number) => void, signal: AbortSignal): Promise<Uint8Array[]>;
+export declare function readSogAsset(
+  name: string,
+  args: SplatSourceArgs,
+  sourceUrl: string | undefined,
+  progress: (bytes: number) => void,
+  signal: AbortSignal,
+): Promise<Uint8Array[]>;

package/dist/types/loaders/sog/sogZip.d.cts

@@ -1,17 +1,17 @@
-import { ByteSource as Source } from '../source.cjs';
+import type { ByteSource as Source } from "../source.cjs";
 type Entry = {
-    name: string;
-    nameLength: number;
-    method: number;
-    flags: number;
-    crc: number;
-    compressedSize: number;
-    size: number;
-    offset: number;
+  name: string;
+  nameLength: number;
+  method: number;
+  flags: number;
+  crc: number;
+  compressedSize: number;
+  size: number;
+  offset: number;
 };
 export declare function readZip(source: Source): Promise<{
-    meta: Entry;
-    read: (entry: Entry) => Promise<Uint8Array<ArrayBufferLike>[]>;
-    entry(name: string): Entry | undefined;
+  meta: Entry;
+  read: (entry: Entry) => Promise<Uint8Array<ArrayBufferLike>[]>;
+  entry(name: string): Entry | undefined;
 }>;
 export {};

package/dist/types/loaders/sog/sogZip.d.ts

@@ -1,17 +1,17 @@
-import { ByteSource as Source } from '../source';
+import type { ByteSource as Source } from "../source.js";
 type Entry = {
-    name: string;
-    nameLength: number;
-    method: number;
-    flags: number;
-    crc: number;
-    compressedSize: number;
-    size: number;
-    offset: number;
+  name: string;
+  nameLength: number;
+  method: number;
+  flags: number;
+  crc: number;
+  compressedSize: number;
+  size: number;
+  offset: number;
 };
 export declare function readZip(source: Source): Promise<{
-    meta: Entry;
-    read: (entry: Entry) => Promise<Uint8Array<ArrayBufferLike>[]>;
-    entry(name: string): Entry | undefined;
+  meta: Entry;
+  read: (entry: Entry) => Promise<Uint8Array<ArrayBufferLike>[]>;
+  entry(name: string): Entry | undefined;
 }>;
 export {};