@loaders.gl/core 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/lib/api/load-in-batches.js

@@ -1,28 +1,42 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isLoaderObject } from "../loader-utils/normalize-loader.js";
 import { getFetchFunction } from "../loader-utils/get-fetch-function.js";
 import { parseInBatches } from "./parse-in-batches.js";
 export function loadInBatches(files, loaders, options, context) {
-  let loadersArray;
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loadersArray = undefined;
-  } else {
-    loadersArray = loaders;
-  }
-  const fetch = getFetchFunction(options || {});
-  if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loadersArray, options || {}, fetch);
-  }
-  const promises = files.map(file => loadOneFileInBatches(file, loadersArray, options || {}, fetch));
-  return promises;
+    let loadersArray;
+    // Signature: load(url, options)
+    if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loadersArray = undefined;
+    }
+    else {
+        loadersArray = loaders;
+    }
+    // Select fetch function
+    const fetch = getFetchFunction(options || {});
+    // Single url/file
+    if (!Array.isArray(files)) {
+        return loadOneFileInBatches(files, loadersArray, options || {}, fetch);
+    }
+    // Multiple URLs / files
+    const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch));
+    // No point in waiting here for all responses before starting to stream individual streams?
+    return promises;
 }
 async function loadOneFileInBatches(file, loaders, options, fetch) {
-  if (typeof file === 'string') {
-    const url = file;
-    const response = await fetch(url);
-    return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
-  }
-  return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
+    if (typeof file === 'string') {
+        const url = file;
+        const response = await fetch(url);
+        // pick right overload
+        return Array.isArray(loaders)
+            ? await parseInBatches(response, loaders, options)
+            : await parseInBatches(response, loaders, options);
+    }
+    // pick right overload
+    return Array.isArray(loaders)
+        ? await parseInBatches(file, loaders, options)
+        : await parseInBatches(file, loaders, options);
 }
-//# sourceMappingURL=load-in-batches.js.map

package/dist/lib/api/load.js

@@ -1,26 +1,41 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isBlob } from "../../javascript-utils/is-type.js";
 import { isLoaderObject } from "../loader-utils/normalize-loader.js";
 import { getFetchFunction } from "../loader-utils/get-fetch-function.js";
 import { parse } from "./parse.js";
+// implementation signature
 export async function load(url, loaders, options, context) {
-  let resolvedLoaders;
-  let resolvedOptions;
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    resolvedLoaders = [];
-    resolvedOptions = loaders;
-    context = undefined;
-  } else {
-    resolvedLoaders = loaders;
-    resolvedOptions = options;
-  }
-  const fetch = getFetchFunction(resolvedOptions);
-  let data = url;
-  if (typeof url === 'string') {
-    data = await fetch(url);
-  }
-  if (isBlob(url)) {
-    data = await fetch(url);
-  }
-  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
+    let resolvedLoaders;
+    let resolvedOptions;
+    // Signature: load(url, options)
+    if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+        resolvedLoaders = [];
+        resolvedOptions = loaders;
+        context = undefined; // context not supported in short signature
+    }
+    else {
+        resolvedLoaders = loaders;
+        resolvedOptions = options;
+    }
+    // Select fetch function
+    const fetch = getFetchFunction(resolvedOptions);
+    // at this point, `url` could be already loaded binary data
+    let data = url;
+    // url is a string, fetch the url
+    if (typeof url === 'string') {
+        data = await fetch(url);
+        // URL is Blob or File, fetchFile handles it (alt: we could generate ObjectURL here)
+    }
+    if (isBlob(url)) {
+        // The fetch response object will contain blob.name
+        // @ts-expect-error TODO - This may not work for overridden fetch functions
+        data = await fetch(url);
+    }
+    // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`
+    // return await parse(data, loaders as Loader[], options);
+    return Array.isArray(resolvedLoaders)
+        ? await parse(data, resolvedLoaders, resolvedOptions) // loader array overload
+        : await parse(data, resolvedLoaders, resolvedOptions); // single loader overload
 }
-//# sourceMappingURL=load.js.map

package/dist/lib/api/loader-options.d.ts

