@loaders.gl/core 3.1.0-alpha.5 → 3.1.0-beta.1

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInBatches = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+const loader_context_1 = require("../loader-utils/loader-context");
+const get_data_1 = require("../loader-utils/get-data");
+const resource_utils_1 = require("../utils/resource-utils");
+const select_loader_1 = require("./select-loader");
+// Ensure `parse` is available in context if loader falls back to `parse`
+const parse_1 = require("./parse");
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+async function parseInBatches(data, loaders, options, context) {
+    (0, loader_utils_1.assert)(!context || typeof context === 'object'); // parseInBatches no longer accepts final url
+    // Signature: parseInBatches(data, options, url) - Uses registered loaders
+    if (!Array.isArray(loaders) && !(0, normalize_loader_1.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 } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    // Chooses a loader and normalizes it
+    // Note - only uses URL and contentType for streams and iterator inputs
+    const loader = await (0, select_loader_1.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) {
+        // @ts-ignore
+        return null;
+    }
+    // Normalize options
+    // @ts-ignore
+    options = (0, option_utils_1.normalizeOptions)(options, loader, loaders, url);
+    // @ts-ignore
+    context = (0, loader_context_1.getLoaderContext)(
+    // @ts-ignore
+    { url, parseInBatches, parse: parse_1.parse, loaders: loaders }, options, context);
+    return await parseWithLoaderInBatches(loader, data, options, context);
+}
+exports.parseInBatches = parseInBatches;
+/**
+ * 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);
+    // Generate metadata batch if requested
+    if (!options.metadata) {
+        return outputIterator;
+    }
+    const metadataBatch = {
+        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) {
+    // Get an iterator from the input
+    const inputIterator = await (0, get_data_1.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);
+    }
+    // Fallback: load atomically using `parse` concatenating input iterator into single chunk
+    async function* parseChunkInBatches() {
+        const arrayBuffer = await (0, loader_utils_1.concatenateArrayBuffersAsync)(transformedIterator);
+        // Call `parse` instead of `loader.parse` to ensure we can call workers etc.
+        const parsedData = await (0, parse_1.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()
+        // TODO - run through batch builder to apply options etc...
+        const batch = {
+            mimeType: loader.mimeTypes[0],
+            shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',
+            batchType: 'data',
+            data: parsedData,
+            length: Array.isArray(parsedData) ? parsedData.length : 1
+        };
+        yield batch;
+    }
+    return parseChunkInBatches();
+}
+/**
+ * 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;
+}

package/dist/lib/api/parse-sync.d.ts

@@ -0,0 +1,10 @@
+import type { SyncDataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Parses `data` synchronously using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+export declare function parseSync(data: SyncDataType, loaders?: Loader | Loader[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): any;
+//# sourceMappingURL=parse-sync.d.ts.map

package/dist/lib/api/parse-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-sync.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse-sync.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EAEN,aAAa,EACb,aAAa,EACd,MAAM,0BAA0B,CAAC;AASlC;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,YAAY,EAClB,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,GAAG,CAmCL"}

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSync = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const select_loader_1 = require("./select-loader");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+const get_data_1 = require("../loader-utils/get-data");
+const loader_context_1 = require("../loader-utils/loader-context");
+const resource_utils_1 = require("../utils/resource-utils");
+/**
+ * Parses `data` synchronously using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+function parseSync(data, loaders, options, context) {
+    (0, loader_utils_1.assert)(!context || typeof context === 'object'); // parseSync no longer accepts final url
+    // Signature: parseSync(data, options)
+    // Uses registered loaders
+    if (!Array.isArray(loaders) && !(0, normalize_loader_1.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 = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
+    const loader = (0, select_loader_1.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 = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders);
+    // Extract a url for auto detection
+    const { url } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    const parse = () => {
+        throw new Error('parseSync called parse');
+    };
+    context = (0, loader_context_1.getLoaderContext)({ url, parseSync, parse, loaders: loaders }, options);
+    return parseWithLoaderSync(loader, data, options, context);
+}
+exports.parseSync = parseSync;
+// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
+function parseWithLoaderSync(loader, data, options, context) {
+    data = (0, get_data_1.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 || ''}`);
+}

package/dist/lib/api/parse.d.ts

@@ -0,0 +1,10 @@
+import type { DataType, Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+export declare function parse(data: DataType | Promise<DataType>, loaders?: Loader | Loader[] | LoaderOptions, options?: LoaderOptions, context?: LoaderContext): Promise<any>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/lib/api/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/lib/api/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAU7F;;;;;;GAMG;AACH,wBAAsB,KAAK,CACzB,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EAClC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,aAAa,EAC3C,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,GAAG,CAAC,CAmCd"}

package/dist/lib/api/parse.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const worker_utils_1 = require("@loaders.gl/worker-utils");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+const get_data_1 = require("../loader-utils/get-data");
+const loader_context_1 = require("../loader-utils/loader-context");
+const resource_utils_1 = require("../utils/resource-utils");
+const select_loader_1 = require("./select-loader");
+/**
+ * Parses `data` using a specified loader
+ * @param data
+ * @param loaders
+ * @param options
+ * @param context
+ */
+async function parse(data, loaders, options, context) {
+    (0, worker_utils_1.assert)(!context || typeof context === 'object'); // parse no longer accepts final url
+    // Signature: parse(data, options, context | url)
+    // Uses registered loaders
+    if (loaders && !Array.isArray(loaders) && !(0, normalize_loader_1.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 } = (0, resource_utils_1.getResourceUrlAndType)(data);
+    // Chooses a loader (and normalizes it)
+    // Also use any loaders in the context, new loaders take priority
+    const typedLoaders = loaders;
+    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
+    // todo hacky type cast
+    const loader = await (0, select_loader_1.selectLoader)(data, candidateLoaders, options);
+    // Note: if no loader was found, if so just return null
+    if (!loader) {
+        return null;
+    }
+    // Normalize options
+    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders, url);
+    // Get a context (if already present, will be unchanged)
+    context = (0, loader_context_1.getLoaderContext)({ url, parse, loaders: candidateLoaders }, options, context);
+    return await parseWithLoader(loader, data, options, context);
+}
+exports.parse = parse;
+// TODO: support progress and abort
+// TODO - should accept loader.parseAsyncIterator and concatenate.
+async function parseWithLoader(loader, data, options, context) {
+    (0, worker_utils_1.validateWorkerVersion)(loader);
+    data = await (0, get_data_1.getArrayBufferOrStringFromData)(data, loader, options);
+    // First check for synchronous text parser, wrap results in promises
+    if (loader.parseTextSync && typeof data === 'string') {
+        options.dataType = 'text';
+        return loader.parseTextSync(data, options, context, loader);
+    }
+    // If we have a workerUrl and the loader can parse the given options efficiently in a worker
+    if ((0, loader_utils_1.canParseWithWorker)(loader, options)) {
+        return await (0, loader_utils_1.parseWithWorker)(loader, data, options, context, parse);
+    }
+    // Check for asynchronous parser
+    if (loader.parseText && typeof data === 'string') {
+        return await loader.parseText(data, options, context, loader);
+    }
+    if (loader.parse) {
+        return await loader.parse(data, options, context, loader);
+    }
+    // This should not happen, all sync loaders should also offer `parse` function
+    (0, worker_utils_1.assert)(!loader.parseSync);
+    // TBD - If asynchronous parser not available, return null
+    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+}

package/dist/lib/api/register-loaders.d.ts

@@ -0,0 +1,7 @@
+import { Loader } from '@loaders.gl/loader-utils';
+/** Register a list of global loaders */
+export declare function registerLoaders(loaders: Loader[]): void;
+export declare function getRegisteredLoaders(): Loader[];
+/** @deprecated For testing only  */
+export declare function _unregisterLoaders(): void;
+//# sourceMappingURL=register-loaders.d.ts.map

package/dist/lib/api/register-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-loaders.d.ts","sourceRoot":"","sources":["../../../src/lib/api/register-loaders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAYhD,wCAAwC;AACxC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAYhD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED,oCAAoC;AACpC,wBAAgB,kBAAkB,SAGjC"}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._unregisterLoaders = exports.getRegisteredLoaders = exports.registerLoaders = void 0;
+const normalize_loader_1 = require("../loader-utils/normalize-loader");
+const option_utils_1 = require("../loader-utils/option-utils");
+// 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 = (0, option_utils_1.getGlobalLoaderState)();
+    state.loaderRegistry = state.loaderRegistry || [];
+    return state.loaderRegistry;
+};
+/** Register a list of global loaders */
+function registerLoaders(loaders) {
+    const loaderRegistry = getGlobalLoaderRegistry();
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    for (const loader of loaders) {
+        const normalizedLoader = (0, normalize_loader_1.normalizeLoader)(loader);
+        if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
+            // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
+            loaderRegistry.unshift(normalizedLoader);
+        }
+    }
+}
+exports.registerLoaders = registerLoaders;
+function getRegisteredLoaders() {
+    return getGlobalLoaderRegistry();
+}
+exports.getRegisteredLoaders = getRegisteredLoaders;
+/** @deprecated For testing only  */
+function _unregisterLoaders() {
+    const state = (0, option_utils_1.getGlobalLoaderState)();
+    state.loaderRegistry = [];
+}
+exports._unregisterLoaders = _unregisterLoaders;

