@loaders.gl/images 3.4.11 → 3.4.13

package/dist/es5/lib/utils/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VERSION = void 0;
-var VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+var VERSION = typeof "3.4.13" !== 'undefined' ? "3.4.13" : 'latest';
 exports.VERSION = VERSION;
 //# sourceMappingURL=version.js.map

package/dist/esm/lib/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+export const VERSION = typeof "3.4.13" !== 'undefined' ? "3.4.13" : 'latest';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/images",
-  "version": "3.4.11",
+  "version": "3.4.13",
   "description": "Framework-independent loaders and writers for images (PNG, JPG, ...)",
   "license": "MIT",
   "publishConfig": {
@@ -32,9 +32,9 @@
     "build-bundle": "esbuild src/bundle.ts --outfile=dist/dist.min.js --bundle --minify --sourcemap"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "3.4.11"
+    "@loaders.gl/loader-utils": "3.4.13"
   },
-  "gitHead": "2b8d490d2372e70dd89eef8f6b215a5205c16621",
+  "gitHead": "be8849c02972ce541e01720d29b976f830d6af92",
   "devDependencies": {
     "@types/get-pixels": "^3.3.2"
   }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/image-loader.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckImageLoader = exports.ImageLoader = void 0;
-const version_1 = require("./lib/utils/version");
-const parse_image_1 = __importDefault(require("./lib/parsers/parse-image"));
-const binary_image_api_1 = require("./lib/category-api/binary-image-api");
-const EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg', 'avif'];
-const MIME_TYPES = [
-    'image/png',
-    'image/jpeg',
-    'image/gif',
-    'image/webp',
-    'image/avif',
-    'image/bmp',
-    'image/vnd.microsoft.icon',
-    'image/svg+xml'
-];
-const DEFAULT_IMAGE_LOADER_OPTIONS = {
-    image: {
-        type: 'auto',
-        decode: true // if format is HTML
-    }
-    // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
-};
-/**
- * Loads a platform-specific image type
- * Note: This type can be used as input data to WebGL texture creation
- */
-exports.ImageLoader = {
-    id: 'image',
-    module: 'images',
-    name: 'Images',
-    version: version_1.VERSION,
-    mimeTypes: MIME_TYPES,
-    extensions: EXTENSIONS,
-    parse: parse_image_1.default,
-    // TODO: byteOffset, byteLength;
-    tests: [(arrayBuffer) => Boolean((0, binary_image_api_1.getBinaryImageMetadata)(new DataView(arrayBuffer)))],
-    options: DEFAULT_IMAGE_LOADER_OPTIONS
-};
-exports._typecheckImageLoader = exports.ImageLoader;

package/dist/image-writer.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImageWriter = void 0;
-// import type {Writer} from '@loaders.gl/loader-utils';
-const version_1 = require("./lib/utils/version");
-const encode_image_1 = require("./lib/encoders/encode-image");
-exports.ImageWriter = {
-    name: 'Images',
-    id: 'image',
-    module: 'images',
-    version: version_1.VERSION,
-    extensions: ['jpeg'],
-    options: {
-        image: {
-            mimeType: 'image/png',
-            jpegQuality: null
-        }
-    },
-    encode: encode_image_1.encodeImage
-};

package/dist/index.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadImage = exports.isImageFormatSupported = exports.getSupportedImageFormats = exports.getImageData = exports.getImageSize = exports.getImageType = exports.isImage = exports.getDefaultImageType = exports.isImageTypeSupported = exports.getBinaryImageMetadata = exports.ImageWriter = exports.ImageLoader = void 0;
-// LOADERS AND WRITERS
-var image_loader_1 = require("./image-loader");
-Object.defineProperty(exports, "ImageLoader", { enumerable: true, get: function () { return image_loader_1.ImageLoader; } });
-var image_writer_1 = require("./image-writer");
-Object.defineProperty(exports, "ImageWriter", { enumerable: true, get: function () { return image_writer_1.ImageWriter; } });
-// IMAGE CATEGORY API
-// Binary Image API
-var binary_image_api_1 = require("./lib/category-api/binary-image-api");
-Object.defineProperty(exports, "getBinaryImageMetadata", { enumerable: true, get: function () { return binary_image_api_1.getBinaryImageMetadata; } });
-// Parsed Image API
-var image_type_1 = require("./lib/category-api/image-type");
-Object.defineProperty(exports, "isImageTypeSupported", { enumerable: true, get: function () { return image_type_1.isImageTypeSupported; } });
-Object.defineProperty(exports, "getDefaultImageType", { enumerable: true, get: function () { return image_type_1.getDefaultImageType; } });
-var parsed_image_api_1 = require("./lib/category-api/parsed-image-api");
-Object.defineProperty(exports, "isImage", { enumerable: true, get: function () { return parsed_image_api_1.isImage; } });
-Object.defineProperty(exports, "getImageType", { enumerable: true, get: function () { return parsed_image_api_1.getImageType; } });
-Object.defineProperty(exports, "getImageSize", { enumerable: true, get: function () { return parsed_image_api_1.getImageSize; } });
-Object.defineProperty(exports, "getImageData", { enumerable: true, get: function () { return parsed_image_api_1.getImageData; } });
-// EXPERIMENTAL
-var image_format_1 = require("./lib/category-api/image-format");
-Object.defineProperty(exports, "getSupportedImageFormats", { enumerable: true, get: function () { return image_format_1.getSupportedImageFormats; } });
-var image_format_2 = require("./lib/category-api/image-format");
-Object.defineProperty(exports, "isImageFormatSupported", { enumerable: true, get: function () { return image_format_2.isImageFormatSupported; } });
-// DEPRECATED - Remove in V4 (fix dependency in luma.gl)
-var load_image_1 = require("./lib/texture-api/load-image");
-Object.defineProperty(exports, "loadImage", { enumerable: true, get: function () { return load_image_1.loadImage; } });

