{
  "version": 3,
  "sources": ["index.js", "lib/streaming/binary-chunk-reader.js", "lib/parsers/parse-shp-header.js", "lib/parsers/parse-shp-geometry.js", "lib/parsers/parse-shp.js", "shp-loader.js", "lib/parsers/parse-shapefile.js", "lib/parsers/parse-shx.js", "lib/streaming/zip-batch-iterators.js", "lib/parsers/parse-dbf.js", "dbf-loader.js", "shapefile-loader.js", "lib/streaming/binary-reader.js"],
  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport { ShapefileLoader } from \"./shapefile-loader.js\";\nexport { DBFLoader, DBFWorkerLoader } from \"./dbf-loader.js\";\nexport { SHPLoader, SHPWorkerLoader } from \"./shp-loader.js\";\n// EXPERIMENTAL\nexport { BinaryReader as _BinaryReader } from \"./lib/streaming/binary-reader.js\";\nexport { BinaryChunkReader as _BinaryChunkReader } from \"./lib/streaming/binary-chunk-reader.js\";\nexport { zipBatchIterators as _zipBatchIterators } from \"./lib/streaming/zip-batch-iterators.js\";\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport class BinaryChunkReader {\n    offset;\n    arrayBuffers;\n    ended;\n    maxRewindBytes;\n    constructor(options) {\n        const { maxRewindBytes = 0 } = options || {};\n        /** current global offset into current array buffer*/\n        this.offset = 0;\n        /** current buffer from iterator */\n        this.arrayBuffers = [];\n        this.ended = false;\n        /** bytes behind offset to hold on to */\n        this.maxRewindBytes = maxRewindBytes;\n    }\n    /**\n     * @param arrayBuffer\n     */\n    write(arrayBuffer) {\n        this.arrayBuffers.push(arrayBuffer);\n    }\n    end() {\n        this.arrayBuffers = [];\n        this.ended = true;\n    }\n    /**\n     * Has enough bytes available in array buffers\n     *\n     * @param bytes Number of bytes\n     * @return boolean\n     */\n    hasAvailableBytes(bytes) {\n        let bytesAvailable = -this.offset;\n        for (const arrayBuffer of this.arrayBuffers) {\n            bytesAvailable += arrayBuffer.byteLength;\n            if (bytesAvailable >= bytes) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * Find offsets of byte ranges within this.arrayBuffers\n     *\n     * @param  bytes Byte length to read\n     * @return Arrays with byte ranges pointing to this.arrayBuffers, Output type is nested array, e.g. [ [0, [1, 2]], ...]\n     */\n    findBufferOffsets(bytes) {\n        let offset = -this.offset;\n        const selectedBuffers = [];\n        for (let i = 0; i < this.arrayBuffers.length; i++) {\n            const buf = this.arrayBuffers[i];\n            // Current buffer isn't long enough to reach global offset\n            if (offset + buf.byteLength <= 0) {\n                offset += buf.byteLength;\n                // eslint-disable-next-line no-continue\n                continue;\n            }\n            // Find start/end offsets for this buffer\n            // When offset < 0, need to skip over Math.abs(offset) bytes\n            // When offset > 0, implies bytes in previous buffer, start at 0\n            const start = offset <= 0 ? Math.abs(offset) : 0;\n            let end;\n            // Length of requested bytes is contained in current buffer\n            if (start + bytes <= buf.byteLength) {\n                end = start + bytes;\n                selectedBuffers.push([i, [start, end]]);\n                return selectedBuffers;\n            }\n            // Will need to look into next buffer\n            end = buf.byteLength;\n            selectedBuffers.push([i, [start, end]]);\n            // Need to read fewer bytes in next iter\n            bytes -= buf.byteLength - start;\n            offset += buf.byteLength;\n        }\n        // Should only finish loop if exhausted all arrays\n        return null;\n    }\n    /**\n     * Get the required number of bytes from the iterator\n     *\n     * @param bytes Number of bytes\n     * @return DataView with data\n     */\n    getDataView(bytes) {\n        const bufferOffsets = this.findBufferOffsets(bytes);\n        // return `null` if not enough data, except if end() already called, in\n        // which case throw an error.\n        if (!bufferOffsets && this.ended) {\n            throw new Error('binary data exhausted');\n        }\n        if (!bufferOffsets) {\n            return null;\n        }\n        // If only one arrayBuffer needed, return DataView directly\n        if (bufferOffsets.length === 1) {\n            const [bufferIndex, [start, end]] = bufferOffsets[0];\n            const arrayBuffer = this.arrayBuffers[bufferIndex];\n            const view = new DataView(arrayBuffer, start, end - start);\n            this.offset += bytes;\n            this.disposeBuffers();\n            return view;\n        }\n        // Concatenate portions of multiple ArrayBuffers\n        const view = new DataView(this._combineArrayBuffers(bufferOffsets));\n        this.offset += bytes;\n        this.disposeBuffers();\n        return view;\n    }\n    /**\n     * Dispose of old array buffers\n     */\n    disposeBuffers() {\n        while (this.arrayBuffers.length > 0 &&\n            this.offset - this.maxRewindBytes >= this.arrayBuffers[0].byteLength) {\n            this.offset -= this.arrayBuffers[0].byteLength;\n            this.arrayBuffers.shift();\n        }\n    }\n    /**\n     * Copy multiple ArrayBuffers into one contiguous ArrayBuffer\n     *\n     * In contrast to concatenateArrayBuffers, this only copies the necessary\n     * portions of the source arrays, rather than first copying the entire arrays\n     * then taking a part of them.\n     *\n     * @param bufferOffsets List of internal array offsets\n     * @return New contiguous ArrayBuffer\n     */\n    _combineArrayBuffers(bufferOffsets) {\n        let byteLength = 0;\n        for (const bufferOffset of bufferOffsets) {\n            const [start, end] = bufferOffset[1];\n            byteLength += end - start;\n        }\n        const result = new Uint8Array(byteLength);\n        // Copy the subarrays\n        let resultOffset = 0;\n        for (const bufferOffset of bufferOffsets) {\n            const [bufferIndex, [start, end]] = bufferOffset;\n            const sourceArray = new Uint8Array(this.arrayBuffers[bufferIndex]);\n            result.set(sourceArray.subarray(start, end), resultOffset);\n            resultOffset += end - start;\n        }\n        return result.buffer;\n    }\n    /**\n     * @param bytes\n     */\n    skip(bytes) {\n        this.offset += bytes;\n    }\n    /**\n     * @param bytes\n     */\n    rewind(bytes) {\n        // TODO - only works if offset is already set\n        this.offset -= bytes;\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst LITTLE_ENDIAN = true;\nconst BIG_ENDIAN = false;\nconst SHP_MAGIC_NUMBER = 0x0000270a;\n/**\n * Extract the binary header\n * Note: Also used by SHX\n * @param headerView\n * @returns SHPHeader\n */\nexport function parseSHPHeader(headerView) {\n    // Note: The SHP format switches endianness between fields!\n    // https://www.esri.com/library/whitepapers/pdfs/shapefile.pdf\n    const header = {\n        magic: headerView.getInt32(0, BIG_ENDIAN),\n        // Length is stored as # of 2-byte words; multiply by 2 to get # of bytes\n        length: headerView.getInt32(24, BIG_ENDIAN) * 2,\n        version: headerView.getInt32(28, LITTLE_ENDIAN),\n        type: headerView.getInt32(32, LITTLE_ENDIAN),\n        bbox: {\n            minX: headerView.getFloat64(36, LITTLE_ENDIAN),\n            minY: headerView.getFloat64(44, LITTLE_ENDIAN),\n            minZ: headerView.getFloat64(68, LITTLE_ENDIAN),\n            minM: headerView.getFloat64(84, LITTLE_ENDIAN),\n            maxX: headerView.getFloat64(52, LITTLE_ENDIAN),\n            maxY: headerView.getFloat64(60, LITTLE_ENDIAN),\n            maxZ: headerView.getFloat64(76, LITTLE_ENDIAN),\n            maxM: headerView.getFloat64(92, LITTLE_ENDIAN)\n        }\n    };\n    if (header.magic !== SHP_MAGIC_NUMBER) {\n        // eslint-disable-next-line\n        console.error(`SHP file: bad magic number ${header.magic}`);\n    }\n    if (header.version !== 1000) {\n        // eslint-disable-next-line\n        console.error(`SHP file: bad version ${header.version}`);\n    }\n    return header;\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nconst LITTLE_ENDIAN = true;\n/**\n * Parse individual record\n *\n * @param view Record data\n * @return Binary Geometry Object\n */\n// eslint-disable-next-line complexity\nexport function parseRecord(view, options) {\n    const { _maxDimensions = 4 } = options?.shp || {};\n    let offset = 0;\n    const type = view.getInt32(offset, LITTLE_ENDIAN);\n    offset += Int32Array.BYTES_PER_ELEMENT;\n    switch (type) {\n        case 0:\n            // Null Shape\n            return parseNull();\n        case 1:\n            // Point\n            return parsePoint(view, offset, Math.min(2, _maxDimensions));\n        case 3:\n            // PolyLine\n            return parsePoly(view, offset, Math.min(2, _maxDimensions), 'LineString');\n        case 5:\n            // Polygon\n            return parsePoly(view, offset, Math.min(2, _maxDimensions), 'Polygon');\n        case 8:\n            // MultiPoint\n            return parseMultiPoint(view, offset, Math.min(2, _maxDimensions));\n        // GeometryZ can have 3 or 4 dimensions, since the M is not required to\n        // exist\n        case 11:\n            // PointZ\n            return parsePoint(view, offset, Math.min(4, _maxDimensions));\n        case 13:\n            // PolyLineZ\n            return parsePoly(view, offset, Math.min(4, _maxDimensions), 'LineString');\n        case 15:\n            // PolygonZ\n            return parsePoly(view, offset, Math.min(4, _maxDimensions), 'Polygon');\n        case 18:\n            // MultiPointZ\n            return parseMultiPoint(view, offset, Math.min(4, _maxDimensions));\n        case 21:\n            // PointM\n            return parsePoint(view, offset, Math.min(3, _maxDimensions));\n        case 23:\n            // PolyLineM\n            return parsePoly(view, offset, Math.min(3, _maxDimensions), 'LineString');\n        case 25:\n            // PolygonM\n            return parsePoly(view, offset, Math.min(3, _maxDimensions), 'Polygon');\n        case 28:\n            // MultiPointM\n            return parseMultiPoint(view, offset, Math.min(3, _maxDimensions));\n        default:\n            throw new Error(`unsupported shape type: ${type}`);\n    }\n}\n// TODO handle null\n/**\n * Parse Null geometry\n *\n * @return null\n */\nfunction parseNull() {\n    return null;\n}\n/**\n * Parse point geometry\n *\n * @param view Geometry data\n * @param offset Offset in view\n * @param dim Dimension size\n */\nfunction parsePoint(view, offset, dim) {\n    let positions;\n    [positions, offset] = parsePositions(view, offset, 1, dim);\n    return {\n        positions: { value: positions, size: dim },\n        type: 'Point'\n    };\n}\n/**\n * Parse MultiPoint geometry\n *\n * @param view Geometry data\n * @param offset Offset in view\n * @param dim Input dimension\n * @return Binary geometry object\n */\nfunction parseMultiPoint(view, offset, dim) {\n    // skip parsing box\n    offset += 4 * Float64Array.BYTES_PER_ELEMENT;\n    const nPoints = view.getInt32(offset, LITTLE_ENDIAN);\n    offset += Int32Array.BYTES_PER_ELEMENT;\n    let xyPositions = null;\n    let mPositions = null;\n    let zPositions = null;\n    [xyPositions, offset] = parsePositions(view, offset, nPoints, 2);\n    // Parse Z coordinates\n    if (dim === 4) {\n        // skip parsing range\n        offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n        [zPositions, offset] = parsePositions(view, offset, nPoints, 1);\n    }\n    // Parse M coordinates\n    if (dim >= 3) {\n        // skip parsing range\n        offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n        [mPositions, offset] = parsePositions(view, offset, nPoints, 1);\n    }\n    const positions = concatPositions(xyPositions, mPositions, zPositions);\n    return {\n        positions: { value: positions, size: dim },\n        type: 'Point'\n    };\n}\n/**\n * Polygon and PolyLine parsing\n *\n * @param view Geometry data\n * @param offset Offset in view\n * @param dim Input dimension\n * @param type Either 'Polygon' or 'Polyline'\n * @return Binary geometry object\n */\n// eslint-disable-next-line max-statements\nfunction parsePoly(view, offset, dim, type) {\n    // skip parsing bounding box\n    offset += 4 * Float64Array.BYTES_PER_ELEMENT;\n    const nParts = view.getInt32(offset, LITTLE_ENDIAN);\n    offset += Int32Array.BYTES_PER_ELEMENT;\n    const nPoints = view.getInt32(offset, LITTLE_ENDIAN);\n    offset += Int32Array.BYTES_PER_ELEMENT;\n    // Create longer indices array by 1 because output format is expected to\n    // include the last index as the total number of positions\n    const bufferOffset = view.byteOffset + offset;\n    const bufferLength = nParts * Int32Array.BYTES_PER_ELEMENT;\n    const ringIndices = new Int32Array(nParts + 1);\n    ringIndices.set(new Int32Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)));\n    ringIndices[nParts] = nPoints;\n    offset += nParts * Int32Array.BYTES_PER_ELEMENT;\n    let xyPositions = null;\n    let mPositions = null;\n    let zPositions = null;\n    [xyPositions, offset] = parsePositions(view, offset, nPoints, 2);\n    // Parse Z coordinates\n    if (dim === 4) {\n        // skip parsing range\n        offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n        [zPositions, offset] = parsePositions(view, offset, nPoints, 1);\n    }\n    // Parse M coordinates\n    if (dim >= 3) {\n        // skip parsing range\n        offset += 2 * Float64Array.BYTES_PER_ELEMENT;\n        [mPositions, offset] = parsePositions(view, offset, nPoints, 1);\n    }\n    const positions = concatPositions(xyPositions, mPositions, zPositions);\n    // parsePoly only accepts type = LineString or Polygon\n    if (type === 'LineString') {\n        return {\n            type,\n            positions: { value: positions, size: dim },\n            pathIndices: { value: ringIndices, size: 1 }\n        };\n    }\n    // for every ring, determine sign of polygon\n    // Use only 2D positions for ring calc\n    const polygonIndices = [];\n    for (let i = 1; i < ringIndices.length; i++) {\n        const startRingIndex = ringIndices[i - 1];\n        const endRingIndex = ringIndices[i];\n        // @ts-ignore\n        const ring = xyPositions.subarray(startRingIndex * 2, endRingIndex * 2);\n        const sign = getWindingDirection(ring);\n        // A positive sign implies clockwise\n        // A clockwise ring is a filled ring\n        if (sign > 0) {\n            polygonIndices.push(startRingIndex);\n        }\n    }\n    polygonIndices.push(nPoints);\n    return {\n        type,\n        positions: { value: positions, size: dim },\n        primitivePolygonIndices: { value: ringIndices, size: 1 },\n        // TODO: Dynamically choose Uint32Array over Uint16Array only when\n        // necessary. I believe the implementation requires nPoints to be the\n        // largest value in the array, so you should be able to use Uint32Array only\n        // when nPoints > 65535.\n        polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 }\n    };\n}\n/**\n * Parse a contiguous block of positions into a Float64Array\n *\n * @param view  Geometry data\n * @param offset  Offset in view\n * @param nPoints Number of points\n * @param dim     Input dimension\n * @return Data and offset\n */\nfunction parsePositions(view, offset, nPoints, dim) {\n    const bufferOffset = view.byteOffset + offset;\n    const bufferLength = nPoints * dim * Float64Array.BYTES_PER_ELEMENT;\n    return [\n        new Float64Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)),\n        offset + bufferLength\n    ];\n}\n/**\n * Concatenate and interleave positions arrays\n * xy positions are interleaved; mPositions, zPositions are their own arrays\n *\n * @param xyPositions 2d positions\n * @param mPositions  M positions\n * @param zPositions  Z positions\n * @return Combined interleaved positions\n */\n// eslint-disable-next-line complexity\nfunction concatPositions(xyPositions, mPositions, zPositions) {\n    if (!(mPositions || zPositions)) {\n        return xyPositions;\n    }\n    let arrayLength = xyPositions.length;\n    let nDim = 2;\n    if (zPositions && zPositions.length) {\n        arrayLength += zPositions.length;\n        nDim++;\n    }\n    if (mPositions && mPositions.length) {\n        arrayLength += mPositions.length;\n        nDim++;\n    }\n    const positions = new Float64Array(arrayLength);\n    for (let i = 0; i < xyPositions.length / 2; i++) {\n        positions[nDim * i] = xyPositions[i * 2];\n        positions[nDim * i + 1] = xyPositions[i * 2 + 1];\n    }\n    if (zPositions && zPositions.length) {\n        for (let i = 0; i < zPositions.length; i++) {\n            // If Z coordinates exist; used as third coord in positions array\n            positions[nDim * i + 2] = zPositions[i];\n        }\n    }\n    if (mPositions && mPositions.length) {\n        for (let i = 0; i < mPositions.length; i++) {\n            // M is always last, either 3rd or 4th depending on if Z exists\n            positions[nDim * i + (nDim - 1)] = mPositions[i];\n        }\n    }\n    return positions;\n}\n/**\n * Returns the direction of the polygon path\n * A positive number is clockwise.\n * A negative number is counter clockwise.\n *\n * @param positions\n * @return Sign of polygon ring\n */\nfunction getWindingDirection(positions) {\n    return Math.sign(getSignedArea(positions));\n}\n/**\n * Get signed area of flat typed array of 2d positions\n *\n * @param positions\n * @return Signed area of polygon ring\n */\nfunction getSignedArea(positions) {\n    let area = 0;\n    // Rings are closed according to shapefile spec\n    const nCoords = positions.length / 2 - 1;\n    for (let i = 0; i < nCoords; i++) {\n        area +=\n            (positions[i * 2] + positions[(i + 1) * 2]) *\n                (positions[i * 2 + 1] - positions[(i + 1) * 2 + 1]);\n    }\n    return area / 2;\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { BinaryChunkReader } from \"../streaming/binary-chunk-reader.js\";\nimport { parseSHPHeader } from \"./parse-shp-header.js\";\nimport { parseRecord } from \"./parse-shp-geometry.js\";\nconst LITTLE_ENDIAN = true;\nconst BIG_ENDIAN = false;\nconst SHP_HEADER_SIZE = 100;\n// According to the spec, the record header is just 8 bytes, but here we set it\n// to 12 so that we can also access the record's type\nconst SHP_RECORD_HEADER_SIZE = 12;\nconst STATE = {\n    EXPECTING_HEADER: 0,\n    EXPECTING_RECORD: 1,\n    END: 2,\n    ERROR: 3\n};\nclass SHPParser {\n    options = {};\n    binaryReader = new BinaryChunkReader({ maxRewindBytes: SHP_RECORD_HEADER_SIZE });\n    state = STATE.EXPECTING_HEADER;\n    result = {\n        geometries: [],\n        // Initialize with number values to make TS happy\n        // These are initialized for real in STATE.EXPECTING_HEADER\n        progress: {\n            bytesTotal: NaN,\n            bytesUsed: NaN,\n            rows: NaN\n        },\n        currentIndex: NaN\n    };\n    constructor(options) {\n        this.options = options;\n    }\n    write(arrayBuffer) {\n        this.binaryReader.write(arrayBuffer);\n        this.state = parseState(this.state, this.result, this.binaryReader, this.options);\n    }\n    end() {\n        this.binaryReader.end();\n        this.state = parseState(this.state, this.result, this.binaryReader, this.options);\n        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();\n        if (this.state !== STATE.END) {\n            this.state = STATE.ERROR;\n            this.result.error = 'SHP incomplete file';\n        }\n    }\n}\nexport function parseSHP(arrayBuffer, options) {\n    const shpParser = new SHPParser(options);\n    shpParser.write(arrayBuffer);\n    shpParser.end();\n    // @ts-ignore\n    return shpParser.result;\n}\n/**\n * @param asyncIterator\n * @param options\n * @returns\n */\nexport async function* parseSHPInBatches(asyncIterator, options) {\n    const parser = new SHPParser(options);\n    let headerReturned = false;\n    for await (const arrayBuffer of asyncIterator) {\n        parser.write(arrayBuffer);\n        if (!headerReturned && parser.result.header) {\n            headerReturned = true;\n            yield parser.result.header;\n        }\n        if (parser.result.geometries.length > 0) {\n            yield parser.result.geometries;\n            parser.result.geometries = [];\n        }\n    }\n    parser.end();\n    if (parser.result.geometries.length > 0) {\n        yield parser.result.geometries;\n    }\n    return;\n}\n/**\n * State-machine parser for SHP data\n *\n * Note that whenever more data is needed, a `return`, not a `break`, is\n * necessary, as the `break` keeps the context within `parseState`, while\n * `return` releases context so that more data can be written into the\n * BinaryChunkReader.\n *\n * @param  state Current state\n * @param  result An object to hold result data\n * @param  binaryReader\n * @return State at end of current parsing\n */\n/* eslint-disable complexity, max-depth */\nfunction parseState(state, result, binaryReader, options) {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        try {\n            switch (state) {\n                case STATE.ERROR:\n                case STATE.END:\n                    return state;\n                case STATE.EXPECTING_HEADER:\n                    // Parse initial file header\n                    const dataView = binaryReader.getDataView(SHP_HEADER_SIZE);\n                    if (!dataView) {\n                        return state;\n                    }\n                    result.header = parseSHPHeader(dataView);\n                    result.progress = {\n                        bytesUsed: 0,\n                        bytesTotal: result.header.length,\n                        rows: 0\n                    };\n                    // index numbering starts at 1\n                    result.currentIndex = 1;\n                    state = STATE.EXPECTING_RECORD;\n                    break;\n                case STATE.EXPECTING_RECORD:\n                    while (binaryReader.hasAvailableBytes(SHP_RECORD_HEADER_SIZE)) {\n                        const recordHeaderView = binaryReader.getDataView(SHP_RECORD_HEADER_SIZE);\n                        const recordHeader = {\n                            recordNumber: recordHeaderView.getInt32(0, BIG_ENDIAN),\n                            // 2 byte words; includes the four words of record header\n                            byteLength: recordHeaderView.getInt32(4, BIG_ENDIAN) * 2,\n                            // This is actually part of the record, not the header...\n                            type: recordHeaderView.getInt32(8, LITTLE_ENDIAN)\n                        };\n                        if (!binaryReader.hasAvailableBytes(recordHeader.byteLength - 4)) {\n                            binaryReader.rewind(SHP_RECORD_HEADER_SIZE);\n                            return state;\n                        }\n                        const invalidRecord = recordHeader.byteLength < 4 ||\n                            recordHeader.type !== result.header?.type ||\n                            recordHeader.recordNumber !== result.currentIndex;\n                        // All records must have at least four bytes (for the record shape type)\n                        if (invalidRecord) {\n                            // Malformed record, try again, advancing just 4 bytes\n                            // Note: this is a rewind because binaryReader.getDataView above\n                            // moved the pointer forward 12 bytes, so rewinding 8 bytes still\n                            // leaves us 4 bytes ahead\n                            binaryReader.rewind(SHP_RECORD_HEADER_SIZE - 4);\n                        }\n                        else {\n                            // Note: type is actually part of the record, not the header, so\n                            // rewind 4 bytes before reading record\n                            binaryReader.rewind(4);\n                            const recordView = binaryReader.getDataView(recordHeader.byteLength);\n                            const geometry = parseRecord(recordView, options);\n                            result.geometries.push(geometry);\n                            result.currentIndex++;\n                            result.progress.rows = result.currentIndex - 1;\n                        }\n                    }\n                    if (binaryReader.ended) {\n                        state = STATE.END;\n                    }\n                    return state;\n                default:\n                    state = STATE.ERROR;\n                    result.error = `illegal parser state ${state}`;\n                    return state;\n            }\n        }\n        catch (error) {\n            state = STATE.ERROR;\n            result.error = `SHP parsing failed: ${error?.message}`;\n            return state;\n        }\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { parseSHP, parseSHPInBatches } from \"./lib/parsers/parse-shp.js\";\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.3.3\" !== 'undefined' ? \"4.3.3\" : 'latest';\nexport const SHP_MAGIC_NUMBER = [0x00, 0x00, 0x27, 0x0a];\n/**\n * SHP file loader\n */\nexport const SHPWorkerLoader = {\n    dataType: null,\n    batchType: null,\n    name: 'SHP',\n    id: 'shp',\n    module: 'shapefile',\n    version: VERSION,\n    worker: true,\n    category: 'geometry',\n    extensions: ['shp'],\n    mimeTypes: ['application/octet-stream'],\n    // ISSUE: This also identifies SHX files, which are identical to SHP for the first 100 bytes...\n    tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],\n    options: {\n        shp: {\n            _maxDimensions: 4\n        }\n    }\n};\n/** SHP file loader */\nexport const SHPLoader = {\n    ...SHPWorkerLoader,\n    parse: async (arrayBuffer, options) => parseSHP(arrayBuffer, options),\n    parseSync: parseSHP,\n    parseInBatches: (arrayBufferIterator, options) => parseSHPInBatches(arrayBufferIterator, options)\n};\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n// import type {Feature} from '@loaders.gl/gis';\nimport { parseInBatchesFromContext, parseFromContext } from '@loaders.gl/loader-utils';\nimport { binaryToGeometry, transformGeoJsonCoords } from '@loaders.gl/gis';\nimport { Proj4Projection } from '@math.gl/proj4';\nimport { parseShx } from \"./parse-shx.js\";\nimport { zipBatchIterators } from \"../streaming/zip-batch-iterators.js\";\nimport { SHPLoader } from \"../../shp-loader.js\";\nimport { DBFLoader } from \"../../dbf-loader.js\";\n/**\n * Parsing of file in batches\n */\n// eslint-disable-next-line max-statements, complexity\nexport async function* parseShapefileInBatches(asyncIterator, options, context) {\n    const { reproject = false, _targetCrs = 'WGS84' } = options?.gis || {};\n    const { shx, cpg, prj } = await loadShapefileSidecarFiles(options, context);\n    // parse geometries\n    const shapeIterable = await parseInBatchesFromContext(asyncIterator, SHPLoader, options, context);\n    const shapeIterator = shapeIterable[Symbol.asyncIterator]?.() || shapeIterable[Symbol.iterator]?.();\n    // parse properties\n    let propertyIterator = null;\n    const dbfResponse = await context?.fetch(replaceExtension(context?.url || '', 'dbf'));\n    if (dbfResponse?.ok) {\n        const propertyIterable = await parseInBatchesFromContext(dbfResponse, DBFLoader, {\n            ...options,\n            dbf: { encoding: cpg || 'latin1' }\n        }, context);\n        propertyIterator =\n            propertyIterable[Symbol.asyncIterator]?.() || propertyIterable[Symbol.iterator]();\n    }\n    // When `options.metadata` is `true`, there's an extra initial `metadata`\n    // object before the iterator starts. zipBatchIterators expects to receive\n    // batches of Array objects, and will fail with non-iterable batches, so it's\n    // important to skip over the first batch.\n    let shapeHeader = (await shapeIterator.next()).value;\n    if (shapeHeader && shapeHeader.batchType === 'metadata') {\n        shapeHeader = (await shapeIterator.next()).value;\n    }\n    let dbfHeader = {};\n    if (propertyIterator) {\n        dbfHeader = (await propertyIterator.next()).value;\n        if (dbfHeader && dbfHeader.batchType === 'metadata') {\n            dbfHeader = (await propertyIterator.next()).value;\n        }\n    }\n    const zippedIterator = propertyIterator\n        ? zipBatchIterators(shapeIterator, propertyIterator, 'object-row-table')\n        : shapeIterator;\n    const zippedBatchIterable = {\n        [Symbol.asyncIterator]() {\n            return zippedIterator;\n        }\n    };\n    for await (const batch of zippedBatchIterable) {\n        let geometries;\n        let properties;\n        if (!propertyIterator) {\n            geometries = batch;\n        }\n        else {\n            [geometries, properties] = batch.data;\n        }\n        const geojsonGeometries = parseGeometries(geometries);\n        let features = joinProperties(geojsonGeometries, properties);\n        if (reproject) {\n            // @ts-ignore\n            features = reprojectFeatures(features, prj, _targetCrs);\n        }\n        yield {\n            encoding: cpg,\n            prj,\n            shx,\n            header: shapeHeader,\n            data: features\n        };\n    }\n}\n/**\n * Parse shapefile\n *\n * @param arrayBuffer\n * @param options\n * @param context\n * @returns output of shapefile\n */\nexport async function parseShapefile(arrayBuffer, options, context) {\n    const { reproject = false, _targetCrs = 'WGS84' } = options?.gis || {};\n    const { shx, cpg, prj } = await loadShapefileSidecarFiles(options, context);\n    // parse geometries\n    const { header, geometries } = await parseFromContext(arrayBuffer, SHPLoader, options, context); // {shp: shx}\n    const geojsonGeometries = parseGeometries(geometries);\n    // parse properties\n    let propertyTable;\n    const dbfResponse = await context?.fetch(replaceExtension(context?.url, 'dbf'));\n    if (dbfResponse?.ok) {\n        propertyTable = await parseFromContext(dbfResponse, DBFLoader, { dbf: { shape: 'object-row-table', encoding: cpg || 'latin1' } }, context);\n    }\n    let features = joinProperties(geojsonGeometries, propertyTable?.data || []);\n    if (reproject) {\n        features = reprojectFeatures(features, prj, _targetCrs);\n    }\n    switch (options?.shapefile?.shape) {\n        case 'geojson-table':\n            return {\n                // @ts-expect-error\n                shape: 'geojson-table',\n                type: 'FeatureCollection',\n                encoding: cpg,\n                schema: propertyTable?.schema || { metadata: {}, fields: [] },\n                prj,\n                shx,\n                header,\n                features\n            };\n        default:\n            return {\n                encoding: cpg,\n                prj,\n                shx,\n                header,\n                data: features\n            };\n    }\n}\n/**\n * Parse geometries\n *\n * @param geometries\n * @returns geometries as an array\n */\nfunction parseGeometries(geometries) {\n    const geojsonGeometries = [];\n    for (const geom of geometries) {\n        geojsonGeometries.push(binaryToGeometry(geom));\n    }\n    return geojsonGeometries;\n}\n/**\n * Join properties and geometries into features\n *\n * @param geometries [description]\n * @param  properties [description]\n * @return [description]\n */\nfunction joinProperties(geometries, properties) {\n    const features = [];\n    for (let i = 0; i < geometries.length; i++) {\n        const geometry = geometries[i];\n        const feature = {\n            type: 'Feature',\n            geometry,\n            // properties can be undefined if dbfResponse above was empty\n            properties: (properties && properties[i]) || {}\n        };\n        features.push(feature);\n    }\n    return features;\n}\n/**\n * Reproject GeoJSON features to output CRS\n *\n * @param features parsed GeoJSON features\n * @param sourceCrs source coordinate reference system\n * @param targetCrs \u2020arget coordinate reference system\n * @return Reprojected Features\n */\nfunction reprojectFeatures(features, sourceCrs, targetCrs) {\n    if (!sourceCrs && !targetCrs) {\n        return features;\n    }\n    const projection = new Proj4Projection({ from: sourceCrs || 'WGS84', to: targetCrs || 'WGS84' });\n    return transformGeoJsonCoords(features, (coord) => projection.project(coord));\n}\n/**\n *\n * @param options\n * @param context\n * @returns Promise\n */\n// eslint-disable-next-line max-statements\nexport async function loadShapefileSidecarFiles(options, context) {\n    // Attempt a parallel load of the small sidecar files\n    // @ts-ignore context must be defined\n    const { url, fetch } = context;\n    const shxPromise = fetch(replaceExtension(url, 'shx'));\n    const cpgPromise = fetch(replaceExtension(url, 'cpg'));\n    const prjPromise = fetch(replaceExtension(url, 'prj'));\n    await Promise.all([shxPromise, cpgPromise, prjPromise]);\n    let shx;\n    let cpg;\n    let prj;\n    const shxResponse = await shxPromise;\n    if (shxResponse.ok) {\n        const arrayBuffer = await shxResponse.arrayBuffer();\n        shx = parseShx(arrayBuffer);\n    }\n    const cpgResponse = await cpgPromise;\n    if (cpgResponse.ok) {\n        cpg = await cpgResponse.text();\n    }\n    const prjResponse = await prjPromise;\n    if (prjResponse.ok) {\n        prj = await prjResponse.text();\n    }\n    return {\n        shx,\n        cpg,\n        prj\n    };\n}\n/**\n * Replace the extension at the end of a path.\n *\n * Matches the case of new extension with the case of the original file extension,\n * to increase the chance of finding files without firing off a request storm looking for various case combinations\n *\n * NOTE: Extensions can be both lower and uppercase\n * per spec, extensions should be lower case, but that doesn't mean they always are. See:\n * calvinmetcalf/shapefile-js#64, mapserver/mapserver#4712\n * https://trac.osgeo.org/mapserver/ticket/166\n */\nexport function replaceExtension(url, newExtension) {\n    const baseName = basename(url);\n    const extension = extname(url);\n    const isUpperCase = extension === extension.toUpperCase();\n    if (isUpperCase) {\n        newExtension = newExtension.toUpperCase();\n    }\n    return `${baseName}.${newExtension}`;\n}\n// NOTE - this gives the entire path minus extension (i.e. NOT same as path.basename)\n/**\n * @param url\n * @returns string\n */\nfunction basename(url) {\n    const extIndex = url && url.lastIndexOf('.');\n    if (typeof extIndex === 'number') {\n        return extIndex >= 0 ? url.substr(0, extIndex) : '';\n    }\n    return extIndex;\n}\n/**\n * @param url\n * @returns string\n */\nfunction extname(url) {\n    const extIndex = url && url.lastIndexOf('.');\n    if (typeof extIndex === 'number') {\n        return extIndex >= 0 ? url.substr(extIndex + 1) : '';\n    }\n    return extIndex;\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { parseSHPHeader } from \"./parse-shp-header.js\";\nconst SHX_HEADER_SIZE = 100;\nconst BIG_ENDIAN = false;\n/**\n * @param arrayBuffer\n * @returns SHXOutput\n */\nexport function parseShx(arrayBuffer) {\n    // SHX header is identical to SHP Header\n    const headerView = new DataView(arrayBuffer, 0, SHX_HEADER_SIZE);\n    const header = parseSHPHeader(headerView);\n    const contentLength = header.length - SHX_HEADER_SIZE;\n    const contentView = new DataView(arrayBuffer, SHX_HEADER_SIZE, contentLength);\n    const offsets = new Int32Array(contentLength);\n    const lengths = new Int32Array(contentLength);\n    for (let i = 0; i < contentLength / 8; i++) {\n        offsets[i] = contentView.getInt32(i * 8, BIG_ENDIAN);\n        lengths[i] = contentView.getInt32(i * 8 + 4, BIG_ENDIAN);\n    }\n    return {\n        offsets,\n        lengths\n    };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/**\n * Zip two iterators together\n *\n * @param iterator1\n * @param iterator2\n */\nexport async function* zipBatchIterators(iterator1, iterator2, shape) {\n    const batch1Data = [];\n    const batch2Data = [];\n    let iterator1Done = false;\n    let iterator2Done = false;\n    // TODO - one could let all iterators flow at full speed using `Promise.race`\n    // however we might end up with a big temporary buffer\n    while (!iterator1Done && !iterator2Done) {\n        if (batch1Data.length === 0 && !iterator1Done) {\n            const { value, done } = await iterator1.next();\n            if (done) {\n                iterator1Done = true;\n            }\n            else {\n                // @ts-expect-error\n                batch1Data.push(...value);\n            }\n        }\n        if (batch2Data.length === 0 && !iterator2Done) {\n            const { value, done } = await iterator2.next();\n            if (done) {\n                iterator2Done = true;\n            }\n            else {\n                batch2Data.push(...value);\n            }\n        }\n        const batchData = extractBatchData(batch1Data, batch2Data);\n        if (batchData) {\n            yield {\n                batchType: 'data',\n                shape,\n                length: batchData.length,\n                data: batchData\n            };\n        }\n    }\n}\n/**\n * Extract batch of same length from two batches\n *\n * @param batch1\n * @param batch2\n * @return array | null\n */\nfunction extractBatchData(batch1, batch2) {\n    const batchLength = Math.min(batch1.length, batch2.length);\n    if (batchLength === 0) {\n        return null;\n    }\n    // Non interleaved arrays\n    const batch = [batch1.slice(0, batchLength), batch2.slice(0, batchLength)];\n    // Modify the 2 batches\n    batch1.splice(0, batchLength);\n    batch2.splice(0, batchLength);\n    return batch;\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { BinaryChunkReader } from \"../streaming/binary-chunk-reader.js\";\nconst LITTLE_ENDIAN = true;\nconst DBF_HEADER_SIZE = 32;\nvar STATE;\n(function (STATE) {\n    STATE[STATE[\"START\"] = 0] = \"START\";\n    STATE[STATE[\"FIELD_DESCRIPTORS\"] = 1] = \"FIELD_DESCRIPTORS\";\n    STATE[STATE[\"FIELD_PROPERTIES\"] = 2] = \"FIELD_PROPERTIES\";\n    STATE[STATE[\"END\"] = 3] = \"END\";\n    STATE[STATE[\"ERROR\"] = 4] = \"ERROR\";\n})(STATE || (STATE = {}));\nclass DBFParser {\n    binaryReader = new BinaryChunkReader();\n    textDecoder;\n    state = STATE.START;\n    result = {\n        data: []\n    };\n    constructor(options) {\n        this.textDecoder = new TextDecoder(options.encoding);\n    }\n    /**\n     * @param arrayBuffer\n     */\n    write(arrayBuffer) {\n        this.binaryReader.write(arrayBuffer);\n        this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);\n        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();\n        // important events:\n        // - schema available\n        // - first rows available\n        // - all rows available\n    }\n    end() {\n        this.binaryReader.end();\n        this.state = parseState(this.state, this.result, this.binaryReader, this.textDecoder);\n        // this.result.progress.bytesUsed = this.binaryReader.bytesUsed();\n        if (this.state !== STATE.END) {\n            this.state = STATE.ERROR;\n            this.result.error = 'DBF incomplete file';\n        }\n    }\n}\n/**\n * @param arrayBuffer\n * @param options\n * @returns DBFTable or rows\n */\nexport function parseDBF(arrayBuffer, options = {}) {\n    const { encoding = 'latin1' } = options.dbf || {};\n    const dbfParser = new DBFParser({ encoding });\n    dbfParser.write(arrayBuffer);\n    dbfParser.end();\n    const { data, schema } = dbfParser.result;\n    const shape = options?.dbf?.shape;\n    switch (shape) {\n        case 'object-row-table': {\n            const table = {\n                shape: 'object-row-table',\n                schema,\n                data\n            };\n            return table;\n        }\n        case 'table':\n            return { schema, rows: data };\n        case 'rows':\n        default:\n            return data;\n    }\n}\n/**\n * @param asyncIterator\n * @param options\n */\nexport async function* parseDBFInBatches(asyncIterator, options = {}) {\n    const { encoding = 'latin1' } = options.dbf || {};\n    const parser = new DBFParser({ encoding });\n    let headerReturned = false;\n    for await (const arrayBuffer of asyncIterator) {\n        parser.write(arrayBuffer);\n        if (!headerReturned && parser.result.dbfHeader) {\n            headerReturned = true;\n            yield parser.result.dbfHeader;\n        }\n        if (parser.result.data.length > 0) {\n            yield parser.result.data;\n            parser.result.data = [];\n        }\n    }\n    parser.end();\n    if (parser.result.data.length > 0) {\n        yield parser.result.data;\n    }\n}\n/**\n * https://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm\n * @param state\n * @param result\n * @param binaryReader\n * @param textDecoder\n * @returns\n */\n/* eslint-disable complexity, max-depth */\nfunction parseState(state, result, binaryReader, textDecoder) {\n    // eslint-disable-next-line no-constant-condition\n    while (true) {\n        try {\n            switch (state) {\n                case STATE.ERROR:\n                case STATE.END:\n                    return state;\n                case STATE.START:\n                    // Parse initial file header\n                    // DBF Header\n                    const dataView = binaryReader.getDataView(DBF_HEADER_SIZE);\n                    if (!dataView) {\n                        return state;\n                    }\n                    result.dbfHeader = parseDBFHeader(dataView);\n                    result.progress = {\n                        bytesUsed: 0,\n                        rowsTotal: result.dbfHeader.nRecords,\n                        rows: 0\n                    };\n                    state = STATE.FIELD_DESCRIPTORS;\n                    break;\n                case STATE.FIELD_DESCRIPTORS:\n                    // Parse DBF field descriptors (schema)\n                    const fieldDescriptorView = binaryReader.getDataView(\n                    // @ts-ignore\n                    result.dbfHeader.headerLength - DBF_HEADER_SIZE);\n                    if (!fieldDescriptorView) {\n                        return state;\n                    }\n                    result.dbfFields = parseFieldDescriptors(fieldDescriptorView, textDecoder);\n                    result.schema = {\n                        fields: result.dbfFields.map((dbfField) => makeField(dbfField)),\n                        metadata: {}\n                    };\n                    state = STATE.FIELD_PROPERTIES;\n                    // TODO(kyle) Not exactly sure why start offset needs to be headerLength + 1?\n                    // parsedbf uses ((fields.length + 1) << 5) + 2;\n                    binaryReader.skip(1);\n                    break;\n                case STATE.FIELD_PROPERTIES:\n                    const { recordLength = 0, nRecords = 0 } = result?.dbfHeader || {};\n                    while (result.data.length < nRecords) {\n                        const recordView = binaryReader.getDataView(recordLength - 1);\n                        if (!recordView) {\n                            return state;\n                        }\n                        // Note: Avoid actually reading the last byte, which may not be present\n                        binaryReader.skip(1);\n                        // @ts-ignore\n                        const row = parseRow(recordView, result.dbfFields, textDecoder);\n                        result.data.push(row);\n                        // @ts-ignore\n                        result.progress.rows = result.data.length;\n                    }\n                    state = STATE.END;\n                    break;\n                default:\n                    state = STATE.ERROR;\n                    result.error = `illegal parser state ${state}`;\n                    return state;\n            }\n        }\n        catch (error) {\n            state = STATE.ERROR;\n            result.error = `DBF parsing failed: ${error.message}`;\n            return state;\n        }\n    }\n}\n/**\n * @param headerView\n */\nfunction parseDBFHeader(headerView) {\n    return {\n        // Last updated date\n        year: headerView.getUint8(1) + 1900,\n        month: headerView.getUint8(2),\n        day: headerView.getUint8(3),\n        // Number of records in data file\n        nRecords: headerView.getUint32(4, LITTLE_ENDIAN),\n        // Length of header in bytes\n        headerLength: headerView.getUint16(8, LITTLE_ENDIAN),\n        // Length of each record\n        recordLength: headerView.getUint16(10, LITTLE_ENDIAN),\n        // Not sure if this is usually set\n        languageDriver: headerView.getUint8(29)\n    };\n}\n/**\n * @param view\n */\nfunction parseFieldDescriptors(view, textDecoder) {\n    // NOTE: this might overestimate the number of fields if the \"Database\n    // Container\" container exists and is included in the headerLength\n    const nFields = (view.byteLength - 1) / 32;\n    const fields = [];\n    let offset = 0;\n    for (let i = 0; i < nFields; i++) {\n        const name = textDecoder\n            .decode(new Uint8Array(view.buffer, view.byteOffset + offset, 11))\n            // eslint-disable-next-line no-control-regex\n            .replace(/\\u0000/g, '');\n        fields.push({\n            name,\n            dataType: String.fromCharCode(view.getUint8(offset + 11)),\n            fieldLength: view.getUint8(offset + 16),\n            decimal: view.getUint8(offset + 17)\n        });\n        offset += 32;\n    }\n    return fields;\n}\n/*\n * @param {BinaryChunkReader} binaryReader\nfunction parseRows(binaryReader, fields, nRecords, recordLength, textDecoder) {\n  const rows = [];\n  for (let i = 0; i < nRecords; i++) {\n    const recordView = binaryReader.getDataView(recordLength - 1);\n    binaryReader.skip(1);\n    // @ts-ignore\n    rows.push(parseRow(recordView, fields, textDecoder));\n  }\n  return rows;\n}\n */\n/**\n *\n * @param view\n * @param fields\n * @param textDecoder\n * @returns\n */\nfunction parseRow(view, fields, textDecoder) {\n    const out = {};\n    let offset = 0;\n    for (const field of fields) {\n        const text = textDecoder.decode(new Uint8Array(view.buffer, view.byteOffset + offset, field.fieldLength));\n        out[field.name] = parseField(text, field.dataType);\n        offset += field.fieldLength;\n    }\n    return out;\n}\n/**\n * Should NaN be coerced to null?\n * @param text\n * @param dataType\n * @returns Field depends on a type of the data\n */\nfunction parseField(text, dataType) {\n    switch (dataType) {\n        case 'B':\n            return parseNumber(text);\n        case 'C':\n            return parseCharacter(text);\n        case 'F':\n            return parseNumber(text);\n        case 'N':\n            return parseNumber(text);\n        case 'O':\n            return parseNumber(text);\n        case 'D':\n            return parseDate(text);\n        case 'L':\n            return parseBoolean(text);\n        default:\n            throw new Error('Unsupported data type');\n    }\n}\n/**\n * Parse YYYYMMDD to date in milliseconds\n * @param str YYYYMMDD\n * @returns new Date as a number\n */\nfunction parseDate(str) {\n    return Date.UTC(str.slice(0, 4), parseInt(str.slice(4, 6), 10) - 1, str.slice(6, 8));\n}\n/**\n * Read boolean value\n * any of Y, y, T, t coerce to true\n * any of N, n, F, f coerce to false\n * otherwise null\n * @param value\n * @returns boolean | null\n */\nfunction parseBoolean(value) {\n    return /^[nf]$/i.test(value) ? false : /^[yt]$/i.test(value) ? true : null;\n}\n/**\n * Return null instead of NaN\n * @param text\n * @returns number | null\n */\nfunction parseNumber(text) {\n    const number = parseFloat(text);\n    return isNaN(number) ? null : number;\n}\n/**\n *\n * @param text\n * @returns string | null\n */\nfunction parseCharacter(text) {\n    return text.trim() || null;\n}\n/**\n * Create a standard Arrow-style `Field` from field descriptor.\n * TODO - use `fieldLength` and `decimal` to generate smaller types?\n * @param param0\n * @returns Field\n */\n// eslint-disable\nfunction makeField({ name, dataType, fieldLength, decimal }) {\n    switch (dataType) {\n        case 'B':\n            return { name, type: 'float64', nullable: true, metadata: {} };\n        case 'C':\n            return { name, type: 'utf8', nullable: true, metadata: {} };\n        case 'F':\n            return { name, type: 'float64', nullable: true, metadata: {} };\n        case 'N':\n            return { name, type: 'float64', nullable: true, metadata: {} };\n        case 'O':\n            return { name, type: 'float64', nullable: true, metadata: {} };\n        case 'D':\n            return { name, type: 'timestamp-millisecond', nullable: true, metadata: {} };\n        case 'L':\n            return { name, type: 'bool', nullable: true, metadata: {} };\n        default:\n            throw new Error('Unsupported data type');\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { parseDBF, parseDBFInBatches } from \"./lib/parsers/parse-dbf.js\";\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.3.3\" !== 'undefined' ? \"4.3.3\" : 'latest';\n/**\n * DBFLoader - DBF files are used to contain non-geometry columns in Shapefiles\n */\nexport const DBFWorkerLoader = {\n    name: 'DBF',\n    dataType: null,\n    batchType: null,\n    id: 'dbf',\n    module: 'shapefile',\n    version: VERSION,\n    worker: true,\n    category: 'table',\n    extensions: ['dbf'],\n    mimeTypes: ['application/x-dbf'],\n    options: {\n        dbf: {\n            encoding: 'latin1'\n        }\n    }\n};\n/** DBF file loader */\nexport const DBFLoader = {\n    ...DBFWorkerLoader,\n    parse: async (arrayBuffer, options) => parseDBF(arrayBuffer, options),\n    parseSync: parseDBF,\n    parseInBatches(arrayBufferIterator, options) {\n        return parseDBFInBatches(arrayBufferIterator, options);\n    }\n};\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { SHP_MAGIC_NUMBER } from \"./shp-loader.js\";\nimport { parseShapefile, parseShapefileInBatches } from \"./lib/parsers/parse-shapefile.js\";\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.3.3\" !== 'undefined' ? \"4.3.3\" : 'latest';\n/**\n * Shapefile loader\n * @note Shapefile is multifile format and requires providing additional files\n */\nexport const ShapefileLoader = {\n    name: 'Shapefile',\n    id: 'shapefile',\n    module: 'shapefile',\n    version: VERSION,\n    category: 'geometry',\n    extensions: ['shp'],\n    mimeTypes: ['application/octet-stream'],\n    tests: [new Uint8Array(SHP_MAGIC_NUMBER).buffer],\n    options: {\n        shapefile: {\n            shape: 'v3'\n        },\n        shp: {\n            _maxDimensions: 4\n        }\n    },\n    // @ts-expect-error\n    parse: parseShapefile,\n    // @ts-expect-error\n    parseInBatches: parseShapefileInBatches\n};\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport class BinaryReader {\n    offset;\n    arrayBuffer;\n    constructor(arrayBuffer) {\n        /** current global (stream) offset */\n        this.offset = 0;\n        /** current buffer from iterator */\n        this.arrayBuffer = arrayBuffer;\n    }\n    /**\n     * Checks if there are available bytes in data\n     *\n     * @param bytes\n     * @returns boolean\n     */\n    hasAvailableBytes(bytes) {\n        return this.arrayBuffer.byteLength - this.offset >= bytes;\n    }\n    /**\n     * Get the required number of bytes from the iterator\n     *\n     * @param bytes\n     * @returns Dataview\n     */\n    getDataView(bytes) {\n        if (bytes && !this.hasAvailableBytes(bytes)) {\n            throw new Error('binary data exhausted');\n        }\n        const dataView = bytes\n            ? new DataView(this.arrayBuffer, this.offset, bytes)\n            : new DataView(this.arrayBuffer, this.offset);\n        this.offset += bytes;\n        return dataView;\n    }\n    /**\n     * Skipping\n     *\n     * @param bytes\n     */\n    skip(bytes) {\n        this.offset += bytes;\n    }\n    /**\n     * Rewinding\n     *\n     * @param bytes\n     */\n    rewind(bytes) {\n        this.offset -= bytes;\n    }\n}\n"],
  "mappings": "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",
  "names": ["view", "LITTLE_ENDIAN", "LITTLE_ENDIAN", "BIG_ENDIAN", "SHP_MAGIC_NUMBER", "BIG_ENDIAN", "LITTLE_ENDIAN", "STATE", "parseState", "VERSION", "VERSION", "SHP_MAGIC_NUMBER"]
}