@loaders.gl/core 4.4.0-alpha.2 → 4.4.0-alpha.9

package/src/lib/loader-utils/get-data.ts

@@ -9,21 +9,30 @@ import type {
   Loader,
   LoaderOptions
 } from '@loaders.gl/loader-utils';
-import {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
 import {
+  concatenateArrayBuffersAsync,
+  isPromise,
   isResponse,
   isReadableStream,
   isAsyncIterable,
   isIterable,
   isIterator,
   isBlob,
-  isBuffer
-} from '../../javascript-utils/is-type';
+  isBuffer,
+  isArrayBufferLike,
+  toArrayBuffer,
+  toArrayBufferView
+} from '@loaders.gl/loader-utils';
 import {makeIterator} from '../../iterators/make-iterator/make-iterator';
 import {checkResponse, makeResponse} from '../utils/response-utils';
 
 const ERR_DATA = 'Cannot convert supplied data type';
 
+/**
+ * Returns an {@link ArrayBuffer} or string from the provided data synchronously.
+ * Supports `ArrayBuffer`, `ArrayBufferView`, and `ArrayBufferLike` (e.g. `SharedArrayBuffer`)
+ * while preserving typed array view offsets.
+ */
 // eslint-disable-next-line complexity
 export function getArrayBufferOrStringFromDataSync(
   data: SyncDataType,
@@ -35,52 +44,32 @@ export function getArrayBufferOrStringFromDataSync(
   }
 
   if (isBuffer(data)) {
-    // @ts-ignore
     data = data.buffer;
   }
 
-  if (data instanceof ArrayBuffer) {
-    const arrayBuffer = data;
-    if (loader.text && !loader.binary) {
-      const textDecoder = new TextDecoder('utf8');
-      return textDecoder.decode(arrayBuffer);
-    }
-    return arrayBuffer;
-  }
-
-  // We may need to handle offsets
-  if (ArrayBuffer.isView(data)) {
-    // TextDecoder is invoked on typed arrays and will handle offsets
+  if (isArrayBufferLike(data)) {
+    const bufferSource = toArrayBufferView(data);
     if (loader.text && !loader.binary) {
       const textDecoder = new TextDecoder('utf8');
-      return textDecoder.decode(data);
-    }
-
-    let arrayBuffer = data.buffer;
-
-    // Since we are returning the underlying arrayBuffer, we must create a new copy
-    // if this typed array / Buffer is a partial view into the ArryayBuffer
-    // TODO - this is a potentially unnecessary copy
-    const byteLength = data.byteLength || data.length;
-    if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
-      // console.warn(`loaders.gl copying arraybuffer of length ${byteLength}`);
-      arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+      return textDecoder.decode(bufferSource);
     }
-    return arrayBuffer;
+    return toArrayBuffer(bufferSource);
   }
 
   throw new Error(ERR_DATA);
 }
 
