@loaders.gl/core 3.1.0-alpha.4 → 3.1.0-beta.3

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 });

package/dist/lib/fetch/fetch-error-message.d.ts

@@ -0,0 +1,3 @@
+export declare function getErrorMessageFromResponseSync(response: Response): string;
+export declare function getErrorMessageFromResponse(response: Response): Promise<string>;
+//# sourceMappingURL=fetch-error-message.d.ts.map

package/dist/lib/fetch/fetch-error-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-error-message.d.ts","sourceRoot":"","sources":["../../../src/lib/fetch/fetch-error-message.ts"],"names":[],"mappings":"AAAA,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE1E;AAED,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAcrF"}

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

@@ -0,0 +1,25 @@
+"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} `;
+}
+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;
+    }
+    return message;
+}
+exports.getErrorMessageFromResponse = getErrorMessageFromResponse;

package/dist/lib/fetch/fetch-file.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+export declare function fetchFile(url: string | Blob, options?: RequestInit & {
+    fetch?: RequestInit | Function;
+}): Promise<Response>;
+//# sourceMappingURL=fetch-file.d.ts.map

package/dist/lib/fetch/fetch-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-file.d.ts","sourceRoot":"","sources":["../../../src/lib/fetch/fetch-file.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,OAAO,CAAC,EAAE,WAAW,GAAG;IAAC,KAAK,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAA;CAAC,GACvD,OAAO,CAAC,QAAQ,CAAC,CAanB"}

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

@@ -0,0 +1,27 @@
+"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';
+/**
+ * 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);
+    }
+    return await (0, response_utils_1.makeResponse)(url);
+}
+exports.fetchFile = fetchFile;

package/dist/lib/fetch/read-array-buffer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Reads a chunk from a random access file
+ * @param file
+ * @param start
+ * @param length
+ * @returns
+ */
+export declare function readArrayBuffer(file: Blob | ArrayBuffer | string | number, start: number, length: number): Promise<ArrayBuffer>;
+/**
+ * Read a slice of a Blob or File, without loading the entire file into memory
+ * The trick when reading File objects is to read successive "slices" of the File
+ * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
+ * Actually reading from file happens in `readAsArrayBuffer`
+ * @param blob to read
+ */
+export declare function readBlob(blob: Blob): Promise<ArrayBuffer>;
+//# sourceMappingURL=read-array-buffer.d.ts.map

package/dist/lib/fetch/read-array-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-array-buffer.d.ts","sourceRoot":"","sources":["../../../src/lib/fetch/read-array-buffer.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,EAC1C,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC,CAUtB;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAS/D"}

package/dist/lib/fetch/read-array-buffer.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBlob = exports.readArrayBuffer = void 0;
+//
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+/**
+ * Reads a chunk from a random access file
+ * @param file
+ * @param start
+ * @param length
+ * @returns
+ */
+async function readArrayBuffer(file, start, length) {
+    if (typeof file === 'number') {
+        return await loader_utils_1.fs._readToArrayBuffer(file, start, length);
+    }
+    // TODO - we can do better for ArrayBuffer and string
+    if (!(file instanceof Blob)) {
+        file = new Blob([file]);
+    }
+    const slice = file.slice(start, start + length);
+    return await readBlob(slice);
+}
+exports.readArrayBuffer = readArrayBuffer;
+/**
+ * Read a slice of a Blob or File, without loading the entire file into memory
+ * The trick when reading File objects is to read successive "slices" of the File
+ * Per spec https://w3c.github.io/FileAPI/, slicing a File only updates the start and end fields
+ * Actually reading from file happens in `readAsArrayBuffer`
+ * @param blob to read
+ */
+async function readBlob(blob) {
+    return await new Promise((resolve, reject) => {
+        const fileReader = new FileReader();
+        fileReader.onload = (event) => resolve(event?.target?.result);
+        // TODO - reject with a proper Error
+        fileReader.onerror = (error) => reject(error);
+        fileReader.readAsArrayBuffer(blob);
+    });
+}
+exports.readBlob = readBlob;

package/dist/lib/fetch/read-file.d.ts

@@ -0,0 +1,5 @@
+/**
+ * In a few cases (data URIs, node.js) "files" can be read synchronously
+ */
+export declare function readFileSync(url: string, options?: object): ArrayBuffer | null;
+//# sourceMappingURL=read-file.d.ts.map

