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

package/dist/flatgeobuf/3.27.2/geojson/geometry.js

@@ -0,0 +1,118 @@
+import { GeometryType } from '../flat-geobuf/geometry-type.js';
+import { flat, pairFlatCoordinates, toGeometryType } from '../generic/geometry.js';
+export function parseGeometry(geometry) {
+  const cs = geometry.coordinates;
+  const xy = [];
+  const z = [];
+  let ends;
+  let parts;
+  const type = toGeometryType(geometry.type);
+  let end = 0;
+  switch (geometry.type) {
+    case 'Point':
+      flat(cs, xy, z);
+      break;
+    case 'MultiPoint':
+    case 'LineString':
+      flat(cs, xy, z);
+      break;
+    case 'MultiLineString':
+    case 'Polygon':
+      {
+        const css = cs;
+        flat(css, xy, z);
+        if (css.length > 1) ends = css.map(c => end += c.length);
+        break;
+      }
+    case 'MultiPolygon':
+      {
+        const csss = cs;
+        const geometries = csss.map(coordinates => ({
+          type: 'Polygon',
+          coordinates
+        }));
+        parts = geometries.map(parseGeometry);
+        break;
+      }
+  }
+  return {
+    xy,
+    z: z.length > 0 ? z : undefined,
+    ends,
+    type,
+    parts
+  };
+}
+export function parseGC(geometry) {
+  const type = toGeometryType(geometry.type);
+  const parts = [];
+  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
+  };
+}
+function extractParts(xy, z, ends) {
+  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;
+  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, type) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  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());
+    case GeometryType.Polygon:
+      return extractParts(xy, z, geometry.endsArray());
+  }
+}
+export function fromGeometry(geometry, headerType) {
+  let type = headerType;
+  if (type === GeometryType.Unknown) {
+    type = geometry.type();
+  }
+  if (type === GeometryType.GeometryCollection) {
+    const geometries = [];
+    for (let i = 0; i < geometry.partsLength(); i++) {
+      const part = geometry.parts(i);
+      const partType = part.type();
+      geometries.push(fromGeometry(part, partType));
+    }
+    return {
+      type: GeometryType[type],
+      geometries
+    };
+  } else if (type === GeometryType.MultiPolygon) {
+    const geometries = [];
+    for (let i = 0; i < geometry.partsLength(); i++) geometries.push(fromGeometry(geometry.parts(i), GeometryType.Polygon));
+    return {
+      type: GeometryType[type],
+      coordinates: geometries.map(g => g.coordinates)
+    };
+  }
+  const coordinates = toGeoJsonCoordinates(geometry, type);
+  return {
+    type: GeometryType[type],
+    coordinates
+  };
+}
+//# sourceMappingURL=geometry.js.map

package/dist/flatgeobuf/3.27.2/geojson/geometry.js.map

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

package/dist/flatgeobuf/3.27.2/geojson.d.ts