package/dist/lib/category-api/binary-image-api.js

@@ -1,161 +0,0 @@
-"use strict";
-// Attributions
-// * Based on binary-gltf-utils under MIT license: Copyright (c) 2016-17 Karl Cheng
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBmpMetadata = exports.getBinaryImageMetadata = void 0;
-// TODO: make these functions work for Node.js buffers?
-// Quarantine references to Buffer to prevent bundler from adding big polyfills
-// import {bufferToArrayBuffer} from '../node/buffer-to-array-buffer';
-// TODO - this should be handled in @loaders.gl/polyfills
-const parse_isobmff_binary_1 = require("./parse-isobmff-binary");
-const BIG_ENDIAN = false;
-const LITTLE_ENDIAN = true;
-/**
- * Extracts `{mimeType, width and height}` from a memory buffer containing a known image format
- * Currently supports `image/png`, `image/jpeg`, `image/bmp` and `image/gif`.
- * @param binaryData: DataView | ArrayBuffer image file memory to parse
- * @returns metadata or null if memory is not a valid image file format layout.
- */
-function getBinaryImageMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    return (getPngMetadata(dataView) ||
-        getJpegMetadata(dataView) ||
-        getGifMetadata(dataView) ||
-        getBmpMetadata(dataView) ||
-        getISOBMFFMetadata(dataView));
-}
-exports.getBinaryImageMetadata = getBinaryImageMetadata;
-// ISOBMFF
-function getISOBMFFMetadata(binaryData) {
-    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
-    const mediaType = (0, parse_isobmff_binary_1.getISOBMFFMediaType)(buffer);
-    if (!mediaType) {
-        return null;
-    }
-    return {
-        mimeType: mediaType.mimeType,
-        // TODO - decode width and height
-        width: 0,
-        height: 0
-    };
-}
-// PNG
-function getPngMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    // Check file contains the first 4 bytes of the PNG signature.
-    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 0x89504e47;
-    if (!isPng) {
-        return null;
-    }
-    // Extract size from a binary PNG file
-    return {
-        mimeType: 'image/png',
-        width: dataView.getUint32(16, BIG_ENDIAN),
-        height: dataView.getUint32(20, BIG_ENDIAN)
-    };
-}
-// GIF
-// Extract size from a binary GIF file
-// TODO: GIF is not this simple
-function getGifMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    // Check first 4 bytes of the GIF signature ("GIF8").
-    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 0x47494638;
-    if (!isGif) {
-        return null;
-    }
-    // GIF is little endian.
-    return {
-        mimeType: 'image/gif',
-        width: dataView.getUint16(6, LITTLE_ENDIAN),
-        height: dataView.getUint16(8, LITTLE_ENDIAN)
-    };
-}
-// BMP
-// TODO: BMP is not this simple
-function getBmpMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    // Check magic number is valid (first 2 characters should be "BM").
-    // The mandatory bitmap file header is 14 bytes long.
-    const isBmp = dataView.byteLength >= 14 &&
-        dataView.getUint16(0, BIG_ENDIAN) === 0x424d &&
-        dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
-    if (!isBmp) {
-        return null;
-    }
-    // BMP is little endian.
-    return {
-        mimeType: 'image/bmp',
-        width: dataView.getUint32(18, LITTLE_ENDIAN),
-        height: dataView.getUint32(22, LITTLE_ENDIAN)
-    };
-}
-exports.getBmpMetadata = getBmpMetadata;
-// JPEG
-// Extract width and height from a binary JPEG file
-function getJpegMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    // Check file contains the JPEG "start of image" (SOI) marker
-    // followed by another marker.
-    const isJpeg = dataView.byteLength >= 3 &&
-        dataView.getUint16(0, BIG_ENDIAN) === 0xffd8 &&
-        dataView.getUint8(2) === 0xff;
-    if (!isJpeg) {
-        return null;
-    }
-    const { tableMarkers, sofMarkers } = getJpegMarkers();
-    // Exclude the two byte SOI marker.
-    let i = 2;
-    while (i + 9 < dataView.byteLength) {
-        const marker = dataView.getUint16(i, BIG_ENDIAN);
-        // The frame that contains the width and height of the JPEG image.
-        if (sofMarkers.has(marker)) {
-            return {
-                mimeType: 'image/jpeg',
-                height: dataView.getUint16(i + 5, BIG_ENDIAN),
-                width: dataView.getUint16(i + 7, BIG_ENDIAN) // Number of pixels per line
-            };
-        }
-        // Miscellaneous tables/data preceding the frame header.
-        if (!tableMarkers.has(marker)) {
-            return null;
-        }
-        // Length includes size of length parameter but not the two byte header.
-        i += 2;
-        i += dataView.getUint16(i, BIG_ENDIAN);
-    }
-    return null;
-}
-function getJpegMarkers() {
-    // Tables/misc header markers.
-    // DQT, DHT, DAC, DRI, COM, APP_n
-    const tableMarkers = new Set([0xffdb, 0xffc4, 0xffcc, 0xffdd, 0xfffe]);
-    for (let i = 0xffe0; i < 0xfff0; ++i) {
-        tableMarkers.add(i);
-    }
-    // SOF markers and DHP marker.
-    // These markers are after tables/misc data.
-    const sofMarkers = new Set([
-        0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc9, 0xffca, 0xffcb, 0xffcd, 0xffce,
-        0xffcf, 0xffde
-    ]);
-    return { tableMarkers, sofMarkers };
-}
-// TODO - move into image module?
-function toDataView(data) {
-    if (data instanceof DataView) {
-        return data;
-    }
-    if (ArrayBuffer.isView(data)) {
-        return new DataView(data.buffer);
-    }
-    // TODO: make these functions work for Node.js buffers?
-    // if (bufferToArrayBuffer) {
-    //   data = bufferToArrayBuffer(data);
-    // }
-    // Careful - Node Buffers will look like ArrayBuffers (keep after isBuffer)
-    if (data instanceof ArrayBuffer) {
-        return new DataView(data);
-    }
-    throw new Error('toDataView');
-}

