@loaders.gl/flatgeobuf 4.1.0-alpha.6 → 4.1.0-alpha.7

package/src/flatgeobuf/3.27.2/geojson/featurecollection.ts

@@ -0,0 +1,101 @@
+import ColumnMeta from '../column-meta.js';
+import HeaderMeta from '../header-meta.js';
+
+import {fromFeature} from './feature.js';
+import {parseGeometry, parseGC} from './geometry.js';
+import {
+  buildHeader,
+  deserialize as genericDeserialize,
+  deserializeStream as genericDeserializeStream,
+  deserializeFiltered as genericDeserializeFiltered,
+  mapColumn
+} from '../generic/featurecollection.js';
+import {Rect} from '../packedrtree.js';
+import {buildFeature, IProperties} from '../generic/feature.js';
+import {HeaderMetaFn} from '../generic.js';
+import {magicbytes} from '../constants.js';
+import {inferGeometryType} from '../generic/header.js';
+
+import {
+  FeatureCollection as GeoJsonFeatureCollection,
+  // Point,
+  // MultiPoint,
+  // LineString,
+  // MultiLineString,
+  // Polygon,
+  // MultiPolygon,
+  GeometryCollection
+} from 'geojson';
+
+export function serialize(featurecollection: GeoJsonFeatureCollection): Uint8Array {
+  const headerMeta = introspectHeaderMeta(featurecollection);
+  const header = buildHeader(headerMeta);
+  const features: Uint8Array[] = featurecollection.features.map((f) =>
+    buildFeature(
+      f.geometry.type === 'GeometryCollection'
+        ? parseGC(f.geometry as GeometryCollection)
+        : parseGeometry(f.geometry),
+      f.properties as IProperties,
+      headerMeta
+    )
+  );
+  const featuresLength = features.map((f) => f.length).reduce((a, b) => a + b);
+  const uint8 = new Uint8Array(magicbytes.length + header.length + featuresLength);
+  uint8.set(header, magicbytes.length);
+  let offset = magicbytes.length + header.length;
+  for (const feature of features) {
+    uint8.set(feature, offset);
+    offset += feature.length;
+  }
+  uint8.set(magicbytes);
+  return uint8;
+}
+
+export function deserialize(
+  bytes: Uint8Array,
+  headerMetaFn?: HeaderMetaFn
+): GeoJsonFeatureCollection {
+  const features = genericDeserialize(bytes, fromFeature, headerMetaFn);
+  return {
+    type: 'FeatureCollection',
+    features
+  } as GeoJsonFeatureCollection;
+}
+
+export function deserializeStream(
+  stream: ReadableStream,
+  headerMetaFn?: HeaderMetaFn
+): AsyncGenerator<any, void, unknown> {
+  return genericDeserializeStream(stream, fromFeature, headerMetaFn);
+}
+
+export function deserializeFiltered(
+  url: string,
+  rect: Rect,
+  headerMetaFn?: HeaderMetaFn
+): AsyncGenerator<any, void, unknown> {
+  return genericDeserializeFiltered(url, rect, fromFeature, headerMetaFn);
+}
+
+function introspectHeaderMeta(featurecollection: GeoJsonFeatureCollection): HeaderMeta {
+  const feature = featurecollection.features[0];
+  const properties = feature.properties;
+
+  let columns: ColumnMeta[] | null = null;
+  if (properties) columns = Object.keys(properties).map((k) => mapColumn(properties, k));
+
+  const geometryType = inferGeometryType(featurecollection.features);
+  const headerMeta: HeaderMeta = {
+    geometryType,
+    columns,
+    envelope: null,
+    featuresCount: featurecollection.features.length,
+    indexNodeSize: 0,
+    crs: null,
+    title: null,
+    description: null,
+    metadata: null
+  };
+
+  return headerMeta;
+}

package/src/flatgeobuf/3.27.2/geojson/geometry.ts