@@ -0,0 +1,17 @@
+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 declare function serialize(geojson: GeoJsonFeatureCollection): Uint8Array;
+/**
+ * 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 declare function deserialize(input: Uint8Array | ReadableStream | string, rect?: Rect, headerMetaFn?: HeaderMetaFn): GeoJsonFeatureCollection | AsyncGenerator<IGeoJsonFeature>;
+//# sourceMappingURL=geojson.d.ts.map

package/dist/flatgeobuf/3.27.2/geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/geojson.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,iBAAiB,IAAI,wBAAwB,EAAC,MAAM,SAAS,CAAC;AAEtE,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAC;AACtC,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAC;AAE1C;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,wBAAwB,GAAG,UAAU,CAGvE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,GAAG,cAAc,GAAG,MAAM,EAC3C,IAAI,CAAC,EAAE,IAAI,EACX,YAAY,CAAC,EAAE,YAAY,GAC1B,wBAAwB,GAAG,cAAc,CAAC,eAAe,CAAC,CAI5D"}

package/dist/flatgeobuf/3.27.2/geojson.js

@@ -0,0 +1,10 @@
+import { deserialize as fcDeserialize, deserializeStream as fcDeserializeStream, deserializeFiltered as fcDeserializeFiltered, serialize as fcSerialize } from './geojson/featurecollection.js';
+export function serialize(geojson) {
+  const bytes = fcSerialize(geojson);
+  return bytes;
+}
+export function deserialize(input, rect, headerMetaFn) {
+  if (input instanceof Uint8Array) return fcDeserialize(input, headerMetaFn);else if (input instanceof ReadableStream) return fcDeserializeStream(input, headerMetaFn);
+  return fcDeserializeFiltered(input, rect, headerMetaFn);
+}
+//# sourceMappingURL=geojson.js.map

package/dist/flatgeobuf/3.27.2/geojson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson.js","names":["deserialize","fcDeserialize","deserializeStream","fcDeserializeStream","deserializeFiltered","fcDeserializeFiltered","serialize","fcSerialize","geojson","bytes","input","rect","headerMetaFn","Uint8Array","ReadableStream"],"sources":["../../../src/flatgeobuf/3.27.2/geojson.ts"],"sourcesContent":["import {\n  deserialize as fcDeserialize,\n  deserializeStream as fcDeserializeStream,\n  deserializeFiltered as fcDeserializeFiltered,\n  serialize as fcSerialize\n} from './geojson/featurecollection.js';\n\nimport {FeatureCollection as GeoJsonFeatureCollection} from 'geojson';\n\nimport {Rect} from './packedrtree.js';\nimport {IGeoJsonFeature} from './geojson/feature.js';\nimport {HeaderMetaFn} from './generic.js';\n\n/**\n * Serialize GeoJSON to FlatGeobuf\n * @param geojson GeoJSON object to serialize\n */\nexport function serialize(geojson: GeoJsonFeatureCollection): Uint8Array {\n  const bytes = fcSerialize(geojson);\n  return bytes;\n}\n\n/**\n * Deserialize FlatGeobuf into GeoJSON\n * @param input Input byte array, stream or string\n * @param rect Filter rectangle\n * @param headerMetaFn Callback that will recieve header metadata when available\n */\nexport function deserialize(\n  input: Uint8Array | ReadableStream | string,\n  rect?: Rect,\n  headerMetaFn?: HeaderMetaFn\n): GeoJsonFeatureCollection | AsyncGenerator<IGeoJsonFeature> {\n  if (input instanceof Uint8Array) return fcDeserialize(input, headerMetaFn);\n  else if (input instanceof ReadableStream) return fcDeserializeStream(input, headerMetaFn);\n  return fcDeserializeFiltered(input, rect as Rect, headerMetaFn);\n}\n"],"mappings":"AAAA,SACEA,WAAW,IAAIC,aAAa,EAC5BC,iBAAiB,IAAIC,mBAAmB,EACxCC,mBAAmB,IAAIC,qBAAqB,EAC5CC,SAAS,IAAIC,WAAW,QACnB,gCAAgC;AAYvC,OAAO,SAASD,SAASA,CAACE,OAAiC,EAAc;EACvE,MAAMC,KAAK,GAAGF,WAAW,CAACC,OAAO,CAAC;EAClC,OAAOC,KAAK;AACd;AAQA,OAAO,SAAST,WAAWA,CACzBU,KAA2C,EAC3CC,IAAW,EACXC,YAA2B,EACiC;EAC5D,IAAIF,KAAK,YAAYG,UAAU,EAAE,OAAOZ,aAAa,CAACS,KAAK,EAAEE,YAAY,CAAC,CAAC,KACtE,IAAIF,KAAK,YAAYI,cAAc,EAAE,OAAOX,mBAAmB,CAACO,KAAK,EAAEE,YAAY,CAAC;EACzF,OAAOP,qBAAqB,CAACK,KAAK,EAAEC,IAAI,EAAUC,YAAY,CAAC;AACjE"}

package/dist/flatgeobuf/3.27.2/header-meta.d.ts

@@ -0,0 +1,17 @@
+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';
+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 declare function fromByteBuffer(bb: flatbuffers.ByteBuffer): HeaderMeta;
+//# sourceMappingURL=header-meta.d.ts.map

package/dist/flatgeobuf/3.27.2/header-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-meta.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/header-meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,aAAa,CAAC;AAE3C,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,OAAO,MAAM,eAAe,CAAC;AACpC,OAAO,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAG5D,MAAM,CAAC,OAAO,WAAW,UAAU;IACjC,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IAC7B,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,WAAW,CAAC,UAAU,GAAG,UAAU,CA8CrE"}