package/dist/lib/category-api/image-format.js

@@ -1,110 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImageFormatSupported = exports.getSupportedImageFormats = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const MIME_TYPES = [
-    'image/png',
-    'image/jpeg',
-    'image/gif',
-    'image/webp',
-    'image/avif',
-    'image/tiff',
-    // TODO - what is the correct type for SVG
-    'image/svg',
-    'image/svg+xml',
-    'image/bmp',
-    'image/vnd.microsoft.icon'
-];
-/** Only one round of tests is performed */
-const mimeTypeSupportedPromise = null;
-/** Run-time browser detection of file formats requires async tests for most precise results */
-async function getSupportedImageFormats() {
-    if (mimeTypeSupportedPromise) {
-        return await mimeTypeSupportedPromise;
-    }
-    const supportedMimeTypes = new Set();
-    for (const mimeType of MIME_TYPES) {
-        const supported = loader_utils_1.isBrowser
-            ? await checkBrowserImageFormatSupportAsync(mimeType)
-            : checkNodeImageFormatSupport(mimeType);
-        if (supported) {
-            supportedMimeTypes.add(mimeType);
-        }
-    }
-    return supportedMimeTypes;
-}
-exports.getSupportedImageFormats = getSupportedImageFormats;
-/** Cache sync values for speed */
-const mimeTypeSupportedSync = {};
-/**
- * Check if image MIME type is supported. Result is cached to avoid repeated tests.
- */
-function isImageFormatSupported(mimeType) {
-    if (mimeTypeSupportedSync[mimeType] === undefined) {
-        const supported = loader_utils_1.isBrowser
-            ? checkBrowserImageFormatSupport(mimeType)
-            : checkNodeImageFormatSupport(mimeType);
-        mimeTypeSupportedSync[mimeType] = supported;
-    }
-    return mimeTypeSupportedSync[mimeType];
-}
-exports.isImageFormatSupported = isImageFormatSupported;
-/**
- * Checks that polyfills are installed and that mimeType is supported by polyfills
- * @todo Ideally polyfills should declare what formats they support, instead of storing that data here.
- */
-function checkNodeImageFormatSupport(mimeType) {
-    /** @deprecated Remove these in 4.0 and rely on polyfills to inject them */
-    const NODE_FORMAT_SUPPORT = ['image/png', 'image/jpeg', 'image/gif'];
-    // @ts-ignore
-    const { _parseImageNode, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
-    return Boolean(_parseImageNode) && _imageFormatsNode.includes(mimeType);
-}
-/** Checks image format support synchronously.
- * @note Unreliable, fails on AVIF
- */
-function checkBrowserImageFormatSupport(mimeType) {
-    switch (mimeType) {
-        case 'image/avif': // Will fail
-        case 'image/webp':
-            return testBrowserImageFormatSupport(mimeType);
-        default:
-            return true;
-    }
-}
-const TEST_IMAGE = {
-    'image/avif': 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=',
-    // Lossy test image. Support for lossy images doesn't guarantee support for all WebP images.
-    'image/webp': 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA'
-};
-/** Checks WebP and AVIF support asynchronously */
-async function checkBrowserImageFormatSupportAsync(mimeType) {
-    const dataURL = TEST_IMAGE[mimeType];
-    return dataURL ? await testBrowserImageFormatSupportAsync(dataURL) : true;
-}
-/**
- * Checks browser synchronously
- * Checks if toDataURL supports the mimeType.
- * @note Imperfect testOn Chrome this is true for WebP but not for AVIF
- */
-function testBrowserImageFormatSupport(mimeType) {
-    try {
-        const element = document.createElement('canvas');
-        const dataURL = element.toDataURL(mimeType);
-        return dataURL.indexOf(`data:${mimeType}`) === 0;
-    }
-    catch {
-        // Probably Safari...
-        return false;
-    }
-}
-// Check WebPSupport asynchronously
-async function testBrowserImageFormatSupportAsync(testImageDataURL) {
-    return new Promise((resolve) => {
-        const image = new Image();
-        image.src = testImageDataURL;
-        image.onload = () => resolve(image.height > 0);
-        image.onerror = () => resolve(false);
-    });
-}

package/dist/lib/category-api/image-type.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultImageType = exports.isImageTypeSupported = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-// @ts-ignore TS2339: Property does not exist on type
-const { _parseImageNode } = globalThis;
-const IMAGE_SUPPORTED = typeof Image !== 'undefined'; // NOTE: "false" positives if jsdom is installed
-const IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== 'undefined';
-const NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
-const DATA_SUPPORTED = loader_utils_1.isBrowser ? true : NODE_IMAGE_SUPPORTED;
-/**
- * Checks if a loaders.gl image type is supported
- * @param type image type string
- */
-function isImageTypeSupported(type) {
-    switch (type) {
-        case 'auto':
-            // Should only ever be false in Node.js, if polyfills have not been installed...
-            return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
-        case 'imagebitmap':
-            return IMAGE_BITMAP_SUPPORTED;
-        case 'image':
-            return IMAGE_SUPPORTED;
-        case 'data':
-            return DATA_SUPPORTED;
-        default:
-            throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
-    }
-}
-exports.isImageTypeSupported = isImageTypeSupported;
-/**
- * Returns the "most performant" supported image type on this platform
- * @returns image type string
- */
-function getDefaultImageType() {
-    if (IMAGE_BITMAP_SUPPORTED) {
-        return 'imagebitmap';
-    }
-    if (IMAGE_SUPPORTED) {
-        return 'image';
-    }
-    if (DATA_SUPPORTED) {
-        return 'data';
-    }
-    // This should only happen in Node.js
-    throw new Error('Install \'@loaders.gl/polyfills\' to parse images under Node.js');
-}
-exports.getDefaultImageType = getDefaultImageType;

package/dist/lib/category-api/parse-isobmff-binary.js

@@ -1,94 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-// code adapted from https://github.com/sindresorhus/file-type under MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeMajorBrand = exports.getISOBMFFMediaType = void 0;
-/**
- * Tests if a buffer is in ISO base media file format (ISOBMFF) @see https://en.wikipedia.org/wiki/ISO_base_media_file_format
- * (ISOBMFF is a media container standard based on the Apple QuickTime container format)
- */
-function getISOBMFFMediaType(buffer) {
-    // Almost all ISO base media files start with `ftyp` box. (It's not required to be first, but it's recommended to be.)
-    if (!checkString(buffer, 'ftyp', 4)) {
-        return null;
-    }
-    // Extra check: test for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
-    if ((buffer[8] & 0x60) === 0x00) {
-        return null;
-    }
-    // `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
-    return decodeMajorBrand(buffer);
-}
-exports.getISOBMFFMediaType = getISOBMFFMediaType;
-/**
- * brands explained @see https://github.com/strukturag/libheif/issues/83
- * code adapted from @see https://github.com/sindresorhus/file-type/blob/main/core.js#L489-L492
- */
-function decodeMajorBrand(buffer) {
-    const brandMajor = getUTF8String(buffer, 8, 12).replace('\0', ' ').trim();
-    switch (brandMajor) {
-        case 'avif':
-        case 'avis':
-            return { extension: 'avif', mimeType: 'image/avif' };
-        default:
-            return null;
-    }
-    // We don't need these now, but they are easy to add
-    // case 'mif1':
-    //   return {extension: 'heic', mimeType: 'image/heif'};
-    // case 'msf1':
-    //   return {extension: 'heic', mimeType: 'image/heif-sequence'};
-    // case 'heic':
-    // case 'heix':
-    //   return {extension: 'heic', mimeType: 'image/heic'};
-    // case 'hevc':
-    // case 'hevx':
-    //   return {extension: 'heic', mimeType: 'image/heic-sequence'};
-    // case 'qt':
-    //   return {ext: 'mov', mime: 'video/quicktime'};
-    // case 'M4V':
-    // case 'M4VH':
-    // case 'M4VP':
-    //   return {ext: 'm4v', mime: 'video/x-m4v'};
-    // case 'M4P':
-    //   return {ext: 'm4p', mime: 'video/mp4'};
-    // case 'M4B':
-    //   return {ext: 'm4b', mime: 'audio/mp4'};
-    // case 'M4A':
-    //   return {ext: 'm4a', mime: 'audio/x-m4a'};
-    // case 'F4V':
-    //   return {ext: 'f4v', mime: 'video/mp4'};
-    // case 'F4P':
-    //   return {ext: 'f4p', mime: 'video/mp4'};
-    // case 'F4A':
-    //   return {ext: 'f4a', mime: 'audio/mp4'};
-    // case 'F4B':
-    //   return {ext: 'f4b', mime: 'audio/mp4'};
-    // case 'crx':
-    //   return {ext: 'cr3', mime: 'image/x-canon-cr3'};
-    // default:
-    // if (brandMajor.startsWith('3g')) {
-    //   if (brandMajor.startsWith('3g2')) {
-    //     return {ext: '3g2', mime: 'video/3gpp2'};
-    //   }
-    //   return {ext: '3gp', mime: 'video/3gpp'};
-    // }
-    // return {ext: 'mp4', mime: 'video/mp4'};
-}
-exports.decodeMajorBrand = decodeMajorBrand;
-/** Interpret a chunk of bytes as a UTF8 string */
-function getUTF8String(array, start, end) {
-    return String.fromCharCode(...array.slice(start, end));
-}
-function stringToBytes(string) {
-    return [...string].map((character) => character.charCodeAt(0));
-}
-function checkString(buffer, header, offset = 0) {
-    const headerBytes = stringToBytes(header);
-    for (let i = 0; i < headerBytes.length; ++i) {
-        if (headerBytes[i] !== buffer[i + offset]) {
-            return false;
-        }
-    }
-    return true;
-}

package/dist/lib/category-api/parsed-image-api.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getImageData = exports.getImageSize = exports.getImageType = exports.deleteImage = exports.isImage = void 0;
-function isImage(image) {
-    return Boolean(getImageTypeOrNull(image));
-}
-exports.isImage = isImage;
-function deleteImage(image) {
-    switch (getImageType(image)) {
-        case 'imagebitmap':
-            image.close();
-            break;
-        default:
-        // Nothing to do for images and image data objects
-    }
-}
-exports.deleteImage = deleteImage;
-function getImageType(image) {
-    const format = getImageTypeOrNull(image);
-    if (!format) {
-        throw new Error('Not an image');
-    }
-    return format;
-}
-exports.getImageType = getImageType;
-function getImageSize(image) {
-    return getImageData(image);
-}
-exports.getImageSize = getImageSize;
-function getImageData(image) {
-    switch (getImageType(image)) {
-        case 'data':
-            return image;
-        case 'image':
-        case 'imagebitmap':
-            // Extract the image data from the image via a canvas
-            const canvas = document.createElement('canvas');
-            // TODO - reuse the canvas?
-            const context = canvas.getContext('2d');
-            if (!context) {
-                throw new Error('getImageData');
-            }
-            // @ts-ignore
-            canvas.width = image.width;
-            // @ts-ignore
-            canvas.height = image.height;
-            // @ts-ignore
-            context.drawImage(image, 0, 0);
-            // @ts-ignore
-            return context.getImageData(0, 0, image.width, image.height);
-        default:
-            throw new Error('getImageData');
-    }
-}
-exports.getImageData = getImageData;
-// PRIVATE
-// eslint-disable-next-line complexity
-function getImageTypeOrNull(image) {
-    if (typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-        return 'imagebitmap';
-    }
-    if (typeof Image !== 'undefined' && image instanceof Image) {
-        return 'image';
-    }
-    if (image && typeof image === 'object' && image.data && image.width && image.height) {
-        return 'data';
-    }
-    return null;
-}

package/dist/lib/encoders/encode-image.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeImage = void 0;
-// Image loading/saving for browser and Node.js
-const parsed_image_api_1 = require("../category-api/parsed-image-api");
-// @ts-ignore TS2339: Property does not exist on type
-const { _encodeImageNode } = globalThis;
-/**
- * Returns data bytes representing a compressed image in PNG or JPG format,
- * This data can be saved using file system (f) methods or used in a request.
- * @param image - ImageBitmap Image or Canvas
- * @param options
- * param opt.type='png' - png, jpg or image/png, image/jpg are valid
- * param mimeType= - Whether to include a data URI header
- */
-async function encodeImage(image, options) {
-    options = options || {};
-    options.image = options.image || {};
-    return _encodeImageNode
-        ? _encodeImageNode(image, { type: options.image.mimeType })
-        : encodeImageInBrowser(image, options);
-}
-exports.encodeImage = encodeImage;
-// In case we get exceptions from canvas.toBlob(resolve, type, quality)
-let qualityParamSupported = true;
-/**
- *
- * @param image
- * @param options
- * @note Based on canvas.toBlob
- * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob
- */
-async function encodeImageInBrowser(image, options) {
-    const { mimeType, jpegQuality } = options.image;
-    const { width, height } = (0, parsed_image_api_1.getImageSize)(image);
-    // create a canvas and resize it to the size of our image
-    const canvas = document.createElement('canvas');
-    canvas.width = width;
-    canvas.height = height;
-    drawImageToCanvas(image, canvas);
-    // The actual encoding is done asynchronously with `canvas.toBlob()`
-    const blob = await new Promise((resolve) => {
-        // get it back as a Blob
-        if (jpegQuality && qualityParamSupported) {
-            try {
-                canvas.toBlob(resolve, mimeType, jpegQuality);
-                return;
-            }
-            catch (error) {
-                qualityParamSupported = false;
-            }
-        }
-        canvas.toBlob(resolve, mimeType);
-    });
-    if (!blob) {
-        throw new Error('image encoding failed');
-    }
-    return await blob.arrayBuffer();
-}
-function drawImageToCanvas(image, canvas, x = 0, y = 0) {
-    // Try optimized path for ImageBitmaps via bitmaprenderer context
-    if (x === 0 && y === 0 && typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
-        const context = canvas.getContext('bitmaprenderer');
-        if (context) {
-            // transfer the ImageBitmap to it
-            context.transferFromImageBitmap(image);
-            return canvas;
-        }
-    }
-    // Available on most platforms, except IE11 and Andriod WebViews...
-    const context = canvas.getContext('2d');
-    if (image.data) {
-        // ImageData constructor expects clamped array even though getImageData does not return a clamped array...
-        const clampedArray = new Uint8ClampedArray(image.data);
-        const imageData = new ImageData(clampedArray, image.width, image.height);
-        context.putImageData(imageData, 0, 0);
-        return canvas;
-    }
-    // Fall back to generic image/image bitmap rendering path
-    context.drawImage(image, 0, 0);
-    return canvas;
-}

package/dist/lib/parsers/parse-image.js

@@ -1,57 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const image_type_1 = require("../category-api/image-type");
-const parsed_image_api_1 = require("../category-api/parsed-image-api");
-const parse_to_image_1 = __importDefault(require("./parse-to-image"));
-const parse_to_image_bitmap_1 = __importDefault(require("./parse-to-image-bitmap"));
-const parse_to_node_image_1 = __importDefault(require("./parse-to-node-image"));
-// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)
-// eslint-disable-next-line complexity
-async function parseImage(arrayBuffer, options, context) {
-    options = options || {};
-    const imageOptions = options.image || {};
-    // The user can request a specific output format via `options.image.type`
-    const imageType = imageOptions.type || 'auto';
-    const { url } = context || {};
-    // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`
-    const loadType = getLoadableImageType(imageType);
-    let image;
-    switch (loadType) {
-        case 'imagebitmap':
-            image = await (0, parse_to_image_bitmap_1.default)(arrayBuffer, options, url);
-            break;
-        case 'image':
-            image = await (0, parse_to_image_1.default)(arrayBuffer, options, url);
-            break;
-        case 'data':
-            // Node.js loads imagedata directly
-            image = await (0, parse_to_node_image_1.default)(arrayBuffer, options);
-            break;
-        default:
-            (0, loader_utils_1.assert)(false);
-    }
-    // Browser: if options.image.type === 'data', we can now extract data from the loaded image
-    if (imageType === 'data') {
-        image = (0, parsed_image_api_1.getImageData)(image);
-    }
-    return image;
-}
-exports.default = parseImage;
-// Get a loadable image type from image type
-function getLoadableImageType(type) {
-    switch (type) {
-        case 'auto':
-        case 'data':
-            // Browser: For image data we need still need to load using an image format
-            // Node: the default image type is `data`.
-            return (0, image_type_1.getDefaultImageType)();
-        default:
-            // Throw an error if not supported
-            (0, image_type_1.isImageTypeSupported)(type);
-            return type;
-    }
-}

package/dist/lib/parsers/parse-to-image-bitmap.js

@@ -1,61 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const svg_utils_1 = require("./svg-utils");
-const parse_to_image_1 = __importDefault(require("./parse-to-image"));
-const EMPTY_OBJECT = {};
-let imagebitmapOptionsSupported = true;
-/**
- * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data
- * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari
- * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility
- *
- * TODO - createImageBitmap supports source rect (5 param overload), pass through?
- */
-async function parseToImageBitmap(arrayBuffer, options, url) {
-    let blob;
-    // Cannot parse SVG directly to ImageBitmap, parse to Image first
-    if ((0, svg_utils_1.isSVG)(url)) {
-        // Note: this only works on main thread
-        const image = await (0, parse_to_image_1.default)(arrayBuffer, options, url);
-        blob = image;
-    }
-    else {
-        // Create blob from the array buffer
-        blob = (0, svg_utils_1.getBlob)(arrayBuffer, url);
-    }
-    const imagebitmapOptions = options && options.imagebitmap;
-    return await safeCreateImageBitmap(blob, imagebitmapOptions);
-}
-exports.default = parseToImageBitmap;
-/**
- * Safely creates an imageBitmap with options
- * *
- * Firefox crashes if imagebitmapOptions is supplied
- * Avoid supplying if not provided or supported, remember if not supported
- */
-async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
-    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
-        imagebitmapOptions = null;
-    }
-    if (imagebitmapOptions) {
-        try {
-            // @ts-ignore Options
-            return await createImageBitmap(blob, imagebitmapOptions);
-        }
-        catch (error) {
-            console.warn(error); // eslint-disable-line
-            imagebitmapOptionsSupported = false;
-        }
-    }
-    return await createImageBitmap(blob);
-}
-function isEmptyObject(object) {
-    // @ts-ignore
-    for (const key in object || EMPTY_OBJECT) {
-        return false;
-    }
-    return true;
-}