@@ -0,0 +1,142 @@
+import {GeometryType} from '../flat-geobuf/geometry-type.js';
+import {Geometry} from '../flat-geobuf/geometry.js';
+
+import {
+  Geometry as GeoJsonGeometry,
+  Point,
+  MultiPoint,
+  LineString,
+  MultiLineString,
+  Polygon,
+  MultiPolygon,
+  GeometryCollection
+} from 'geojson';
+
+import {IParsedGeometry, flat, pairFlatCoordinates, toGeometryType} from '../generic/geometry.js';
+
+export interface IGeoJsonGeometry {
+  type: string;
+  coordinates: number[] | number[][] | number[][][] | number[][][][];
+  geometries?: IGeoJsonGeometry[];
+}
+
+export function parseGeometry(
+  geometry: Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon
+): IParsedGeometry {
+  const cs = geometry.coordinates;
+  const xy: number[] = [];
+  const z: number[] = [];
+  let ends: number[] | undefined;
+  let parts: IParsedGeometry[] | undefined;
+  const type: GeometryType = toGeometryType(geometry.type);
+  let end = 0;
+  switch (geometry.type) {
+    case 'Point':
+      flat(cs, xy, z);
+      break;
+    case 'MultiPoint':
+    case 'LineString':
+      flat(cs as number[][], xy, z);
+      break;
+    case 'MultiLineString':
+    case 'Polygon': {
+      const css = cs as number[][][];
+      flat(css, xy, z);
+      if (css.length > 1) ends = css.map((c) => (end += c.length));
+      break;
+    }
+    case 'MultiPolygon': {
+      const csss = cs as number[][][][];
+      const geometries = csss.map((coordinates) => ({
+        type: 'Polygon',
+        coordinates
+      })) as Polygon[];
+      parts = geometries.map(parseGeometry);
+      break;
+    }
+  }
+  return {
+    xy,
+    z: z.length > 0 ? z : undefined,
+    ends,
+    type,
+    parts
+  } as IParsedGeometry;
+}
+
+export function parseGC(geometry: GeometryCollection): IParsedGeometry {
+  const type: GeometryType = toGeometryType(geometry.type);
+  const parts: IParsedGeometry[] = [];
+  for (let i = 0; i < geometry.geometries.length; i++) {
+    const g = geometry.geometries[i];
+    if (g.type === 'GeometryCollection') parts.push(parseGC(g));
+    else parts.push(parseGeometry(g));
+  }
+  return {
+    type,
+    parts
+  } as IParsedGeometry;
+}
+
+function extractParts(xy: Float64Array, z: Float64Array, ends: Uint32Array) {
+  if (!ends || ends.length === 0) return [pairFlatCoordinates(xy, z)];
+  let s = 0;
+  const xySlices = Array.from(ends).map((e) => xy.slice(s, (s = e << 1)));
+  let zSlices: Float64Array[];
+  if (z) {
+    s = 0;
+    zSlices = Array.from(ends).map((e) => z.slice(s, (s = e)));
+  }
+  return xySlices.map((xy, i) => pairFlatCoordinates(xy, zSlices ? zSlices[i] : undefined));
+}
+
+function toGeoJsonCoordinates(geometry: Geometry, type: GeometryType) {
+  const xy = geometry.xyArray() as Float64Array;
+  const z = geometry.zArray() as Float64Array;
+  switch (type) {
+    case GeometryType.Point: {
+      const a = Array.from(xy);
+      if (z) a.push(z[0]);
+      return a;
+    }
+    case GeometryType.MultiPoint:
+    case GeometryType.LineString:
+      return pairFlatCoordinates(xy, z);
+    case GeometryType.MultiLineString:
+      return extractParts(xy, z, geometry.endsArray() as Uint32Array);
+    case GeometryType.Polygon:
+      return extractParts(xy, z, geometry.endsArray() as Uint32Array);
+  }
+}
+
+export function fromGeometry(geometry: Geometry, headerType: GeometryType): GeoJsonGeometry {
+  let type = headerType;
+  if (type === GeometryType.Unknown) {
+    type = geometry.type();
+  }
+  if (type === GeometryType.GeometryCollection) {
+    const geometries: GeoJsonGeometry[] = [];
+    for (let i = 0; i < geometry.partsLength(); i++) {
+      const part = geometry.parts(i) as Geometry;
+      const partType = part.type() as GeometryType;
+      geometries.push(fromGeometry(part, partType));
+    }
+    return {
+      type: GeometryType[type],
+      geometries
+    } as GeoJsonGeometry;
+  } else if (type === GeometryType.MultiPolygon) {
+    const geometries: GeoJsonGeometry[] = [];
+    for (let i = 0; i < geometry.partsLength(); i++)
+      geometries.push(fromGeometry(geometry.parts(i) as Geometry, GeometryType.Polygon));
+    return {
+      type: GeometryType[type],
+      coordinates: geometries.map((g) => (g as Polygon).coordinates)
+    } as GeoJsonGeometry;
+  }
+  const coordinates = toGeoJsonCoordinates(geometry, type);
+  return {
+    type: GeometryType[type],
+    coordinates
+  } as GeoJsonGeometry;
+}