package/dist/lib/fetch/read-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../../src/lib/fetch/read-file.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,MAAW,sBAoB7D"}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileSync = void 0;
+// File read
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const loader_utils_2 = require("@loaders.gl/loader-utils");
+// TODO - this is not tested
+// const isDataURL = (url) => url.startsWith('data:');
+/**
+ * In a few cases (data URIs, node.js) "files" can be read synchronously
+ */
+function readFileSync(url, options = {}) {
+    url = (0, loader_utils_1.resolvePath)(url);
+    // Only support this if we can also support sync data URL decoding in browser
+    // if (isDataURL(url)) {
+    //   return decodeDataUri(url);
+    // }
+    if (!loader_utils_1.isBrowser) {
+        const buffer = loader_utils_1.fs.readFileSync(url, options);
+        return typeof buffer !== 'string' ? (0, loader_utils_1.toArrayBuffer)(buffer) : buffer;
+    }
+    // @ts-ignore
+    if (!options.nothrow) {
+        // throw new Error('Cant load URI synchronously');
+        (0, loader_utils_2.assert)(false);
+    }
+    return null;
+}
+exports.readFileSync = readFileSync;

package/dist/lib/fetch/write-file.d.ts

@@ -0,0 +1,3 @@
+export declare function writeFile(filePath: string, arrayBufferOrString: ArrayBuffer | string, options?: any): Promise<void>;
+export declare function writeFileSync(filePath: string, arrayBufferOrString: ArrayBuffer | string, options?: any): void;
+//# sourceMappingURL=write-file.d.ts.map

package/dist/lib/fetch/write-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-file.d.ts","sourceRoot":"","sources":["../../../src/lib/fetch/write-file.ts"],"names":[],"mappings":"AAIA,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,WAAW,GAAG,MAAM,EACzC,OAAO,CAAC,KAAA,GACP,OAAO,CAAC,IAAI,CAAC,CAMf;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,mBAAmB,EAAE,WAAW,GAAG,MAAM,EACzC,OAAO,CAAC,KAAA,GACP,IAAI,CAMN"}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileSync = exports.writeFile = void 0;
+// file write
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const loader_utils_2 = require("@loaders.gl/loader-utils");
+async function writeFile(filePath, arrayBufferOrString, options) {
+    filePath = (0, loader_utils_1.resolvePath)(filePath);
+    if (!loader_utils_1.isBrowser) {
+        await loader_utils_2.fs.writeFile(filePath, (0, loader_utils_2.toBuffer)(arrayBufferOrString), { flag: 'w' });
+    }
+    (0, loader_utils_1.assert)(false);
+}
+exports.writeFile = writeFile;
+function writeFileSync(filePath, arrayBufferOrString, options) {
+    filePath = (0, loader_utils_1.resolvePath)(filePath);
+    if (!loader_utils_1.isBrowser) {
+        loader_utils_2.fs.writeFileSync(filePath, (0, loader_utils_2.toBuffer)(arrayBufferOrString), { flag: 'w' });
+    }
+    (0, loader_utils_1.assert)(false);
+}
+exports.writeFileSync = writeFileSync;

package/dist/lib/filesystems/browser-filesystem.d.ts

@@ -0,0 +1,58 @@
+import type { FileSystem } from './filesystem';
+declare type BrowserFileSystemOptions = {
+    fetch?: typeof fetch;
+};
+/**
+ * FileSystem adapter for a browser FileList.
+ * Holds a list of browser 'File' objects.
+ */
+export default class BrowserFileSystem implements FileSystem {
+    private _fetch;
+    private files;
+    private lowerCaseFiles;
+    private usedFiles;
+    /**
+     * A FileSystem API wrapper around a list of browser 'File' objects
+     * @param files
+     * @param options
+     */
+    constructor(files: FileList | File[], options?: BrowserFileSystemOptions);
+    /**
+     * Implementation of fetch against this file system
+     * Delegates to global fetch for http{s}:// or data://
+     */
+    fetch(path: string, options?: RequestInit): Promise<Response>;
+    /**
+     * List filenames in this filesystem
+     * @param dirname
+     * @returns
+     */
+    readdir(dirname?: string): Promise<string[]>;
+    /**
+     * Return information (size) about files in this file system
+     */
+    stat(path: string, options?: object): Promise<{
+        size: number;
+    }>;
+    /**
+     * Just removes the file from the list
+     */
+    unlink(path: string): Promise<void>;
+    open(pathname: string, flags: any, mode?: any): Promise<any>;
+    /**
+     * Read a range into a buffer
+     * @todo - handle position memory
+     * @param buffer is the buffer that the data (read from the fd) will be written to.
+     * @param offset is the offset in the buffer to start writing at.
+     * @param length is an integer specifying the number of bytes to read.
+     * @param position is an argument specifying where to begin reading from in the file. If position is null, data will be read from the current file position, and the file position will be updated. If position is an integer, the file position will remain unchanged.
+     */
+    read(fd: any, buffer: ArrayBuffer, offset?: number, length?: number, position?: number | null): Promise<{
+        bytesRead: number;
+        buffer: ArrayBuffer;
+    }>;
+    close(fd: number): Promise<void>;
+    _getFile(path: any, used: any): File;
+}
+export {};
+//# sourceMappingURL=browser-filesystem.d.ts.map