@loaders.gl/core 4.5.3 → 5.0.0-alpha.10

package/src/lib/api/parse-file.ts

@@ -0,0 +1,156 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  Loader,
+  LoaderContext,
+  LoaderOptions,
+  LoaderOptionsWithShape,
+  LoaderOptionsType,
+  LoaderShapeType,
+  LoaderReturnType,
+  LoaderArrayOptionsType,
+  LoaderArrayReturnType,
+  LoaderWithParser,
+  ReadableFile,
+  StrictLoaderOptions
+} from '@loaders.gl/loader-utils';
+import {
+  isSourceLoader,
+  mergeOptions,
+  resolveLoaderAuthenticationOptions
+} from '@loaders.gl/loader-utils';
+import {validateWorkerVersion} from '@loaders.gl/worker-utils';
+import {isLoaderObject} from '../loader-utils/normalize-loader';
+import {normalizeOptions} from '../loader-utils/option-utils';
+import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
+import {getLoaderImplementation} from './load-loader';
+import {parse} from './parse';
+import {selectLoader} from './select-loader';
+
+/**
+ * Parses a random access readable file asynchronously using the supplied loader.
+ */
+export async function parseFile<
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
+>(
+  file: ReadableFile,
+  loader: LoaderT,
+  options?: OptionsT,
+  context?: LoaderContext
+): Promise<LoaderReturnType<LoaderT>>;
+
+/**
+ * Parses a random access readable file asynchronously by matching one of the supplied loaders.
+ */
+export async function parseFile<
+  LoaderArrayT extends Loader[],
+  OptionsT extends LoaderOptions = LoaderArrayOptionsType<LoaderArrayT>
+>(
+  file: ReadableFile,
+  loaders: LoaderArrayT,
+  options?: OptionsT,
+  context?: LoaderContext
+): Promise<LoaderArrayReturnType<LoaderArrayT>>;
+
+/**
+ * Parses a random access readable file asynchronously by matching a pre-registered loader.
+ * @deprecated Loader registration is deprecated, use parseFile(file, loaders, options) instead.
+ */
+export async function parseFile(file: ReadableFile, options?: LoaderOptions): Promise<unknown>;
+
+/**
+ * Parses a random access readable file using a specified loader.
+ * @param file readable file
+ * @param loaders loader or loaders to use
+ * @param options loader options
+ * @param context loader context
+ * @returns parsed data
+ */
+export async function parseFile(
+  file: ReadableFile,
+  loaders?: Loader | Loader[] | LoaderOptions,
+  options?: LoaderOptions,
+  context?: LoaderContext
+): Promise<unknown> {
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = undefined;
+    options = loaders as LoaderOptions;
+    loaders = undefined;
+  }
+
+  options = options || {};
+  const url = file.url || '';
+  const typedLoaders = loaders as Loader | Loader[] | undefined;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(url, candidateLoaders, options);
+  if (!loader) {
+    return null;
+  }
+
+  if (isSourceLoader(loader)) {
+    throw new Error(
+      `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`
+    );
+  }
+
+  // @ts-expect-error candidateLoaders may be a single forced loader
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const authenticationLoader =
+    !loader.getAuthentications && normalizedOptions.core?.credentials?.length
+      ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url)
+      : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(
+    authenticationLoader,
+    url,
+    normalizedOptions
+  );
+  context = getLoaderContext(
+    // @ts-expect-error candidateLoaders may be a single forced loader
+    {url, _parse: parse, loaders: candidateLoaders},
+    strictOptions,
+    context || null
+  );
+
+  return await parseFileWithLoader(loader, file, strictOptions, context);
+}
+
+/**
+ * Parses a readable file after a loader has been selected.
+ * @param loader selected loader
+ * @param file readable file
+ * @param options strict loader options
+ * @param context loader context
+ * @returns parsed data
+ */
+async function parseFileWithLoader(
+  loader: Loader,
+  file: ReadableFile,
+  options: StrictLoaderOptions,
+  context: LoaderContext
+): Promise<unknown> {
+  validateWorkerVersion(loader);
+  options = mergeOptions(loader.options, options);
+
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if (loaderWithParser.parseFile) {
+    return await loaderWithParser.parseFile(file, options, context);
+  }
+
+  const parseFunction = (loaderWithParser as {parse?: LoaderWithParser['parse']}).parse;
+  if (parseFunction) {
+    const length = file.bigsize > 0n ? Number(file.bigsize) : file.size;
+    if (!length) {
+      throw new Error(`${loader.id} loader - cannot fall back to parse without a file size`);
+    }
+    const data = await file.read(0n, length);
+    return await parse(data, loaderWithParser, options, context);
+  }
+
+  throw new Error(`${loader.id} loader - no file parser found`);
+}