@@ -1,3 +1,3 @@
-export { setGlobalOptions as setLoaderOptions } from '../loader-utils/option-utils';
-export { getGlobalLoaderOptions as getLoaderOptions } from '../loader-utils/option-utils';
+export { setGlobalOptions as setLoaderOptions } from "../loader-utils/option-utils.js";
+export { getGlobalLoaderOptions as getLoaderOptions } from "../loader-utils/option-utils.js";
 //# sourceMappingURL=loader-options.d.ts.map

package/dist/lib/api/loader-options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader-options.d.ts","sourceRoot":"","sources":["../../../src/lib/api/loader-options.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,gBAAgB,IAAI,gBAAgB,EAAC,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAC,sBAAsB,IAAI,gBAAgB,EAAC,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"loader-options.d.ts","sourceRoot":"","sources":["../../../src/lib/api/loader-options.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,gBAAgB,IAAI,gBAAgB,EAAC,wCAAqC;AAClF,OAAO,EAAC,sBAAsB,IAAI,gBAAgB,EAAC,wCAAqC"}

package/dist/lib/api/loader-options.js

@@ -1,3 +1,5 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 export { setGlobalOptions as setLoaderOptions } from "../loader-utils/option-utils.js";
 export { getGlobalLoaderOptions as getLoaderOptions } from "../loader-utils/option-utils.js";
-//# sourceMappingURL=loader-options.js.map

package/dist/lib/api/parse-in-batches.js

@@ -1,3 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isTable, makeBatchFromTable } from '@loaders.gl/schema';
 import { concatenateArrayBuffersAsync } from '@loaders.gl/loader-utils';
 import { isLoaderObject } from "../loader-utils/normalize-loader.js";
@@ -6,84 +9,117 @@ import { getLoaderContext } from "../loader-utils/loader-context.js";
 import { getAsyncIterableFromData } from "../loader-utils/get-data.js";
 import { getResourceUrl } from "../utils/resource-utils.js";
 import { selectLoader } from "./select-loader.js";
+// Ensure `parse` is available in context if loader falls back to `parse`
 import { parse } from "./parse.js";
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
 export async function parseInBatches(data, loaders, options, context) {
-  const loaderArray = Array.isArray(loaders) ? loaders : undefined;
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-  data = await data;
-  options = options || {};
-  const url = getResourceUrl(data);
-  const loader = await selectLoader(data, loaders, options);
-  if (!loader) {
-    return [];
-  }
-  options = normalizeOptions(options, loader, loaderArray, url);
-  context = getLoaderContext({
-    url,
-    _parseInBatches: parseInBatches,
-    _parse: parse,
-    loaders: loaderArray
-  }, options, context || null);
-  return await parseWithLoaderInBatches(loader, data, options, context);
+    const loaderArray = Array.isArray(loaders) ? loaders : undefined;
+    // Signature: parseInBatches(data, options, url) - Uses registered loaders
+    if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = undefined;
+    }
+    data = await data; // Resolve any promise
+    options = options || {};
+    // Extract a url for auto detection
+    const url = getResourceUrl(data);
+    // Chooses a loader and normalizes it
+    // Note - only uses URL and contentType for streams and iterator inputs
+    const loader = await selectLoader(data, loaders, options);
+    // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null
+    if (!loader) {
+        return [];
+    }
+    // Normalize options
+    options = normalizeOptions(options, loader, loaderArray, url);
+    context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, options, context || null);
+    return await parseWithLoaderInBatches(loader, data, options, context);
 }
+/**
+ * Loader has been selected and context has been prepared, see if we need to emit a metadata batch
+ */
 async function parseWithLoaderInBatches(loader, data, options, context) {
-  const outputIterator = await parseToOutputIterator(loader, data, options, context);
-  if (!options.metadata) {
-    return outputIterator;
-  }
-  const metadataBatch = {
-    shape: 'metadata',
-    batchType: 'metadata',
-    metadata: {
-      _loader: loader,
-      _context: context
-    },
-    data: [],
-    bytesUsed: 0
-  };
-  async function* makeMetadataBatchIterator(iterator) {
-    yield metadataBatch;
-    yield* iterator;
-  }
-  return makeMetadataBatchIterator(outputIterator);
+    const outputIterator = await parseToOutputIterator(loader, data, options, context);
+    // Generate metadata batch if requested
+    if (!options.metadata) {
+        return outputIterator;
+    }
+    const metadataBatch = {
+        shape: 'metadata',
+        batchType: 'metadata',
+        metadata: {
+            _loader: loader,
+            _context: context
+        },
+        // Populate with some default fields to avoid crashing
+        data: [],
+        bytesUsed: 0
+    };
+    async function* makeMetadataBatchIterator(iterator) {
+        yield metadataBatch;
+        yield* iterator;
+    }
+    return makeMetadataBatchIterator(outputIterator);
 }