package/dist/flatgeobuf/3.27.2/header-meta.js

@@ -0,0 +1,46 @@
+import { Header } from './flat-geobuf/header.js';
+export function fromByteBuffer(bb) {
+  const header = Header.getRootAsHeader(bb);
+  const featuresCount = header.featuresCount();
+  const indexNodeSize = header.indexNodeSize();
+  const columns = [];
+  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(),
+      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 = crs ? {
+    org: crs.org(),
+    code: crs.code(),
+    name: crs.name(),
+    description: crs.description(),
+    wkt: crs.wkt(),
+    code_string: crs.codeString()
+  } : null;
+  const headerMeta = {
+    geometryType: header.geometryType(),
+    columns,
+    envelope: null,
+    featuresCount: Number(featuresCount),
+    indexNodeSize,
+    crs: crsMeta,
+    title: header.title(),
+    description: header.description(),
+    metadata: header.metadata()
+  };
+  return headerMeta;
+}
+//# sourceMappingURL=header-meta.js.map

package/dist/flatgeobuf/3.27.2/header-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header-meta.js","names":["Header","fromByteBuffer","bb","header","getRootAsHeader","featuresCount","indexNodeSize","columns","j","columnsLength","column","Error","name","push","type","title","description","width","precision","scale","nullable","unique","primary_key","primaryKey","crs","crsMeta","org","code","wkt","code_string","codeString","headerMeta","geometryType","envelope","Number","metadata"],"sources":["../../../src/flatgeobuf/3.27.2/header-meta.ts"],"sourcesContent":["import * as flatbuffers from 'flatbuffers';\n\nimport ColumnMeta from './column-meta.js';\nimport CrsMeta from './crs-meta.js';\nimport {GeometryType} from './flat-geobuf/geometry-type.js';\nimport {Header} from './flat-geobuf/header.js';\n\nexport default interface HeaderMeta {\n  geometryType: GeometryType;\n  columns: ColumnMeta[] | null;\n  envelope: Float64Array | null;\n  featuresCount: number;\n  indexNodeSize: number;\n  crs: CrsMeta | null;\n  title: string | null;\n  description: string | null;\n  metadata: string | null;\n}\n\nexport function fromByteBuffer(bb: flatbuffers.ByteBuffer): HeaderMeta {\n  const header = Header.getRootAsHeader(bb);\n  const featuresCount = header.featuresCount();\n  const indexNodeSize = header.indexNodeSize();\n\n  const columns: ColumnMeta[] = [];\n  for (let j = 0; j < header.columnsLength(); j++) {\n    const column = header.columns(j);\n    if (!column) throw new Error('Column unexpectedly missing');\n    if (!column.name()) throw new Error('Column name unexpectedly missing');\n    columns.push({\n      name: column.name() as string,\n      type: column.type(),\n      title: column.title(),\n      description: column.description(),\n      width: column.width(),\n      precision: column.precision(),\n      scale: column.scale(),\n      nullable: column.nullable(),\n      unique: column.unique(),\n      primary_key: column.primaryKey()\n    });\n  }\n  const crs = header.crs();\n  const crsMeta: CrsMeta | null = crs\n    ? {\n        org: crs.org(),\n        code: crs.code(),\n        name: crs.name(),\n        description: crs.description(),\n        wkt: crs.wkt(),\n        code_string: crs.codeString()\n      }\n    : null;\n  const headerMeta: HeaderMeta = {\n    geometryType: header.geometryType(),\n    columns,\n    envelope: null,\n    featuresCount: Number(featuresCount),\n    indexNodeSize,\n    crs: crsMeta,\n    title: header.title(),\n    description: header.description(),\n    metadata: header.metadata()\n  };\n  return headerMeta;\n}\n"],"mappings":"AAKA,SAAQA,MAAM,QAAO,yBAAyB;AAc9C,OAAO,SAASC,cAAcA,CAACC,EAA0B,EAAc;EACrE,MAAMC,MAAM,GAAGH,MAAM,CAACI,eAAe,CAACF,EAAE,CAAC;EACzC,MAAMG,aAAa,GAAGF,MAAM,CAACE,aAAa,CAAC,CAAC;EAC5C,MAAMC,aAAa,GAAGH,MAAM,CAACG,aAAa,CAAC,CAAC;EAE5C,MAAMC,OAAqB,GAAG,EAAE;EAChC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,MAAM,CAACM,aAAa,CAAC,CAAC,EAAED,CAAC,EAAE,EAAE;IAC/C,MAAME,MAAM,GAAGP,MAAM,CAACI,OAAO,CAACC,CAAC,CAAC;IAChC,IAAI,CAACE,MAAM,EAAE,MAAM,IAAIC,KAAK,CAAC,6BAA6B,CAAC;IAC3D,IAAI,CAACD,MAAM,CAACE,IAAI,CAAC,CAAC,EAAE,MAAM,IAAID,KAAK,CAAC,kCAAkC,CAAC;IACvEJ,OAAO,CAACM,IAAI,CAAC;MACXD,IAAI,EAAEF,MAAM,CAACE,IAAI,CAAC,CAAW;MAC7BE,IAAI,EAAEJ,MAAM,CAACI,IAAI,CAAC,CAAC;MACnBC,KAAK,EAAEL,MAAM,CAACK,KAAK,CAAC,CAAC;MACrBC,WAAW,EAAEN,MAAM,CAACM,WAAW,CAAC,CAAC;MACjCC,KAAK,EAAEP,MAAM,CAACO,KAAK,CAAC,CAAC;MACrBC,SAAS,EAAER,MAAM,CAACQ,SAAS,CAAC,CAAC;MAC7BC,KAAK,EAAET,MAAM,CAACS,KAAK,CAAC,CAAC;MACrBC,QAAQ,EAAEV,MAAM,CAACU,QAAQ,CAAC,CAAC;MAC3BC,MAAM,EAAEX,MAAM,CAACW,MAAM,CAAC,CAAC;MACvBC,WAAW,EAAEZ,MAAM,CAACa,UAAU,CAAC;IACjC,CAAC,CAAC;EACJ;EACA,MAAMC,GAAG,GAAGrB,MAAM,CAACqB,GAAG,CAAC,CAAC;EACxB,MAAMC,OAAuB,GAAGD,GAAG,GAC/B;IACEE,GAAG,EAAEF,GAAG,CAACE,GAAG,CAAC,CAAC;IACdC,IAAI,EAAEH,GAAG,CAACG,IAAI,CAAC,CAAC;IAChBf,IAAI,EAAEY,GAAG,CAACZ,IAAI,CAAC,CAAC;IAChBI,WAAW,EAAEQ,GAAG,CAACR,WAAW,CAAC,CAAC;IAC9BY,GAAG,EAAEJ,GAAG,CAACI,GAAG,CAAC,CAAC;IACdC,WAAW,EAAEL,GAAG,CAACM,UAAU,CAAC;EAC9B,CAAC,GACD,IAAI;EACR,MAAMC,UAAsB,GAAG;IAC7BC,YAAY,EAAE7B,MAAM,CAAC6B,YAAY,CAAC,CAAC;IACnCzB,OAAO;IACP0B,QAAQ,EAAE,IAAI;IACd5B,aAAa,EAAE6B,MAAM,CAAC7B,aAAa,CAAC;IACpCC,aAAa;IACbkB,GAAG,EAAEC,OAAO;IACZV,KAAK,EAAEZ,MAAM,CAACY,KAAK,CAAC,CAAC;IACrBC,WAAW,EAAEb,MAAM,CAACa,WAAW,CAAC,CAAC;IACjCmB,QAAQ,EAAEhC,MAAM,CAACgC,QAAQ,CAAC;EAC5B,CAAC;EACD,OAAOJ,UAAU;AACnB"}

