@loaders.gl/shapefile
Version:
Loader for the Shapefile Format
1,340 lines (1,316 loc) • 678 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if (typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if (typeof define === 'function' && define.amd) define([], factory);
else if (typeof exports === 'object') exports['loaders'] = factory();
else root['loaders'] = factory();})(globalThis, function () {
"use strict";
var __exports__ = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// external-global-plugin:@loaders.gl/core
var require_core = __commonJS({
"external-global-plugin:@loaders.gl/core"(exports4, module) {
module.exports = globalThis.loaders;
}
});
// bundle.ts
var bundle_exports = {};
__export(bundle_exports, {
DBFArrowLoader: () => DBFArrowLoader,
DBFArrowWorkerLoader: () => DBFArrowWorkerLoader,
DBFLoader: () => DBFLoader,
DBFWorkerLoader: () => DBFWorkerLoader,
SHPLoader: () => SHPLoader,
SHPWorkerLoader: () => SHPWorkerLoader,
ShapefileLoader: () => ShapefileLoader,
_BinaryChunkReader: () => BinaryChunkReader,
_BinaryReader: () => BinaryReader,
_zipBatchIterators: () => zipBatchIterators
});
__reExport(bundle_exports, __toESM(require_core(), 1));
// ../loader-utils/src/loader-types.ts
async function parseFromContext(data, loaders, options, context) {
return context._parse(data, loaders, options, context);
}
async function parseInBatchesFromContext(data, loader, options, context) {
if (!context._parseInBatches) {
throw new Error("parseInBatches");
}
return context._parseInBatches(data, loader, options, context);
}
// ../loader-utils/src/lib/iterators/async-iteration.ts
async function* toArrayBufferIterator(asyncIterator) {
for await (const chunk of asyncIterator) {
yield copyToArrayBuffer(chunk);
}
}
function copyToArrayBuffer(chunk) {
if (chunk instanceof ArrayBuffer) {
return chunk;
}
if (ArrayBuffer.isView(chunk)) {
const { buffer, byteOffset, byteLength } = chunk;
return copyFromBuffer(buffer, byteOffset, byteLength);
}
return copyFromBuffer(chunk);
}
function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
const view = new Uint8Array(buffer, byteOffset, byteLength);
const copy = new Uint8Array(view.length);
copy.set(view);
return copy.buffer;
}
// src/lib/streaming/binary-chunk-reader.ts
var BinaryChunkReader = class {
offset;
arrayBuffers;
ended;
maxRewindBytes;
constructor(options) {
const { maxRewindBytes = 0 } = options || {};
this.offset = 0;
this.arrayBuffers = [];
this.ended = false;
this.maxRewindBytes = maxRewindBytes;
}
/**
* @param arrayBuffer
*/
write(arrayBuffer) {
this.arrayBuffers.push(arrayBuffer);
}
end() {
this.arrayBuffers = [];
this.ended = true;
}
/**
* Has enough bytes available in array buffers
*
* @param bytes Number of bytes
* @return boolean
*/
hasAvailableBytes(bytes) {
let bytesAvailable = -this.offset;
for (const arrayBuffer of this.arrayBuffers) {
bytesAvailable += arrayBuffer.byteLength;
if (bytesAvailable >= bytes) {
return true;
}
}
return false;
}
/**
* Find offsets of byte ranges within this.arrayBuffers
*
* @param bytes Byte length to read
* @return Arrays with byte ranges pointing to this.arrayBuffers, Output type is nested array, e.g. [ [0, [1, 2]], ...]
*/
findBufferOffsets(bytes) {
let offset = -this.offset;
const selectedBuffers = [];
for (let i = 0; i < this.arrayBuffers.length; i++) {
const buf = this.arrayBuffers[i];
if (offset + buf.byteLength <= 0) {
offset += buf.byteLength;
continue;
}
const start2 = offset <= 0 ? Math.abs(offset) : 0;
let end;
if (start2 + bytes <= buf.byteLength) {
end = start2 + bytes;
selectedBuffers.push([i, [start2, end]]);
return selectedBuffers;
}
end = buf.byteLength;
selectedBuffers.push([i, [start2, end]]);
bytes -= buf.byteLength - start2;
offset += buf.byteLength;
}
return null;
}
/**
* Get the required number of bytes from the iterator
*
* @param bytes Number of bytes
* @return DataView with data
*/
getDataView(bytes) {
const bufferOffsets = this.findBufferOffsets(bytes);
if (!bufferOffsets && this.ended) {
throw new Error("binary data exhausted");
}
if (!bufferOffsets) {
return null;
}
if (bufferOffsets.length === 1) {
const [bufferIndex, [start2, end]] = bufferOffsets[0];
const arrayBuffer = this.arrayBuffers[bufferIndex];
const view2 = new DataView(arrayBuffer, start2, end - start2);
this.offset += bytes;
this.disposeBuffers();
return view2;
}
const view = new DataView(this._combineArrayBuffers(bufferOffsets));
this.offset += bytes;
this.disposeBuffers();
return view;
}
/**
* Dispose of old array buffers
*/
disposeBuffers() {
while (this.arrayBuffers.length > 0 && this.offset - this.maxRewindBytes >= this.arrayBuffers[0].byteLength) {
this.offset -= this.arrayBuffers[0].byteLength;
this.arrayBuffers.shift();
}
}
/**
* Copy multiple ArrayBuffers into one contiguous ArrayBuffer
*
* In contrast to concatenateArrayBuffers, this only copies the necessary
* portions of the source arrays, rather than first copying the entire arrays
* then taking a part of them.
*
* @param bufferOffsets List of internal array offsets
* @return New contiguous ArrayBuffer
*/
_combineArrayBuffers(bufferOffsets) {
let byteLength = 0;
for (const bufferOffset of bufferOffsets) {
const [start2, end] = bufferOffset[1];
byteLength += end - start2;
}
const result = new Uint8Array(byteLength);
let resultOffset = 0;
for (const bufferOffset of bufferOffsets) {
const [bufferIndex, [start2, end]] = bufferOffset;
const sourceArray = new Uint8Array(this.arrayBuffers[bufferIndex]);
result.set(sourceArray.subarray(start2, end), resultOffset);
resultOffset += end - start2;
}
return result.buffer;
}
/**
* @param bytes
*/
skip(bytes) {
this.offset += bytes;
}
/**
* @param bytes
*/
rewind(bytes) {
this.offset -= bytes;
}
};
// src/lib/parsers/parse-shp-header.ts
var LITTLE_ENDIAN = true;
var BIG_ENDIAN = false;
var SHP_MAGIC_NUMBER = 9994;
function parseSHPHeader(headerView) {
const header = {
magic: headerView.getInt32(0, BIG_ENDIAN),
// Length is stored as # of 2-byte words; multiply by 2 to get # of bytes
length: headerView.getInt32(24, BIG_ENDIAN) * 2,
version: headerView.getInt32(28, LITTLE_ENDIAN),
type: headerView.getInt32(32, LITTLE_ENDIAN),
bbox: {
minX: headerView.getFloat64(36, LITTLE_ENDIAN),
minY: headerView.getFloat64(44, LITTLE_ENDIAN),
minZ: headerView.getFloat64(68, LITTLE_ENDIAN),
minM: headerView.getFloat64(84, LITTLE_ENDIAN),
maxX: headerView.getFloat64(52, LITTLE_ENDIAN),
maxY: headerView.getFloat64(60, LITTLE_ENDIAN),
maxZ: headerView.getFloat64(76, LITTLE_ENDIAN),
maxM: headerView.getFloat64(92, LITTLE_ENDIAN)
}
};
if (header.magic !== SHP_MAGIC_NUMBER) {
console.error(`SHP file: bad magic number ${header.magic}`);
}
if (header.version !== 1e3) {
console.error(`SHP file: bad version ${header.version}`);
}
return header;
}
// src/lib/parsers/parse-shp-geometry.ts
var LITTLE_ENDIAN2 = true;
function parseRecord(view, options) {
const { _maxDimensions = 4 } = options?.shp || {};
let offset = 0;
const type = view.getInt32(offset, LITTLE_ENDIAN2);
offset += Int32Array.BYTES_PER_ELEMENT;
switch (type) {
case 0:
return parseNull();
case 1:
return parsePoint(view, offset, Math.min(2, _maxDimensions));
case 3:
return parsePoly(view, offset, Math.min(2, _maxDimensions), "LineString");
case 5:
return parsePoly(view, offset, Math.min(2, _maxDimensions), "Polygon");
case 8:
return parseMultiPoint(view, offset, Math.min(2, _maxDimensions));
case 11:
return parsePoint(view, offset, Math.min(4, _maxDimensions));
case 13:
return parsePoly(view, offset, Math.min(4, _maxDimensions), "LineString");
case 15:
return parsePoly(view, offset, Math.min(4, _maxDimensions), "Polygon");
case 18:
return parseMultiPoint(view, offset, Math.min(4, _maxDimensions));
case 21:
return parsePoint(view, offset, Math.min(3, _maxDimensions));
case 23:
return parsePoly(view, offset, Math.min(3, _maxDimensions), "LineString");
case 25:
return parsePoly(view, offset, Math.min(3, _maxDimensions), "Polygon");
case 28:
return parseMultiPoint(view, offset, Math.min(3, _maxDimensions));
default:
throw new Error(`unsupported shape type: ${type}`);
}
}
function parseNull() {
return null;
}
function parsePoint(view, offset, dim) {
let positions;
[positions, offset] = parsePositions(view, offset, 1, dim);
return {
positions: { value: positions, size: dim },
type: "Point"
};
}
function parseMultiPoint(view, offset, dim) {
offset += 4 * Float64Array.BYTES_PER_ELEMENT;
const nPoints = view.getInt32(offset, LITTLE_ENDIAN2);
offset += Int32Array.BYTES_PER_ELEMENT;
let xyPositions = null;
let mPositions = null;
let zPositions = null;
[xyPositions, offset] = parsePositions(view, offset, nPoints, 2);
if (dim === 4) {
offset += 2 * Float64Array.BYTES_PER_ELEMENT;
[zPositions, offset] = parsePositions(view, offset, nPoints, 1);
}
if (dim >= 3) {
offset += 2 * Float64Array.BYTES_PER_ELEMENT;
[mPositions, offset] = parsePositions(view, offset, nPoints, 1);
}
const positions = concatPositions(xyPositions, mPositions, zPositions);
return {
positions: { value: positions, size: dim },
type: "Point"
};
}
function parsePoly(view, offset, dim, type) {
offset += 4 * Float64Array.BYTES_PER_ELEMENT;
const nParts = view.getInt32(offset, LITTLE_ENDIAN2);
offset += Int32Array.BYTES_PER_ELEMENT;
const nPoints = view.getInt32(offset, LITTLE_ENDIAN2);
offset += Int32Array.BYTES_PER_ELEMENT;
const bufferOffset = view.byteOffset + offset;
const bufferLength = nParts * Int32Array.BYTES_PER_ELEMENT;
const ringIndices = new Int32Array(nParts + 1);
ringIndices.set(new Int32Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)));
ringIndices[nParts] = nPoints;
offset += nParts * Int32Array.BYTES_PER_ELEMENT;
let xyPositions = null;
let mPositions = null;
let zPositions = null;
[xyPositions, offset] = parsePositions(view, offset, nPoints, 2);
if (dim === 4) {
offset += 2 * Float64Array.BYTES_PER_ELEMENT;
[zPositions, offset] = parsePositions(view, offset, nPoints, 1);
}
if (dim >= 3) {
offset += 2 * Float64Array.BYTES_PER_ELEMENT;
[mPositions, offset] = parsePositions(view, offset, nPoints, 1);
}
const positions = concatPositions(xyPositions, mPositions, zPositions);
if (type === "LineString") {
return {
type,
positions: { value: positions, size: dim },
pathIndices: { value: ringIndices, size: 1 }
};
}
const polygonIndices = [];
for (let i = 1; i < ringIndices.length; i++) {
const startRingIndex = ringIndices[i - 1];
const endRingIndex = ringIndices[i];
const ring = xyPositions.subarray(startRingIndex * 2, endRingIndex * 2);
const sign = getWindingDirection(ring);
if (sign > 0) {
polygonIndices.push(startRingIndex);
}
}
polygonIndices.push(nPoints);
return {
type,
positions: { value: positions, size: dim },
primitivePolygonIndices: { value: ringIndices, size: 1 },
// TODO: Dynamically choose Uint32Array over Uint16Array only when
// necessary. I believe the implementation requires nPoints to be the
// largest value in the array, so you should be able to use Uint32Array only
// when nPoints > 65535.
polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 }
};
}
function parsePositions(view, offset, nPoints, dim) {
const bufferOffset = view.byteOffset + offset;
const bufferLength = nPoints * dim * Float64Array.BYTES_PER_ELEMENT;
return [
new Float64Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)),
offset + bufferLength
];
}
function concatPositions(xyPositions, mPositions, zPositions) {
if (!(mPositions || zPositions)) {
return xyPositions;
}
let arrayLength = xyPositions.length;
let nDim = 2;
if (zPositions && zPositions.length) {
arrayLength += zPositions.length;
nDim++;
}
if (mPositions && mPositions.length) {
arrayLength += mPositions.length;
nDim++;
}
const positions = new Float64Array(arrayLength);
for (let i = 0; i < xyPositions.length / 2; i++) {
positions[nDim * i] = xyPositions[i * 2];
positions[nDim * i + 1] = xyPositions[i * 2 + 1];
}
if (zPositions && zPositions.length) {
for (let i = 0; i < zPositions.length; i++) {
positions[nDim * i + 2] = zPositions[i];
}
}
if (mPositions && mPositions.length) {
for (let i = 0; i < mPositions.length; i++) {
positions[nDim * i + (nDim - 1)] = mPositions[i];
}
}
return positions;
}
function getWindingDirection(positions) {
return Math.sign(getSignedArea(positions));
}
function getSignedArea(positions) {
let area = 0;
const nCoords = positions.length / 2 - 1;
for (let i = 0; i < nCoords; i++) {
area += (positions[i * 2] + positions[(i + 1) * 2]) * (positions[i * 2 + 1] - positions[(i + 1) * 2 + 1]);
}
return area / 2;
}
// src/lib/parsers/parse-shp.ts
var LITTLE_ENDIAN3 = true;
var BIG_ENDIAN2 = false;
var SHP_HEADER_SIZE = 100;
var SHP_RECORD_HEADER_SIZE = 12;
var STATE = {
EXPECTING_HEADER: 0,
EXPECTING_RECORD: 1,
END: 2,
ERROR: 3
};
var SHPParser = class {
options = {};
binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });
state = STATE.EXPECTING_HEADER;
result = {
geometries: [],
// Initialize with number values to make TS happy
// These are initialized for real in STATE.EXPECTING_HEADER
progress: {
bytesTotal: NaN,
bytesUsed: NaN,
rows: NaN
},
currentIndex: NaN
};
constructor(options) {
this.options = options;
}
write(arrayBuffer) {
this.binaryReader.write(arrayBuffer);
this.state = parseState(this.state, this.result, this.binaryReader, this.options);
}
end() {
this.binaryReader.end();
this.state = parseState(this.state, this.result, this.binaryReader, this.options);
if (this.state !== STATE.END) {
this.state = STATE.ERROR;
this.result.error = "SHP incomplete file";
}
}
};
function parseSHP(arrayBuffer, options) {
const shpParser = new SHPParser(options);
shpParser.write(arrayBuffer);
shpParser.end();
return shpParser.result;
}
async function* parseSHPInBatches(asyncIterator, options) {
const parser = new SHPParser(options);
let headerReturned = false;
for await (const arrayBuffer of toArrayBufferIterator(asyncIterator)) {
parser.write(arrayBuffer);
if (!headerReturned && parser.result.header) {
headerReturned = true;
yield parser.result.header;
}
if (parser.result.geometries.length > 0) {
yield parser.result.geometries;
parser.result.geometries = [];
}
}
parser.end();
if (parser.result.geometries.length > 0) {
yield parser.result.geometries;
}
return;
}
function parseState(state, result, binaryReader, options) {
while (true) {
try {
switch (state) {
case STATE.ERROR:
case STATE.END:
return state;
case STATE.EXPECTING_HEADER:
const dataView = binaryReader.getDataView(SHP_HEADER_SIZE);
if (!dataView) {
return state;
}
result.header = parseSHPHeader(dataView);
result.progress = {
bytesUsed: 0,
bytesTotal: result.header.length,
rows: 0
};
result.currentIndex = 1;
state = STATE.EXPECTING_RECORD;
break;
case STATE.EXPECTING_RECORD:
while (binaryReader.hasAvailableBytes(SHP_RECORD_HEADER_SIZE)) {
const recordHeaderView = binaryReader.getDataView(SHP_RECORD_HEADER_SIZE);
const recordHeader = {
recordNumber: recordHeaderView.getInt32(0, BIG_ENDIAN2),
// 2 byte words; includes the four words of record header
byteLength: recordHeaderView.getInt32(4, BIG_ENDIAN2) * 2,
// This is actually part of the record, not the header...
type: recordHeaderView.getInt32(8, LITTLE_ENDIAN3)
};
if (!binaryReader.hasAvailableBytes(recordHeader.byteLength - 4)) {
binaryReader.rewind(SHP_RECORD_HEADER_SIZE);
return state;
}
const invalidRecord = recordHeader.byteLength < 4 || recordHeader.type !== result.header?.type || recordHeader.recordNumber !== result.currentIndex;
if (invalidRecord) {
binaryReader.rewind(SHP_RECORD_HEADER_SIZE - 4);
} else {
binaryReader.rewind(4);
const recordView = binaryReader.getDataView(recordHeader.byteLength);
const geometry = parseRecord(recordView, options);
result.geometries.push(geometry);
result.currentIndex++;
result.progress.rows = result.currentIndex - 1;
}
}
if (binaryReader.ended) {
state = STATE.END;
}
return state;
default:
state = STATE.ERROR;
result.error = `illegal parser state ${state}`;
return state;
}
} catch (error) {
state = STATE.ERROR;
result.error = `SHP parsing failed: ${error?.message}`;
return state;
}
}
}
// src/shp-loader.ts
var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
var SHP_MAGIC_NUMBER2 = [0, 0, 39, 10];
var SHPWorkerLoader = {
dataType: null,
batchType: null,
name: "SHP",
id: "shp",
module: "shapefile",
version: VERSION,
worker: true,
category: "geometry",
extensions: ["shp"],
mimeTypes: ["application/octet-stream"],
// ISSUE: This also identifies SHX files, which are identical to SHP for the first 100 bytes...
tests: [new Uint8Array(SHP_MAGIC_NUMBER2).buffer],
options: {
shp: {
_maxDimensions: 4
}
}
};
var SHPLoader = {
...SHPWorkerLoader,
parse: async (arrayBuffer, options) => parseSHP(arrayBuffer, options),
parseSync: parseSHP,
parseInBatches: (arrayBufferIterator, options) => parseSHPInBatches(arrayBufferIterator, options)
};
// ../gis/src/lib/binary-geometry-api/transform-coordinates.ts
function transformGeoJsonCoords(features, fn) {
for (const feature of features) {
feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
}
return features;
}
function coordMap(array, fn) {
if (isCoord(array)) {
return fn(array);
}
return array.map((item) => {
return coordMap(item, fn);
});
}
function isCoord(array) {
return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
}
// ../../node_modules/tslib/tslib.es6.mjs
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function(resolve) {
resolve(value);
});
}
return new (P || (P = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e) {
reject(e);
}
}
function step(result) {
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function() {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function awaitReturn(f) {
return function(v) {
return Promise.resolve(v).then(f, reject);
};
}
function verb(n, f) {
if (g[n]) {
i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
if (f)
i[n] = f(i[n]);
}
}
function resume(n, v) {
try {
step(g[n](v));
} catch (e) {
settle(q[0][3], e);
}
}
function step(r) {
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
function fulfill(value) {
resume("next", value);
}
function reject(value) {
resume("throw", value);
}
function settle(f, v) {
if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]);
}
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function(e) {
throw e;
}), verb("return"), i[Symbol.iterator] = function() {
return this;
}, i;
function verb(n, f) {
i[n] = o[n] ? function(v) {
return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
} : f;
}
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i);
function verb(n) {
i[n] = o[n] && function(v) {
return new Promise(function(resolve, reject) {
v = o[n](v), settle(resolve, reject, v.done, v.value);
});
};
}
function settle(resolve, reject, d, v) {
Promise.resolve(v).then(function(v2) {
resolve({ value: v2, done: d });
}, reject);
}
}
// ../../node_modules/apache-arrow/util/buffer.mjs
var buffer_exports = {};
__export(buffer_exports, {
compareArrayLike: () => compareArrayLike,
joinUint8Arrays: () => joinUint8Arrays,
memcpy: () => memcpy,
rebaseValueOffsets: () => rebaseValueOffsets,
toArrayBufferView: () => toArrayBufferView,
toArrayBufferViewAsyncIterator: () => toArrayBufferViewAsyncIterator,
toArrayBufferViewIterator: () => toArrayBufferViewIterator,
toBigInt64Array: () => toBigInt64Array,
toBigUint64Array: () => toBigUint64Array,
toFloat32Array: () => toFloat32Array,
toFloat32ArrayAsyncIterator: () => toFloat32ArrayAsyncIterator,
toFloat32ArrayIterator: () => toFloat32ArrayIterator,
toFloat64Array: () => toFloat64Array,
toFloat64ArrayAsyncIterator: () => toFloat64ArrayAsyncIterator,
toFloat64ArrayIterator: () => toFloat64ArrayIterator,
toInt16Array: () => toInt16Array,
toInt16ArrayAsyncIterator: () => toInt16ArrayAsyncIterator,
toInt16ArrayIterator: () => toInt16ArrayIterator,
toInt32Array: () => toInt32Array,
toInt32ArrayAsyncIterator: () => toInt32ArrayAsyncIterator,
toInt32ArrayIterator: () => toInt32ArrayIterator,
toInt8Array: () => toInt8Array,
toInt8ArrayAsyncIterator: () => toInt8ArrayAsyncIterator,
toInt8ArrayIterator: () => toInt8ArrayIterator,
toUint16Array: () => toUint16Array,
toUint16ArrayAsyncIterator: () => toUint16ArrayAsyncIterator,
toUint16ArrayIterator: () => toUint16ArrayIterator,
toUint32Array: () => toUint32Array,
toUint32ArrayAsyncIterator: () => toUint32ArrayAsyncIterator,
toUint32ArrayIterator: () => toUint32ArrayIterator,
toUint8Array: () => toUint8Array,
toUint8ArrayAsyncIterator: () => toUint8ArrayAsyncIterator,
toUint8ArrayIterator: () => toUint8ArrayIterator,
toUint8ClampedArray: () => toUint8ClampedArray,
toUint8ClampedArrayAsyncIterator: () => toUint8ClampedArrayAsyncIterator,
toUint8ClampedArrayIterator: () => toUint8ClampedArrayIterator
});
// ../../node_modules/apache-arrow/util/utf8.mjs
var decoder = new TextDecoder("utf-8");
var decodeUtf8 = decoder.decode.bind(decoder);
var encoder = new TextEncoder();
var encodeUtf8 = (value) => encoder.encode(value);
// ../../node_modules/apache-arrow/util/compat.mjs
var isNumber = (x) => typeof x === "number";
var isBoolean = (x) => typeof x === "boolean";
var isFunction = (x) => typeof x === "function";
var isObject = (x) => x != null && Object(x) === x;
var isPromise = (x) => {
return isObject(x) && isFunction(x.then);
};
var isIterable = (x) => {
return isObject(x) && isFunction(x[Symbol.iterator]);
};
var isAsyncIterable = (x) => {
return isObject(x) && isFunction(x[Symbol.asyncIterator]);
};
var isArrowJSON = (x) => {
return isObject(x) && isObject(x["schema"]);
};
var isIteratorResult = (x) => {
return isObject(x) && "done" in x && "value" in x;
};
var isFileHandle = (x) => {
return isObject(x) && isFunction(x["stat"]) && isNumber(x["fd"]);
};
var isFetchResponse = (x) => {
return isObject(x) && isReadableDOMStream(x["body"]);
};
var isReadableInterop = (x) => "_getDOMStream" in x && "_getNodeStream" in x;
var isWritableDOMStream = (x) => {
return isObject(x) && isFunction(x["abort"]) && isFunction(x["getWriter"]) && !isReadableInterop(x);
};
var isReadableDOMStream = (x) => {
return isObject(x) && isFunction(x["cancel"]) && isFunction(x["getReader"]) && !isReadableInterop(x);
};
var isWritableNodeStream = (x) => {
return isObject(x) && isFunction(x["end"]) && isFunction(x["write"]) && isBoolean(x["writable"]) && !isReadableInterop(x);
};
var isReadableNodeStream = (x) => {
return isObject(x) && isFunction(x["read"]) && isFunction(x["pipe"]) && isBoolean(x["readable"]) && !isReadableInterop(x);
};
var isFlatbuffersByteBuffer = (x) => {
return isObject(x) && isFunction(x["clear"]) && isFunction(x["bytes"]) && isFunction(x["position"]) && isFunction(x["setPosition"]) && isFunction(x["capacity"]) && isFunction(x["getBufferIdentifier"]) && isFunction(x["createLong"]);
};
// ../../node_modules/apache-arrow/util/buffer.mjs
var SharedArrayBuf = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : ArrayBuffer;
function collapseContiguousByteRanges(chunks) {
const result = chunks[0] ? [chunks[0]] : [];
let xOffset, yOffset, xLen, yLen;
for (let x, y, i = 0, j = 0, n = chunks.length; ++i < n; ) {
x = result[j];
y = chunks[i];
if (!x || !y || x.buffer !== y.buffer || y.byteOffset < x.byteOffset) {
y && (result[++j] = y);
continue;
}
({ byteOffset: xOffset, byteLength: xLen } = x);
({ byteOffset: yOffset, byteLength: yLen } = y);
if (xOffset + xLen < yOffset || yOffset + yLen < xOffset) {
y && (result[++j] = y);
continue;
}
result[j] = new Uint8Array(x.buffer, xOffset, yOffset - xOffset + yLen);
}
return result;
}
function memcpy(target, source, targetByteOffset = 0, sourceByteLength = source.byteLength) {
const targetByteLength = target.byteLength;
const dst = new Uint8Array(target.buffer, target.byteOffset, targetByteLength);
const src = new Uint8Array(source.buffer, source.byteOffset, Math.min(sourceByteLength, targetByteLength));
dst.set(src, targetByteOffset);
return target;
}
function joinUint8Arrays(chunks, size) {
const result = collapseContiguousByteRanges(chunks);
const byteLength = result.reduce((x, b) => x + b.byteLength, 0);
let source, sliced, buffer;
let offset = 0, index = -1;
const length = Math.min(size || Number.POSITIVE_INFINITY, byteLength);
for (const n = result.length; ++index < n; ) {
source = result[index];
sliced = source.subarray(0, Math.min(source.length, length - offset));
if (length <= offset + sliced.length) {
if (sliced.length < source.length) {
result[index] = source.subarray(sliced.length);
} else if (sliced.length === source.length) {
index++;
}
buffer ? memcpy(buffer, sliced, offset) : buffer = sliced;
break;
}
memcpy(buffer || (buffer = new Uint8Array(length)), sliced, offset);
offset += sliced.length;
}
return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];
}
function toArrayBufferView(ArrayBufferViewCtor, input) {
let value = isIteratorResult(input) ? input.value : input;
if (value instanceof ArrayBufferViewCtor) {
if (ArrayBufferViewCtor === Uint8Array) {
return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);
}
return value;
}
if (!value) {
return new ArrayBufferViewCtor(0);
}
if (typeof value === "string") {
value = encodeUtf8(value);
}
if (value instanceof ArrayBuffer) {
return new ArrayBufferViewCtor(value);
}
if (value instanceof SharedArrayBuf) {
return new ArrayBufferViewCtor(value);
}
if (isFlatbuffersByteBuffer(value)) {
return toArrayBufferView(ArrayBufferViewCtor, value.bytes());
}
return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0) : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);
}
var toInt8Array = (input) => toArrayBufferView(Int8Array, input);
var toInt16Array = (input) => toArrayBufferView(Int16Array, input);
var toInt32Array = (input) => toArrayBufferView(Int32Array, input);
var toBigInt64Array = (input) => toArrayBufferView(BigInt64Array, input);
var toUint8Array = (input) => toArrayBufferView(Uint8Array, input);
var toUint16Array = (input) => toArrayBufferView(Uint16Array, input);
var toUint32Array = (input) => toArrayBufferView(Uint32Array, input);
var toBigUint64Array = (input) => toArrayBufferView(BigUint64Array, input);
var toFloat32Array = (input) => toArrayBufferView(Float32Array, input);
var toFloat64Array = (input) => toArrayBufferView(Float64Array, input);
var toUint8ClampedArray = (input) => toArrayBufferView(Uint8ClampedArray, input);
var pump = (iterator) => {
iterator.next();
return iterator;
};
function* toArrayBufferViewIterator(ArrayCtor, source) {
const wrap = function* (x) {
yield x;
};
const buffers = typeof source === "string" ? wrap(source) : ArrayBuffer.isView(source) ? wrap(source) : source instanceof ArrayBuffer ? wrap(source) : source instanceof SharedArrayBuf ? wrap(source) : !isIterable(source) ? wrap(source) : source;
yield* pump(function* (it) {
let r = null;
do {
r = it.next(yield toArrayBufferView(ArrayCtor, r));
} while (!r.done);
}(buffers[Symbol.iterator]()));
return new ArrayCtor();
}
var toInt8ArrayIterator = (input) => toArrayBufferViewIterator(Int8Array, input);
var toInt16ArrayIterator = (input) => toArrayBufferViewIterator(Int16Array, input);
var toInt32ArrayIterator = (input) => toArrayBufferViewIterator(Int32Array, input);
var toUint8ArrayIterator = (input) => toArrayBufferViewIterator(Uint8Array, input);
var toUint16ArrayIterator = (input) => toArrayBufferViewIterator(Uint16Array, input);
var toUint32ArrayIterator = (input) => toArrayBufferViewIterator(Uint32Array, input);
var toFloat32ArrayIterator = (input) => toArrayBufferViewIterator(Float32Array, input);
var toFloat64ArrayIterator = (input) => toArrayBufferViewIterator(Float64Array, input);
var toUint8ClampedArrayIterator = (input) => toArrayBufferViewIterator(Uint8ClampedArray, input);
function toArrayBufferViewAsyncIterator(ArrayCtor, source) {
return __asyncGenerator(this, arguments, function* toArrayBufferViewAsyncIterator_1() {
if (isPromise(source)) {
return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(toArrayBufferViewAsyncIterator(ArrayCtor, yield __await(source))))));
}
const wrap = function(x) {
return __asyncGenerator(this, arguments, function* () {
yield yield __await(yield __await(x));
});
};
const emit = function(source2) {
return __asyncGenerator(this, arguments, function* () {
yield __await(yield* __asyncDelegator(__asyncValues(pump(function* (it) {
let r = null;
do {
r = it.next(yield r === null || r === void 0 ? void 0 : r.value);
} while (!r.done);
}(source2[Symbol.iterator]())))));
});
};
const buffers = typeof source === "string" ? wrap(source) : ArrayBuffer.isView(source) ? wrap(source) : source instanceof ArrayBuffer ? wrap(source) : source instanceof SharedArrayBuf ? wrap(source) : isIterable(source) ? emit(source) : !isAsyncIterable(source) ? wrap(source) : source;
yield __await(
// otherwise if AsyncIterable, use it
yield* __asyncDelegator(__asyncValues(pump(function(it) {
return __asyncGenerator(this, arguments, function* () {
let r = null;
do {
r = yield __await(it.next(yield yield __await(toArrayBufferView(ArrayCtor, r))));
} while (!r.done);
});
}(buffers[Symbol.asyncIterator]()))))
);
return yield __await(new ArrayCtor());
});
}
var toInt8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int8Array, input);
var toInt16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int16Array, input);
var toInt32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int32Array, input);
var toUint8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8Array, input);
var toUint16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint16Array, input);
var toUint32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint32Array, input);
var toFloat32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float32Array, input);
var toFloat64ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float64Array, input);
var toUint8ClampedArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);
function rebaseValueOffsets(offset, length, valueOffsets) {
if (offset !== 0) {
valueOffsets = valueOffsets.slice(0, length);
for (let i = -1, n = valueOffsets.length; ++i < n; ) {
valueOffsets[i] += offset;
}
}
return valueOffsets.subarray(0, length);
}
function compareArrayLike(a, b) {
let i = 0;
const n = a.length;
if (n !== b.length) {
return false;
}
if (n > 0) {
do {
if (a[i] !== b[i]) {
return false;
}
} while (++i < n);
}
return true;
}
// ../../node_modules/apache-arrow/io/adapters.mjs
var adapters_default = {
fromIterable(source) {
return pump2(fromIterable(source));
},
fromAsyncIterable(source) {
return pump2(fromAsyncIterable(source));
},
fromDOMStream(source) {
return pump2(fromDOMStream(source));
},
fromNodeStream(stream) {
return pump2(fromNodeStream(stream));
},
// @ts-ignore
toDOMStream(source, options) {
throw new Error(`"toDOMStream" not available in this environment`);
},
// @ts-ignore
toNodeStream(source, options) {
throw new Error(`"toNodeStream" not available in this environment`);
}
};
var pump2 = (iterator) => {
iterator.next();
return iterator;
};
function* fromIterable(source) {
let done, threw = false;
let buffers = [], buffer;
let cmd, size, bufferLength = 0;
function byteRange() {
if (cmd === "peek") {
return joinUint8Arrays(buffers, size)[0];
}
[buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
return buffer;
}
({ cmd, size } = (yield (() => null)()) || { cmd: "read", size: 0 });
const it = toUint8ArrayIterator(source)[Symbol.iterator]();
try {
do {
({ done, value: buffer } = Number.isNaN(size - bufferLength) ? it.next() : it.next(size - bufferLength));
if (!done && buffer.byteLength > 0) {
buffers.push(buffer);
bufferLength += buffer.byteLength;
}
if (done || size <= bufferLength) {
do {
({ cmd, size } = yield byteRange());
} while (size < bufferLength);
}
} while (!done);
} catch (e) {
threw = true;
typeof it.throw === "function" && it.throw(e);
} finally {
threw === false && typeof it.return === "function" && it.return(null);
}
return null;
}
function fromAsyncIterable(source) {
return __asyncGenerator(this, arguments, function* fromAsyncIterable_1() {
let done, threw = false;
let buffers = [], buffer;
let cmd, size, bufferLength = 0;
function byteRange() {
if (cmd === "peek") {
return joinUint8Arrays(buffers, size)[0];
}
[buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
return buffer;
}
({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
const it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();
try {
do {
({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it.next()) : yield __await(it.next(size - bufferLength)));
if (!done && buffer.byteLength > 0) {
buffers.push(buffer);
bufferLength += buffer.byteLength;
}
if (done || size <= bufferLength) {
do {
({ cmd, size } = yield yield __await(byteRange()));
} while (size < bufferLength);
}
} while (!done);
} catch (e) {
threw = true;
typeof it.throw === "function" && (yield __await(it.throw(e)));
} finally {
threw === false && typeof it.return === "function" && (yield __await(it.return(new Uint8Array(0))));
}
return yield __await(null);
});
}
function fromDOMStream(source) {
return __asyncGenerator(this, arguments, function* fromDOMStream_1() {
let done = false, threw = false;
let buffers = [], buffer;
let cmd, size, bufferLength = 0;
function byteRange() {
if (cmd === "peek") {
return joinUint8Arrays(buffers, size)[0];
}
[buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
return buffer;
}
({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
const it = new AdaptiveByteReader(source);
try {
do {
({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it["read"]()) : yield __await(it["read"](size - bufferLength)));
if (!done && buffer.byteLength > 0) {
buffers.push(toUint8Array(buffer));
bufferLength += buffer.byteLength;
}
if (done || size <= bufferLength) {
do {
({ cmd, size } = yield yield __await(byteRange()));
} while (size < bufferLength);
}
} while (!done);
} catch (e) {
threw = true;
yield __await(it["cancel"](e));
} finally {
threw === false ? yield __await(it["cancel"]()) : source["locked"] && it.releaseLock();
}
return yield __await(null);
});
}
var AdaptiveByteReader = class {
constructor(source) {
this.source = source;
this.reader = null;
this.reader = this.source["getReader"]();
this.reader["closed"].catch(() => {
});
}
get closed() {
return this.reader ? this.reader["closed"].catch(() => {
}) : Promise.resolve();
}
releaseLock() {
if (this.reader) {
this.reader.releaseLock();
}
this.reader = null;
}
cancel(reason) {
return __awaiter(this, void 0, void 0, function* () {
const { reader, source } = this;
reader && (yield reader["cancel"](reason).catch(() => {
}));
source && (source["locked"] && this.releaseLock());
});
}
read(size) {
return __awaiter(this, void 0, void 0, function* () {
if (size === 0) {
return { done: this.reader == null, value: new Uint8Array(0) };
}
const result = yield this.reader.read();
!result.done && (result.value = toUint8Array(result));
return result;
});
}
};
var onEvent = (stream, event) => {
const handler = (_) => resolve([event, _]);
let resolve;
return [event, handler, new Promise((r) => (resolve = r) && stream["once"](event, handler))];
};
function fromNodeStream(stream) {
return __asyncGenerator(this, arguments, function* fromNodeStream_1() {
const events = [];
let event = "error";
let done = false, err = null;
let cmd, size, bufferLength = 0;
let buffers = [], buffer;
function byteRange() {
if (cmd === "peek") {
return joinUint8Arrays(buffers, size)[0];
}
[buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
return buffer;
}
({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
if (stream["isTTY"]) {
yield yield __await(new Uint8Array(0));
return yield __await(null);
}
try {
events[0] = onEvent(stream, "end");
events[1] = onEvent(stream, "error");
do {
events[2] = onEvent(stream, "readable");
[event, err] = yield __await(Promise.race(events.map((x) => x[2])));
if (event === "error") {
break;
}
if (!(done = event === "end")) {
if (!Number.isFinite(size - bufferLength)) {
buffer = toUint8Array(stream["read"]());
} else {
buffer = toUint8Array(stream["read"](size - bufferLength));
if (buffer.byteLength < size - bufferLength) {
buffer = toUint8Array(stream["read"]());
}
}
if (buffer.byteLength > 0) {
buffers.push(buffer);
bufferLength += buffer.byteLength;
}
}
if (done || size <= bufferLength) {
do {
({ cmd, size } = yield yield __await(byteRange()));
} while (size < bufferLength);
}
} while (!done);
} finally {
yield __await(cleanup(events, event === "error" ? err : null));
}
return yield __await(null);
function cleanup(events2, err2) {
buffer = buffers = null;
return new Promise((resolve, reject) => {
for (const [evt, fn] of events2) {
stream["off"](evt, fn);
}
try {
const destroy = stream["destroy"];
destroy && destroy.call(stream, err2);
err2 = void 0;
} catch (e) {
err2 = e || err2;
} finally {
err2 != null ? reject(err2) : resolve();
}
});
}
});
}
// ../../node_modules/apache-arrow/fb/metadata-version.mjs
var MetadataVersion;
(function(MetadataVersion2) {
MetadataVersion2[MetadataVersion2["V1"] = 0] = "V1";
MetadataVersion2[MetadataVersion2["V2"] = 1] = "V2";
MetadataVersion2[MetadataVersion2["V3"] = 2] = "V3";
MetadataVersion2[MetadataVersion2["V4"] = 3] = "V4";
MetadataVersion2[MetadataVersion2["V5"] = 4] = "V5";
})(MetadataVersion || (MetadataVersion = {}));
// ../../node_modules/apache-arrow/fb/union-mode.mjs
var UnionMode;
(function(UnionMode2) {
UnionMode2[UnionMode2["Sparse"] = 0] = "Sparse";
UnionMode2[UnionMode2["Dense"] = 1] = "Dense";
})(UnionMode || (UnionMode = {}));
// ../../node_modules/apache-arrow/fb/precision.mjs
var Precision;
(function(Precision2) {
Precision2[Precision2["HALF"] = 0] = "HALF";
Precision2[Precision2["SINGLE"] = 1] = "SINGLE";
Precision2[Precision2["DOUBLE"] = 2] = "DOUBLE";
})(Precision || (Precision = {}));
// ../../node_modules/apache-arrow/fb/date-unit.mjs
var DateUnit;
(function(DateUnit2) {
DateUnit2[DateUnit2["DAY"] = 0] = "DAY";
DateUnit2[DateUnit2["MILLISECOND"] = 1] = "MILLISECOND";
})(DateUnit || (DateUnit = {}));
// ../../node_modules/apache-arrow/fb/time-unit.mjs
var TimeUnit;
(function(TimeUnit2) {
TimeUnit2[TimeUnit2["SECOND"] = 0] = "SECOND";
TimeUnit2[TimeUnit2["MILLISECOND"] = 1] = "MILLISECOND";
TimeUnit2[TimeUnit2["MICROSECOND"] = 2] = "MICROSECOND";
TimeUnit2[TimeUnit2["NANOSECOND"] = 3] = "NANOSECOND";
})(TimeUnit || (TimeUnit = {}));
// ../../node_modules/apache-arrow/fb/interval-unit.mjs
var IntervalUnit;
(function(IntervalUnit2) {
IntervalUnit2[IntervalUnit2["YEAR_MONTH"] = 0] = "YEAR_MONTH";
IntervalUnit2[IntervalUnit2["DAY_TIME"] = 1] = "DAY_TIME";
IntervalUnit2[IntervalUnit2["MONTH_DAY_NANO"] = 2] = "MONTH_DAY_NANO";
})(IntervalUnit || (IntervalUnit = {}));
// ../../node_modules/flatbuffers/mjs/constants.js
var SIZEOF_SHORT = 2;
var SIZEOF_INT = 4;
var FILE_IDENTIFIER_LENGTH = 4;
var SIZE_PREFIX_LENGTH = 4;
// ../../node_modules/flatbuffers/mjs/utils.js
var int32 =