@loaders.gl/core 3.1.3 → 4.0.0-alpha.5

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

@@ -1,239 +1,228 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectLoaderSync = exports.selectLoader = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const resource_utils_1 = require("../utils/resource-utils");
-const register_loaders_1 = require("./register-loaders");
-const is_type_1 = require("../../javascript-utils/is-type");
+import { compareArrayBuffers, path } from '@loaders.gl/loader-utils';
+import { normalizeLoader } from '../loader-utils/normalize-loader';
+import { getResourceUrlAndType } from '../utils/resource-utils';
+import { getRegisteredLoaders } from './register-loaders';
+import { isBlob } from '../../javascript-utils/is-type';
 const EXT_PATTERN = /\.([^.]+)$/;
-// TODO - Need a variant that peeks at streams for parseInBatches
-// TODO - Detect multiple matching loaders? Use heuristics to grade matches?
-// TODO - Allow apps to pass context to disambiguate between multiple matches (e.g. multiple .json formats)?
-/**
- * Find a loader that matches file extension and/or initial file content
- * Search the loaders array argument for a loader that matches url extension or initial data
- * Returns: a normalized loader
- * @param data data to assist
- * @param loaders
- * @param options
- * @param context used internally, applications should not provide this parameter
- */
-async function selectLoader(data, loaders = [], options, context) {
-    if (!validHTTPResponse(data)) {
-        return null;
-    }
-    // First make a sync attempt, disabling exceptions
-    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
-    if (loader) {
-        return loader;
-    }
-    // For Blobs and Files, try to asynchronously read a small initial slice and test again with that
-    // to see if we can detect by initial content
-    if ((0, is_type_1.isBlob)(data)) {
-        data = await data.slice(0, 10).arrayBuffer();
-        loader = selectLoaderSync(data, loaders, options, context);
-    }
-    // no loader available
-    if (!loader && !options?.nothrow) {
-        throw new Error(getNoValidLoaderMessage(data));
-    }
+export async function selectLoader(data, loaders = [], options, context) {
+  if (!validHTTPResponse(data)) {
+    return null;
+  }
+
+  let loader = selectLoaderSync(data, loaders, { ...options,
+    nothrow: true
+  }, context);
+
+  if (loader) {
     return loader;
+  }
+
+  if (isBlob(data)) {
+    data = await data.slice(0, 10).arrayBuffer();
+    loader = selectLoaderSync(data, loaders, options, context);
+  }
+
+  if (!loader && !(options !== null && options !== void 0 && options.nothrow)) {
+    throw new Error(getNoValidLoaderMessage(data));
+  }
+
+  return loader;
 }
-exports.selectLoader = selectLoader;
-/**
- * Find a loader that matches file extension and/or initial file content
- * Search the loaders array argument for a loader that matches url extension or initial data
- * Returns: a normalized loader
- * @param data data to assist
- * @param loaders
- * @param options
- * @param context used internally, applications should not provide this parameter
- */
-function selectLoaderSync(data, loaders = [], options, context) {
-    if (!validHTTPResponse(data)) {
-        return null;
-    }
-    // eslint-disable-next-line complexity
-    // if only a single loader was provided (not as array), force its use
-    // TODO - Should this behavior be kept and documented?
-    if (loaders && !Array.isArray(loaders)) {
-        // TODO - remove support for legacy loaders
-        return (0, normalize_loader_1.normalizeLoader)(loaders);
-    }
-    // Build list of candidate loaders that will be searched in order for a match
-    let candidateLoaders = [];
-    // First search supplied loaders
-    if (loaders) {
-        candidateLoaders = candidateLoaders.concat(loaders);
-    }
-    // Then fall back to registered loaders
-    if (!options?.ignoreRegisteredLoaders) {
-        candidateLoaders.push(...(0, register_loaders_1.getRegisteredLoaders)());
-    }
-    // TODO - remove support for legacy loaders
-    normalizeLoaders(candidateLoaders);
-    const loader = selectLoaderInternal(data, candidateLoaders, options, context);
-    // no loader available
-    if (!loader && !options?.nothrow) {
-        throw new Error(getNoValidLoaderMessage(data));
-    }
-    return loader;
+export function selectLoaderSync(data, loaders = [], options, context) {
+  if (!validHTTPResponse(data)) {
+    return null;
+  }
+
+  if (loaders && !Array.isArray(loaders)) {
+    return normalizeLoader(loaders);
+  }
+
+  let candidateLoaders = [];
+
+  if (loaders) {
+    candidateLoaders = candidateLoaders.concat(loaders);
+  }
+
+  if (!(options !== null && options !== void 0 && options.ignoreRegisteredLoaders)) {
+    candidateLoaders.push(...getRegisteredLoaders());
+  }
+
+  normalizeLoaders(candidateLoaders);
+  const loader = selectLoaderInternal(data, candidateLoaders, options, context);
+
+  if (!loader && !(options !== null && options !== void 0 && options.nothrow)) {
+    throw new Error(getNoValidLoaderMessage(data));
+  }
+
+  return loader;
 }
-exports.selectLoaderSync = selectLoaderSync;
-/** Implements loaders selection logic */
+
 function selectLoaderInternal(data, loaders, options, context) {
-    const { url, type } = (0, resource_utils_1.getResourceUrlAndType)(data);
-    const testUrl = url || context?.url;
-    let loader = null;
-    // if options.mimeType is supplied, it takes precedence
-    if (options?.mimeType) {
-        loader = findLoaderByMIMEType(loaders, options?.mimeType);
-    }
-    // Look up loader by url
-    loader = loader || findLoaderByUrl(loaders, testUrl);
-    // Look up loader by mime type
-    loader = loader || findLoaderByMIMEType(loaders, type);
-    // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)
-    loader = loader || findLoaderByInitialBytes(loaders, data);
-    // Look up loader by fallback mime type
-    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-    return loader;
+  const {
+    url,
+    type
+  } = getResourceUrlAndType(data);
+  const testUrl = url || (context === null || context === void 0 ? void 0 : context.url);
+  let loader = null;
+
+  if (options !== null && options !== void 0 && options.mimeType) {
+    loader = findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.mimeType);
+  }
+
+  loader = loader || findLoaderByUrl(loaders, testUrl);
+  loader = loader || findLoaderByMIMEType(loaders, type);
+  loader = loader || findLoaderByInitialBytes(loaders, data);
+  loader = loader || findLoaderByMIMEType(loaders, options === null || options === void 0 ? void 0 : options.fallbackMimeType);
+  return loader;
 }
-/** Check HTTP Response */
+
 function validHTTPResponse(data) {
-    // HANDLE HTTP status
-    if (data instanceof Response) {
-        // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile
-        if (data.status === 204) {
-            return false;
-        }
+  if (data instanceof Response) {
+    if (data.status === 204) {
+      return false;
     }
-    return true;
+  }
+
+  return true;
 }
-/** Generate a helpful message to help explain why loader selection failed. */
+
 function getNoValidLoaderMessage(data) {
-    const { url, type } = (0, resource_utils_1.getResourceUrlAndType)(data);
-    let message = 'No valid loader found (';
-    message += url ? `${loader_utils_1.path.filename(url)}, ` : 'no url provided, ';
-    message += `MIME type: ${type ? `"${type}"` : 'not provided'}, `;
-    // First characters are only accessible when called on data (string or arrayBuffer).
-    const firstCharacters = data ? getFirstCharacters(data) : '';
-    message += firstCharacters ? ` first bytes: "${firstCharacters}"` : 'first bytes: not available';
-    message += ')';
-    return message;
+  const {
+    url,
+    type
+  } = getResourceUrlAndType(data);
+  let message = 'No valid loader found (';
+  message += url ? "".concat(path.filename(url), ", ") : 'no url provided, ';
+  message += "MIME type: ".concat(type ? "\"".concat(type, "\"") : 'not provided', ", ");
+  const firstCharacters = data ? getFirstCharacters(data) : '';
+  message += firstCharacters ? " first bytes: \"".concat(firstCharacters, "\"") : 'first bytes: not available';
+  message += ')';
+  return message;
 }
+
 function normalizeLoaders(loaders) {
-    for (const loader of loaders) {
-        (0, normalize_loader_1.normalizeLoader)(loader);
-    }
+  for (const loader of loaders) {
+    normalizeLoader(loader);
+  }
 }
-// TODO - Would be nice to support http://example.com/file.glb?parameter=1
-// E.g: x = new URL('http://example.com/file.glb?load=1'; x.pathname
+
 function findLoaderByUrl(loaders, url) {
-    // Get extension
-    const match = url && EXT_PATTERN.exec(url);
-    const extension = match && match[1];
-    return extension ? findLoaderByExtension(loaders, extension) : null;
+  const match = url && EXT_PATTERN.exec(url);
+  const extension = match && match[1];
+  return extension ? findLoaderByExtension(loaders, extension) : null;
 }
+
 function findLoaderByExtension(loaders, extension) {
-    extension = extension.toLowerCase();
-    for (const loader of loaders) {
-        for (const loaderExtension of loader.extensions) {
-            if (loaderExtension.toLowerCase() === extension) {
-                return loader;
-            }
-        }
+  extension = extension.toLowerCase();
+
+  for (const loader of loaders) {
+    for (const loaderExtension of loader.extensions) {
+      if (loaderExtension.toLowerCase() === extension) {
+        return loader;
+      }
     }
-    return null;
+  }
+
+  return null;
 }
+
 function findLoaderByMIMEType(loaders, mimeType) {
-    for (const loader of loaders) {
-        if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
-            return loader;
-        }
-        // Support referring to loaders using the "unregistered tree"
-        // https://en.wikipedia.org/wiki/Media_type#Unregistered_tree
-        if (mimeType === `application/x.${loader.id}`) {
-            return loader;
-        }
+  for (const loader of loaders) {
+    if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
+      return loader;
     }
-    return null;
+
+    if (mimeType === "application/x.".concat(loader.id)) {
+      return loader;
+    }
+  }
+
+  return null;
 }
+
 function findLoaderByInitialBytes(loaders, data) {
-    if (!data) {
-        return null;
-    }
-    for (const loader of loaders) {
-        if (typeof data === 'string') {
-            if (testDataAgainstText(data, loader)) {
-                return loader;
-            }
-        }
-        else if (ArrayBuffer.isView(data)) {
-            // Typed Arrays can have offsets into underlying buffer
-            if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
-                return loader;
-            }
-        }
-        else if (data instanceof ArrayBuffer) {
-            const byteOffset = 0;
-            if (testDataAgainstBinary(data, byteOffset, loader)) {
-                return loader;
-            }
-        }
-        // TODO Handle streaming case (requires creating a new AsyncIterator)
-    }
+  if (!data) {
     return null;
+  }
+
+  for (const loader of loaders) {
+    if (typeof data === 'string') {
+      if (testDataAgainstText(data, loader)) {
+        return loader;
+      }
+    } else if (ArrayBuffer.isView(data)) {
+      if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
+        return loader;
+      }
+    } else if (data instanceof ArrayBuffer) {
+      const byteOffset = 0;
+
+      if (testDataAgainstBinary(data, byteOffset, loader)) {
+        return loader;
+      }
+    }
+  }
+
+  return null;
 }