package/dist/flatgeobuf/3.27.2/header.d.ts

@@ -0,0 +1,2 @@
+export * as FlatGeobuf from './flat-geobuf.js';
+//# sourceMappingURL=header.d.ts.map

package/dist/flatgeobuf/3.27.2/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/header.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC"}

package/dist/flatgeobuf/3.27.2/header.js

@@ -0,0 +1,3 @@
+import * as _FlatGeobuf from './flat-geobuf.js';
+export { _FlatGeobuf as FlatGeobuf };
+//# sourceMappingURL=header.js.map

package/dist/flatgeobuf/3.27.2/header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.js","names":["_FlatGeobuf","FlatGeobuf"],"sources":["../../../src/flatgeobuf/3.27.2/header.ts"],"sourcesContent":["// automatically generated by the FlatBuffers compiler, do not modify\n\nexport * as FlatGeobuf from './flat-geobuf.js';\n"],"mappings":"6BAE4B,kBAAkB;AAAA,SAAAA,WAAA,IAAlCC,UAAU"}

package/dist/flatgeobuf/3.27.2/http-reader.d.ts

@@ -0,0 +1,41 @@
+import { Rect } from './packedrtree.js';
+import HeaderMeta from './header-meta.js';
+import { Feature } from './flat-geobuf/feature.js';
+export declare class HttpReader {
+    private headerClient;
+    header: HeaderMeta;
+    private headerLength;
+    private indexLength;
+    constructor(headerClient: BufferedHttpRangeClient, header: HeaderMeta, headerLength: number, indexLength: number);
+    static open(url: string): Promise<HttpReader>;
+    selectBbox(rect: Rect): AsyncGenerator<Feature, void, unknown>;
+    lengthBeforeTree(): number;
+    lengthBeforeFeatures(): number;
+    buildFeatureClient(): BufferedHttpRangeClient;
+    /**
+     * Fetch a batch of features in a single request, yielding each Feature
+     *
+     * `batch`: [offset, length] of features in the batch
+     */
+    readFeatureBatch(batch: [number, number][]): AsyncGenerator<Feature, void, unknown>;
+    readFeature(featureClient: BufferedHttpRangeClient, featureOffset: number, minFeatureReqLength: number): Promise<Feature>;
+}
+declare class BufferedHttpRangeClient {
+    httpClient: HttpRangeClient;
+    bytesEverUsed: number;
+    bytesEverFetched: number;
+    private buffer;
+    private head;
+    constructor(source: string | HttpRangeClient);
+    getRange(start: number, length: number, minReqLength: number, purpose: string): Promise<ArrayBuffer>;
+    logUsage(purpose: string): void;
+}
+declare class HttpRangeClient {
+    url: string;
+    requestsEverMade: number;
+    bytesEverRequested: number;
+    constructor(url: string);
+    getRange(begin: number, length: number, purpose: string): Promise<ArrayBuffer>;
+}
+export {};
+//# sourceMappingURL=http-reader.d.ts.map