package/dist/lib/api/save.d.ts

@@ -0,0 +1,4 @@
+import type { Writer, WriterOptions } from '@loaders.gl/loader-utils';
+export declare function save(data: any, url: any, writer: Writer, options: WriterOptions): Promise<void>;
+export declare function saveSync(data: any, url: any, writer: any, options: any): void;
+//# sourceMappingURL=save.d.ts.map

package/dist/lib/api/save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../../src/lib/api/save.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAIpE,wBAAsB,IAAI,CAAC,IAAI,KAAA,EAAE,GAAG,KAAA,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,iBAG3E;AAED,wBAAgB,QAAQ,CAAC,IAAI,KAAA,EAAE,GAAG,KAAA,EAAE,MAAM,KAAA,EAAE,OAAO,KAAA,QAGlD"}

package/dist/lib/api/save.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSync = exports.save = void 0;
+const encode_1 = require("./encode");
+const write_file_1 = require("../fetch/write-file");
+async function save(data, url, writer, options) {
+    const encodedData = await (0, encode_1.encode)(data, writer, options);
+    return await (0, write_file_1.writeFile)(url, encodedData);
+}
+exports.save = save;
+function saveSync(data, url, writer, options) {
+    const encodedData = (0, encode_1.encodeSync)(data, writer, options);
+    return (0, write_file_1.writeFileSync)(url, encodedData);
+}
+exports.saveSync = saveSync;

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