+
 function testDataAgainstText(data, loader) {
-    if (loader.testText) {
-        return loader.testText(data);
-    }
-    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-    return tests.some((test) => data.startsWith(test));
+  if (loader.testText) {
+    return loader.testText(data);
+  }
+
+  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+  return tests.some(test => data.startsWith(test));
 }
+
 function testDataAgainstBinary(data, byteOffset, loader) {
-    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-    return tests.some((test) => testBinary(data, byteOffset, loader, test));
+  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
+  return tests.some(test => testBinary(data, byteOffset, loader, test));
 }
+
 function testBinary(data, byteOffset, loader, test) {
-    if (test instanceof ArrayBuffer) {
-        return (0, loader_utils_1.compareArrayBuffers)(test, data, test.byteLength);
-    }
-    switch (typeof test) {
-        case 'function':
-            return test(data, loader);
-        case 'string':
-            // Magic bytes check: If `test` is a string, check if binary data starts with that strings
-            const magic = getMagicString(data, byteOffset, test.length);
-            return test === magic;
-        default:
-            return false;
-    }
+  if (test instanceof ArrayBuffer) {
+    return compareArrayBuffers(test, data, test.byteLength);
+  }
+
+  switch (typeof test) {
+    case 'function':
+      return test(data, loader);
+
+    case 'string':
+      const magic = getMagicString(data, byteOffset, test.length);
+      return test === magic;
+
+    default:
+      return false;
+  }
 }
+
 function getFirstCharacters(data, length = 5) {
-    if (typeof data === 'string') {
-        return data.slice(0, length);
-    }
-    else if (ArrayBuffer.isView(data)) {
-        // Typed Arrays can have offsets into underlying buffer
-        return getMagicString(data.buffer, data.byteOffset, length);
-    }
-    else if (data instanceof ArrayBuffer) {
-        const byteOffset = 0;
-        return getMagicString(data, byteOffset, length);
-    }
-    return '';
+  if (typeof data === 'string') {
+    return data.slice(0, length);
+  } else if (ArrayBuffer.isView(data)) {
+    return getMagicString(data.buffer, data.byteOffset, length);
+  } else if (data instanceof ArrayBuffer) {
+    const byteOffset = 0;
+    return getMagicString(data, byteOffset, length);
+  }
+
+  return '';
 }
+
 function getMagicString(arrayBuffer, byteOffset, length) {
-    if (arrayBuffer.byteLength < byteOffset + length) {
-        return '';
-    }
-    const dataView = new DataView(arrayBuffer);
-    let magic = '';
-    for (let i = 0; i < length; i++) {
-        magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
-    }
-    return magic;
+  if (arrayBuffer.byteLength < byteOffset + length) {
+    return '';
+  }
+
+  const dataView = new DataView(arrayBuffer);
+  let magic = '';
+
+  for (let i = 0; i < length; i++) {
+    magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
+  }
+
+  return magic;
 }