package/src/flatgeobuf/3.27.2/geojson.ts

@@ -0,0 +1,37 @@
+import {
+  deserialize as fcDeserialize,
+  deserializeStream as fcDeserializeStream,
+  deserializeFiltered as fcDeserializeFiltered,
+  serialize as fcSerialize
+} from './geojson/featurecollection.js';
+
+import {FeatureCollection as GeoJsonFeatureCollection} from 'geojson';
+
+import {Rect} from './packedrtree.js';
+import {IGeoJsonFeature} from './geojson/feature.js';
+import {HeaderMetaFn} from './generic.js';
+
+/**
+ * Serialize GeoJSON to FlatGeobuf
+ * @param geojson GeoJSON object to serialize
+ */
+export function serialize(geojson: GeoJsonFeatureCollection): Uint8Array {
+  const bytes = fcSerialize(geojson);
+  return bytes;
+}
+
+/**
+ * Deserialize FlatGeobuf into GeoJSON
+ * @param input Input byte array, stream or string
+ * @param rect Filter rectangle
+ * @param headerMetaFn Callback that will recieve header metadata when available
+ */
+export function deserialize(
+  input: Uint8Array | ReadableStream | string,
+  rect?: Rect,
+  headerMetaFn?: HeaderMetaFn
+): GeoJsonFeatureCollection | AsyncGenerator<IGeoJsonFeature> {
+  if (input instanceof Uint8Array) return fcDeserialize(input, headerMetaFn);
+  else if (input instanceof ReadableStream) return fcDeserializeStream(input, headerMetaFn);
+  return fcDeserializeFiltered(input, rect as Rect, headerMetaFn);
+}

package/src/flatgeobuf/3.27.2/header-meta.ts

@@ -0,0 +1,66 @@
+import * as flatbuffers from 'flatbuffers';
+
+import ColumnMeta from './column-meta.js';
+import CrsMeta from './crs-meta.js';
+import {GeometryType} from './flat-geobuf/geometry-type.js';
+import {Header} from './flat-geobuf/header.js';
+
+export default interface HeaderMeta {
+  geometryType: GeometryType;
+  columns: ColumnMeta[] | null;
+  envelope: Float64Array | null;
+  featuresCount: number;
+  indexNodeSize: number;
+  crs: CrsMeta | null;
+  title: string | null;
+  description: string | null;
+  metadata: string | null;
+}
+
+export function fromByteBuffer(bb: flatbuffers.ByteBuffer): HeaderMeta {
+  const header = Header.getRootAsHeader(bb);
+  const featuresCount = header.featuresCount();
+  const indexNodeSize = header.indexNodeSize();
+
+  const columns: ColumnMeta[] = [];
+  for (let j = 0; j < header.columnsLength(); j++) {
+    const column = header.columns(j);
+    if (!column) throw new Error('Column unexpectedly missing');
+    if (!column.name()) throw new Error('Column name unexpectedly missing');
+    columns.push({
+      name: column.name() as string,
+      type: column.type(),
+      title: column.title(),
+      description: column.description(),
+      width: column.width(),
+      precision: column.precision(),
+      scale: column.scale(),
+      nullable: column.nullable(),
+      unique: column.unique(),
+      primary_key: column.primaryKey()
+    });
+  }
+  const crs = header.crs();
+  const crsMeta: CrsMeta | null = crs
+    ? {
+        org: crs.org(),
+        code: crs.code(),
+        name: crs.name(),
+        description: crs.description(),
+        wkt: crs.wkt(),
+        code_string: crs.codeString()
+      }
+    : null;
+  const headerMeta: HeaderMeta = {
+    geometryType: header.geometryType(),
+    columns,
+    envelope: null,
+    featuresCount: Number(featuresCount),
+    indexNodeSize,
+    crs: crsMeta,
+    title: header.title(),
+    description: header.description(),
+    metadata: header.metadata()
+  };
+  return headerMeta;
+}

package/src/flatgeobuf/3.27.2/header.ts

@@ -0,0 +1,3 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+export * as FlatGeobuf from './flat-geobuf.js';

package/src/flatgeobuf/3.27.2/http-reader.ts