package/dist/lib/parsers/parse-to-image.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadToImage = void 0;
-const svg_utils_1 = require("./svg-utils");
-// Parses html image from array buffer
-async function parseToImage(arrayBuffer, options, url) {
-    // Note: image parsing requires conversion to Blob (for createObjectURL).
-    // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...
-    // But presumably not worth adding 'blob' flag to loader objects?
-    const blobOrDataUrl = (0, svg_utils_1.getBlobOrSVGDataUrl)(arrayBuffer, url);
-    const URL = self.URL || self.webkitURL;
-    const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
-    try {
-        return await loadToImage(objectUrl || blobOrDataUrl, options);
-    }
-    finally {
-        if (objectUrl) {
-            URL.revokeObjectURL(objectUrl);
-        }
-    }
-}
-exports.default = parseToImage;
-async function loadToImage(url, options) {
-    const image = new Image();
-    image.src = url;
-    // The `image.onload()` callback does not guarantee that the image has been decoded
-    // so a main thread "freeze" can be incurred when using the image for the first time.
-    // `Image.decode()` returns a promise that completes when image is decoded.
-    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode
-    // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`
-    // Note: `HTMLImageElement.decode()` is not available in Edge and IE11
-    if (options.image && options.image.decode && image.decode) {
-        await image.decode();
-        return image;
-    }
-    // Create a promise that tracks onload/onerror callbacks
-    return await new Promise((resolve, reject) => {
-        try {
-            image.onload = () => resolve(image);
-            image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
-        }
-        catch (error) {
-            reject(error);
-        }
-    });
-}
-exports.loadToImage = loadToImage;