package/dist/flatgeobuf/3.27.2/http-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-reader.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/http-reader.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,IAAI,EAKL,MAAM,kBAAkB,CAAC;AAI1B,OAAO,UAA4B,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAEjD,qBAAa,UAAU;IACrB,OAAO,CAAC,YAAY,CAA0B;IACvC,MAAM,EAAE,UAAU,CAAC;IAC1B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,WAAW,CAAS;gBAG1B,YAAY,EAAE,uBAAuB,EACrC,MAAM,EAAE,UAAU,EAClB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM;WAWR,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAkE5C,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC;IAoErE,gBAAgB,IAAI,MAAM;IAK1B,oBAAoB,IAAI,MAAM;IAI9B,kBAAkB,IAAI,uBAAuB;IAI7C;;;;OAIG;IACI,gBAAgB,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC;IAyBpF,WAAW,CACf,aAAa,EAAE,uBAAuB,EACtC,aAAa,EAAE,MAAM,EACrB,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC,OAAO,CAAC;CAsBpB;AAED,cAAM,uBAAuB;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,aAAa,SAAK;IAClB,gBAAgB,SAAK;IAErB,OAAO,CAAC,MAAM,CAAmC;IAIjD,OAAO,CAAC,IAAI,CAAK;gBAEL,MAAM,EAAE,MAAM,GAAG,eAAe;IAUtC,QAAQ,CACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC;IAmBvB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAQhC;AAED,cAAM,eAAe;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,SAAK;IACrB,kBAAkB,SAAK;gBAEX,GAAG,EAAE,MAAM;IAIjB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;CA4CrF"}

package/dist/flatgeobuf/3.27.2/http-reader.js