+/**
+ * Prep work is done, now it is time to start parsing into an output operator
+ * The approach depends on which parse function the loader exposes
+ * `parseInBatches` (preferred), `parse` (fallback)
+ */
 async function parseToOutputIterator(loader, data, options, context) {
-  const inputIterator = await getAsyncIterableFromData(data, options);
-  const transformedIterator = await applyInputTransforms(inputIterator, (options === null || options === void 0 ? void 0 : options.transforms) || []);
-  if (loader.parseInBatches) {
-    return loader.parseInBatches(transformedIterator, options, context);
-  }
-  return parseChunkInBatches(transformedIterator, loader, options, context);
+    // Get an iterator from the input
+    const inputIterator = await getAsyncIterableFromData(data, options);
+    // Apply any iterator transforms (options.transforms)
+    const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);
+    // If loader supports parseInBatches, we are done
+    if (loader.parseInBatches) {
+        return loader.parseInBatches(transformedIterator, options, context);
+    }
+    return parseChunkInBatches(transformedIterator, loader, options, context);
 }
+// Fallback: load atomically using `parse` concatenating input iterator into single chunk
 async function* parseChunkInBatches(transformedIterator, loader, options, context) {
-  const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
-  const parsedData = await parse(arrayBuffer, loader, {
-    ...options,
-    mimeType: loader.mimeTypes[0]
-  }, context);
-  const batch = convertDataToBatch(parsedData, loader);
-  yield batch;
+    const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
+    // Call `parse` instead of `loader.parse` to ensure we can call workers etc.
+    const parsedData = await parse(arrayBuffer, loader, 
+    // TODO - Hack: supply loaders MIME type to ensure we match it
+    { ...options, mimeType: loader.mimeTypes[0] }, context);
+    // yield a single batch, the output from loader.parse() repackaged as a batch
+    const batch = convertDataToBatch(parsedData, loader);
+    yield batch;
 }
+/**
+ * Convert parsed data into a single batch
+ * @todo run through batch builder to apply options etc...
+ */
 function convertDataToBatch(parsedData, loader) {
-  const batch = isTable(parsedData) ? makeBatchFromTable(parsedData) : {
-    shape: 'unknown',
-    batchType: 'data',
-    data: parsedData,
-    length: Array.isArray(parsedData) ? parsedData.length : 1
-  };
-  batch.mimeType = loader.mimeTypes[0];
-  return batch;
+    const batch = isTable(parsedData)
+        ? makeBatchFromTable(parsedData)
+        : {
+            shape: 'unknown',
+            batchType: 'data',
+            data: parsedData,
+            length: Array.isArray(parsedData) ? parsedData.length : 1
+        };
+    batch.mimeType = loader.mimeTypes[0];
+    return batch;
 }