package/src/lib/api/parse-in-batches.ts

@@ -4,25 +4,34 @@
 
 import type {Batch} from '@loaders.gl/schema';
 import {isTable, makeBatchFromTable} from '@loaders.gl/schema-utils';
+import {resolveLoaderAuthenticationOptions} from '@loaders.gl/loader-utils';
 import type {
   Loader,
   LoaderWithParser,
   StrictLoaderOptions,
   LoaderOptions,
   LoaderContext,
+  LoaderOptionsWithShape,
   BatchableDataType,
   LoaderOptionsType,
+  LoaderShapeType,
   LoaderBatchType,
   LoaderArrayOptionsType,
   LoaderArrayBatchType,
   TransformBatches
 } from '@loaders.gl/loader-utils';
-import {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
+import {
+  canParseWithWorker,
+  concatenateArrayBuffersAsync,
+  isBrowser,
+  parseWithWorkerInBatches
+} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
 import {getLoaderContext} from '../loader-utils/loader-context';
 import {getAsyncIterableFromData} from '../loader-utils/get-data';
 import {getResourceUrl} from '../utils/resource-utils';
+import {getLoaderImplementation} from './load-loader';
 import {selectLoader} from './select-loader';
 
 // Ensure `parse` is available in context if loader falls back to `parse`
@@ -33,7 +42,10 @@ import {parse} from './parse';
  */
 export async function parseInBatches<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
 >(
   data: BatchableDataType,
   loader: LoaderT,
@@ -101,20 +113,31 @@ export async function parseInBatches(
   }
 
   // Normalize options
-  const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+  const normalizedOptions = normalizeOptions(options, loader, loaderArray, url);
+  const authenticationLoader =
+    !loader.getAuthentications && normalizedOptions.core?.credentials?.length
+      ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url)
+      : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(
+    authenticationLoader,
+    url || '',
+    normalizedOptions
+  );
   context = getLoaderContext(
     {url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray},
     strictOptions,
     context || null
   );
 
-  return await parseWithLoaderInBatches(loader as LoaderWithParser, data, strictOptions, context);
+  const loaderWithParser = await getLoaderImplementation(loader, strictOptions, context.url);
+  return await parseWithLoaderInBatches(loader, loaderWithParser, data, strictOptions, context);
 }
 
 /**
  * Loader has been selected and context has been prepared, see if we need to emit a metadata batch
  */
 async function parseWithLoaderInBatches(
+  originalLoader: Loader,
   loader: LoaderWithParser,
   data: BatchableDataType,
   options: StrictLoaderOptions,
@@ -131,7 +154,7 @@ async function parseWithLoaderInBatches(
     shape: 'metadata',
     batchType: 'metadata',
     metadata: {
-      _loader: loader,
+      _loader: originalLoader,
       _context: context
     },
     // Populate with some default fields to avoid crashing
@@ -169,8 +192,12 @@ async function parseToOutputIterator(
     options?.core?.transforms || []
   );
 
-  // If loader supports parseInBatches, we are done
+  // Stream supported browser batch parsers through one stateful worker session.
   if (loader.parseInBatches) {
+    // The loader-level adapter is intentionally piloted with CSV Arrow batches first.
+    if (loader.id === 'csv' && isBrowser && canParseWithWorker(loader, options)) {
+      return parseWithWorkerInBatches(loader, transformedIterator, options, context, parse);
+    }
     return loader.parseInBatches(transformedIterator, options, context);
   }
 
@@ -182,7 +209,7 @@ async function* parseChunkInBatches(
   transformedIterator:
     | Iterable<ArrayBufferLike | ArrayBufferView>
     | AsyncIterable<ArrayBufferLike | ArrayBufferView>,
-  loader: Loader,
+  loader: LoaderWithParser,
   options: StrictLoaderOptions,
   context: LoaderContext
 ): AsyncIterable<Batch> {
@@ -207,7 +234,7 @@ async function* parseChunkInBatches(
  * @todo run through batch builder to apply options etc...
  */
 function convertDataToBatch(parsedData: unknown, loader: Loader): Batch {
-  // prettier-ignore
+  // biome-ignore format: preserve intentional fixture layout
   const batch: Batch = isTable(parsedData)
     ? makeBatchFromTable(parsedData)
     : {

package/src/lib/api/parse-sync.ts

@@ -7,19 +7,23 @@ import type {
   LoaderWithParser,
   LoaderOptions,
   LoaderContext,
+  LoaderOptionsWithShape,
   SyncDataType,
   LoaderOptionsType,
+  LoaderShapeType,
   LoaderReturnType,
   LoaderArrayOptionsType,
   LoaderArrayReturnType,
   StrictLoaderOptions
 } from '@loaders.gl/loader-utils';
+import {isSourceLoader} from '@loaders.gl/loader-utils';
 import {selectLoaderSync} from './select-loader';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
 import {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';
 import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
 import {getResourceUrl} from '../utils/resource-utils';
+import {getLoaderImplementationSync} from './load-loader';
 
 // OVERLOADS
 
@@ -28,7 +32,10 @@ import {getResourceUrl} from '../utils/resource-utils';
  */
 export function parseSync<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
 >(
   data: SyncDataType,
   loader: LoaderT,
@@ -84,6 +91,12 @@ export function parseSync(
     return null;
   }
 
+  if (isSourceLoader(loader)) {
+    throw new Error(
+      `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseSync().`
+    );
+  }
+
   // Normalize options
   const strictOptions = normalizeOptions(options, loader, candidateLoaders as Loader[] | undefined);
 
@@ -99,7 +112,13 @@ export function parseSync(
     context || null
   );
 
-  return parseWithLoaderSync(loader as LoaderWithParser, data, strictOptions, context);
+  const loaderWithParser = getLoaderImplementationSync(loader);
+  return parseWithLoaderSync(
+    loaderWithParser || (loader as LoaderWithParser),
+    data,
+    strictOptions,
+    context
+  );
 }
 
 // TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
@@ -119,6 +138,12 @@ function parseWithLoaderSync(
     return loader.parseSync(data, options, context); // , loader);
   }
 
+  if (loader.preload) {
+    throw new Error(
+      `${loader.name} loader: 'parseSync' requires a parser-bearing loader. Import the loader implementation directly, or call preload(loader) before parseSync(). ${context.url || ''}`
+    );
+  }
+
   // TBD - If synchronous parser not available, return null
   throw new Error(
     `${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${

package/src/lib/api/parse.ts

@@ -2,13 +2,16 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {resolveLoaderAuthenticationOptions} from '@loaders.gl/loader-utils';
 import type {
   Loader,
   LoaderContext,
   LoaderOptions,
+  LoaderOptionsWithShape,
   DataType,
   LoaderWithParser,
   LoaderOptionsType,
+  LoaderShapeType,
   LoaderReturnType,
   LoaderArrayOptionsType,
   LoaderArrayReturnType,
@@ -16,16 +19,20 @@ import type {
 } from '@loaders.gl/loader-utils';
 import {
   parseWithWorker,
-  canParseWithWorker,
+  shouldParseWithWorker,
   mergeOptions,
-  isResponse
+  isResponse,
+  isBlob,
+  isSourceLoader
 } from '@loaders.gl/loader-utils';
-import {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';
+import {validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
 import {getArrayBufferOrStringFromData} from '../loader-utils/get-data';
+import {getArrayBufferFromData} from '../loader-utils/get-data';
 import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
 import {getResourceUrl} from '../utils/resource-utils';
+import {getLoaderImplementation} from './load-loader';
 import {selectLoader} from './select-loader';
 
 // type LoaderArrayType<T> = T extends (infer Loader)[] ? LoaderOptionsType<Loader> : T
@@ -35,7 +42,10 @@ import {selectLoader} from './select-loader';
  */
 export async function parse<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
 >(
   data: DataType | Promise<DataType>,
   loader: LoaderT,
@@ -104,9 +114,24 @@ export async function parse(
     return null;
   }
 
+  if (isSourceLoader(loader)) {
+    throw new Error(
+      `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`
+    );
+  }
+
   // Normalize options
   // @ts-expect-error candidateLoaders
-  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
+  const authenticationLoader =
+    !loader.getAuthentications && normalizedOptions.core?.credentials?.length
+      ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url)
+      : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(
+    authenticationLoader,
+    url || '',
+    normalizedOptions
+  );
 
   // Get a context (if already present, will be unchanged)
   context = getLoaderContext(
@@ -139,31 +164,47 @@ async function parseWithLoader(
     context.response = {headers, ok, redirected, status, statusText, type, url};
   }
 
-  data = await getArrayBufferOrStringFromData(data, loader, options);
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
 
-  const loaderWithParser = loader as LoaderWithParser;
+  if (shouldParseWithWorker(loaderWithParser, data, options, context, loader)) {
+    data = await getArrayBufferFromData(data, options);
+    return await parseWithWorker(loaderWithParser, data, options, context, parse);
+  }
 
-  // First check for synchronous text parser, wrap results in promises
-  if (loaderWithParser.parseTextSync && typeof data === 'string') {
-    return loaderWithParser.parseTextSync(data, options, context);
+  if (isBlob(data) && loaderWithParser.parseBlob) {
+    return await loaderWithParser.parseBlob(data, options, context);
   }
 
-  // If we have a workerUrl and the loader can parse the given options efficiently in a worker
-  if (canParseWithWorker(loader, options)) {
-    return await parseWithWorker(loader, data, options, context, parse);
+  data = await getArrayBufferOrStringFromData(data, loader, options);
+
+  return await parseWithLoaderImplementation(loaderWithParser, data, options, context);
+}
+
+async function parseWithLoaderImplementation(
+  loader: LoaderWithParser,
+  data: string | ArrayBuffer,
+  options: StrictLoaderOptions,
+  context: LoaderContext
+): Promise<unknown> {
+  if (loader.parseText && typeof data === 'string') {
+    return await loader.parseText(data, options, context);
   }
 
-  // Check for asynchronous parser
-  if (loaderWithParser.parseText && typeof data === 'string') {
-    return await loaderWithParser.parseText(data, options, context);
+  // Fall back to synchronous text parser, wrap results in promises
+  if (loader.parseTextSync && typeof data === 'string') {
+    return loader.parseTextSync(data, options, context);
   }
 
-  if (loaderWithParser.parse) {
-    return await loaderWithParser.parse(data, options, context);
+  if (loader.parse) {
+    return await loader.parse(data as ArrayBuffer, options, context);
   }
 
-  // This should not happen, all sync loaders should also offer `parse` function
-  assert(!loaderWithParser.parseSync);
+  // All parser-bearing sync loaders should also offer `parse` so async APIs can use them.
+  if (loader.parseSync) {
+    throw new Error(
+      `${loader.name} loader: 'parse' not available on parser-bearing sync loader. Add an async 'parse' function to this loader, or call preload(loader) before parseSync(). ${context.url || ''}`
+    );
+  }
 
   // TBD - If asynchronous parser not available, return null
   throw new Error(`${loader.id} loader - no parser found and worker is disabled`);

package/src/lib/api/preload.ts

@@ -0,0 +1,46 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader, LoaderOptions, LoaderWithParser, SourceLoader} from '@loaders.gl/loader-utils';
+import {
+  getLoaderImplementation,
+  getLoaderImplementationSync,
+  preloadLoaderDependencies
+} from './load-loader';
+
+/**
+ * Prepares a source implementation and its declared dependencies before source creation.
+ */
+export async function preload<SourceT extends SourceLoader>(
+  loader: SourceT,
+  options?: LoaderOptions,
+  url?: string
+): Promise<SourceT>;
+
+/** Prepares a parser and its recursively declared dependencies. */
+export async function preload<LoaderT extends Loader>(
+  loader: LoaderT,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser>;
+
+export async function preload(
+  loader: Loader,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser | SourceLoader> {
+  return loader.subloaders
+    ? await preloadLoaderDependencies(loader, options, url)
+    : await getLoaderImplementation(loader, options, url);
+}
+
+/**
+ * Returns a cached parser-bearing loader implementation if one is already available.
+ */
+export function preloadSync<SourceT extends SourceLoader>(loader: SourceT): SourceT | null;
+/** Returns a cached parser, including prepared default dependency bindings. */
+export function preloadSync(loader: Loader): LoaderWithParser | null;
+export function preloadSync(loader: Loader): LoaderWithParser | SourceLoader | null {
+  return getLoaderImplementationSync(loader);
+}

package/src/lib/api/register-loaders.ts

@@ -28,7 +28,7 @@ export function registerLoaders(loaders: Loader[] | Loader) {
 
   for (const loader of loaders) {
     const normalizedLoader = normalizeLoader(loader);
-    if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
+    if (!loaderRegistry.find(registeredLoader => normalizedLoader === registeredLoader)) {
       // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
       loaderRegistry.unshift(normalizedLoader);
     }

package/src/lib/api/select-loader.ts

@@ -9,7 +9,8 @@ import {
   log,
   isBlob,
   ensureArrayBuffer,
-  isArrayBufferLike
+  isArrayBufferLike,
+  isSourceLoader
 } from '@loaders.gl/loader-utils';
 import {TypedArray} from '@loaders.gl/schema';
 import {normalizeLoader} from '../loader-utils/normalize-loader';
@@ -95,7 +96,9 @@ function mayContainText(response: Response): boolean {
   const mimeType = getResourceMIMEType(response);
   return Boolean(
     mimeType &&
-    (mimeType.startsWith('text/') || mimeType === 'application/json' || mimeType.endsWith('+json'))
+      (mimeType.startsWith('text/') ||
+        mimeType === 'application/json' ||
+        mimeType.endsWith('+json'))
   );
 }
 
@@ -169,12 +172,23 @@ function selectLoaderInternal(
   let loader: Loader | null = null;
   let reason: string = '';
 
+  // if options.mimeType is supplied, it takes precedence
+  const sourceType =
+    options?.core && 'type' in options.core ? (options.core.type as string | undefined) : undefined;
+  if (sourceType && sourceType !== 'auto') {
+    loader = findSourceLoaderByType(loaders, sourceType);
+    reason = loader ? `match forced by supplied source type ${sourceType}` : '';
+  }
+
   // if options.mimeType is supplied, it takes precedence
   if (options?.core?.mimeType) {
     loader = findLoaderByMIMEType(loaders, options?.core?.mimeType);
     reason = `match forced by supplied MIME type ${options?.core?.mimeType}`;
   }
 
+  loader = loader || findSourceLoaderByTestURL(loaders, testUrl);
+  reason = reason || (loader ? `matched source url ${testUrl}` : '');
+
   // Look up loader by url
   loader = loader || findLoaderByUrl(loaders, testUrl);
   reason = reason || (loader ? `matched url ${testUrl}` : '');
@@ -189,6 +203,11 @@ function selectLoaderInternal(
   // @ts-ignore Blob | Response
   reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : '');
 
+  if (!loader && isBlob(data)) {
+    loader = findSourceLoaderByTestData(loaders, data);
+    reason = reason || (loader ? 'matched source testData' : '');
+  }
+
   // Look up loader by fallback mime type
   if (options?.core?.fallbackMimeType) {
     loader = loader || findLoaderByMIMEType(loaders, options?.core?.fallbackMimeType);
@@ -258,9 +277,42 @@ function findLoaderByExtension(loaders: Loader[], extension: string): Loader | n
   return null;
 }
 
+function findSourceLoaderByType(loaders: Loader[], type: string): Loader | null {
+  for (const loader of loaders) {
+    if (isSourceLoader(loader) && loader.type === type) {
+      return loader;
+    }
+  }
+  return null;
+}
+
+function findSourceLoaderByTestURL(loaders: Loader[], url?: string): Loader | null {
+  if (!url) {
+    return null;
+  }
+
+  for (const loader of loaders) {
+    if (isSourceLoader(loader) && loader.testURL(url)) {
+      return loader;
+    }
+  }
+  return null;
+}
+
+function findSourceLoaderByTestData(loaders: Loader[], data: Blob): Loader | null {
+  for (const loader of loaders) {
+    if (isSourceLoader(loader)) {
+      if (loader.testData?.(data)) {
+        return loader;
+      }
+    }
+  }
+  return null;
+}
+
 function findLoaderByMIMEType(loaders: Loader[], mimeType: string): Loader | null {
   for (const loader of loaders) {
-    if (loader.mimeTypes?.some((mimeType1) => compareMIMETypes(mimeType, mimeType1))) {
+    if (loader.mimeTypes?.some(mimeType1 => compareMIMETypes(mimeType, mimeType1))) {
       return loader;
     }
 
@@ -305,12 +357,12 @@ function testDataAgainstText(data: string, loader: Loader): boolean {
   }
 
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-  return tests.some((test) => data.startsWith(test as string));
+  return tests.some(test => data.startsWith(test as string));
 }
 
 function testDataAgainstBinary(data: ArrayBufferLike, byteOffset: number, loader: Loader): boolean {
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-  return tests.some((test) => testBinary(data, byteOffset, loader, test));
+  return tests.some(test => testBinary(data, byteOffset, loader, test));
 }
 
 function testBinary(