-// Convert async iterator to a promise
+/**
+ * Resolves the provided data into an {@link ArrayBuffer} or string asynchronously.
+ * Accepts the full {@link DataType} surface including responses and async iterables.
+ */
 export async function getArrayBufferOrStringFromData(
   data: DataType,
   loader: Loader,
   options: LoaderOptions
 ): Promise<ArrayBuffer | string> {
-  const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
-  if (typeof data === 'string' || isArrayBuffer) {
-    return getArrayBufferOrStringFromDataSync(data as string | ArrayBuffer, loader, options);
+  if (typeof data === 'string' || isArrayBufferLike(data)) {
+    return getArrayBufferOrStringFromDataSync(data as SyncDataType, loader, options);
   }
 
   // Blobs and files are FileReader compatible
@@ -89,9 +78,8 @@ export async function getArrayBufferOrStringFromData(
   }
 
   if (isResponse(data)) {
-    const response = data as Response;
-    await checkResponse(response);
-    return loader.binary ? await response.arrayBuffer() : await response.text();
+    await checkResponse(data);
+    return loader.binary ? await data.arrayBuffer() : await data.text();
   }
 
   if (isReadableStream(data)) {
@@ -101,29 +89,41 @@ export async function getArrayBufferOrStringFromData(
 
   if (isIterable(data) || isAsyncIterable(data)) {
     // Assume arrayBuffer iterator - attempt to concatenate
-    return concatenateArrayBuffersAsync(data as AsyncIterable<ArrayBuffer>);
+    return concatenateArrayBuffersAsync(data as AsyncIterable<ArrayBufferLike>);
   }
 
   throw new Error(ERR_DATA);
 }
 
+/**
+ * Normalizes batchable inputs into async iterables for batch parsing flows.
+ * Supports synchronous iterables, async iterables, fetch responses, readable streams, and
+ * single binary chunks (including typed array views and `ArrayBufferLike` values).
+ */
 export async function getAsyncIterableFromData(
   data: BatchableDataType,
   options: LoaderOptions
-): Promise<AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>> {
+): Promise<
+  AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>
+> {
+  if (isPromise(data)) {
+    data = await data;
+  }
+
   if (isIterator(data)) {
     return data as AsyncIterable<ArrayBuffer>;
   }
 
   if (isResponse(data)) {
-    const response = data as Response;
     // Note Since this function is not async, we currently can't load error message, just status
-    await checkResponse(response);
+    await checkResponse(data);
     // TODO - bug in polyfill, body can be a Promise under Node.js
     // eslint-disable-next-line @typescript-eslint/await-thenable
-    const body = await response.body;
-    // TODO - body can be null?
-    return makeIterator(body as ReadableStream<Uint8Array>, options as any);
+    const body = await data.body;
+    if (!body) {
+      throw new Error(ERR_DATA);
+    }
+    return makeIterator(body, options as any);
   }
 
   if (isBlob(data) || isReadableStream(data)) {
@@ -131,38 +131,52 @@ export async function getAsyncIterableFromData(
   }
 
   if (isAsyncIterable(data)) {
-    return data as AsyncIterable<ArrayBuffer>;
+    return data as AsyncIterable<ArrayBufferLike | ArrayBufferView>;
   }
 
+  if (isIterable(data)) {
+    return data as Iterable<ArrayBufferLike | ArrayBufferView>;
+  }
+
+  // @ts-expect-error TODO - fix type mess
   return getIterableFromData(data);
 }
 
+/**
+ * Returns a readable stream for streaming loader inputs when available.
+ */
 export async function getReadableStream(data: BatchableDataType): Promise<ReadableStream> {
   if (isReadableStream(data)) {
     return data as ReadableStream;
   }
   if (isResponse(data)) {
     // @ts-ignore
+    if (!data.body) {
+      throw new Error(ERR_DATA);
+    }
     return data.body;
   }
   const response = await makeResponse(data);
   // @ts-ignore
+  if (!response.body) {
+    throw new Error(ERR_DATA);
+  }
   return response.body;
 }
 
 // HELPERS
 
-function getIterableFromData(data) {
+function getIterableFromData(data: string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView) {
   // generate an iterator that emits a single chunk
   if (ArrayBuffer.isView(data)) {
     return (function* oneChunk() {
-      yield data.buffer;
+      yield toArrayBuffer(data);
     })();
   }
 
-  if (data instanceof ArrayBuffer) {
+  if (isArrayBufferLike(data)) {
     return (function* oneChunk() {
-      yield data;
+      yield toArrayBuffer(data);
     })();
   }
 

package/src/lib/loader-utils/get-fetch-function.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import type {LoaderContext, LoaderOptions, FetchLike} from '@loaders.gl/loader-utils';
-import {isObject} from '../../javascript-utils/is-type';
+import {isObject} from '@loaders.gl/loader-utils';
 import {fetchFile} from '../fetch/fetch-file';
 import {getGlobalLoaderOptions} from './option-utils';
 
@@ -19,15 +19,16 @@ export function getFetchFunction(
   const globalOptions = getGlobalLoaderOptions();
 
   const loaderOptions = options || globalOptions;
+  const fetchOption = loaderOptions.fetch ?? loaderOptions.core?.fetch;
 
   // options.fetch can be a function
-  if (typeof loaderOptions.fetch === 'function') {
-    return loaderOptions.fetch;
+  if (typeof fetchOption === 'function') {
+    return fetchOption;
   }
 
   // options.fetch can be an options object
-  if (isObject(loaderOptions.fetch)) {
-    return (url) => fetchFile(url, loaderOptions.fetch as RequestInit);
+  if (isObject(fetchOption)) {
+    return (url) => fetchFile(url, fetchOption as RequestInit);
   }
 
   // else refer to context (from parent loader) if available

package/src/lib/loader-utils/loader-context.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
+import type {Loader, LoaderContext, StrictLoaderOptions} from '@loaders.gl/loader-utils';
 import {getFetchFunction} from './get-fetch-function';
 import {extractQueryString, stripQueryString} from '../utils/url-utils';
 import {path} from '@loaders.gl/loader-utils';
@@ -21,7 +21,7 @@ type LoaderContextProps = Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderCont
  */
 export function getLoaderContext(
   context: LoaderContextProps,
-  options: LoaderOptions,
+  options: StrictLoaderOptions,
   parentContext: LoaderContext | null
 ): LoaderContext {
   // For recursive calls, we already have a context

package/src/lib/loader-utils/option-defaults.ts

@@ -7,34 +7,66 @@ import {isBrowser} from '@loaders.gl/loader-utils';
 import {ConsoleLog} from './loggers';
 
 export const DEFAULT_LOADER_OPTIONS: LoaderOptions = {
-  // baseUri
-  fetch: null,
-  mimeType: undefined,
-  nothrow: false,
-  log: new ConsoleLog(), // A probe.gl compatible (`log.log()()` syntax) that just logs to console
-  useLocalLibraries: false,
-
-  CDN: 'https://unpkg.com/@loaders.gl',
-  worker: true, // By default, use worker if provided by loader.
-  maxConcurrency: 3, // How many worker instances should be created for each loader.
-  maxMobileConcurrency: 1, // How many worker instances should be created for each loader on mobile devices.
-  reuseWorkers: isBrowser, // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
-  _nodeWorkers: false, // By default do not support node workers
-  _workerType: '', // 'test' to use locally generated workers
-
-  limit: 0,
-  _limitMB: 0,
-  batchSize: 'auto',
-  batchDebounceMs: 0,
-  metadata: false, // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
-  transforms: []
+  core: {
+    baseUri: undefined,
+    // baseUri
+    fetch: null,
+    mimeType: undefined,
+    fallbackMimeType: undefined,
+    ignoreRegisteredLoaders: undefined,
+    nothrow: false,
+    log: new ConsoleLog(), // A probe.gl compatible (`log.log()()` syntax) that just logs to console
+    useLocalLibraries: false,
+
+    CDN: 'https://unpkg.com/@loaders.gl',
+    worker: true, // By default, use worker if provided by loader.
+    maxConcurrency: 3, // How many worker instances should be created for each loader.
+    maxMobileConcurrency: 1, // How many worker instances should be created for each loader on mobile devices.
+    reuseWorkers: isBrowser, // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
+    _nodeWorkers: false, // By default do not support node workers
+    _workerType: '', // 'test' to use locally generated workers
+
+    limit: 0,
+    _limitMB: 0,
+    batchSize: 'auto',
+    batchDebounceMs: 0,
+    metadata: false, // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
+    transforms: []
+  }
 };
 
 export const REMOVED_LOADER_OPTIONS = {
+  // baseUri
+  baseUri: 'core.baseUri',
+  fetch: 'core.fetch',
+  mimeType: 'core.mimeType',
+  fallbackMimeType: 'core.fallbackMimeType',
+  ignoreRegisteredLoaders: 'core.ignoreRegisteredLoaders',
+  nothrow: 'core.nothrow',
+  log: 'core.log',
+  useLocalLibraries: 'core.useLocalLibraries',
+
+  CDN: 'core.CDN',
+  worker: 'core.worker',
+  maxConcurrency: 'core.maxConcurrency',
+  maxMobileConcurrency: 'core.maxMobileConcurrency',
+  reuseWorkers: 'core.reuseWorkers',
+  _nodeWorkers: 'core.nodeWorkers',
+  _workerType: 'core._workerType',
+  _worker: 'core._workerType',
+
+  limit: 'core.limit',
+  _limitMB: 'core._limitMB',
+  batchSize: 'core.batchSize',
+  batchDebounceMs: 'core.batchDebounceMs',
+  metadata: 'core.metadata',
+  transforms: 'core.transforms',
+
+  // Older deprecations
   throws: 'nothrow',
   dataType: '(no longer used)',
   uri: 'baseUri',
-  // Warn if fetch options are used on top-level
+  // Warn if fetch options are used on toplevel
   method: 'fetch.method',
   headers: 'fetch.headers',
   body: 'fetch.body',

package/src/lib/loader-utils/option-utils.ts

@@ -2,11 +2,41 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Loader, LoaderOptions, registerJSModules} from '@loaders.gl/loader-utils';
-import {isPureObject, isObject} from '../../javascript-utils/is-type';
+import {
+  Loader,
+  LoaderOptions,
+  registerJSModules,
+  isPureObject,
+  isObject,
+  StrictLoaderOptions
+} from '@loaders.gl/loader-utils';
 import {probeLog, NullLog} from './loggers';
 import {DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS} from './option-defaults';
 
+const CORE_LOADER_OPTION_KEYS = [
+  'baseUri',
+  'fetch',
+  'mimeType',
+  'fallbackMimeType',
+  'ignoreRegisteredLoaders',
+  'nothrow',
+  'log',
+  'useLocalLibraries',
+  'CDN',
+  'worker',
+  'maxConcurrency',
+  'maxMobileConcurrency',
+  'reuseWorkers',
+  '_nodeWorkers',
+  '_workerType',
+  'limit',
+  '_limitMB',
+  'batchSize',
+  'batchDebounceMs',
+  'metadata',
+  'transforms'
+] as const;
+
 /**
  * Global state for loaders.gl. Stored on `globalThis.loaders._state`
  */
@@ -37,11 +67,14 @@ export function getGlobalLoaderState(): GlobalLoaderState {
  * NOTE: This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
  * @returns global loader options merged with default loader options
  */
-export function getGlobalLoaderOptions(): LoaderOptions {
+export function getGlobalLoaderOptions(): StrictLoaderOptions {
   const state = getGlobalLoaderState();
   // Ensure all default loader options from this library are mentioned
-  state.globalOptions = state.globalOptions || {...DEFAULT_LOADER_OPTIONS};
-  return state.globalOptions;
+  state.globalOptions = state.globalOptions || {
+    ...DEFAULT_LOADER_OPTIONS,
+    core: {...DEFAULT_LOADER_OPTIONS.core}
+  };
+  return normalizeLoaderOptions(state.globalOptions);
 }
 
 /**
@@ -69,12 +102,31 @@ export function normalizeOptions(
   loader: Loader,
   loaders?: Loader[],
   url?: string
-): LoaderOptions {
+): StrictLoaderOptions {
   loaders = loaders || [];
   loaders = Array.isArray(loaders) ? loaders : [loaders];
 
   validateOptions(options, loaders);
-  return normalizeOptionsInternal(loader, options, url);
+  return normalizeLoaderOptions(normalizeOptionsInternal(loader, options, url));
+}
+
+/**
+ * Returns a copy of the provided options with deprecated top-level core fields moved into `core`
+ * and removed from the top level. This keeps global options from leaking deprecated aliases into
+ * loader-specific option maps during normalization.
+ */
+export function normalizeLoaderOptions(options: LoaderOptions): StrictLoaderOptions {
+  const normalized = cloneLoaderOptions(options);
+  moveDeprecatedTopLevelOptionsToCore(normalized);
+  for (const key of CORE_LOADER_OPTION_KEYS) {
+    if (normalized.core && normalized.core[key] !== undefined) {
+      delete (normalized as Record<string, unknown>)[key];
+    }
+  }
+  if (normalized.core && normalized.core._workerType !== undefined) {
+    delete (normalized as any)._worker;
+  }
+  return normalized as StrictLoaderOptions;
 }
 
 // VALIDATE OPTIONS
@@ -89,10 +141,8 @@ function validateOptions(options: LoaderOptions, loaders: Loader[]): void {
   validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
   for (const loader of loaders) {
     // Get the scoped, loader specific options from the user supplied options
-    const idOptions: Record<string, unknown> = ((options && options[loader.id]) || {}) as Record<
-      string,
-      unknown
-    >;
+    const idOptions: Record<string, unknown> =
+      ((options && options[loader.id]) as Record<string, unknown>) || {};
 
     // Get scoped, loader specific default and deprecated options from the selected loader
     const loaderOptions = (loader.options && loader.options[loader.id]) || {};
@@ -165,16 +215,23 @@ function normalizeOptionsInternal(
   const loaderDefaultOptions = loader.options || {};
 
   const mergedOptions = {...loaderDefaultOptions};
-
-  addUrlOptions(mergedOptions, url);
+  if (loaderDefaultOptions.core) {
+    mergedOptions.core = {...loaderDefaultOptions.core};
+  }
+  moveDeprecatedTopLevelOptionsToCore(mergedOptions);
 
   // LOGGING: options.log can be set to `null` to defeat logging
-  if (mergedOptions.log === null) {
-    mergedOptions.log = new NullLog();
+  if (mergedOptions.core?.log === null) {
+    mergedOptions.core = {...mergedOptions.core, log: new NullLog()};
   }
 
-  mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
-  mergeNestedFields(mergedOptions, options);
+  mergeNestedFields(mergedOptions, normalizeLoaderOptions(getGlobalLoaderOptions()));
+
+  const userOptions = normalizeLoaderOptions(options);
+  mergeNestedFields(mergedOptions, userOptions);
+
+  addUrlOptions(mergedOptions, url);
+  addDeprecatedTopLevelOptions(mergedOptions);
 
   return mergedOptions;
 }
@@ -208,7 +265,56 @@ function mergeNestedFields(mergedOptions: LoaderOptions, options: LoaderOptions)
  * TODO - should these be injected on context instead of options?
  */
 function addUrlOptions(options: LoaderOptions, url?: string): void {
-  if (url && !('baseUri' in options)) {
-    options.baseUri = url;
+  if (!url) {
+    return;
+  }
+  const hasTopLevelBaseUri = options.baseUri !== undefined;
+  const hasCoreBaseUri = options.core?.baseUri !== undefined;
+  if (!hasTopLevelBaseUri && !hasCoreBaseUri) {
+    options.core ||= {};
+    options.core.baseUri = url;
+  }
+}
+
+function cloneLoaderOptions(options: LoaderOptions): LoaderOptions {
+  const clonedOptions = {...options};
+  if (options.core) {
+    clonedOptions.core = {...options.core};
+  }
+  return clonedOptions;
+}
+
+function moveDeprecatedTopLevelOptionsToCore(options: LoaderOptions): void {
+  for (const key of CORE_LOADER_OPTION_KEYS) {
+    if ((options as Record<string, unknown>)[key] !== undefined) {
+      const coreOptions = (options.core = options.core || {});
+      const coreRecord = coreOptions as Record<string, unknown>;
+      // Treat deprecated top-level core options as aliases to `options.core`, but never override an explicitly
+      // provided `options.core` value.
+      if (coreRecord[key] === undefined) {
+        coreRecord[key] = (options as Record<string, unknown>)[key];
+      }
+    }
+  }
+
+  // Support the older internal `_worker` alias (used by some tests and integrations) for `_workerType`.
+  const workerTypeAlias = (options as any)._worker;
+  if (workerTypeAlias !== undefined) {
+    options.core ||= {};
+    if (options.core._workerType === undefined) {
+      options.core._workerType = workerTypeAlias;
+    }
+  }
+}
+
+function addDeprecatedTopLevelOptions(options: LoaderOptions): void {
+  const coreOptions = options.core as Record<string, unknown> | undefined;
+  if (!coreOptions) {
+    return;
+  }
+  for (const key of CORE_LOADER_OPTION_KEYS) {
+    if (coreOptions[key] !== undefined) {
+      (options as Record<string, unknown>)[key] = coreOptions[key];
+    }
   }
 }

package/src/lib/utils/resource-utils.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {isResponse, isBlob} from '../../javascript-utils/is-type';
+import {isResponse, isBlob} from '@loaders.gl/loader-utils';
 import {parseMIMEType, parseMIMETypeFromURL} from './mime-type-utils';
 import {stripQueryString} from './url-utils';
 
@@ -22,16 +22,15 @@ export type Resource = Response | Blob | string;
 export function getResourceUrl(resource: unknown): string {
   // If resource is a `Response`, it contains the information directly as a field
   if (isResponse(resource)) {
-    const response = resource as Response;
-    return response.url;
+    return resource.url;
   }
 
   // If the resource is a Blob or a File (subclass of Blob)
   if (isBlob(resource)) {
-    const blob = resource as Blob;
     // File objects have a "name" property. Blob objects don't have any
     // url (name) information
-    return (blob as any).name || '';
+    const fileName = 'name' in resource ? (resource as File).name : '';
+    return fileName || '';
   }
 
   if (typeof resource === 'string') {
@@ -52,16 +51,14 @@ export function getResourceUrl(resource: unknown): string {
 export function getResourceMIMEType(resource: unknown): string {
   // If resource is a response, it contains the information directly
   if (isResponse(resource)) {
-    const response = resource as Response;
-    const contentTypeHeader = response.headers.get('content-type') || '';
-    const noQueryUrl = stripQueryString(response.url);
+    const contentTypeHeader = resource.headers.get('content-type') || '';
+    const noQueryUrl = stripQueryString(resource.url);
     return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
   }
 
   // If the resource is a Blob or a File (subclass of Blob)
   if (isBlob(resource)) {
-    const blob = resource as Blob;
-    return blob.type || '';
+    return resource.type || '';
   }
 
   if (typeof resource === 'string') {
@@ -81,11 +78,11 @@ export function getResourceMIMEType(resource: unknown): string {
   */
 export function getResourceContentLength(resource: unknown): number {
   if (isResponse(resource)) {
-    const response = resource as Response;
+    const response = resource;
     return response.headers['content-length'] || -1;
   }
   if (isBlob(resource)) {
-    const blob = resource as Blob;
+    const blob = resource;
     return blob.size;
   }
   if (typeof resource === 'string') {

package/src/lib/utils/response-utils.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {isResponse} from '../../javascript-utils/is-type';
+import {isResponse} from '@loaders.gl/loader-utils';
 import {FetchError} from '../fetch/fetch-error';
 import {getResourceContentLength, getResourceUrl, getResourceMIMEType} from './resource-utils';
 import {shortenUrlForDisplay} from './url-utils';
@@ -15,7 +15,7 @@ import {shortenUrlForDisplay} from './url-utils';
  */
 export async function makeResponse(resource: unknown): Promise<Response> {
   if (isResponse(resource)) {
-    return resource as Response;
+    return resource;
   }
 
   // Add content-length header if possible

package/src/null-loader.ts

@@ -45,8 +45,11 @@ export const NullLoader = {
   version: VERSION,
   mimeTypes: ['application/x.empty'],
   extensions: ['null'],
-  parse: async (arrayBuffer: ArrayBuffer, options?: NullLoaderOptions, context?: LoaderContext) =>
-    parseSync(arrayBuffer, options || {}, context),
+  parse: async (
+    arrayBuffer: ArrayBufferLike | ArrayBufferView,
+    options?: NullLoaderOptions,
+    context?: LoaderContext
+  ) => parseSync(arrayBuffer, options || {}, context),
   parseSync,
   parseInBatches: async function* generator(asyncIterator, options, context) {
     for await (const batch of asyncIterator) {
@@ -64,7 +67,7 @@ export const NullLoader = {
  * web worker. The `context` parameter is stripped using JSON.stringify & parse.
  */
 function parseSync(
-  arrayBuffer: ArrayBuffer,
+  arrayBuffer: ArrayBufferLike | ArrayBufferView,
   options?: NullLoaderOptions,
   context?: LoaderContext
 ): null {

package/dist/javascript-utils/is-type.d.ts

@@ -1,21 +0,0 @@
-import type { Readable } from 'stream';
-/** A DOM or Node readable stream */
-export type ReadableStreamType = ReadableStream | Readable;
-export declare const isObject: (x: unknown) => boolean;
-export declare const isPureObject: (x: any) => boolean;
-export declare const isPromise: (x: any) => boolean;
-export declare const isIterable: (x: any) => boolean;
-export declare const isAsyncIterable: (x: any) => boolean;
-export declare const isIterator: (x: any) => boolean;
-export declare const isResponse: (x: any) => boolean;
-export declare const isFile: (x: unknown) => boolean;
-export declare const isBlob: (x: unknown) => boolean;
-/** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
-export declare const isBuffer: (x: any) => boolean;
-export declare const isWritableDOMStream: (x: any) => boolean;
-export declare const isReadableDOMStream: (x: any) => boolean;
-export declare const isWritableNodeStream: (x: any) => boolean;
-export declare const isReadableNodeStream: (x: any) => boolean;
-export declare const isReadableStream: (x: unknown) => boolean;
-export declare const isWritableStream: (x: unknown) => boolean;
-//# sourceMappingURL=is-type.d.ts.map