-async function applyInputTransforms(inputIterator) {
-  let transforms = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-  let iteratorChain = inputIterator;
-  for await (const transformBatches of transforms) {
-    iteratorChain = transformBatches(iteratorChain);
-  }
-  return iteratorChain;
+/**
+ * Create an iterator chain with any transform iterators (crypto, decompression)
+ * @param inputIterator
+ * @param options
+ */
+async function applyInputTransforms(inputIterator, transforms = []) {
+    let iteratorChain = inputIterator;
+    for await (const transformBatches of transforms) {
+        iteratorChain = transformBatches(iteratorChain);
+    }
+    return iteratorChain;
 }
-//# sourceMappingURL=parse-in-batches.js.map

package/dist/lib/api/parse-sync.js

@@ -1,43 +1,52 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { selectLoaderSync } from "./select-loader.js";
 import { isLoaderObject } from "../loader-utils/normalize-loader.js";
 import { normalizeOptions } from "../loader-utils/option-utils.js";
 import { getArrayBufferOrStringFromDataSync } from "../loader-utils/get-data.js";
 import { getLoaderContext, getLoadersFromContext } from "../loader-utils/loader-context.js";
 import { getResourceUrl } from "../utils/resource-utils.js";
+/**
+ * Parses `data` synchronously using a specified loader
+ */
 export function parseSync(data, loaders, options, context) {
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-  options = options || {};
-  const typedLoaders = loaders;
-  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = selectLoaderSync(data, candidateLoaders, options);
-  if (!loader) {
-    return null;
-  }
-  options = normalizeOptions(options, loader, candidateLoaders);
-  const url = getResourceUrl(data);
-  const parse = () => {
-    throw new Error('parseSync called parse (which is async');
-  };
-  context = getLoaderContext({
-    url,
-    _parseSync: parse,
-    _parse: parse,
-    loaders: loaders
-  }, options, context || null);
-  return parseWithLoaderSync(loader, data, options, context);
+    // Signature: parseSync(data, options)
+    // Uses registered loaders
+    if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = undefined;
+    }
+    options = options || {};
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+    const loader = selectLoaderSync(data, candidateLoaders, options);
+    // Note: if nothrow option was set, it is possible that no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    options = normalizeOptions(options, loader, candidateLoaders);
+    // Extract a url for auto detection
+    const url = getResourceUrl(data);
+    const parse = () => {
+        throw new Error('parseSync called parse (which is async');
+    };
+    context = getLoaderContext({ url, _parseSync: parse, _parse: parse, loaders: loaders }, options, context || null);
+    return parseWithLoaderSync(loader, data, options, context);
 }
+// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
 function parseWithLoaderSync(loader, data, options, context) {
-  data = getArrayBufferOrStringFromDataSync(data, loader, options);
-  if (loader.parseTextSync && typeof data === 'string') {
-    return loader.parseTextSync(data, options);
-  }
-  if (loader.parseSync && data instanceof ArrayBuffer) {
-    return loader.parseSync(data, options, context);
-  }
-  throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ''}`);
+    data = getArrayBufferOrStringFromDataSync(data, loader, options);
+    if (loader.parseTextSync && typeof data === 'string') {
+        return loader.parseTextSync(data, options); // , context, loader);
+    }
+    if (loader.parseSync && data instanceof ArrayBuffer) {
+        return loader.parseSync(data, options, context); // , loader);
+    }
+    // TBD - If synchronous parser not available, return null
+    throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ''}`);
 }
-//# sourceMappingURL=parse-sync.js.map

package/dist/lib/api/parse.js

@@ -1,3 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { parseWithWorker, canParseWithWorker } from '@loaders.gl/loader-utils';
 import { assert, validateWorkerVersion } from '@loaders.gl/worker-utils';
 import { isLoaderObject } from "../loader-utils/normalize-loader.js";
@@ -8,68 +11,77 @@ import { getArrayBufferOrStringFromData } from "../loader-utils/get-data.js";
 import { getLoaderContext, getLoadersFromContext } from "../loader-utils/loader-context.js";
 import { getResourceUrl } from "../utils/resource-utils.js";
 import { selectLoader } from "./select-loader.js";
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+// implementation signature
 export async function parse(data, loaders, options, context) {
-  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
-    context = undefined;
-    options = loaders;
-    loaders = undefined;
-  }
-  data = await data;
-  options = options || {};
-  const url = getResourceUrl(data);
-  const typedLoaders = loaders;
-  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = await selectLoader(data, candidateLoaders, options);
-  if (!loader) {
-    return null;
-  }
-  options = normalizeOptions(options, loader, candidateLoaders, url);
-  context = getLoaderContext({
-    url,
-    _parse: parse,
-    loaders: candidateLoaders
-  }, options, context || null);
-  return await parseWithLoader(loader, data, options, context);
+    // Signature: parse(data, options, context | url)
+    // Uses registered loaders
+    if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
+        context = undefined; // context not supported in short signature
+        options = loaders;
+        loaders = undefined;
+    }
+    data = await data; // Resolve any promise
+    options = options || {}; // Could be invalid...
+    // Extract a url for auto detection
+    const url = getResourceUrl(data);
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+    // todo hacky type cast
+    const loader = await selectLoader(data, candidateLoaders, options);
+    // Note: if no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    // @ts-expect-error
+    options = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
+    // Get a context (if already present, will be unchanged)
+    context = getLoaderContext(
+    // @ts-expect-error
+    { url, _parse: parse, loaders: candidateLoaders }, options, context || null);
+    return await parseWithLoader(loader, data, options, context);
 }