@@ -0,0 +1,351 @@
+import * as flatbuffers from 'flatbuffers';
+import {Repeater} from '@repeaterjs/repeater';
+
+import {
+  Rect,
+  calcTreeSize,
+  DEFAULT_NODE_SIZE,
+  NODE_ITEM_BYTE_LEN,
+  streamSearch
+} from './packedrtree.js';
+import {magicbytes, SIZE_PREFIX_LEN} from './constants.js';
+import Config from './config.js';
+import Logger from './logger.js';
+import HeaderMeta, {fromByteBuffer} from './header-meta.js';
+import {Feature} from './flat-geobuf/feature.js';
+
+export class HttpReader {
+  private headerClient: BufferedHttpRangeClient;
+  public header: HeaderMeta;
+  private headerLength: number;
+  private indexLength: number;
+
+  constructor(
+    headerClient: BufferedHttpRangeClient,
+    header: HeaderMeta,
+    headerLength: number,
+    indexLength: number
+  ) {
+    this.headerClient = headerClient;
+    this.header = header;
+    this.headerLength = headerLength;
+    this.indexLength = indexLength;
+  }
+
+  // Fetch the header, preparing the reader to read Feature data.
+  //
+  // and potentially some opportunistic fetching of the index.
+  static async open(url: string): Promise<HttpReader> {
+    // In reality, the header is probably less than half this size, but
+    // better to overshoot and fetch an extra kb rather than have to issue
+    // a second request.
+    const assumedHeaderLength = 2024;
+
+    const headerClient = new BufferedHttpRangeClient(url);
+
+    // Immediately following the header is the optional spatial index, we deliberately fetch
+    // a small part of that to skip subsequent requests.
+    const assumedIndexLength = (() => {
+      // The actual branching factor will be in the header, but since we
+      // don't have the header yet, we just guess. The consequence of
+      // getting this wrong isn't terminal, it only means we may be
+      // fetching slightly more than we need or that we need to make an
+      // extra request later.
+      const assumedBranchingFactor = DEFAULT_NODE_SIZE;
+
+      // NOTE: each layer is exponentially larger
+      const prefetchedLayers = 3;
+
+      let result = 0;
+      let i: number;
+      for (i = 0; i < prefetchedLayers; i++) {
+        const layer_width = assumedBranchingFactor ** i * NODE_ITEM_BYTE_LEN;
+        result += layer_width;
+      }
+      return result;
+    })();
+
+    const minReqLength = assumedHeaderLength + assumedIndexLength;
+    Logger.debug(
+      `fetching header. minReqLength: ${minReqLength} (assumedHeaderLength: ${assumedHeaderLength}, assumedIndexLength: ${assumedIndexLength})`
+    );
+
+    {
+      const bytes = new Uint8Array(await headerClient.getRange(0, 8, minReqLength, 'header'));
+      if (!bytes.subarray(0, 3).every((v, i) => magicbytes[i] === v)) {
+        Logger.error(`bytes: ${bytes} != ${magicbytes}`);
+        throw new Error('Not a FlatGeobuf file');
+      }
+      Logger.debug('magic bytes look good');
+    }
+
+    let headerLength: number;
+    {
+      const bytes = await headerClient.getRange(8, 4, minReqLength, 'header');
+      headerLength = new DataView(bytes).getUint32(0, true);
+      const HEADER_MAX_BUFFER_SIZE = 1048576 * 10;
+      if (headerLength > HEADER_MAX_BUFFER_SIZE || headerLength < 8) {
+        // minimum size check avoids panic in FlatBuffers header decoding
+        throw new Error('Invalid header size');
+      }
+      Logger.debug(`headerLength: ${headerLength}`);
+    }
+
+    const bytes = await headerClient.getRange(12, headerLength, minReqLength, 'header');
+    const bb = new flatbuffers.ByteBuffer(new Uint8Array(bytes));
+    const header = fromByteBuffer(bb);
+
+    const indexLength = calcTreeSize(header.featuresCount, header.indexNodeSize);
+
+    Logger.debug('completed: opening http reader');
+    return new HttpReader(headerClient, header, headerLength, indexLength);
+  }
+
+  async *selectBbox(rect: Rect): AsyncGenerator<Feature, void, unknown> {
+    // Read R-Tree index and build filter for features within bbox
+    const lengthBeforeTree = this.lengthBeforeTree();
+
+    const bufferedClient = this.headerClient;
+    const readNode = async function (offsetIntoTree: number, size: number): Promise<ArrayBuffer> {
+      const minReqLength = 0;
+      return bufferedClient.getRange(
+        lengthBeforeTree + offsetIntoTree,
+        size,
+        minReqLength,
+        'index'
+      );
+    };
+
+    const batches: [number, number][][] = [];
+    let currentBatch: [number, number][] = [];
+    for await (const searchResult of streamSearch(
+      this.header.featuresCount,
+      this.header.indexNodeSize,
+      rect,
+      readNode
+    )) {
+      const [featureOffset, ,] = searchResult;
+      let [, , featureLength] = searchResult;
+      if (!featureLength) {
+        Logger.info('final feature');
+        // Normally we get the feature length by subtracting between
+        // adjacent nodes from the index, which we can't do for the
+        // _very_ last feature in a dataset.
+        //
+        // We could *guess* the size, but we'd risk overshooting the length,
+        // which will cause some webservers to return HTTP 416: Unsatisfiable range
+        //
+        // So instead we fetch only the final features byte length, stored in the
+        // first 4 bytes.
+        featureLength = 4;
+      }
+
+      if (currentBatch.length == 0) {
+        currentBatch.push([featureOffset, featureLength]);
+        continue;
+      }
+
+      const prevFeature = currentBatch[currentBatch.length - 1];
+      const gap = featureOffset - (prevFeature[0] + prevFeature[1]);
+      if (gap > Config.global.extraRequestThreshold()) {
+        Logger.info(`Pushing new feature batch, since gap ${gap} was too large`);
+        batches.push(currentBatch);
+        currentBatch = [];
+      }
+
+      currentBatch.push([featureOffset, featureLength]);
+    }
+    this.headerClient.logUsage('header+index');
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+
+    const promises: AsyncGenerator<Feature, any, any>[] = batches.flatMap(
+      (batch: [number, number][]) => this.readFeatureBatch(batch)
+    );
+
+    // Fetch all batches concurrently, yielding features as they become
+    // available, meaning the results may be intermixed.
+    yield* Repeater.merge(promises);
+  }
+
+  lengthBeforeTree(): number {
+    // FGB Layout is: [magicbytes (fixed), headerLength (i32), header (variable), Tree (variable), Features (variable)]
+    return magicbytes.length + SIZE_PREFIX_LEN + this.headerLength;
+  }
+
+  lengthBeforeFeatures(): number {
+    return this.lengthBeforeTree() + this.indexLength;
+  }
+
+  buildFeatureClient(): BufferedHttpRangeClient {
+    return new BufferedHttpRangeClient(this.headerClient.httpClient);
+  }
+
+  /**
+   * Fetch a batch of features in a single request, yielding each Feature
+   *
+   * `batch`: [offset, length] of features in the batch
+   */
+  async *readFeatureBatch(batch: [number, number][]): AsyncGenerator<Feature, void, unknown> {
+    const [firstFeatureOffset] = batch[0];
+    const [lastFeatureOffset, lastFeatureLength] = batch[batch.length - 1];
+
+    const batchStart = firstFeatureOffset;
+    const batchEnd = lastFeatureOffset + lastFeatureLength;
+    const batchSize = batchEnd - batchStart;
+
+    // A new feature client is needed for each batch to own the underlying buffer as features are yielded.
+    const featureClient = this.buildFeatureClient();
+
+    let minFeatureReqLength = batchSize;
+    for (const [featureOffset] of batch) {
+      yield await this.readFeature(featureClient, featureOffset, minFeatureReqLength);
+      // Only set minFeatureReqLength for the first request.
+      //
+      // This should only affect a batch that contains the final feature, otherwise
+      // we've calculated `batchSize` to get all the data we need for the batch.
+      // For the very final feature in a dataset, we don't know it's length, so we
+      // will end up executing an extra request for that batch.
+      minFeatureReqLength = 0;
+    }
+    featureClient.logUsage('feature');
+  }
+
+  async readFeature(
+    featureClient: BufferedHttpRangeClient,
+    featureOffset: number,
+    minFeatureReqLength: number
+  ): Promise<Feature> {
+    const offset = featureOffset + this.lengthBeforeFeatures();
+
+    let featureLength: number;
+    {
+      const bytes = await featureClient.getRange(offset, 4, minFeatureReqLength, 'feature length');
+      featureLength = new DataView(bytes).getUint32(0, true);
+    }
+
+    const byteBuffer = await featureClient.getRange(
+      offset + 4,
+      featureLength,
+      minFeatureReqLength,
+      'feature data'
+    );
+    const bytes = new Uint8Array(byteBuffer);
+    const bytesAligned = new Uint8Array(featureLength + SIZE_PREFIX_LEN);
+    bytesAligned.set(bytes, SIZE_PREFIX_LEN);
+    const bb = new flatbuffers.ByteBuffer(bytesAligned);
+    bb.setPosition(SIZE_PREFIX_LEN);
+    return Feature.getRootAsFeature(bb);
+  }
+}
+
+class BufferedHttpRangeClient {
+  httpClient: HttpRangeClient;
+  bytesEverUsed = 0;
+  bytesEverFetched = 0;
+
+  private buffer: ArrayBuffer = new ArrayBuffer(0);
+
+  // Byte offset of `buffer` with respect to the beginning of the file being
+  // buffered
+  private head = 0;
+
+  constructor(source: string | HttpRangeClient) {
+    if (typeof source === 'string') {
+      this.httpClient = new HttpRangeClient(source);
+    } else if (source instanceof HttpRangeClient) {
+      this.httpClient = source;
+    } else {
+      throw new Error('Unknown source ');
+    }
+  }
+
+  async getRange(
+    start: number,
+    length: number,
+    minReqLength: number,
+    purpose: string
+  ): Promise<ArrayBuffer> {
+    this.bytesEverUsed += length;
+
+    const start_i = start - this.head;
+    const end_i = start_i + length;
+    if (start_i >= 0 && end_i <= this.buffer.byteLength) {
+      return this.buffer.slice(start_i, end_i);
+    }
+
+    const lengthToFetch = Math.max(length, minReqLength);
+
+    this.bytesEverFetched += lengthToFetch;
+    Logger.debug(`requesting for new Range: ${start}-${start + lengthToFetch - 1}`);
+    this.buffer = await this.httpClient.getRange(start, lengthToFetch, purpose);
+    this.head = start;
+
+    return this.buffer.slice(0, length);
+  }
+
+  logUsage(purpose: string): void {
+    const category = purpose.split(' ')[0];
+    const used = this.bytesEverUsed;
+    const requested = this.bytesEverFetched;
+    const efficiency = ((100.0 * used) / requested).toFixed(2);
+
+    Logger.info(`${category} bytes used/requested: ${used} / ${requested} = ${efficiency}%`);
+  }
+}
+
+class HttpRangeClient {
+  url: string;
+  requestsEverMade = 0;
+  bytesEverRequested = 0;
+
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  async getRange(begin: number, length: number, purpose: string): Promise<ArrayBuffer> {
+    this.requestsEverMade += 1;
+    this.bytesEverRequested += length;
+
+    const range = `bytes=${begin}-${begin + length - 1}`;
+    Logger.info(
+      `request: #${this.requestsEverMade}, purpose: ${purpose}), bytes: (this_request: ${length}, ever: ${this.bytesEverRequested}), Range: ${range}`
+    );
+
+    const response = await fetch(this.url, {
+      headers: {
+        Range: range
+        // TODO: better parallelize requests on Chrome
+        //
+        // Safari and Firefox have no issue performing Range requests
+        // for a resource in parallel, but Chrome will stall a
+        // subsequent request to the resource until it's received the
+        // response headers of the prior request. So, it still allows
+        // some limited parallelization, but it's not ideal.
+        //
+        // This is seemingly an artifact of how Chrome manages caching
+        // and it might differ between platforms. We could work around it
+        // by setting the request header:
+        //
+        //      'Cache-Control': 'no-cache, no-store'
+        //
+        // This allows requests to be fully parallelized in Chrome, but
+        // then Chrome won't cache the response, so it seems not a
+        // great trade-off.
+        //
+        // Another work around would be to make each Range request for
+        // a separate URL by appending something like
+        // `?cache_buster=<range>` to the URL, but then Chrome will
+        // require an additional CORS preflight OPTIONS requests per
+        // Range, which is also not a great trade-off.
+        //
+        // See:
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=969828&q=concurrent%20range%20requests&can=2
+        // https://stackoverflow.com/questions/27513994/chrome-stalls-when-making-multiple-requests-to-same-resource
+      }
+    });
+
+    return response.arrayBuffer();
+  }
+}