@loaders.gl/textures 4.0.0-alpha.23 → 4.0.0-alpha.25

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

@@ -1,245 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectSupportedBasisFormat = void 0;
-const basis_module_loader_1 = require("./basis-module-loader");
-const gl_extensions_1 = require("../gl-extensions");
-const texture_formats_1 = require("../utils/texture-formats");
-const parse_ktx_1 = require("./parse-ktx");
-const OutputFormat = {
-    etc1: {
-        basisFormat: 0,
-        compressed: true,
-        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
-    },
-    etc2: { basisFormat: 1, compressed: true },
-    bc1: {
-        basisFormat: 2,
-        compressed: true,
-        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
-    },
-    bc3: {
-        basisFormat: 3,
-        compressed: true,
-        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
-    },
-    bc4: { basisFormat: 4, compressed: true },
-    bc5: { basisFormat: 5, compressed: true },
-    'bc7-m6-opaque-only': { basisFormat: 6, compressed: true },
-    'bc7-m5': { basisFormat: 7, compressed: true },
-    'pvrtc1-4-rgb': {
-        basisFormat: 8,
-        compressed: true,
-        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
-    },
-    'pvrtc1-4-rgba': {
-        basisFormat: 9,
-        compressed: true,
-        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
-    },
-    'astc-4x4': {
-        basisFormat: 10,
-        compressed: true,
-        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
-    },
-    'atc-rgb': { basisFormat: 11, compressed: true },
-    'atc-rgba-interpolated-alpha': { basisFormat: 12, compressed: true },
-    rgba32: { basisFormat: 13, compressed: false },
-    rgb565: { basisFormat: 14, compressed: false },
-    bgr565: { basisFormat: 15, compressed: false },
-    rgba4444: { basisFormat: 16, compressed: false }
-};
-/**
- * parse data with a Binomial Basis_Universal module
- * @param data
- * @param options
- * @returns compressed texture data
- */
-async function parseBasis(data, options) {
-    if (options.basis.containerFormat === 'auto') {
-        if ((0, parse_ktx_1.isKTX)(data)) {
-            const fileConstructors = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
-            return parseKTX2File(fileConstructors.KTX2File, data, options);
-        }
-        const { BasisFile } = await (0, basis_module_loader_1.loadBasisTranscoderModule)(options);
-        return parseBasisFile(BasisFile, data, options);
-    }
-    switch (options.basis.module) {
-        case 'encoder':
-            const fileConstructors = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
-            switch (options.basis.containerFormat) {
-                case 'ktx2':
-                    return parseKTX2File(fileConstructors.KTX2File, data, options);
-                case 'basis':
-                default:
-                    return parseBasisFile(fileConstructors.BasisFile, data, options);
-            }
-        case 'transcoder':
-        default:
-            const { BasisFile } = await (0, basis_module_loader_1.loadBasisTranscoderModule)(options);
-            return parseBasisFile(BasisFile, data, options);
-    }
-}
-exports.default = parseBasis;
-/**
- * Parse *.basis file data
- * @param BasisFile - initialized transcoder module
- * @param data
- * @param options
- * @returns compressed texture data
- */
-function parseBasisFile(BasisFile, data, options) {
-    const basisFile = new BasisFile(new Uint8Array(data));
-    try {
-        if (!basisFile.startTranscoding()) {
-            throw new Error('Failed to start basis transcoding');
-        }
-        const imageCount = basisFile.getNumImages();
-        const images = [];
-        for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
-            const levelsCount = basisFile.getNumLevels(imageIndex);
-            const levels = [];
-            for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-                levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
-            }
-            images.push(levels);
-        }
-        return images;
-    }
-    finally {
-        basisFile.close();
-        basisFile.delete();
-    }
-}
-/**
- * Parse the particular level image of a basis file
- * @param basisFile
- * @param imageIndex
- * @param levelIndex
- * @param options
- * @returns compressed texture data
- */
-function transcodeImage(basisFile, imageIndex, levelIndex, options) {
-    const width = basisFile.getImageWidth(imageIndex, levelIndex);
-    const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    // See https://github.com/BinomialLLC/basis_universal/pull/83
-    const hasAlpha = basisFile.getHasAlpha( /* imageIndex, levelIndex */);
-    // Check options for output format etc
-    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
-    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-        throw new Error('failed to start Basis transcoding');
-    }
-    return {
-        // standard loaders.gl image category payload
-        width,
-        height,
-        data: decodedData,
-        compressed,
-        format,
-        // Additional fields
-        // Add levelSize field.
-        hasAlpha
-    };
-}
-/**
- * Parse *.ktx2 file data
- * @param KTX2File
- * @param data
- * @param options
- * @returns compressed texture data
- */
-function parseKTX2File(KTX2File, data, options) {
-    const ktx2File = new KTX2File(new Uint8Array(data));
-    try {
-        if (!ktx2File.startTranscoding()) {
-            throw new Error('failed to start KTX2 transcoding');
-        }
-        const levelsCount = ktx2File.getLevels();
-        const levels = [];
-        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-            levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-            break; // texture app can only show one level for some reason
-        }
-        return [levels];
-    }
-    finally {
-        ktx2File.close();
-        ktx2File.delete();
-    }
-}
-/**
- * Parse the particular level image of a ktx2 file
- * @param ktx2File
- * @param levelIndex
- * @param options
- * @returns
- */
-function transcodeKTX2Image(ktx2File, levelIndex, options) {
-    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
-    // Check options for output format etc
-    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
-    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0 /* layerIndex */, 0 /* faceIndex */, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0 /* layerIndex */, 0 /* faceIndex */, basisFormat, 0, -1 /* channel0 */, -1 /* channel1 */)) {
-        throw new Error('Failed to transcode KTX2 image');
-    }
-    return {
-        // standard loaders.gl image category payload
-        width,
-        height,
-        data: decodedData,
-        compressed,
-        // Additional fields
-        levelSize: decodedSize,
-        hasAlpha: alphaFlag,
-        format
-    };
-}
-/**
- * Get BasisFormat by loader format option
- * @param options
- * @param hasAlpha
- * @returns BasisFormat data
- */
-function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
-    if (format === 'auto') {
-        format = selectSupportedBasisFormat();
-    }
-    if (typeof format === 'object') {
-        format = hasAlpha ? format.alpha : format.noAlpha;
-    }
-    format = format.toLowerCase();
-    return OutputFormat[format];
-}
-/**
- * Select transcode format from the list of supported formats
- * @returns key for OutputFormat map
- */
-function selectSupportedBasisFormat() {
-    const supportedFormats = (0, texture_formats_1.getSupportedGPUTextureFormats)();
-    if (supportedFormats.has('astc')) {
-        return 'astc-4x4';
-    }
-    else if (supportedFormats.has('dxt')) {
-        return {
-            alpha: 'bc3',
-            noAlpha: 'bc1'
-        };
-    }
-    else if (supportedFormats.has('pvrtc')) {
-        return {
-            alpha: 'pvrtc1-4-rgba',
-            noAlpha: 'pvrtc1-4-rgb'
-        };
-    }
-    else if (supportedFormats.has('etc1')) {
-        return 'etc1';
-    }
-    else if (supportedFormats.has('etc2')) {
-        return 'etc2';
-    }
-    return 'rgb565';
-}
-exports.selectSupportedBasisFormat = selectSupportedBasisFormat;