+// TODO: support progress and abort
+// TODO - should accept loader.parseAsyncIterator and concatenate.
 async function parseWithLoader(loader, data, options, context) {
-  validateWorkerVersion(loader);
-  options = mergeLoaderOptions(loader.options, options);
-  if (isResponse(data)) {
-    const response = data;
-    const {
-      ok,
-      redirected,
-      status,
-      statusText,
-      type,
-      url
-    } = response;
-    const headers = Object.fromEntries(response.headers.entries());
-    context.response = {
-      headers,
-      ok,
-      redirected,
-      status,
-      statusText,
-      type,
-      url
-    };
-  }
-  data = await getArrayBufferOrStringFromData(data, loader, options);
-  const loaderWithParser = loader;
-  if (loaderWithParser.parseTextSync && typeof data === 'string') {
-    return loaderWithParser.parseTextSync(data, options, context);
-  }
-  if (canParseWithWorker(loader, options)) {
-    return await parseWithWorker(loader, data, options, context, parse);
-  }
-  if (loaderWithParser.parseText && typeof data === 'string') {
-    return await loaderWithParser.parseText(data, options, context);
-  }
-  if (loaderWithParser.parse) {
-    return await loaderWithParser.parse(data, options, context);
-  }
-  assert(!loaderWithParser.parseSync);
-  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+    validateWorkerVersion(loader);
+    options = mergeLoaderOptions(loader.options, options);
+    if (isResponse(data)) {
+        // Serialize to support passing the response to web worker
+        const response = data;
+        const { ok, redirected, status, statusText, type, url } = response;
+        const headers = Object.fromEntries(response.headers.entries());
+        // @ts-expect-error TODO - fix this
+        context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
+    data = await getArrayBufferOrStringFromData(data, loader, options);
+    const loaderWithParser = loader;
+    // First check for synchronous text parser, wrap results in promises
+    if (loaderWithParser.parseTextSync && typeof data === 'string') {
+        return loaderWithParser.parseTextSync(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);
+    }
+    // Check for asynchronous parser
+    if (loaderWithParser.parseText && typeof data === 'string') {
+        return await loaderWithParser.parseText(data, options, context);
+    }
+    if (loaderWithParser.parse) {
+        return await loaderWithParser.parse(data, options, context);
+    }
+    // This should not happen, all sync loaders should also offer `parse` function
+    assert(!loaderWithParser.parseSync);
+    // TBD - If asynchronous parser not available, return null
+    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
 }
-//# sourceMappingURL=parse.js.map

package/dist/lib/api/register-loaders.js

@@ -1,25 +1,34 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { normalizeLoader } from "../loader-utils/normalize-loader.js";
 import { getGlobalLoaderState } from "../loader-utils/option-utils.js";
+/**
+ * Store global registered loaders on the global object to increase chances of cross loaders-version interoperability
+ * This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
+ */
 const getGlobalLoaderRegistry = () => {
-  const state = getGlobalLoaderState();
-  state.loaderRegistry = state.loaderRegistry || [];
-  return state.loaderRegistry;
+    const state = getGlobalLoaderState();
+    state.loaderRegistry = state.loaderRegistry || [];
+    return state.loaderRegistry;
 };
+/** Register a list of global loaders */
 export function registerLoaders(loaders) {
-  const loaderRegistry = getGlobalLoaderRegistry();
-  loaders = Array.isArray(loaders) ? loaders : [loaders];
-  for (const loader of loaders) {
-    const normalizedLoader = normalizeLoader(loader);
-    if (!loaderRegistry.find(registeredLoader => normalizedLoader === registeredLoader)) {
-      loaderRegistry.unshift(normalizedLoader);
+    const loaderRegistry = getGlobalLoaderRegistry();
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    for (const loader of loaders) {
+        const normalizedLoader = normalizeLoader(loader);
+        if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
+            // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
+            loaderRegistry.unshift(normalizedLoader);
+        }
     }
-  }
 }
 export function getRegisteredLoaders() {
-  return getGlobalLoaderRegistry();
+    return getGlobalLoaderRegistry();
 }
+/** @deprecated For testing only  */
 export function _unregisterLoaders() {
-  const state = getGlobalLoaderState();
-  state.loaderRegistry = [];
+    const state = getGlobalLoaderState();
+    state.loaderRegistry = [];
 }
-//# sourceMappingURL=register-loaders.js.map