package/dist/lib/parsers/parse-to-node-image.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const binary_image_api_1 = require("../category-api/binary-image-api");
-// Use polyfills if installed to parsed image using get-pixels
-async function parseToNodeImage(arrayBuffer, options) {
-    const { mimeType } = (0, binary_image_api_1.getBinaryImageMetadata)(arrayBuffer) || {};
-    // @ts-ignore
-    const _parseImageNode = globalThis._parseImageNode;
-    (0, loader_utils_1.assert)(_parseImageNode); // '@loaders.gl/polyfills not installed'
-    // @ts-expect-error TODO should we throw error in this case?
-    return await _parseImageNode(arrayBuffer, mimeType);
-}
-exports.default = parseToNodeImage;

package/dist/lib/parsers/svg-utils.js

@@ -1,42 +0,0 @@
-"use strict";
-// SVG parsing has limitations, e.g:
-// https://bugs.chromium.org/p/chromium/issues/detail?id=606319
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBlob = exports.getBlobOrSVGDataUrl = exports.isSVG = void 0;
-const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
-const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
-function isSVG(url) {
-    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
-}
-exports.isSVG = isSVG;
-function getBlobOrSVGDataUrl(arrayBuffer, url) {
-    if (isSVG(url)) {
-        // Prepare a properly tagged data URL, and load using normal mechanism
-        const textDecoder = new TextDecoder();
-        let xmlText = textDecoder.decode(arrayBuffer);
-        // TODO Escape in browser to support e.g. Chinese characters
-        try {
-            if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {
-                xmlText = unescape(encodeURIComponent(xmlText));
-            }
-        }
-        catch (error) {
-            throw new Error(error.message);
-        }
-        // base64 encoding is safer. utf-8 fails in some browsers
-        const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
-        return src;
-    }
-    return getBlob(arrayBuffer, url);
-}
-exports.getBlobOrSVGDataUrl = getBlobOrSVGDataUrl;
-function getBlob(arrayBuffer, url) {
-    if (isSVG(url)) {
-        // https://bugs.chromium.org/p/chromium/issues/detail?id=606319
-        // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});
-        throw new Error('SVG cannot be parsed directly to imagebitmap');
-    }
-    // TODO - how to determine mime type? Param? Sniff here?
-    return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?
-}
-exports.getBlob = getBlob;