@@ -0,0 +1,22 @@
+import type { LoaderContext, LoaderOptions, Loader } from '@loaders.gl/loader-utils';
+/**
+ * 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
+ */
+export declare function selectLoader(data: Response | Blob | ArrayBuffer | string, loaders?: Loader[] | Loader, options?: LoaderOptions, context?: LoaderContext): Promise<Loader | null>;
+/**
+ * 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
+ */
+export declare function selectLoaderSync(data: Response | Blob | ArrayBuffer | string, loaders?: Loader[] | Loader, options?: LoaderOptions, context?: LoaderContext): Loader | null;
+//# sourceMappingURL=select-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"select-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/api/select-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAanF;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM,EAC5C,OAAO,GAAE,MAAM,EAAE,GAAG,MAAW,EAC/B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAwBxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,WAAW,GAAG,MAAM,EAC5C,OAAO,GAAE,MAAM,EAAE,GAAG,MAAW,EAC/B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,aAAa,GACtB,MAAM,GAAG,IAAI,CAmCf"}

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

@@ -0,0 +1,239 @@
+"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");
+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));
+    }
+    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;
+}
+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;
+}
+/** 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;
+        }
+    }
+    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;
+}
+function normalizeLoaders(loaders) {
+    for (const loader of loaders) {
+        (0, normalize_loader_1.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;
+}
+function findLoaderByExtension(loaders, extension) {
+    extension = extension.toLowerCase();
+    for (const loader of loaders) {
+        for (const loaderExtension of loader.extensions) {
+            if (loaderExtension.toLowerCase() === extension) {
+                return loader;
+            }
+        }
+    }
+    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;
+        }
+    }
+    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)
+    }
+    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));
+}
+function testDataAgainstBinary(data, byteOffset, loader) {
+    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;
+    }
+}
+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 '';
+}
+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;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Set global loader options
+ * @param options
+ */
+export declare function setLoaderOptions(options: object): void;
+//# sourceMappingURL=set-loader-options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set-loader-options.d.ts","sourceRoot":"","sources":["../../../src/lib/api/set-loader-options.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEtD"}

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

@@ -0,0 +1,12 @@
+"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);
+}
+exports.setLoaderOptions = setLoaderOptions;

package/dist/lib/common.d.ts

@@ -0,0 +1,2 @@
+export type { LoaderWithParser } from '@loaders.gl/loader-utils';
+//# sourceMappingURL=common.d.ts.map

package/dist/lib/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/lib/common.ts"],"names":[],"mappings":"AAAA,YAAY,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC"}

package/dist/lib/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });