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

package/dist/lib/loader-utils/option-defaults.js

@@ -1,37 +1,43 @@
-import { ConsoleLog } from './loggers';
-export const DEFAULT_LOADER_OPTIONS = {
-  fetch: null,
-  mimeType: undefined,
-  nothrow: false,
-  log: new ConsoleLog(),
-  CDN: 'https://unpkg.com/@loaders.gl',
-  worker: true,
-  maxConcurrency: 3,
-  maxMobileConcurrency: 1,
-  reuseWorkers: true,
-  _workerType: '',
-  limit: 0,
-  _limitMB: 0,
-  batchSize: 'auto',
-  batchDebounceMs: 0,
-  metadata: false,
-  transforms: []
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOVED_LOADER_OPTIONS = exports.DEFAULT_LOADER_OPTIONS = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const loggers_1 = require("./loggers");
+exports.DEFAULT_LOADER_OPTIONS = {
+    // baseUri
+    fetch: null,
+    mimeType: undefined,
+    nothrow: false,
+    log: new loggers_1.ConsoleLog(),
+    CDN: 'https://unpkg.com/@loaders.gl',
+    worker: true,
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    reuseWorkers: loader_utils_1.isBrowser,
+    _nodeWorkers: false,
+    _workerType: '',
+    limit: 0,
+    _limitMB: 0,
+    batchSize: 'auto',
+    batchDebounceMs: 0,
+    metadata: false,
+    transforms: []
 };
-export const REMOVED_LOADER_OPTIONS = {
-  throws: 'nothrow',
-  dataType: '(no longer used)',
-  uri: 'baseUri',
-  method: 'fetch.method',
-  headers: 'fetch.headers',
-  body: 'fetch.body',
-  mode: 'fetch.mode',
-  credentials: 'fetch.credentials',
-  cache: 'fetch.cache',
-  redirect: 'fetch.redirect',
-  referrer: 'fetch.referrer',
-  referrerPolicy: 'fetch.referrerPolicy',
-  integrity: 'fetch.integrity',
-  keepalive: 'fetch.keepalive',
-  signal: 'fetch.signal'
+exports.REMOVED_LOADER_OPTIONS = {
+    throws: 'nothrow',
+    dataType: '(no longer used)',
+    uri: 'baseUri',
+    // Warn if fetch options are used on top-level
+    method: 'fetch.method',
+    headers: 'fetch.headers',
+    body: 'fetch.body',
+    mode: 'fetch.mode',
+    credentials: 'fetch.credentials',
+    cache: 'fetch.cache',
+    redirect: 'fetch.redirect',
+    referrer: 'fetch.referrer',
+    referrerPolicy: 'fetch.referrerPolicy',
+    integrity: 'fetch.integrity',
+    keepalive: 'fetch.keepalive',
+    signal: 'fetch.signal'
 };
-//# sourceMappingURL=option-defaults.js.map

package/dist/lib/loader-utils/option-utils.d.ts

@@ -1,23 +1,27 @@
-import type { Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { Loader, LoaderOptions } from '@loaders.gl/loader-utils';
 /**
  * Global state for loaders.gl. Stored on `global.loaders._state`
  */
-declare type GlobalLoaderState = {
+type GlobalLoaderState = {
     loaderRegistry: Loader[];
-    globalOptions: {
-        [key: string]: any;
-    };
+    globalOptions: LoaderOptions;
 };
 /**
  * Helper for safely accessing global loaders.gl variables
  * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers
  */
 export declare function getGlobalLoaderState(): GlobalLoaderState;
+/**
+ * Store global loader options on the global object to increase chances of cross loaders-version interoperability
+ * 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 declare const getGlobalLoaderOptions: () => LoaderOptions;
 /**
  * Set global loader options
  * @param options
  */
-export declare function setGlobalOptions(options: object): void;
+export declare function setGlobalOptions(options: LoaderOptions): void;
 /**
  * Merges options with global opts and loader defaults, also injects baseUri
  * @param options
@@ -25,12 +29,6 @@ export declare function setGlobalOptions(options: object): void;
  * @param loaders
  * @param url
  */
-export declare function normalizeOptions(options: object, loader: Loader, loaders?: Loader[], url?: string): object;
-/**
- * Gets the current fetch function from options and context
- * @param options
- * @param context
- */
-export declare function getFetchFunction(options?: LoaderOptions, context?: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>): any;
+export declare function normalizeOptions(options: LoaderOptions, loader: Loader, loaders?: Loader[], url?: string): LoaderOptions;
 export {};
 //# sourceMappingURL=option-utils.d.ts.map

package/dist/lib/loader-utils/option-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"option-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/option-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAKnF;;GAEG;AACH,aAAK,iBAAiB,GAAG;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;CACrC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CASxD;AAWD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAItD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,GAAG,CAAC,EAAE,MAAM,GACX,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,OAuB/E"}
+{"version":3,"file":"option-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/option-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAKpE;;GAEG;AACH,KAAK,iBAAiB,GAAG;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,aAAa,CAAC;CAC9B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CASxD;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAO,aAKzC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAI7D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,GAAG,CAAC,EAAE,MAAM,GACX,aAAa,CAMf"}

package/dist/lib/loader-utils/option-utils.js

@@ -1,140 +1,160 @@
-import { isPureObject, isObject } from '../../javascript-utils/is-type';
-import { fetchFile } from '../fetch/fetch-file';
-import { probeLog, NullLog } from './loggers';
-import { DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS } from './option-defaults';
-export function getGlobalLoaderState() {
-  globalThis.loaders = globalThis.loaders || {};
-  const {
-    loaders
-  } = globalThis;
-  loaders._state = loaders._state || {};
-  return loaders._state;
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = exports.setGlobalOptions = exports.getGlobalLoaderOptions = exports.getGlobalLoaderState = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const loggers_1 = require("./loggers");
+const option_defaults_1 = require("./option-defaults");
+/**
+ * Helper for safely accessing global loaders.gl variables
+ * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers
+ */
+function getGlobalLoaderState() {
+    // @ts-ignore
+    globalThis.loaders = globalThis.loaders || {};
+    // @ts-ignore
+    const { loaders } = globalThis;
+    // Add _state object to keep separate from modules added to globalThis.loaders
+    loaders._state = loaders._state || {};
+    return loaders._state;
 }
-
+exports.getGlobalLoaderState = getGlobalLoaderState;
+/**
+ * Store global loader options on the global object to increase chances of cross loaders-version interoperability
+ * 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
+ */
 const getGlobalLoaderOptions = () => {
-  const state = getGlobalLoaderState();
-  state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS
-  };
-  return state.globalOptions;
+    const state = getGlobalLoaderState();
+    // Ensure all default loader options from this library are mentioned
+    state.globalOptions = state.globalOptions || { ...option_defaults_1.DEFAULT_LOADER_OPTIONS };
+    return state.globalOptions;
 };
-
-export function setGlobalOptions(options) {
-  const state = getGlobalLoaderState();
-  const globalOptions = getGlobalLoaderOptions();
-  state.globalOptions = normalizeOptionsInternal(globalOptions, options);
+exports.getGlobalLoaderOptions = getGlobalLoaderOptions;
+/**
+ * Set global loader options
+ * @param options
+ */
+function setGlobalOptions(options) {
+    const state = getGlobalLoaderState();
+    const globalOptions = (0, exports.getGlobalLoaderOptions)();
+    state.globalOptions = normalizeOptionsInternal(globalOptions, options);
 }
-export function normalizeOptions(options, loader, loaders, url) {
-  loaders = loaders || [];
-  loaders = Array.isArray(loaders) ? loaders : [loaders];
-  validateOptions(options, loaders);
-  return normalizeOptionsInternal(loader, options, url);
+exports.setGlobalOptions = setGlobalOptions;
+/**
+ * Merges options with global opts and loader defaults, also injects baseUri
+ * @param options
+ * @param loader
+ * @param loaders
+ * @param url
+ */
+function normalizeOptions(options, loader, loaders, url) {
+    loaders = loaders || [];
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    validateOptions(options, loaders);
+    return normalizeOptionsInternal(loader, options, url);
 }
-export function getFetchFunction(options, context) {
-  const globalOptions = getGlobalLoaderOptions();
-  const fetchOptions = options || globalOptions;
-
-  if (typeof fetchOptions.fetch === 'function') {
-    return fetchOptions.fetch;
-  }
-
-  if (isObject(fetchOptions.fetch)) {
-    return url => fetchFile(url, fetchOptions);
-  }
-
-  if (context !== null && context !== void 0 && context.fetch) {
-    return context === null || context === void 0 ? void 0 : context.fetch;
-  }
-
-  return fetchFile;
-}
-
+exports.normalizeOptions = normalizeOptions;
+// VALIDATE OPTIONS
+/**
+ * Warn for unsupported options
+ * @param options
+ * @param loaders
+ */
 function validateOptions(options, loaders) {
-  validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
-
-  for (const loader of loaders) {
-    const idOptions = options && options[loader.id] || {};
-    const loaderOptions = loader.options && loader.options[loader.id] || {};
-    const deprecatedOptions = loader.deprecatedOptions && loader.deprecatedOptions[loader.id] || {};
-    validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
-  }
+    // Check top level options
+    validateOptionsObject(options, null, option_defaults_1.DEFAULT_LOADER_OPTIONS, option_defaults_1.REMOVED_LOADER_OPTIONS, loaders);
+    for (const loader of loaders) {
+        // Get the scoped, loader specific options from the user supplied options
+        const idOptions = (options && options[loader.id]) || {};
+        // Get scoped, loader specific default and deprecated options from the selected loader
+        const loaderOptions = (loader.options && loader.options[loader.id]) || {};
+        const deprecatedOptions = (loader.deprecatedOptions && loader.deprecatedOptions[loader.id]) || {};
+        // Validate loader specific options
+        validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
+    }
 }
-
+// eslint-disable-next-line max-params, complexity
 function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) {
-  const loaderName = id || 'Top level';
-  const prefix = id ? "".concat(id, ".") : '';
-
-  for (const key in options) {
-    const isSubOptions = !id && isObject(options[key]);
-    const isBaseUriOption = key === 'baseUri' && !id;
-    const isWorkerUrlOption = key === 'workerUrl' && id;
-
-    if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
-      if (key in deprecatedOptions) {
-        probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' no longer supported, use '").concat(deprecatedOptions[key], "'"))();
-      } else if (!isSubOptions) {
-        const suggestion = findSimilarOption(key, loaders);
-        probeLog.warn("".concat(loaderName, " loader option '").concat(prefix).concat(key, "' not recognized. ").concat(suggestion))();
-      }
+    const loaderName = id || 'Top level';
+    const prefix = id ? `${id}.` : '';
+    for (const key in options) {
+        // If top level option value is an object it could options for a loader, so ignore
+        const isSubOptions = !id && (0, is_type_1.isObject)(options[key]);
+        const isBaseUriOption = key === 'baseUri' && !id;
+        const isWorkerUrlOption = key === 'workerUrl' && id;
+        // <loader>.workerUrl requires special handling as it is now auto-generated and no longer specified as a default option.
+        if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
+            // Issue deprecation warnings
+            if (key in deprecatedOptions) {
+                loggers_1.probeLog.warn(`${loaderName} loader option \'${prefix}${key}\' no longer supported, use \'${deprecatedOptions[key]}\'`)();
+            }
+            else if (!isSubOptions) {
+                const suggestion = findSimilarOption(key, loaders);
+                loggers_1.probeLog.warn(`${loaderName} loader option \'${prefix}${key}\' not recognized. ${suggestion}`)();
+            }
+        }
     }
-  }
 }
-
 function findSimilarOption(optionKey, loaders) {
-  const lowerCaseOptionKey = optionKey.toLowerCase();
-  let bestSuggestion = '';
-
-  for (const loader of loaders) {
-    for (const key in loader.options) {
-      if (optionKey === key) {
-        return "Did you mean '".concat(loader.id, ".").concat(key, "'?");
-      }
-
-      const lowerCaseKey = key.toLowerCase();
-      const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);
-
-      if (isPartialMatch) {
-        bestSuggestion = bestSuggestion || "Did you mean '".concat(loader.id, ".").concat(key, "'?");
-      }
+    const lowerCaseOptionKey = optionKey.toLowerCase();
+    let bestSuggestion = '';
+    for (const loader of loaders) {
+        for (const key in loader.options) {
+            if (optionKey === key) {
+                return `Did you mean \'${loader.id}.${key}\'?`;
+            }
+            const lowerCaseKey = key.toLowerCase();
+            const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);
+            if (isPartialMatch) {
+                bestSuggestion = bestSuggestion || `Did you mean \'${loader.id}.${key}\'?`;
+            }
+        }
     }
-  }
-
-  return bestSuggestion;
+    return bestSuggestion;
 }
-
 function normalizeOptionsInternal(loader, options, url) {
-  const loaderDefaultOptions = loader.options || {};
-  const mergedOptions = { ...loaderDefaultOptions
-  };
-  addUrlOptions(mergedOptions, url);
-
-  if (mergedOptions.log === null) {
-    mergedOptions.log = new NullLog();
-  }
-
-  mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
-  mergeNestedFields(mergedOptions, options);
-  return mergedOptions;
+    const loaderDefaultOptions = loader.options || {};
+    const mergedOptions = { ...loaderDefaultOptions };
+    addUrlOptions(mergedOptions, url);
+    // LOGGING: options.log can be set to `null` to defeat logging
+    if (mergedOptions.log === null) {
+        mergedOptions.log = new loggers_1.NullLog();
+    }
+    mergeNestedFields(mergedOptions, (0, exports.getGlobalLoaderOptions)());
+    mergeNestedFields(mergedOptions, options);
+    return mergedOptions;
 }
-
+// Merge nested options objects
 function mergeNestedFields(mergedOptions, options) {
-  for (const key in options) {
-    if (key in options) {
-      const value = options[key];
-
-      if (isPureObject(value) && isPureObject(mergedOptions[key])) {
-        mergedOptions[key] = { ...mergedOptions[key],
-          ...options[key]
-        };
-      } else {
-        mergedOptions[key] = options[key];
-      }
+    for (const key in options) {
+        // Check for nested options
+        // object in options => either no key in defaultOptions or object in defaultOptions
+        if (key in options) {
+            const value = options[key];
+            if ((0, is_type_1.isPureObject)(value) && (0, is_type_1.isPureObject)(mergedOptions[key])) {
+                mergedOptions[key] = {
+                    ...mergedOptions[key],
+                    ...options[key]
+                };
+            }
+            else {
+                mergedOptions[key] = options[key];
+            }
+        }
+        // else: No need to merge nested opts, and the initial merge already copied over the nested options
     }
-  }
 }
-
+/**
+ * Harvest information from the url
+ * @deprecated This is mainly there to support a hack in the GLTFLoader
+ * TODO - baseUri should be a directory, i.e. remove file component from baseUri
+ * TODO - extract extension?
+ * TODO - extract query parameters?
+ * TODO - should these be injected on context instead of options?
+ */
 function addUrlOptions(options, url) {
-  if (url && !('baseUri' in options)) {
-    options.baseUri = url;
-  }
+    if (url && !('baseUri' in options)) {
+        options.baseUri = url;
+    }
 }
-//# sourceMappingURL=option-utils.js.map

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

@@ -1,61 +1,59 @@
-export default async function fetchProgress(response, onProgress, onDone = () => {}, onError = () => {}) {
-  response = await response;
-
-  if (!response.ok) {
-    return response;
-  }
-
-  const body = response.body;
-
-  if (!body) {
-    return response;
-  }
-
-  const contentLength = response.headers.get('content-length') || 0;
-  const totalBytes = contentLength && parseInt(contentLength);
-
-  if (!(contentLength > 0)) {
-    return response;
-  }
-
-  if (typeof ReadableStream === 'undefined' || !body.getReader) {
-    return response;
-  }
-
-  const progressStream = new ReadableStream({
-    async start(controller) {
-      const reader = body.getReader();
-      await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+"use strict";
+// Forked from github AnthumChris/fetch-progress-indicators under MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Intercepts the Response stream and creates a new Response
+ */
+async function fetchProgress(response, onProgress, // TODO better callback types
+onDone = () => { }, onError = () => { }) {
+    response = await response;
+    if (!response.ok) {
+        // ERROR checking needs to be done separately
+        return response;
     }
-
-  });
-  return new Response(progressStream);
+    const body = response.body;
+    if (!body) {
+        // 'ReadableStream not yet supported in this browser.
+        return response;
+    }
+    const contentLength = response.headers.get('content-length') || 0;
+    const totalBytes = contentLength ? parseInt(contentLength) : 0;
+    if (!(totalBytes > 0)) {
+        return response;
+    }
+    // Currently override only implemented in browser
+    if (typeof ReadableStream === 'undefined' || !body.getReader) {
+        return response;
+    }
+    // Create a new stream that invisbly wraps original stream
+    const progressStream = new ReadableStream({
+        async start(controller) {
+            const reader = body.getReader();
+            await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+        }
+    });
+    return new Response(progressStream);
 }
-
+exports.default = fetchProgress;
+// Forward to original streams controller
+// TODO - this causes a crazy deep "async stack"... rewrite as async iterator?
+// eslint-disable-next-line max-params
 async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
-  try {
-    const {
-      done,
-      value
-    } = await reader.read();
-
-    if (done) {
-      onDone();
-      controller.close();
-      return;
+    try {
+        const { done, value } = await reader.read();
+        if (done) {
+            onDone();
+            controller.close();
+            return;
+        }
+        loadedBytes += value.byteLength;
+        const percent = Math.round((loadedBytes / totalBytes) * 100);
+        onProgress(percent, { loadedBytes, totalBytes });
+        controller.enqueue(value);
+        await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
+    }
+    catch (error) {
+        controller.error(error);
+        onError(error);
     }
-
-    loadedBytes += value.byteLength;
-    const percent = Math.round(loadedBytes / totalBytes * 100);
-    onProgress(percent, {
-      loadedBytes,
-      totalBytes
-    });
-    controller.enqueue(value);
-    await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
-  } catch (error) {
-    controller.error(error);
-    onError(error);
-  }
 }
-//# sourceMappingURL=fetch-progress.js.map

package/dist/lib/utils/log.d.ts

@@ -0,0 +1,3 @@
+import { Log } from '@probe.gl/log';
+export declare const log: Log;
+//# sourceMappingURL=log.d.ts.map

package/dist/lib/utils/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/log.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,eAAe,CAAC;AAElC,eAAO,MAAM,GAAG,KAA8B,CAAC"}

package/dist/lib/utils/log.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = void 0;
+// loaders.gl, MIT license
+const log_1 = require("@probe.gl/log");
+exports.log = new log_1.Log({ id: 'loaders.gl' });

package/dist/lib/utils/mime-type-utils.js

@@ -1,21 +1,42 @@
+"use strict";
+// TODO - build/integrate proper MIME type parsing
+// https://mimesniff.spec.whatwg.org/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMIMETypeFromURL = exports.parseMIMEType = void 0;
 const DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
 const MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
-export function parseMIMEType(mimeString) {
-  const matches = MIME_TYPE_PATTERN.exec(mimeString);
-
-  if (matches) {
-    return matches[1];
-  }
-
-  return mimeString;
+/**
+ * Remove extra data like `charset` from MIME types
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
+function parseMIMEType(mimeString) {
+    // If resource is a data url, extract any embedded mime type
+    const matches = MIME_TYPE_PATTERN.exec(mimeString);
+    if (matches) {
+        return matches[1];
+    }
+    return mimeString;
 }
-export function parseMIMETypeFromURL(url) {
-  const matches = DATA_URL_PATTERN.exec(url);
-
-  if (matches) {
-    return matches[1];
-  }
-
-  return '';
+exports.parseMIMEType = parseMIMEType;
+/**
+ * Extract MIME type from data URL
+ *
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
+function parseMIMETypeFromURL(url) {
+    // If resource is a data URL, extract any embedded mime type
+    const matches = DATA_URL_PATTERN.exec(url);
+    if (matches) {
+        return matches[1];
+    }
+    return '';
 }
-//# sourceMappingURL=mime-type-utils.js.map
+exports.parseMIMETypeFromURL = parseMIMETypeFromURL;