package/dist/lib/texture-api/async-deep-map.js

@@ -1,56 +0,0 @@
-"use strict";
-/*
-Asynchronously maps a deep structure of values (e.g. objects and arrays of urls).
-
-E.g. a mipmapped cubemap
-{
-  [CUBE_FACE_FRONT]: [
-    "image-front-0.jpg",
-    "image-front-1.jpg",
-    "image-front-2.jpg",
-  ],
-  [CUBE_MAP_BACK]: [
-    ...
-  ]
-}
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapSubtree = exports.asyncDeepMap = void 0;
-const isObject = (value) => value && typeof value === 'object';
-// Loads a deep structure of urls (objects and arrays of urls)
-// Returns an object with six key-value pairs containing the images (or image mip arrays)
-// for each cube face
-async function asyncDeepMap(tree, func, options = {}) {
-    return await mapSubtree(tree, func, options);
-}
-exports.asyncDeepMap = asyncDeepMap;
-async function mapSubtree(object, func, options) {
-    if (Array.isArray(object)) {
-        return await mapArray(object, func, options);
-    }
-    if (isObject(object)) {
-        return await mapObject(object, func, options);
-    }
-    // TODO - ignore non-urls, non-arraybuffers?
-    const url = object;
-    return await func(url, options);
-}
-exports.mapSubtree = mapSubtree;
-// HELPERS
-async function mapObject(object, func, options) {
-    const promises = [];
-    const values = {};
-    for (const key in object) {
-        const url = object[key];
-        const promise = mapSubtree(url, func, options).then((value) => {
-            values[key] = value;
-        });
-        promises.push(promise);
-    }
-    await Promise.all(promises);
-    return values;
-}
-async function mapArray(urlArray, func, options = {}) {
-    const promises = urlArray.map((url) => mapSubtree(url, func, options));
-    return await Promise.all(promises);
-}

package/dist/lib/texture-api/deep-load.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shallowLoad = exports.deepLoad = void 0;
-const async_deep_map_1 = require("./async-deep-map");
-async function deepLoad(urlTree, load, options) {
-    return await (0, async_deep_map_1.asyncDeepMap)(urlTree, (url) => shallowLoad(url, load, options));
-}
-exports.deepLoad = deepLoad;
-async function shallowLoad(url, load, options) {
-    // console.error('loading', url);
-    const response = await fetch(url, options.fetch);
-    const arrayBuffer = await response.arrayBuffer();
-    return await load(arrayBuffer, options);
-}
-exports.shallowLoad = shallowLoad;

package/dist/lib/texture-api/generate-url.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUrl = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-// Generate a url by calling getUrl with mix of options, applying options.baseUrl
-function generateUrl(getUrl, options, urlOptions) {
-    // Get url
-    let url = getUrl;
-    if (typeof getUrl === 'function') {
-        url = getUrl({ ...options, ...urlOptions });
-    }
-    (0, loader_utils_1.assert)(typeof url === 'string');
-    // Apply options.baseUrl
-    const { baseUrl } = options;
-    if (baseUrl) {
-        url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
-    }
-    return (0, loader_utils_1.resolvePath)(url);
-}
-exports.generateUrl = generateUrl;

package/dist/lib/texture-api/load-image.js

@@ -1,47 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMipLevels = exports.getImageUrls = exports.loadImage = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const parse_image_1 = __importDefault(require("../parsers/parse-image"));
-const parsed_image_api_1 = require("../category-api/parsed-image-api");
-const generate_url_1 = require("./generate-url");
-const deep_load_1 = require("./deep-load");
-async function loadImage(getUrl, options = {}) {
-    const imageUrls = await getImageUrls(getUrl, options);
-    return await (0, deep_load_1.deepLoad)(imageUrls, parse_image_1.default, options);
-}
-exports.loadImage = loadImage;
-async function getImageUrls(getUrl, options, urlOptions = {}) {
-    const mipLevels = (options && options.image && options.image.mipLevels) || 0;
-    return mipLevels !== 0
-        ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions)
-        : (0, generate_url_1.generateUrl)(getUrl, options, urlOptions);
-}
-exports.getImageUrls = getImageUrls;
-async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
-    const urls = [];
-    // If no mip levels supplied, we need to load the level 0 image and calculate based on size
-    if (mipLevels === 'auto') {
-        const url = (0, generate_url_1.generateUrl)(getUrl, options, { ...urlOptions, lod: 0 });
-        const image = await (0, deep_load_1.shallowLoad)(url, parse_image_1.default, options);
-        const { width, height } = (0, parsed_image_api_1.getImageSize)(image);
-        mipLevels = getMipLevels({ width, height });
-        // TODO - push image and make `deepLoad` pass through non-url values, avoid loading twice?
-        urls.push(url);
-    }
-    // We now know how many mipLevels we need, remaining image urls can now be constructed
-    (0, loader_utils_1.assert)(mipLevels > 0);
-    for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
-        const url = (0, generate_url_1.generateUrl)(getUrl, options, { ...urlOptions, lod: mipLevel });
-        urls.push(url);
-    }
-    return urls;
-}
-// Calculates number of mipmaps based on texture size (log2)
-function getMipLevels({ width, height }) {
-    return 1 + Math.floor(Math.log2(Math.max(width, height)));
-}
-exports.getMipLevels = getMipLevels;

package/dist/lib/utils/version.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-exports.VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';

package/dist/types.js

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