{
  "version": 3,
  "sources": ["../src/index.ts", "../src/lib/types.ts", "../src/exports/arrow-format.ts", "../src/exports/arrow-loader.ts", "../src/lib/parsers/parse-arrow.ts", "../src/arrow-loader.ts", "../src/lib/encoders/encode-arrow.ts", "../src/arrow-writer.ts", "../src/exports/geoarrow-loader.ts", "../src/lib/parsers/parse-geoarrow.ts", "../src/geoarrow-loader.ts", "../src/workers/hard-clone.ts", "../src/triangulate-on-worker.ts"],
  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// Types\nexport {VECTOR_TYPES} from './lib/types';\n\n// Arrow loader / Writer\n\nexport {ArrowFormat} from './exports/arrow-format';\n\nexport type {ArrowLoaderOptions} from './exports/arrow-loader';\nexport {ArrowWorkerLoader} from './exports/arrow-loader';\nexport {ArrowLoader} from './arrow-loader';\n\nexport {ArrowWriter} from './arrow-writer';\n\n// Geoarrow loader\nexport {GeoArrowWorkerLoader} from './exports/geoarrow-loader';\nexport {GeoArrowLoader} from './geoarrow-loader';\n\n// EXPERIMENTAL\n\n// Arrow Utils\n// getGeometryColumnsFromArrowTable,\n// getGeoArrowEncoding\n\n// EXPERIMENTAL WORKER\nexport {hardClone} from './workers/hard-clone';\n\nexport type {ParseGeoArrowInput, ParseGeoArrowResult} from './triangulate-on-worker';\nexport {\n  TriangulationWorker,\n  triangulateOnWorker,\n  parseGeoArrowOnWorker\n} from './triangulate-on-worker';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\ntype TypedIntArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array;\n\ntype TypedFloatArray = Float32Array | Float64Array;\n\ntype TypedArray = TypedIntArray | TypedFloatArray;\n\nexport type AnyArrayType = Array<any> | TypedArray;\n\nexport enum VECTOR_TYPES {\n  FLOAT,\n  DATE\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Format} from '@loaders.gl/loader-utils';\n\n/** ArrowJS table loader */\nexport const ArrowFormat = {\n  name: 'Apache Arrow',\n  id: 'arrow',\n  module: 'arrow',\n  category: 'table',\n  extensions: ['arrow', 'feather'],\n  mimeTypes: [\n    'application/vnd.apache.arrow.file',\n    'application/vnd.apache.arrow.stream',\n    'application/octet-stream'\n  ],\n  binary: true,\n  tests: ['ARROW']\n} as const satisfies Format;\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {ArrowTable} from '@loaders.gl/schema';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\n/** ArrowLoader options */\nexport type ArrowLoaderOptions = LoaderOptions & {\n  /** ArrowLoader options */\n  arrow?: {\n    /** Shape of returned data */\n    shape: 'arrow-table' | 'columnar-table' | 'array-row-table' | 'object-row-table';\n    /** Debounce time between batches (prevent excessive numbers of small batches) */\n    batchDebounceMs?: number;\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/** ArrowJS table loader */\nexport const ArrowWorkerLoader = {\n  dataType: null as unknown as ArrowTable,\n  batchType: null as never,\n\n  name: 'Apache Arrow',\n  id: 'arrow',\n  module: 'arrow',\n  version: VERSION,\n  // worker: true,\n  category: 'table',\n  extensions: ['arrow', 'feather'],\n  mimeTypes: [\n    'application/vnd.apache.arrow.file',\n    'application/vnd.apache.arrow.stream',\n    'application/octet-stream'\n  ],\n  binary: true,\n  tests: ['ARROW'],\n  options: {\n    arrow: {\n      shape: 'columnar-table'\n    }\n  }\n} as const satisfies Loader<ArrowTable, never, ArrowLoaderOptions>;\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport * as arrow from 'apache-arrow';\nimport type {Table, ArrowTableBatch} from '@loaders.gl/schema';\nimport {ArrowLoaderOptions} from '../../exports/arrow-loader';\nimport {convertArrowToTable} from '@loaders.gl/schema-utils';\nimport {toArrayBufferIterator} from '@loaders.gl/loader-utils';\n\n/** Parses arrow to a loaders.gl table. Defaults to `arrow-table` */\nexport function parseArrowSync(arrayBuffer, options?: {shape?: Table['shape']}): Table {\n  const shape = options?.shape || 'arrow-table';\n  const arrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);\n  return convertArrowToTable(arrowTable, shape);\n}\n\nexport function parseArrowInBatches(\n  asyncIterator:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>,\n  options?: ArrowLoaderOptions\n): AsyncIterable<ArrowTableBatch> {\n  // Creates the appropriate arrow.RecordBatchReader subclasses from the input\n  // This will also close the underlying source in case of early termination or errors\n\n  // As an optimization, return a non-async iterator\n  /*\n  if (isIterable(readers)) {\n    function* makeArrowIterator() {\n      for (const reader of readers) {\n        for (const batch of reader) {\n          yield processBatch(batch, reader);\n        }\n        break; // only processing one stream of batches\n      }\n    }\n    const arrowIterator = makeArrowIterator();\n  }\n  */\n\n  async function* makeArrowAsyncIterator(): AsyncIterator<ArrowTableBatch> {\n    // @ts-ignore\n    const readers = arrow.RecordBatchReader.readAll(toArrayBufferIterator(asyncIterator));\n    for await (const reader of readers) {\n      for await (const recordBatch of reader) {\n        // use options.batchDebounceMs to add a delay between batches if needed (use case: incremental loading)\n        if (options?.arrow?.batchDebounceMs !== undefined && options?.arrow?.batchDebounceMs > 0) {\n          await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));\n        }\n        const arrowTabledBatch: ArrowTableBatch = {\n          shape: 'arrow-table',\n          batchType: 'data',\n          data: new arrow.Table([recordBatch]),\n          length: recordBatch.data.length\n        };\n        // processBatch(recordBatch);\n        yield arrowTabledBatch;\n      }\n      break; // only processing one stream of batches\n    }\n  }\n\n  return makeArrowAsyncIterator() as any; // as AsyncIterator<ArrowTableBatch>;\n}\n\n// function processBatch(batch: RecordBatch): ArrowTableBatch {\n//   const values = {};\n//   batch.schema.fields.forEach(({name}, index) => {\n//     values[name] = batch.getChildAt(index)?.toArray();\n//   });\n//   return {\n//   };\n// }\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {Table, ArrowTableBatch} from '@loaders.gl/schema';\nimport {parseArrowSync, parseArrowInBatches} from './lib/parsers/parse-arrow';\n\nimport type {ArrowLoaderOptions} from './exports/arrow-loader';\nimport {ArrowWorkerLoader} from './exports/arrow-loader';\n\n/** ArrowJS table loader */\nexport const ArrowLoader = {\n  ...ArrowWorkerLoader,\n  parse: async (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>\n    parseArrowSync(arraybuffer, options?.arrow),\n  parseSync: (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>\n    parseArrowSync(arraybuffer, options?.arrow),\n  parseInBatches: parseArrowInBatches\n} as const satisfies LoaderWithParser<Table, ArrowTableBatch, ArrowLoaderOptions>;\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport * as arrow from 'apache-arrow';\nimport {AnyArrayType, VECTOR_TYPES} from '../types';\nimport {ensureArrayBuffer} from '@loaders.gl/loader-utils';\n\nexport type ColumnarTable = {\n  name: string;\n  array: AnyArrayType;\n  type: number;\n}[];\n\n/**\n * Encodes set of arrays into the Apache Arrow columnar format\n * https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format\n * @param data - columns data\n * @param options - the writer options\n * @returns - encoded ArrayBuffer\n */\nexport function encodeArrowSync(data: ColumnarTable): ArrayBuffer {\n  const vectors: Record<string, arrow.Vector> = {};\n  for (const arrayData of data) {\n    const arrayVector = createVector(arrayData.array, arrayData.type);\n    vectors[arrayData.name] = arrayVector;\n  }\n  const table = new arrow.Table(vectors);\n  const arrowBuffer = arrow.tableToIPC(table);\n  return ensureArrayBuffer(arrowBuffer);\n}\n\n/**\n * Create Arrow arrow.Vector from given data and vector type\n * @param array {import('../types').AnyArrayType} - columns data\n * @param type {number} - the writer options\n * @return a vector of one of vector's types defined in the Apache Arrow library\n */\nfunction createVector(array, type): arrow.Vector {\n  switch (type) {\n    case VECTOR_TYPES.DATE:\n      return arrow.vectorFromArray(array);\n    case VECTOR_TYPES.FLOAT:\n    default:\n      return arrow.vectorFromArray(array);\n  }\n}\n", "// import type {} from '@loaders.gl/loader-utils';\n\nimport type {WriterWithEncoder, WriterOptions} from '@loaders.gl/loader-utils';\nimport {ColumnarTable, encodeArrowSync} from './lib/encoders/encode-arrow';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\ntype ArrowWriterOptions = WriterOptions & {\n  arrow?: {};\n};\n\n/** Apache Arrow writer */\nexport const ArrowWriter = {\n  name: 'Apache Arrow',\n  id: 'arrow',\n  module: 'arrow',\n  version: VERSION,\n  extensions: ['arrow', 'feather'],\n  mimeTypes: [\n    'application/vnd.apache.arrow.file',\n    'application/vnd.apache.arrow.stream',\n    'application/octet-stream'\n  ],\n  binary: true,\n  options: {},\n  encode: async function encodeArrow(data, options?): Promise<ArrayBuffer> {\n    return encodeArrowSync(data);\n  },\n  encodeSync(data, options?) {\n    return encodeArrowSync(data);\n  }\n} as const satisfies WriterWithEncoder<ColumnarTable, never, ArrowWriterOptions>;\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';\nimport type {ArrowTable, ArrowTableBatch, BinaryGeometry} from '@loaders.gl/schema';\nimport {ArrowWorkerLoader} from './arrow-loader';\n\nexport type GeoArrowLoaderOptions = LoaderOptions & {\n  arrow?: {\n    shape?: 'arrow-table' | 'binary-geometry';\n  };\n};\n\n/** ArrowJS table loader */\nexport const GeoArrowWorkerLoader = {\n  ...ArrowWorkerLoader,\n  options: {\n    arrow: {\n      shape: 'arrow-table'\n    }\n  }\n} as const satisfies Loader<ArrowTable | BinaryGeometry, ArrowTableBatch, GeoArrowLoaderOptions>;\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {\n  GeoJSONTable,\n  GeoJSONTableBatch,\n  ArrowTable,\n  ArrowTableBatch\n} from '@loaders.gl/schema';\nimport {parseArrowSync, parseArrowInBatches} from './parse-arrow';\nimport {convertGeoArrowToTable} from '@loaders.gl/gis';\n\n// Parses arrow to a columnar table\nexport function parseGeoArrowSync(\n  arrayBuffer,\n  options?: {shape?: 'arrow-table' | 'geojson-table' | 'binary-geometry'}\n): ArrowTable | GeoJSONTable {\n  // | BinaryGeometry\n  const table = parseArrowSync(arrayBuffer, {shape: 'arrow-table'}) as ArrowTable;\n  switch (options?.shape) {\n    case 'geojson-table':\n      return convertGeoArrowToTable(table.data, 'geojson-table');\n    default:\n      return table;\n  }\n}\n\n/**\n */\nexport function parseGeoArrowInBatches(\n  asyncIterator:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>\n): AsyncIterable<ArrowTableBatch | GeoJSONTableBatch> {\n  // | BinaryGeometry\n  return parseArrowInBatches(asyncIterator);\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {\n  ArrowTable,\n  ArrowTableBatch,\n  GeoJSONTable,\n  GeoJSONTableBatch\n} from '@loaders.gl/schema';\nimport {parseGeoArrowSync, parseGeoArrowInBatches} from './lib/parsers/parse-geoarrow';\nimport type {GeoArrowLoaderOptions} from './exports/geoarrow-loader';\nimport {GeoArrowWorkerLoader} from './exports/geoarrow-loader';\n\n/**\n * GeoArrowLoader loads an Apache Arrow table, parses GeoArrow type extension data\n * to convert it to a GeoJSON table or a BinaryGeometry\n */\nexport const GeoArrowLoader = {\n  ...GeoArrowWorkerLoader,\n\n  parse: async (arraybuffer: ArrayBuffer, options?: GeoArrowLoaderOptions) =>\n    parseGeoArrowSync(arraybuffer, options?.arrow),\n  parseSync: (arraybuffer: ArrayBuffer, options?: GeoArrowLoaderOptions) =>\n    parseGeoArrowSync(arraybuffer, options?.arrow),\n  parseInBatches: parseGeoArrowInBatches\n} as const satisfies LoaderWithParser<\n  ArrowTable | GeoJSONTable, // | BinaryGeometry,\n  ArrowTableBatch | GeoJSONTableBatch, // | BinaryGeometry,\n  GeoArrowLoaderOptions\n>;\n", "import * as arrow from 'apache-arrow';\nimport type {Buffers} from 'apache-arrow/data';\n\ntype TypedArray =\n  | Uint8Array\n  | Uint8ClampedArray\n  | Uint16Array\n  | Uint32Array\n  | Int8Array\n  | Int16Array\n  | Int32Array\n  | Float32Array\n  | Float64Array;\n\n/**\n * Clone an Arrow JS Data or Vector, detaching from an existing ArrayBuffer if\n * it is shared with other.\n *\n * The purpose of this function is to enable transferring a `Data` instance,\n * e.g. to a web worker, without neutering any other data.\n *\n * Any internal buffers that are a slice of a larger `ArrayBuffer` (i.e. where\n * the typed array's `byteOffset` is not `0` and where its `byteLength` does not\n * match its `array.buffer.byteLength`) are copied into new `ArrayBuffers`.\n *\n * If `force` is `true`, always clone internal buffers, even if not shared. If\n * the default, `false`, any internal buffers that are **not** a slice of a\n * larger `ArrayBuffer` will not be copied.\n */\nexport function hardClone<T extends arrow.DataType>(\n  input: arrow.Data<T>,\n  force?: boolean\n): arrow.Data<T>;\nexport function hardClone<T extends arrow.DataType>(\n  input: arrow.Vector<T>,\n  force?: boolean\n): arrow.Vector<T>;\n\nexport function hardClone<T extends arrow.DataType>(\n  data: arrow.Data<T> | arrow.Vector<T>,\n  force: boolean = false\n): arrow.Data<T> | arrow.Vector<T> {\n  // Check if `data` is an arrow.Vector\n  if ('data' in data) {\n    return new arrow.Vector(data.data.map((data) => hardClone(data, force)));\n  }\n\n  // Clone each of the children, recursively\n  const clonedChildren: arrow.Data[] = [];\n  for (const childData of data.children) {\n    clonedChildren.push(hardClone(childData, force));\n  }\n\n  // Clone the dictionary if there is one\n  let clonedDictionary: arrow.Vector | undefined;\n  if (data.dictionary !== undefined) {\n    clonedDictionary = hardClone(data.dictionary, force);\n  }\n\n  // Buffers can have up to four entries. Each of these can be `undefined` for\n  // one or more array types.\n  //\n  // - OFFSET: value offsets for variable size list types\n  // - DATA: the underlying data\n  // - VALIDITY: the null buffer. This may be empty or undefined if all elements\n  //   are non-null/valid.\n  // - TYPE: type ids for a union type.\n  const clonedBuffers: Buffers<T> = {\n    [arrow.BufferType.OFFSET]: cloneBuffer(data.buffers[arrow.BufferType.OFFSET], force),\n    [arrow.BufferType.DATA]: cloneBuffer(data.buffers[arrow.BufferType.DATA], force),\n    [arrow.BufferType.VALIDITY]: cloneBuffer(data.buffers[arrow.BufferType.VALIDITY], force),\n    [arrow.BufferType.TYPE]: cloneBuffer(data.buffers[arrow.BufferType.TYPE], force)\n  };\n\n  // Note: the data.offset is passed on so that a sliced Data instance will not\n  // be \"un-sliced\". However keep in mind that this means we're cloning the\n  // _original backing buffer_, not only the portion of the Data that was\n  // sliced.\n  return new arrow.Data(\n    data.type,\n    data.offset,\n    data.length,\n    // @ts-expect-error _nullCount is protected. We're using it here to mimic\n    // `Data.clone`\n    data._nullCount,\n    clonedBuffers,\n    clonedChildren,\n    clonedDictionary\n  );\n}\n\n/**\n * Test whether an arrow.Data instance is a slice of a larger `ArrayBuffer`.\n */\nexport function isShared<T extends arrow.DataType>(data: arrow.Data<T> | arrow.Vector<T>): boolean {\n  // Loop over arrow.Vector\n  if ('data' in data) {\n    return data.data.some((data) => isShared(data));\n  }\n\n  // Check child data\n  for (const childData of data.children) {\n    if (isShared(childData)) {\n      return true;\n    }\n  }\n\n  // Check dictionary\n  if (data.dictionary !== undefined) {\n    if (isShared(data.dictionary)) {\n      return true;\n    }\n  }\n\n  const bufferTypes = [\n    arrow.BufferType.OFFSET,\n    arrow.BufferType.DATA,\n    arrow.BufferType.VALIDITY,\n    arrow.BufferType.TYPE\n  ];\n  for (const bufferType of bufferTypes) {\n    if (data.buffers[bufferType] !== undefined && isTypedArraySliced(data.buffers[bufferType])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the current typed array is a partial slice on a larger\n * ArrayBuffer\n */\nfunction isTypedArraySliced(arr: TypedArray): boolean {\n  return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);\n}\n\n/**\n * If a slice of a larger ArrayBuffer, clone to a fresh `ArrayBuffer`.\n *\n * If `force` is `true`, always clone the array, even if not shared.\n */\nfunction cloneBuffer<A extends TypedArray | undefined>(arr: A, force: boolean): A {\n  // Not all buffer types are defined for every type of Arrow array. E.g.\n  // `arrow.BufferType.TYPE` is only defined for the Union type.\n  if (arr === undefined) {\n    return arr;\n  }\n\n  // The current array is not a part of a larger ArrayBuffer, don't clone it\n  if (!force && !isTypedArraySliced(arr)) {\n    return arr;\n  }\n\n  // Note: TypedArray.slice() **copies** into a new ArrayBuffer\n\n  // @ts-expect-error 'Uint8Array' is assignable to the constraint of type 'A',\n  // but 'A' could be instantiated with a different subtype of constraint\n  // 'TypedArray'\n  // We know from arr.slice that it will always return the same\n  return arr.slice();\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport * as arrow from 'apache-arrow';\nimport type {WorkerOptions} from '@loaders.gl/worker-utils';\nimport {processOnWorker} from '@loaders.gl/worker-utils';\nimport type {GeoArrowEncoding} from '@loaders.gl/geoarrow';\nimport {BinaryDataFromGeoArrow} from '@loaders.gl/gis';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type TriangulationWorkerInput =\n  | ({operation: 'triangulate'} & TriangulateInput)\n  | ParseGeoArrowInput\n  | {operation: 'test'; data: any};\n\nexport type TriangulationWorkerOutput =\n  | ({operation: 'triangulate'} & TriangulateResult)\n  | ({operation: 'parse-geoarrow'} & ParseGeoArrowResult)\n  | {operation: 'test'; data: any};\n\ntype GeoArrowChunkData = {\n  type: arrow.DataType;\n  offset: number;\n  length: number;\n  nullCount: number;\n  buffers: any;\n  children: arrow.Data[];\n  dictionary?: arrow.Vector;\n};\n\nexport type ParseGeoArrowInput = {\n  operation: 'parse-geoarrow';\n  chunkData: GeoArrowChunkData;\n  chunkIndex: number;\n  chunkOffset: number;\n  geometryEncoding: GeoArrowEncoding;\n  calculateMeanCenters: boolean;\n  triangle: boolean;\n};\n\nexport type ParseGeoArrowResult = {\n  chunkIndex: number;\n  binaryDataFromGeoArrow: BinaryDataFromGeoArrow | null;\n};\n\n/** Input data for operation: 'triangulate' */\nexport type TriangulateInput = {\n  polygonIndices: Uint16Array;\n  primitivePolygonIndices: Int32Array;\n  flatCoordinateArray: Float64Array;\n  nDim: number;\n};\n\n/** Result type for operation: 'triangulate' */\nexport type TriangulateResult = TriangulateInput & {\n  triangleIndices?: Uint32Array;\n};\n\n/**\n * Worker for tessellating geometries. Normally called through triangulateOnWorker\n */\nexport const TriangulationWorker = {\n  id: 'triangulation',\n  name: 'Triangulate',\n  module: 'arrow',\n  version: VERSION,\n  options: {}\n};\n\n/**\n * Triangulate a set of polygons on worker, type safe API\n */\nexport function triangulateOnWorker(\n  data: TriangulateInput,\n  options: WorkerOptions = {}\n): Promise<TriangulateResult> {\n  return processOnWorker(TriangulationWorker, {...data, operation: 'triangulate'}, options);\n}\n\n/**\n * Parse GeoArrow geometry colum on worker, type safe API\n */\nexport function parseGeoArrowOnWorker(\n  data: ParseGeoArrowInput,\n  options: WorkerOptions = {}\n): Promise<ParseGeoArrowResult> {\n  return processOnWorker(TriangulationWorker, {...data, operation: 'parse-geoarrow'}, options);\n}\n"],
  "mappings": "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",
  "names": ["VECTOR_TYPES", "_a", "arrow", "import_loader_utils", "VERSION", "arrow", "data", "VERSION"]
}