package/dist/lib/parsers/parse-compressed-texture.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCompressedTexture = void 0;
-const parse_ktx_1 = require("./parse-ktx");
-const parse_dds_1 = require("./parse-dds");
-const parse_pvr_1 = require("./parse-pvr");
-/**
- * Deduces format and parses compressed texture loaded in ArrayBuffer
- * @param data - binary data of compressed texture
- * @returns Array of the texture levels
- */
-function parseCompressedTexture(data) {
-    if ((0, parse_ktx_1.isKTX)(data)) {
-        // TODO: remove @ts-ignore when `parseKTX` output is normalized to loaders.gl texture format
-        // @ts-ignore
-        return (0, parse_ktx_1.parseKTX)(data);
-    }
-    if ((0, parse_dds_1.isDDS)(data)) {
-        return (0, parse_dds_1.parseDDS)(data);
-    }
-    if ((0, parse_pvr_1.isPVR)(data)) {
-        return (0, parse_pvr_1.parsePVR)(data);
-    }
-    throw new Error('Texture container format not recognized');
-}
-exports.parseCompressedTexture = parseCompressedTexture;

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

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCrunch = void 0;
-const crunch_module_loader_1 = require("./crunch-module-loader");
-const gl_extensions_1 = require("../gl-extensions");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const parse_dds_1 = require("./parse-dds");
-const extract_mipmap_images_1 = require("../utils/extract-mipmap-images");
-// Taken from crnlib.h
-const CRN_FORMAT = {
-    cCRNFmtInvalid: -1,
-    cCRNFmtDXT1: 0,
-    // cCRNFmtDXT3 is not currently supported when writing to CRN - only DDS.
-    cCRNFmtDXT3: 1,
-    cCRNFmtDXT5: 2
-    // Crunch supports more formats than this.
-};
-/** Mapping of Crunch formats to DXT formats. */
-const DXT_FORMAT_MAP = {
-    [CRN_FORMAT.cCRNFmtDXT1]: {
-        pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-        sizeFunction: parse_dds_1.getDxt1LevelSize
-    },
-    [CRN_FORMAT.cCRNFmtDXT3]: {
-        pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-        sizeFunction: parse_dds_1.getDxtXLevelSize
-    },
-    [CRN_FORMAT.cCRNFmtDXT5]: {
-        pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-        sizeFunction: parse_dds_1.getDxtXLevelSize
-    }
-};
-let cachedDstSize = 0;
-let dst;
-/**
- * Parse texture data as "CRN" format.
- * Function is "async" as emscriptified decoder module is loaded asyncronously
- * @param data - binary data of compressed texture
- * @returns Promise of Array of the texture levels
- */
-async function parseCrunch(data, options) {
-    const crunchModule = await (0, crunch_module_loader_1.loadCrunchModule)(options);
-    // Copy the contents of the arrayBuffer into emscriptens heap.
-    const srcSize = data.byteLength;
-    const bytes = new Uint8Array(data);
-    const src = crunchModule._malloc(srcSize);
-    arrayBufferCopy(bytes, crunchModule.HEAPU8, src, srcSize);
-    // Determine what type of compressed data the file contains.
-    const format = crunchModule._crn_get_dxt_format(src, srcSize);
-    (0, loader_utils_1.assert)(Boolean(DXT_FORMAT_MAP[format]), 'Unsupported format');
-    // Gather basic metrics about the DXT data.
-    const mipMapLevels = crunchModule._crn_get_levels(src, srcSize);
-    const width = crunchModule._crn_get_width(src, srcSize);
-    const height = crunchModule._crn_get_height(src, srcSize);
-    // const bytesPerBlock = crunchModule._crn_get_bytes_per_block(src, srcSize);
-    // Determine the size of the decoded DXT data.
-    const sizeFunction = DXT_FORMAT_MAP[format].sizeFunction;
-    let dstSize = 0;
-    for (let i = 0; i < mipMapLevels; ++i) {
-        dstSize += sizeFunction(width >> i, height >> i);
-    }
-    // Allocate enough space on the emscripten heap to hold the decoded DXT data
-    // or reuse the existing allocation if a previous call to this function has
-    // already acquired a large enough buffer.
-    if (cachedDstSize < dstSize) {
-        if (dst) {
-            crunchModule._free(dst);
-        }
-        dst = crunchModule._malloc(dstSize);
-        cachedDstSize = dstSize;
-    }
-    // Decompress the DXT data from the Crunch file into the allocated space.
-    crunchModule._crn_decompress(src, srcSize, dst, dstSize, 0, mipMapLevels);
-    // Release the crunch file data from the emscripten heap.
-    crunchModule._free(src);
-    const image = new Uint8Array(crunchModule.HEAPU8.buffer, dst, dstSize).slice();
-    return (0, extract_mipmap_images_1.extractMipmapImages)(image, {
-        mipMapLevels,
-        width,
-        height,
-        sizeFunction,
-        internalFormat: DXT_FORMAT_MAP[format].pixelFormat
-    });
-}
-exports.parseCrunch = parseCrunch;
-/**
- * Copy an array of bytes into or out of the emscripten heap
- * @param {Uint8Array} srcData - Source data array
- * @param {Uint8Array} dstData - Destination data array
- * @param {number} dstByteOffset - Destination data offset
- * @param {number} numBytes - number of bytes to copy
- * @returns {void}
- */
-function arrayBufferCopy(srcData, dstData, dstByteOffset, numBytes) {
-    let i;
-    const dst32Offset = dstByteOffset / 4;
-    const tail = numBytes % 4;
-    const src32 = new Uint32Array(srcData.buffer, 0, (numBytes - tail) / 4);
-    const dst32 = new Uint32Array(dstData.buffer);
-    for (i = 0; i < src32.length; i++) {
-        dst32[dst32Offset + i] = src32[i];
-    }
-    for (i = numBytes - tail; i < numBytes; i++) {
-        dstData[dstByteOffset + i] = srcData[i];
-    }
-}

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

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDxtXLevelSize = exports.getDxt1LevelSize = exports.parseDDS = exports.isDDS = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const gl_extensions_1 = require("../gl-extensions");
-const extract_mipmap_images_1 = require("../utils/extract-mipmap-images");
-const DDS_CONSTANTS = {
-    MAGIC_NUMBER: 0x20534444,
-    HEADER_LENGTH: 31,
-    MAGIC_NUMBER_INDEX: 0,
-    HEADER_SIZE_INDEX: 1,
-    HEADER_FLAGS_INDEX: 2,
-    HEADER_HEIGHT_INDEX: 3,
-    HEADER_WIDTH_INDEX: 4,
-    MIPMAPCOUNT_INDEX: 7,
-    HEADER_PF_FLAGS_INDEX: 20,
-    HEADER_PF_FOURCC_INDEX: 21,
-    DDSD_MIPMAPCOUNT: 0x20000,
-    DDPF_FOURCC: 0x4
-};
-const DDS_PIXEL_FORMATS = {
-    DXT1: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    DXT3: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    DXT5: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    'ATC ': gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ATC_WEBGL,
-    ATCA: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
-    ATCI: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
-};
-const getATCLevelSize = getDxt1LevelSize;
-const getATCALevelSize = getDxtXLevelSize;
-const getATCILevelSize = getDxtXLevelSize;
-const DDS_SIZE_FUNCTIONS = {
-    DXT1: getDxt1LevelSize,
-    DXT3: getDxtXLevelSize,
-    DXT5: getDxtXLevelSize,
-    'ATC ': getATCLevelSize,
-    ATCA: getATCALevelSize,
-    ATCI: getATCILevelSize
-};
-/**
- * Check if data is in "DDS" format by its magic number
- * @param data - binary data of compressed texture
- * @returns true - data in "DDS" format, else - false
- */
-function isDDS(data) {
-    const header = new Uint32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
-    const magic = header[DDS_CONSTANTS.MAGIC_NUMBER_INDEX];
-    return magic === DDS_CONSTANTS.MAGIC_NUMBER;
-}
-exports.isDDS = isDDS;
-/**
- * Parse texture data as "DDS" format
- * @param data - binary data of compressed texture
- * @returns Array of the texture levels
- */
-function parseDDS(data) {
-    const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
-    const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
-    (0, loader_utils_1.assert)(Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC), 'DDS: Unsupported format, must contain a FourCC code');
-    const fourCC = int32ToFourCC(pixelFormatNumber);
-    const internalFormat = DDS_PIXEL_FORMATS[fourCC];
-    const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
-    (0, loader_utils_1.assert)(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
-    let mipMapLevels = 1;
-    if (header[DDS_CONSTANTS.HEADER_FLAGS_INDEX] & DDS_CONSTANTS.DDSD_MIPMAPCOUNT) {
-        mipMapLevels = Math.max(1, header[DDS_CONSTANTS.MIPMAPCOUNT_INDEX]);
-    }
-    const width = header[DDS_CONSTANTS.HEADER_WIDTH_INDEX];
-    const height = header[DDS_CONSTANTS.HEADER_HEIGHT_INDEX];
-    const dataOffset = header[DDS_CONSTANTS.HEADER_SIZE_INDEX] + 4;
-    const image = new Uint8Array(data, dataOffset);
-    return (0, extract_mipmap_images_1.extractMipmapImages)(image, {
-        mipMapLevels,
-        width,
-        height,
-        sizeFunction,
-        internalFormat
-    });
-}
-exports.parseDDS = parseDDS;
-/**
- * DXT1 applicable function to calculate level size
- * @param width - level width
- * @param height - level height
- * @returns level size in bytes
- */
-function getDxt1LevelSize(width, height) {
-    return ((width + 3) >> 2) * ((height + 3) >> 2) * 8;
-}
-exports.getDxt1LevelSize = getDxt1LevelSize;
-/**
- * DXT3 & DXT5 applicable function to calculate level size
- * @param width - level width
- * @param height - level height
- * @returns level size in bytes
- */
-function getDxtXLevelSize(width, height) {
-    return ((width + 3) >> 2) * ((height + 3) >> 2) * 16;
-}
-exports.getDxtXLevelSize = getDxtXLevelSize;
-/**
- * Convert every byte of Int32 value to char
- * @param value - Int32 number
- * @returns string of 4 characters
- */
-function int32ToFourCC(value) {
-    return String.fromCharCode(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff);
-}

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

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseKTX = exports.isKTX = void 0;
-const ktx_parse_1 = require("ktx-parse");
-const extract_mipmap_images_1 = require("../utils/extract-mipmap-images");
-const ktx_format_helper_1 = require("../utils/ktx-format-helper");
-const KTX2_ID = [
-    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
-    0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a
-];
-// eslint-disable-next-line complexity
-function isKTX(data) {
-    // const id = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length ||
-        id[0] !== KTX2_ID[0] || // '´'
-        id[1] !== KTX2_ID[1] || // 'K'
-        id[2] !== KTX2_ID[2] || // 'T'
-        id[3] !== KTX2_ID[3] || // 'X'
-        id[4] !== KTX2_ID[4] || // ' '
-        id[5] !== KTX2_ID[5] || // '2'
-        id[6] !== KTX2_ID[6] || // '0'
-        id[7] !== KTX2_ID[7] || // 'ª'
-        id[8] !== KTX2_ID[8] || // '\r'
-        id[9] !== KTX2_ID[9] || // '\n'
-        id[10] !== KTX2_ID[10] || // '\x1A'
-        id[11] !== KTX2_ID[11]; // '\n'
-    return !notKTX;
-}
-exports.isKTX = isKTX;
-function parseKTX(arrayBuffer) {
-    const uint8Array = new Uint8Array(arrayBuffer);
-    const ktx = (0, ktx_parse_1.read)(uint8Array);
-    const mipMapLevels = Math.max(1, ktx.levels.length);
-    const width = ktx.pixelWidth;
-    const height = ktx.pixelHeight;
-    const internalFormat = (0, ktx_format_helper_1.mapVkFormatToWebGL)(ktx.vkFormat);
-    return (0, extract_mipmap_images_1.extractMipmapImages)(ktx.levels, {
-        mipMapLevels,
-        width,
-        height,
-        sizeFunction: (level) => level.uncompressedByteLength,
-        internalFormat
-    });
-}
-exports.parseKTX = parseKTX;

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

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseNPY = void 0;
-const a = new Uint32Array([0x12345678]);
-const b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
-const isLittleEndian = !(b[0] === 0x12);
-const LITTLE_ENDIAN_OS = isLittleEndian;
-/**
- * The basic string format consists of 3 characters:
- * 1. a character describing the byteorder of the data (<: little-endian, >: big-endian, |: not-relevant)
- * 2. a character code giving the basic type of the array
- * 3. an integer providing the number of bytes the type uses.
- * https://numpy.org/doc/stable/reference/arrays.interface.html
- *
- * Here I only include the second and third characters, and check endianness separately
- */
-const DTYPES = {
-    u1: Uint8Array,
-    i1: Int8Array,
-    u2: Uint16Array,
-    i2: Int16Array,
-    u4: Uint32Array,
-    i4: Int32Array,
-    f4: Float32Array,
-    f8: Float64Array
-};
-function parseNPY(arrayBuffer, options) {
-    const view = new DataView(arrayBuffer);
-    const { header, headerEndOffset } = parseHeader(view);
-    const numpyType = header.descr;
-    const ArrayType = DTYPES[numpyType.slice(1, 3)];
-    if (!ArrayType) {
-        throw new Error(`Unimplemented type ${numpyType}`);
-    }
-    const nArrayElements = header.shape?.reduce((a, b) => a * b);
-    const arrayByteLength = nArrayElements * ArrayType.BYTES_PER_ELEMENT;
-    if (arrayBuffer.byteLength < headerEndOffset + arrayByteLength) {
-        throw new Error('Buffer overflow');
-    }
-    const data = new ArrayType(arrayBuffer.slice(headerEndOffset, headerEndOffset + arrayByteLength));
-    // Swap endianness if needed
-    if ((numpyType[0] === '>' && LITTLE_ENDIAN_OS) || (numpyType[0] === '<' && !LITTLE_ENDIAN_OS)) {
-        throw new Error('Incorrect endianness');
-    }
-    return {
-        data,
-        header
-    };
-}
-exports.parseNPY = parseNPY;
-/**
- * Parse NPY header
- *
- * @param  view
- * @return
- */
-function parseHeader(view) {
-    const majorVersion = view.getUint8(6);
-    // const minorVersion = view.getUint8(7);
-    let offset = 8;
-    let headerLength;
-    if (majorVersion >= 2) {
-        headerLength = view.getUint32(offset, true);
-        offset += 4;
-    }
-    else {
-        headerLength = view.getUint16(offset, true);
-        offset += 2;
-    }
-    const encoding = majorVersion <= 2 ? 'latin1' : 'utf-8';
-    const decoder = new TextDecoder(encoding);
-    const headerArray = new Uint8Array(view.buffer, offset, headerLength);
-    const headerText = decoder.decode(headerArray);
-    offset += headerLength;
-    const header = JSON.parse(headerText
-        .replace(/'/g, '"')
-        .replace('False', 'false')
-        .replace('(', '[')
-        .replace(/,*\),*/g, ']'));
-    return { header, headerEndOffset: offset };
-}