@loaders.gl/textures 4.2.0-alpha.4 → 4.2.0-alpha.5

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

@@ -1,231 +1,243 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { loadBasisEncoderModule, loadBasisTranscoderModule } from "./basis-module-loader.js";
 import { GL_EXTENSIONS_CONSTANTS } from "../gl-extensions.js";
 import { getSupportedGPUTextureFormats } from "../utils/texture-formats.js";
 import { isKTX } from "./parse-ktx.js";
 const OutputFormat = {
-  etc1: {
-    basisFormat: 0,
-    compressed: true,
-    format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
-  },
-  etc2: {
-    basisFormat: 1,
-    compressed: true
-  },
-  bc1: {
-    basisFormat: 2,
-    compressed: true,
-    format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
-  },
-  bc3: {
-    basisFormat: 3,
-    compressed: true,
-    format: 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_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
-  },
-  'pvrtc1-4-rgba': {
-    basisFormat: 9,
-    compressed: true,
-    format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
-  },
-  'astc-4x4': {
-    basisFormat: 10,
-    compressed: true,
-    format: 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
-  }
+    etc1: {
+        basisFormat: 0,
+        compressed: true,
+        format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+    },
+    etc2: { basisFormat: 1, compressed: true },
+    bc1: {
+        basisFormat: 2,
+        compressed: true,
+        format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+    },
+    bc3: {
+        basisFormat: 3,
+        compressed: true,
+        format: 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_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    },
+    'pvrtc1-4-rgba': {
+        basisFormat: 9,
+        compressed: true,
+        format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    },
+    'astc-4x4': {
+        basisFormat: 10,
+        compressed: true,
+        format: 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
+ */
 export default async function parseBasis(data, options) {
-  if (options.basis.containerFormat === 'auto') {
-    if (isKTX(data)) {
-      const fileConstructors = await loadBasisEncoderModule(options);
-      return parseKTX2File(fileConstructors.KTX2File, data, options);
+    if (options.basis.containerFormat === 'auto') {
+        if (isKTX(data)) {
+            const fileConstructors = await loadBasisEncoderModule(options);
+            return parseKTX2File(fileConstructors.KTX2File, data, options);
+        }
+        const { BasisFile } = await loadBasisTranscoderModule(options);
+        return parseBasisFile(BasisFile, data, options);
     }
-    const {
-      BasisFile
-    } = await loadBasisTranscoderModule(options);
-    return parseBasisFile(BasisFile, data, options);
-  }
-  switch (options.basis.module) {
-    case 'encoder':
-      const fileConstructors = await loadBasisEncoderModule(options);
-      switch (options.basis.containerFormat) {
-        case 'ktx2':
-          return parseKTX2File(fileConstructors.KTX2File, data, options);
-        case 'basis':
+    switch (options.basis.module) {
+        case 'encoder':
+            const fileConstructors = await 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:
-          return parseBasisFile(fileConstructors.BasisFile, data, options);
-      }
-    case 'transcoder':
-    default:
-      const {
-        BasisFile
-      } = await loadBasisTranscoderModule(options);
-      return parseBasisFile(BasisFile, data, options);
-  }
+            const { BasisFile } = await loadBasisTranscoderModule(options);
+            return parseBasisFile(BasisFile, data, options);
+    }
 }
+/**
+ * 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 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;
     }
-    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);
+    finally {
+        basisFile.close();
+        basisFile.delete();
     }
-    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);
-  const hasAlpha = basisFile.getHasAlpha();
-  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 {
-    width,
-    height,
-    data: decodedData,
-    compressed,
-    format,
-    hasAlpha
-  };
+    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 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];
     }
-    const levelsCount = ktx2File.getLevels();
-    const levels = [];
-    for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-      levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-      break;
+    finally {
+        ktx2File.close();
+        ktx2File.delete();
     }
-    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);
-  const {
-    compressed,
-    format,
-    basisFormat
-  } = getBasisOptions(options, alphaFlag);
-  const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
-  const decodedData = new Uint8Array(decodedSize);
-  if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
-    throw new Error('Failed to transcode KTX2 image');
-  }
-  return {
-    width,
-    height,
-    data: decodedData,
-    compressed,
-    levelSize: decodedSize,
-    hasAlpha: alphaFlag,
-    format
-  };
+    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];
+    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
+ */
 export function selectSupportedBasisFormat() {
-  const supportedFormats = 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';
+    const supportedFormats = 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';
 }
-//# sourceMappingURL=parse-basis.js.map

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

@@ -1,16 +1,25 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { isKTX, parseKTX } from "./parse-ktx.js";
 import { isDDS, parseDDS } from "./parse-dds.js";
 import { isPVR, parsePVR } from "./parse-pvr.js";
+/**
+ * Deduces format and parses compressed texture loaded in ArrayBuffer
+ * @param data - binary data of compressed texture
+ * @returns Array of the texture levels
+ */
 export function parseCompressedTexture(data) {
-  if (isKTX(data)) {
-    return parseKTX(data);
-  }
-  if (isDDS(data)) {
-    return parseDDS(data);
-  }
-  if (isPVR(data)) {
-    return parsePVR(data);
-  }
-  throw new Error('Texture container format not recognized');
+    if (isKTX(data)) {
+        // TODO: remove @ts-ignore when `parseKTX` output is normalized to loaders.gl texture format
+        // @ts-ignore
+        return parseKTX(data);
+    }
+    if (isDDS(data)) {
+        return parseDDS(data);
+    }
+    if (isPVR(data)) {
+        return parsePVR(data);
+    }
+    throw new Error('Texture container format not recognized');
 }
-//# sourceMappingURL=parse-compressed-texture.js.map

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

@@ -1,75 +1,105 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { loadCrunchModule } from "./crunch-module-loader.js";
 import { GL_EXTENSIONS_CONSTANTS } from "../gl-extensions.js";
 import { assert } from '@loaders.gl/loader-utils';
 import { getDxt1LevelSize, getDxtXLevelSize } from "./parse-dds.js";
 import { extractMipmapImages } from "../utils/extract-mipmap-images.js";
+// Taken from crnlib.h
 const CRN_FORMAT = {
-  cCRNFmtInvalid: -1,
-  cCRNFmtDXT1: 0,
-  cCRNFmtDXT3: 1,
-  cCRNFmtDXT5: 2
+    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_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    sizeFunction: getDxt1LevelSize
-  },
-  [CRN_FORMAT.cCRNFmtDXT3]: {
-    pixelFormat: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    sizeFunction: getDxtXLevelSize
-  },
-  [CRN_FORMAT.cCRNFmtDXT5]: {
-    pixelFormat: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    sizeFunction: getDxtXLevelSize
-  }
+    [CRN_FORMAT.cCRNFmtDXT1]: {
+        pixelFormat: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+        sizeFunction: getDxt1LevelSize
+    },
+    [CRN_FORMAT.cCRNFmtDXT3]: {
+        pixelFormat: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+        sizeFunction: getDxtXLevelSize
+    },
+    [CRN_FORMAT.cCRNFmtDXT5]: {
+        pixelFormat: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+        sizeFunction: 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
+ */
 export async function parseCrunch(data, options) {
-  const crunchModule = await loadCrunchModule(options);
-  const srcSize = data.byteLength;
-  const bytes = new Uint8Array(data);
-  const src = crunchModule._malloc(srcSize);
-  arrayBufferCopy(bytes, crunchModule.HEAPU8, src, srcSize);
-  const format = crunchModule._crn_get_dxt_format(src, srcSize);
-  assert(Boolean(DXT_FORMAT_MAP[format]), 'Unsupported format');
-  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 sizeFunction = DXT_FORMAT_MAP[format].sizeFunction;
-  let dstSize = 0;
-  for (let i = 0; i < mipMapLevels; ++i) {
-    dstSize += sizeFunction(width >> i, height >> i);
-  }
-  if (cachedDstSize < dstSize) {
-    if (dst) {
-      crunchModule._free(dst);
+    const crunchModule = await 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);
+    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;
     }
-    dst = crunchModule._malloc(dstSize);
-    cachedDstSize = dstSize;
-  }
-  crunchModule._crn_decompress(src, srcSize, dst, dstSize, 0, mipMapLevels);
-  crunchModule._free(src);
-  const image = new Uint8Array(crunchModule.HEAPU8.buffer, dst, dstSize).slice();
-  return extractMipmapImages(image, {
-    mipMapLevels,
-    width,
-    height,
-    sizeFunction,
-    internalFormat: DXT_FORMAT_MAP[format].pixelFormat
-  });
+    // 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 extractMipmapImages(image, {
+        mipMapLevels,
+        width,
+        height,
+        sizeFunction,
+        internalFormat: DXT_FORMAT_MAP[format].pixelFormat
+    });
 }
+/**
+ * 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];
-  }
+    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];
+    }
 }
-//# sourceMappingURL=parse-crunch.js.map