@@ -0,0 +1,193 @@
+import * as flatbuffers from 'flatbuffers';
+import { Repeater } from '@repeaterjs/repeater';
+import { 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 { fromByteBuffer } from './header-meta.js';
+import { Feature } from './flat-geobuf/feature.js';
+export class HttpReader {
+  constructor(headerClient, header, headerLength, indexLength) {
+    this.headerClient = void 0;
+    this.header = void 0;
+    this.headerLength = void 0;
+    this.indexLength = void 0;
+    this.headerClient = headerClient;
+    this.header = header;
+    this.headerLength = headerLength;
+    this.indexLength = indexLength;
+  }
+  static async open(url) {
+    const assumedHeaderLength = 2024;
+    const headerClient = new BufferedHttpRangeClient(url);
+    const assumedIndexLength = (() => {
+      const assumedBranchingFactor = DEFAULT_NODE_SIZE;
+      const prefetchedLayers = 3;
+      let result = 0;
+      let i;
+      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;
+    {
+      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) {
+        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) {
+    const lengthBeforeTree = this.lengthBeforeTree();
+    const bufferedClient = this.headerClient;
+    const readNode = async function (offsetIntoTree, size) {
+      const minReqLength = 0;
+      return bufferedClient.getRange(lengthBeforeTree + offsetIntoTree, size, minReqLength, 'index');
+    };
+    const batches = [];
+    let currentBatch = [];
+    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');
+        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 = batches.flatMap(batch => this.readFeatureBatch(batch));
+    yield* Repeater.merge(promises);
+  }
+  lengthBeforeTree() {
+    return magicbytes.length + SIZE_PREFIX_LEN + this.headerLength;
+  }
+  lengthBeforeFeatures() {
+    return this.lengthBeforeTree() + this.indexLength;
+  }
+  buildFeatureClient() {
+    return new BufferedHttpRangeClient(this.headerClient.httpClient);
+  }
+  async *readFeatureBatch(batch) {
+    const [firstFeatureOffset] = batch[0];
+    const [lastFeatureOffset, lastFeatureLength] = batch[batch.length - 1];
+    const batchStart = firstFeatureOffset;
+    const batchEnd = lastFeatureOffset + lastFeatureLength;
+    const batchSize = batchEnd - batchStart;
+    const featureClient = this.buildFeatureClient();
+    let minFeatureReqLength = batchSize;
+    for (const [featureOffset] of batch) {
+      yield await this.readFeature(featureClient, featureOffset, minFeatureReqLength);
+      minFeatureReqLength = 0;
+    }
+    featureClient.logUsage('feature');
+  }
+  async readFeature(featureClient, featureOffset, minFeatureReqLength) {
+    const offset = featureOffset + this.lengthBeforeFeatures();
+    let featureLength;
+    {
+      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 {
+  constructor(source) {
+    this.httpClient = void 0;
+    this.bytesEverUsed = 0;
+    this.bytesEverFetched = 0;
+    this.buffer = new ArrayBuffer(0);
+    this.head = 0;
+    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, length, minReqLength, purpose) {
+    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) {
+    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 {
+  constructor(url) {
+    this.url = void 0;
+    this.requestsEverMade = 0;
+    this.bytesEverRequested = 0;
+    this.url = url;
+  }
+  async getRange(begin, length, purpose) {
+    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
+      }
+    });
+    return response.arrayBuffer();
+  }
+}
+//# sourceMappingURL=http-reader.js.map

package/dist/flatgeobuf/3.27.2/http-reader.js.map

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

package/dist/flatgeobuf/3.27.2/index.d.ts

@@ -0,0 +1,14 @@
+export * as generic from './generic.js';
+export * as geojson from './geojson.js';
+export { Column } from './flat-geobuf/column.js';
+export { Geometry } from './flat-geobuf/geometry.js';
+export { Feature } from './flat-geobuf/feature.js';
+export { ISimpleGeometry } from './generic/geometry.js';
+export { IFeature } from './generic/feature.js';
+export { FromFeatureFn } from './generic/featurecollection.js';
+export { IGeoJsonFeature } from './geojson/feature.js';
+export { default as HeaderMeta } from './header-meta.js';
+export { default as ColumnMeta } from './column-meta.js';
+export { default as CrsMeta } from './crs-meta.js';
+export { Rect } from './packedrtree.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/flatgeobuf/3.27.2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAGxC,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAC,QAAQ,EAAC,MAAM,2BAA2B,CAAC;AACnD,OAAO,EAAC,OAAO,EAAC,MAAM,0BAA0B,CAAC;AAEjD,OAAO,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAC,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAC,aAAa,EAAC,MAAM,gCAAgC,CAAC;AAE7D,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAErD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAC"}

package/dist/flatgeobuf/3.27.2/index.js

@@ -0,0 +1,16 @@
+import * as _generic from './generic.js';
+export { _generic as generic };
+import * as _geojson from './geojson.js';
+export { _geojson as geojson };
+export { Column } from './flat-geobuf/column.js';
+export { Geometry } from './flat-geobuf/geometry.js';
+export { Feature } from './flat-geobuf/feature.js';
+export { ISimpleGeometry } from './generic/geometry.js';
+export { IFeature } from './generic/feature.js';
+export { FromFeatureFn } from './generic/featurecollection.js';
+export { IGeoJsonFeature } from './geojson/feature.js';
+export { default as HeaderMeta } from './header-meta.js';
+export { default as ColumnMeta } from './column-meta.js';
+export { default as CrsMeta } from './crs-meta.js';
+export { Rect } from './packedrtree.js';
+//# sourceMappingURL=index.js.map

package/dist/flatgeobuf/3.27.2/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_generic","generic","_geojson","geojson","Column","Geometry","Feature","ISimpleGeometry","IFeature","FromFeatureFn","IGeoJsonFeature","default","HeaderMeta","ColumnMeta","CrsMeta","Rect"],"sources":["../../../src/flatgeobuf/3.27.2/index.ts"],"sourcesContent":["export * as generic from './generic.js';\nexport * as geojson from './geojson.js';\n// export * as ol from './ol.js';\n\nexport {Column} from './flat-geobuf/column.js';\nexport {Geometry} from './flat-geobuf/geometry.js';\nexport {Feature} from './flat-geobuf/feature.js';\n\nexport {ISimpleGeometry} from './generic/geometry.js';\nexport {IFeature} from './generic/feature.js';\nexport {FromFeatureFn} from './generic/featurecollection.js';\n\nexport {IGeoJsonFeature} from './geojson/feature.js';\n\nexport {default as HeaderMeta} from './header-meta.js';\nexport {default as ColumnMeta} from './column-meta.js';\nexport {default as CrsMeta} from './crs-meta.js';\n\nexport {Rect} from './packedrtree.js';\n"],"mappings":"0BAAyB,cAAc;AAAA,SAAAA,QAAA,IAA3BC,OAAO;AAAA,YAAAC,QAAA,MACM,cAAc;AAAA,SAAAA,QAAA,IAA3BC,OAAO;AAGnB,SAAQC,MAAM,QAAO,yBAAyB;AAC9C,SAAQC,QAAQ,QAAO,2BAA2B;AAClD,SAAQC,OAAO,QAAO,0BAA0B;AAEhD,SAAQC,eAAe,QAAO,uBAAuB;AACrD,SAAQC,QAAQ,QAAO,sBAAsB;AAC7C,SAAQC,aAAa,QAAO,gCAAgC;AAE5D,SAAQC,eAAe,QAAO,sBAAsB;AAEpD,SAAQC,OAAO,IAAIC,UAAU,QAAO,kBAAkB;AACtD,SAAQD,OAAO,IAAIE,UAAU,QAAO,kBAAkB;AACtD,SAAQF,OAAO,IAAIG,OAAO,QAAO,eAAe;AAEhD,SAAQC,IAAI,QAAO,kBAAkB"}

package/dist/flatgeobuf/3.27.2/logger.d.ts

@@ -0,0 +1,15 @@
+export declare enum LogLevel {
+    Debug = 0,
+    Info = 1,
+    Warn = 2,
+    Error = 3
+}
+export default class Logger {
+    static logLevel: LogLevel;
+    static debug(...args: any[]): void;
+    static info(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static error(...args: any[]): void;
+    static log(level: LogLevel, ...args: any[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/flatgeobuf/3.27.2/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/flatgeobuf/3.27.2/logger.ts"],"names":[],"mappings":"AAAA,oBAAY,QAAQ;IAClB,KAAK,IAAA;IACL,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,KAAK,IAAA;CACN;AAED,MAAM,CAAC,OAAO,OAAO,MAAM;IACzB,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAiB;IAE1C,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAIlC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAIjC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAIjC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAIlC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAwBlD"}