+//# sourceMappingURL=select-loader.js.map

package/dist/lib/api/select-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/api/select-loader.ts"],"names":["compareArrayBuffers","path","normalizeLoader","getResourceUrlAndType","getRegisteredLoaders","isBlob","EXT_PATTERN","selectLoader","data","loaders","options","context","validHTTPResponse","loader","selectLoaderSync","nothrow","slice","arrayBuffer","Error","getNoValidLoaderMessage","Array","isArray","candidateLoaders","concat","ignoreRegisteredLoaders","push","normalizeLoaders","selectLoaderInternal","url","type","testUrl","mimeType","findLoaderByMIMEType","findLoaderByUrl","findLoaderByInitialBytes","fallbackMimeType","Response","status","message","filename","firstCharacters","getFirstCharacters","match","exec","extension","findLoaderByExtension","toLowerCase","loaderExtension","extensions","mimeTypes","includes","id","testDataAgainstText","ArrayBuffer","isView","testDataAgainstBinary","buffer","byteOffset","testText","tests","some","test","startsWith","testBinary","byteLength","magic","getMagicString","length","dataView","DataView","i","String","fromCharCode","getUint8"],"mappings":"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","sourcesContent":["import type {LoaderContext, LoaderOptions, Loader} from '@loaders.gl/loader-utils';\nimport {compareArrayBuffers, path} from '@loaders.gl/loader-utils';\nimport {normalizeLoader} from '../loader-utils/normalize-loader';\nimport {getResourceUrlAndType} from '../utils/resource-utils';\nimport {getRegisteredLoaders} from './register-loaders';\nimport {isBlob} from '../../javascript-utils/is-type';\n\nconst EXT_PATTERN = /\\.([^.]+)$/;\n\n// TODO - Need a variant that peeks at streams for parseInBatches\n// TODO - Detect multiple matching loaders? Use heuristics to grade matches?\n// TODO - Allow apps to pass context to disambiguate between multiple matches (e.g. multiple .json formats)?\n\n/**\n * Find a loader that matches file extension and/or initial file content\n * Search the loaders array argument for a loader that matches url extension or initial data\n * Returns: a normalized loader\n * @param data data to assist\n * @param loaders\n * @param options\n * @param context used internally, applications should not provide this parameter\n */\nexport async function selectLoader(\n  data: Response | Blob | ArrayBuffer | string,\n  loaders: Loader[] | Loader = [],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Promise<Loader | null> {\n  if (!validHTTPResponse(data)) {\n    return null;\n  }\n\n  // First make a sync attempt, disabling exceptions\n  let loader = selectLoaderSync(data, loaders, {...options, nothrow: true}, context);\n  if (loader) {\n    return loader;\n  }\n\n  // For Blobs and Files, try to asynchronously read a small initial slice and test again with that\n  // to see if we can detect by initial content\n  if (isBlob(data)) {\n    data = await (data as Blob).slice(0, 10).arrayBuffer();\n    loader = selectLoaderSync(data, loaders, options, context);\n  }\n\n  // no loader available\n  if (!loader && !options?.nothrow) {\n    throw new Error(getNoValidLoaderMessage(data));\n  }\n\n  return loader;\n}\n\n/**\n * Find a loader that matches file extension and/or initial file content\n * Search the loaders array argument for a loader that matches url extension or initial data\n * Returns: a normalized loader\n * @param data data to assist\n * @param loaders\n * @param options\n * @param context used internally, applications should not provide this parameter\n */\nexport function selectLoaderSync(\n  data: Response | Blob | ArrayBuffer | string,\n  loaders: Loader[] | Loader = [],\n  options?: LoaderOptions,\n  context?: LoaderContext\n): Loader | null {\n  if (!validHTTPResponse(data)) {\n    return null;\n  }\n\n  // eslint-disable-next-line complexity\n  // if only a single loader was provided (not as array), force its use\n  // TODO - Should this behavior be kept and documented?\n  if (loaders && !Array.isArray(loaders)) {\n    // TODO - remove support for legacy loaders\n    return normalizeLoader(loaders);\n  }\n\n  // Build list of candidate loaders that will be searched in order for a match\n  let candidateLoaders: Loader[] = [];\n  // First search supplied loaders\n  if (loaders) {\n    candidateLoaders = candidateLoaders.concat(loaders);\n  }\n  // Then fall back to registered loaders\n  if (!options?.ignoreRegisteredLoaders) {\n    candidateLoaders.push(...getRegisteredLoaders());\n  }\n\n  // TODO - remove support for legacy loaders\n  normalizeLoaders(candidateLoaders);\n\n  const loader = selectLoaderInternal(data, candidateLoaders, options, context);\n\n  // no loader available\n  if (!loader && !options?.nothrow) {\n    throw new Error(getNoValidLoaderMessage(data));\n  }\n\n  return loader;\n}\n\n/** Implements loaders selection logic */\nfunction selectLoaderInternal(\n  data: Response | Blob | ArrayBuffer | string,\n  loaders: Loader[],\n  options?: LoaderOptions,\n  context?: LoaderContext\n) {\n  const {url, type} = getResourceUrlAndType(data);\n\n  const testUrl = url || context?.url;\n\n  let loader: Loader | null = null;\n\n  // if options.mimeType is supplied, it takes precedence\n  if (options?.mimeType) {\n    loader = findLoaderByMIMEType(loaders, options?.mimeType);\n  }\n  // Look up loader by url\n  loader = loader || findLoaderByUrl(loaders, testUrl);\n  // Look up loader by mime type\n  loader = loader || findLoaderByMIMEType(loaders, type);\n  // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)\n  loader = loader || findLoaderByInitialBytes(loaders, data);\n  // Look up loader by fallback mime type\n  loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);\n\n  return loader;\n}\n\n/** Check HTTP Response */\nfunction validHTTPResponse(data: any): boolean {\n  // HANDLE HTTP status\n  if (data instanceof Response) {\n    // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile\n    if (data.status === 204) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Generate a helpful message to help explain why loader selection failed. */\nfunction getNoValidLoaderMessage(data): string {\n  const {url, type} = getResourceUrlAndType(data);\n\n  let message = 'No valid loader found (';\n  message += url ? `${path.filename(url)}, ` : 'no url provided, ';\n  message += `MIME type: ${type ? `\"${type}\"` : 'not provided'}, `;\n  // First characters are only accessible when called on data (string or arrayBuffer).\n  const firstCharacters: string = data ? getFirstCharacters(data) : '';\n  message += firstCharacters ? ` first bytes: \"${firstCharacters}\"` : 'first bytes: not available';\n  message += ')';\n  return message;\n}\n\nfunction normalizeLoaders(loaders: Loader[]): void {\n  for (const loader of loaders) {\n    normalizeLoader(loader);\n  }\n}\n\n// TODO - Would be nice to support http://example.com/file.glb?parameter=1\n// E.g: x = new URL('http://example.com/file.glb?load=1'; x.pathname\nfunction findLoaderByUrl(loaders: Loader[], url?: string): Loader | null {\n  // Get extension\n  const match = url && EXT_PATTERN.exec(url);\n  const extension = match && match[1];\n  return extension ? findLoaderByExtension(loaders, extension) : null;\n}\n\nfunction findLoaderByExtension(loaders: Loader[], extension: string): Loader | null {\n  extension = extension.toLowerCase();\n\n  for (const loader of loaders) {\n    for (const loaderExtension of loader.extensions) {\n      if (loaderExtension.toLowerCase() === extension) {\n        return loader;\n      }\n    }\n  }\n  return null;\n}\n\nfunction findLoaderByMIMEType(loaders, mimeType) {\n  for (const loader of loaders) {\n    if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {\n      return loader;\n    }\n\n    // Support referring to loaders using the \"unregistered tree\"\n    // https://en.wikipedia.org/wiki/Media_type#Unregistered_tree\n    if (mimeType === `application/x.${loader.id}`) {\n      return loader;\n    }\n  }\n  return null;\n}\n\nfunction findLoaderByInitialBytes(loaders, data) {\n  if (!data) {\n    return null;\n  }\n\n  for (const loader of loaders) {\n    if (typeof data === 'string') {\n      if (testDataAgainstText(data, loader)) {\n        return loader;\n      }\n    } else if (ArrayBuffer.isView(data)) {\n      // Typed Arrays can have offsets into underlying buffer\n      if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {\n        return loader;\n      }\n    } else if (data instanceof ArrayBuffer) {\n      const byteOffset = 0;\n      if (testDataAgainstBinary(data, byteOffset, loader)) {\n        return loader;\n      }\n    }\n    // TODO Handle streaming case (requires creating a new AsyncIterator)\n  }\n  return null;\n}\n\nfunction testDataAgainstText(data, loader) {\n  if (loader.testText) {\n    return loader.testText(data);\n  }\n\n  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];\n  return tests.some((test) => data.startsWith(test));\n}\n\nfunction testDataAgainstBinary(data, byteOffset, loader) {\n  const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];\n  return tests.some((test) => testBinary(data, byteOffset, loader, test));\n}\n\nfunction testBinary(data, byteOffset, loader, test) {\n  if (test instanceof ArrayBuffer) {\n    return compareArrayBuffers(test, data, test.byteLength);\n  }\n  switch (typeof test) {\n    case 'function':\n      return test(data, loader);\n\n    case 'string':\n      // Magic bytes check: If `test` is a string, check if binary data starts with that strings\n      const magic = getMagicString(data, byteOffset, test.length);\n      return test === magic;\n\n    default:\n      return false;\n  }\n}\n\nfunction getFirstCharacters(data, length: number = 5) {\n  if (typeof data === 'string') {\n    return data.slice(0, length);\n  } else if (ArrayBuffer.isView(data)) {\n    // Typed Arrays can have offsets into underlying buffer\n    return getMagicString(data.buffer, data.byteOffset, length);\n  } else if (data instanceof ArrayBuffer) {\n    const byteOffset = 0;\n    return getMagicString(data, byteOffset, length);\n  }\n  return '';\n}\n\nfunction getMagicString(arrayBuffer, byteOffset, length) {\n  if (arrayBuffer.byteLength < byteOffset + length) {\n    return '';\n  }\n  const dataView = new DataView(arrayBuffer);\n  let magic = '';\n  for (let i = 0; i < length; i++) {\n    magic += String.fromCharCode(dataView.getUint8(byteOffset + i));\n  }\n  return magic;\n}\n"],"file":"select-loader.js"}

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

@@ -1,12 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setLoaderOptions = void 0;
-const option_utils_1 = require("../loader-utils/option-utils");
-/**
- * Set global loader options
- * @param options
- */
-function setLoaderOptions(options) {
-    (0, option_utils_1.setGlobalOptions)(options);
+import { setGlobalOptions } from '../loader-utils/option-utils';
+export function setLoaderOptions(options) {
+  setGlobalOptions(options);
 }
-exports.setLoaderOptions = setLoaderOptions;
+//# sourceMappingURL=set-loader-options.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/api/set-loader-options.ts"],"names":["setGlobalOptions","setLoaderOptions","options"],"mappings":"AAAA,SAAQA,gBAAR,QAA+B,8BAA/B;AAMA,OAAO,SAASC,gBAAT,CAA0BC,OAA1B,EAAiD;AACtDF,EAAAA,gBAAgB,CAACE,OAAD,CAAhB;AACD","sourcesContent":["import {setGlobalOptions} from '../loader-utils/option-utils';\n\n/**\n * Set global loader options\n * @param options\n */\nexport function setLoaderOptions(options: object): void {\n  setGlobalOptions(options);\n}\n"],"file":"set-loader-options.js"}

package/dist/lib/common.js

@@ -1,2 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
+//# sourceMappingURL=common.js.map

package/dist/lib/fetch/fetch-error-message.js

@@ -1,25 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessageFromResponse = exports.getErrorMessageFromResponseSync = void 0;
-function getErrorMessageFromResponseSync(response) {
-    return `Failed to fetch resource ${response.url}(${response.status}): ${response.statusText} `;
+export function getErrorMessageFromResponseSync(response) {
+  return "Failed to fetch resource ".concat(response.url, "(").concat(response.status, "): ").concat(response.statusText, " ");
 }
-exports.getErrorMessageFromResponseSync = getErrorMessageFromResponseSync;
-async function getErrorMessageFromResponse(response) {
-    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
-    try {
-        const contentType = response.headers.get('Content-Type') || '';
-        if (contentType.includes('application/json')) {
-            message += await response.text();
-        }
-        else {
-            message += response.statusText;
-        }
-    }
-    catch (error) {
-        // eslint forbids return in finally statement
-        return message;
+export async function getErrorMessageFromResponse(response) {
+  let message = "Failed to fetch resource ".concat(response.url, " (").concat(response.status, "): ");
+
+  try {
+    const contentType = response.headers.get('Content-Type') || '';
+
+    if (contentType.includes('application/json')) {
+      message += await response.text();
+    } else {
+      message += response.statusText;
     }
+  } catch (error) {
     return message;
+  }
+
+  return message;
 }
-exports.getErrorMessageFromResponse = getErrorMessageFromResponse;
+//# sourceMappingURL=fetch-error-message.js.map

package/dist/lib/fetch/fetch-error-message.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/fetch/fetch-error-message.ts"],"names":["getErrorMessageFromResponseSync","response","url","status","statusText","getErrorMessageFromResponse","message","contentType","headers","get","includes","text","error"],"mappings":"AAAA,OAAO,SAASA,+BAAT,CAAyCC,QAAzC,EAAqE;AAC1E,4CAAmCA,QAAQ,CAACC,GAA5C,cAAmDD,QAAQ,CAACE,MAA5D,gBAAwEF,QAAQ,CAACG,UAAjF;AACD;AAED,OAAO,eAAeC,2BAAf,CAA2CJ,QAA3C,EAAgF;AACrF,MAAIK,OAAO,sCAA+BL,QAAQ,CAACC,GAAxC,eAAgDD,QAAQ,CAACE,MAAzD,QAAX;;AACA,MAAI;AACF,UAAMI,WAAW,GAAGN,QAAQ,CAACO,OAAT,CAAiBC,GAAjB,CAAqB,cAArB,KAAwC,EAA5D;;AACA,QAAIF,WAAW,CAACG,QAAZ,CAAqB,kBAArB,CAAJ,EAA8C;AAC5CJ,MAAAA,OAAO,IAAI,MAAML,QAAQ,CAACU,IAAT,EAAjB;AACD,KAFD,MAEO;AACLL,MAAAA,OAAO,IAAIL,QAAQ,CAACG,UAApB;AACD;AACF,GAPD,CAOE,OAAOQ,KAAP,EAAc;AAEd,WAAON,OAAP;AACD;;AACD,SAAOA,OAAP;AACD","sourcesContent":["export function getErrorMessageFromResponseSync(response: Response): string {\n  return `Failed to fetch resource ${response.url}(${response.status}): ${response.statusText} `;\n}\n\nexport async function getErrorMessageFromResponse(response: Response): Promise<string> {\n  let message = `Failed to fetch resource ${response.url} (${response.status}): `;\n  try {\n    const contentType = response.headers.get('Content-Type') || '';\n    if (contentType.includes('application/json')) {\n      message += await response.text();\n    } else {\n      message += response.statusText;\n    }\n  } catch (error) {\n    // eslint forbids return in finally statement\n    return message;\n  }\n  return message;\n}\n"],"file":"fetch-error-message.js"}

package/dist/lib/fetch/fetch-file.js

@@ -1,27 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchFile = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const response_utils_1 = require("../utils/response-utils");
-// import {getErrorMessageFromResponse} from './fetch-error-message.js';
-/**
- * fetch compatible function
- * Reads file data from:
- * - http/http urls
- * - data urls
- * - File/Blob objects
- * Leverages `@loaders.gl/polyfills` for Node.js support
- * Respects pathPrefix and file aliases
- */
-async function fetchFile(url, options) {
-    if (typeof url === 'string') {
-        url = (0, loader_utils_1.resolvePath)(url);
-        let fetchOptions = options;
-        if (options?.fetch && typeof options?.fetch !== 'function') {
-            fetchOptions = options.fetch;
-        }
-        return await fetch(url, fetchOptions);
+import { resolvePath } from '@loaders.gl/loader-utils';
+import { makeResponse } from '../utils/response-utils';
+export async function fetchFile(url, options) {
+  if (typeof url === 'string') {
+    url = resolvePath(url);
+    let fetchOptions = options;
+
+    if (options !== null && options !== void 0 && options.fetch && typeof (options === null || options === void 0 ? void 0 : options.fetch) !== 'function') {
+      fetchOptions = options.fetch;
     }
-    return await (0, response_utils_1.makeResponse)(url);
+
+    return await fetch(url, fetchOptions);
+  }
+
+  return await makeResponse(url);
 }
-exports.fetchFile = fetchFile;
+//# sourceMappingURL=fetch-file.js.map

package/dist/lib/fetch/fetch-file.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/fetch/fetch-file.ts"],"names":["resolvePath","makeResponse","fetchFile","url","options","fetchOptions","fetch"],"mappings":"AAAA,SAAQA,WAAR,QAA0B,0BAA1B;AACA,SAAQC,YAAR,QAA2B,yBAA3B;AAYA,OAAO,eAAeC,SAAf,CACLC,GADK,EAELC,OAFK,EAGc;AACnB,MAAI,OAAOD,GAAP,KAAe,QAAnB,EAA6B;AAC3BA,IAAAA,GAAG,GAAGH,WAAW,CAACG,GAAD,CAAjB;AAEA,QAAIE,YAAyB,GAAGD,OAAhC;;AACA,QAAIA,OAAO,SAAP,IAAAA,OAAO,WAAP,IAAAA,OAAO,CAAEE,KAAT,IAAkB,QAAOF,OAAP,aAAOA,OAAP,uBAAOA,OAAO,CAAEE,KAAhB,MAA0B,UAAhD,EAA4D;AAC1DD,MAAAA,YAAY,GAAGD,OAAO,CAACE,KAAvB;AACD;;AAED,WAAO,MAAMA,KAAK,CAACH,GAAD,EAAME,YAAN,CAAlB;AACD;;AAED,SAAO,MAAMJ,YAAY,CAACE,GAAD,CAAzB;AACD","sourcesContent":["import {resolvePath} from '@loaders.gl/loader-utils';\nimport {makeResponse} from '../utils/response-utils';\n// import {getErrorMessageFromResponse} from './fetch-error-message';\n\n/**\n * fetch compatible function\n * Reads file data from:\n * - http/http urls\n * - data urls\n * - File/Blob objects\n * Leverages `@loaders.gl/polyfills` for Node.js support\n * Respects pathPrefix and file aliases\n */\nexport async function fetchFile(\n  url: string | Blob,\n  options?: RequestInit & {fetch?: RequestInit | Function}\n): Promise<Response> {\n  if (typeof url === 'string') {\n    url = resolvePath(url);\n\n    let fetchOptions: RequestInit = options as RequestInit;\n    if (options?.fetch && typeof options?.fetch !== 'function') {\n      fetchOptions = options.fetch;\n    }\n\n    return await fetch(url, fetchOptions);\n  }\n\n  return await makeResponse(url);\n}\n"],"file":"fetch-file.js"}