diff --git "a/utilities_cookies/build/static/js/2.422ca0c4.chunk.js.map" "b/utilities_cookies/build/static/js/2.422ca0c4.chunk.js.map"
new file mode 100644--- /dev/null
+++ "b/utilities_cookies/build/static/js/2.422ca0c4.chunk.js.map"
@@ -0,0 +1 @@
+{"version":3,"sources":["../node_modules/@babel/runtime/regenerator/index.js","../node_modules/react/index.js","../../src/event.mjs","../../src/event-target.mjs","../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","../node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js","../node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","../node_modules/@babel/runtime/helpers/esm/classCallCheck.js","../node_modules/@babel/runtime/helpers/esm/createClass.js","../node_modules/@babel/runtime/helpers/esm/slicedToArray.js","../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","../node_modules/@babel/runtime/helpers/esm/AwaitValue.js","../node_modules/@babel/runtime/helpers/esm/awaitAsyncGenerator.js","../node_modules/@babel/runtime/helpers/esm/AsyncGenerator.js","../node_modules/@babel/runtime/helpers/esm/wrapAsyncGenerator.js","../node_modules/@babel/runtime/helpers/esm/asyncIterator.js","../node_modules/@babel/runtime/helpers/esm/asyncGeneratorDelegate.js","../node_modules/flatbuffers/js/flatbuffers.mjs","../node_modules/text-encoding-utf-8/lib/encoding.lib.mjs","../util/utf8.ts","../node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/inherits.js","../node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","../node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","../node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","../node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","../node_modules/@babel/runtime/helpers/esm/createSuper.js","../io/interfaces.ts","../util/compat.ts","../util/buffer.ts","../io/adapters.ts","../node_modules/@babel/runtime/helpers/esm/defineProperty.js","../node_modules/@babel/runtime/helpers/esm/objectSpread2.js","../node_modules/@babel/runtime/helpers/esm/superPropBase.js","../node_modules/@babel/runtime/helpers/esm/get.js","../vector.ts","../fb/Schema.ts","../fb/Message.ts","../enum.ts","../util/bit.ts","../node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","../node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","../node_modules/@babel/runtime/helpers/esm/iterableToArray.js","../node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","../visitor.ts","../visitor/typecomparator.ts","../type.ts","../data.ts","../util/pretty.ts","../builder/valid.ts","../builder/buffer.ts","../builder.ts","../builder/bool.ts","../builder/null.ts","../builder/date.ts","../builder/decimal.ts","../builder/dictionary.ts","../builder/fixedsizebinary.ts","../util/math.ts","../builder/float.ts","../node_modules/@babel/runtime/helpers/esm/construct.js","../util/bn.ts","../builder/int.ts","../builder/time.ts","../builder/timestamp.ts","../builder/interval.ts","../builder/binary.ts","../builder/utf8.ts","../builder/run.ts","../vector/row.ts","../util/vector.ts","../vector/chunked.ts","../column.ts","../util/args.ts","../schema.ts","../builder/list.ts","../builder/fixedsizelist.ts","../builder/map.ts","../builder/struct.ts","../builder/union.ts","../visitor/set.ts","../fb/File.ts","../visitor/builderctor.ts","../builder/index.ts","../ipc/metadata/file.ts","../io/stream.ts","../io/file.ts","../util/int.ts","../visitor/vectorloader.ts","../visitor/typeassembler.ts","../ipc/metadata/json.ts","../ipc/metadata/message.ts","../ipc/message.ts","../visitor/vectorassembler.ts","../ipc/writer.ts","../util/recordbatch.ts","../node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","../node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../vector/base.ts","../vector/binary.ts","../vector/bool.ts","../vector/date.ts","../vector/decimal.ts","../vector/dictionary.ts","../vector/fixedsizebinary.ts","../vector/fixedsizelist.ts","../vector/float.ts","../vector/interval.ts","../vector/int.ts","../vector/list.ts","../vector/map.ts","../vector/null.ts","../vector/struct.ts","../vector/timestamp.ts","../vector/time.ts","../vector/union.ts","../vector/utf8.ts","../util/fn.ts","../visitor/get.ts","../visitor/indexof.ts","../visitor/iterator.ts","../visitor/toarray.ts","../visitor/bytewidth.ts","../visitor/vectorctor.ts","../vector/index.ts","../table.ts","../recordbatch.ts","../ipc/reader.ts","../io/whatwg/builder.ts","../compute/predicate.ts","../compute/dataframe.ts","../Arrow.ts","../Arrow.dom.ts","../io/whatwg/iterable.ts","../io/whatwg/reader.ts","../io/whatwg/writer.ts","../node_modules/streamlit-component-lib/dist/ArrowTable.js","../node_modules/streamlit-component-lib/dist/streamlit.js","../node_modules/streamlit-component-lib/dist/StreamlitReact.js","../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../node_modules/@babel/runtime/helpers/typeof.js","../node_modules/react-is/index.js","../node_modules/react-is/cjs/react-is.production.min.js","../node_modules/react/cjs/react.production.min.js","../node_modules/object-assign/index.js","../node_modules/regenerator-runtime/runtime.js"],"names":["module","exports","require","privateData","WeakMap","wrappers","pd","event","retv","get","console","assert","setCancelFlag","data","passiveListener","cancelable","canceled","preventDefault","error","Event","eventTarget","set","this","eventPhase","currentTarget","stopped","immediateStopped","timeStamp","Date","now","Object","defineProperty","value","enumerable","keys","i","length","key","defineRedirectDescriptor","configurable","defineCallDescriptor","apply","arguments","getWrapper","proto","prototype","wrapper","BaseEvent","CustomEvent","call","create","constructor","writable","isFunc","getOwnPropertyDescriptor","defineWrapper","getPrototypeOf","isStopped","setPassiveListener","type","target","composedPath","NONE","CAPTURING_PHASE","AT_TARGET","BUBBLING_PHASE","stopPropagation","stopImmediatePropagation","bubbles","Boolean","defaultPrevented","composed","srcElement","cancelBubble","returnValue","initEvent","window","setPrototypeOf","listenersMap","isObject","x","getListeners","listeners","TypeError","defineEventAttribute","eventTargetPrototype","eventName","node","listenerType","listener","next","prev","delete","newNode","passive","once","defineEventAttributeDescriptor","defineCustomEventTarget","eventNames","CustomEventTarget","EventTarget","Array","isArray","types","Map","addEventListener","options","optionsIsObj","capture","undefined","removeEventListener","dispatchEvent","wrappedEvent","wrapEvent","err","handleEvent","setEventPhase","setCurrentTarget","_arrayLikeToArray","arr","len","arr2","_unsupportedIterableToArray","o","minLen","n","toString","slice","name","from","test","_createForOfIteratorHelper","allowArrayLike","it","Symbol","iterator","F","s","done","e","_e","f","normalCompletion","didErr","step","_e2","asyncGeneratorStep","gen","resolve","reject","_next","_throw","arg","info","Promise","then","_asyncToGenerator","fn","self","args","_classCallCheck","instance","Constructor","_defineProperties","props","descriptor","_createClass","protoProps","staticProps","_slicedToArray","_i","_s","_arr","_n","_d","push","_AwaitValue","wrapped","_awaitAsyncGenerator","AsyncGenerator","front","back","resume","result","wrappedAwait","settle","_invoke","request","_wrapAsyncGenerator","asyncIterator","_asyncIterator","iterable","method","async","sync","retry","AsyncFromSyncIterator","AsyncFromSyncIteratorContinuation","r","ret","thr","_asyncGeneratorDelegate","inner","awaitWrap","iter","waiting","pump","flatbuffers","inRange","a","min","max","ToDictionary","Offset","Table","SIZEOF_SHORT","SIZEOF_INT","FILE_IDENTIFIER_LENGTH","Encoding","UTF8_BYTES","UTF16_STRING","int32","Int32Array","float32","Float32Array","buffer","float64","Float64Array","isLittleEndian","Uint16Array","Uint8Array","Long","low","high","ZERO","toFloat64","equals","other","Builder","opt_initial_size","initial_size","bb","ByteBuffer","allocate","space","minalign","vtable","vtable_in_use","isNested","object_start","vtables","vector_num_elems","force_defaults","clear","capacity","forceDefaults","dataBuffer","asUint8Array","bytes","subarray","position","offset","prep","size","additional_bytes","align_size","old_buf_size","growByteBuffer","pad","byte_size","writeInt8","writeInt16","writeInt32","writeInt64","writeFloat32","writeFloat64","addInt8","addInt16","addInt32","addInt64","addFloat32","addFloat64","addFieldInt8","voffset","defaultValue","slot","addFieldInt16","addFieldInt32","addFieldInt64","addFieldFloat32","addFieldFloat64","addFieldOffset","addOffset","addFieldStruct","nested","obj","Error","notNested","new_buf_size","nbb","setPosition","startObject","numfields","endObject","vtableloc","trimmed_size","existing_vtable","vt1","outer_loop","vt2","readInt16","j","finish","root_table","opt_file_identifier","file_identifier","charCodeAt","requiredField","table","field","table_start","vtable_start","readInt32","startVector","elem_size","num_elems","alignment","endVector","createString","utf8","codePoint","createLong","bytes_","position_","readInt8","readUint8","readUint16","readUint32","readInt64","readUint64","readFloat32","readFloat64","writeUint8","writeUint16","writeUint32","writeUint64","getBufferIdentifier","String","fromCharCode","__offset","bb_pos","vtable_offset","__union","t","__string","opt_encoding","b","c","__indirect","__vector","__vector_len","__has_identifier","ident","Stream","tokens","endOfStream","read","shift","prepend","token","unshift","pop","finished","decoderError","fatal","opt_code_point","DEFAULT_ENCODING","TextDecoder","encoding","toLowerCase","_streaming","_BOMseen","_decoder","_fatal","_ignoreBOM","TextEncoder","_encoder","_options","UTF8Decoder","utf8_code_point","utf8_bytes_seen","utf8_bytes_needed","utf8_lower_boundary","utf8_upper_boundary","handler","stream","bite","code_point","UTF8Encoder","count","temp","decode","input","ArrayBuffer","byteOffset","byteLength","input_stream","code_points","indexOf","cp","codePointsToString","encode","opt_string","string","u","d","stringToCodePoints","_Buffer","Buffer","useNativeEncoders","decodeUtf8","decoder","encodeUtf8","encoder","_setPrototypeOf","p","__proto__","_inherits","subClass","superClass","_getPrototypeOf","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","valueOf","_assertThisInitialized","ReferenceError","_possibleConstructorReturn","_createSuper","Derived","hasNativeReflectConstruct","Super","NewTarget","ITERATOR_DONE","freeze","_json","_getDOMStream","tee","_getNodeStream","pipe","pipeTo","duplex","pipeThrough","_DOMStream","toDOMStream","_nodeStream","toNodeStream","_values","resolvers","_closedPromise","_closedPromiseResolve","reason","return","_ensureOpen","_error","_","abort","close","BigIntUnavailableError","BigIntUnavailable","asIntN","asUintN","BigInt","BigIntCtor","BigIntAvailable","BigInt64ArrayUnavailableError","BigInt64Array","BigInt64ArrayCtor","BigUint64ArrayUnavailableError","BigUint64Array","BigUint64ArrayCtor","isNumber","isBoolean","isFunction","isPromise","isIterable","isAsyncIterable","isArrowJSON","isIteratorResult","isFileHandle","isFetchResponse","toArrayBufferViewIterator","SharedArrayBuf","SharedArrayBuffer","memcpy","source","targetByteOffset","sourceByteLength","targetByteLength","dst","src","Math","joinUint8Arrays","chunks","sliced","xOffset","yOffset","xLen","yLen","y","collapseContiguousByteRanges","reduce","index","Infinity","toArrayBufferView","ArrayBufferViewCtor","isView","BYTES_PER_ELEMENT","toInt8Array","Int8Array","toInt16Array","Int16Array","toInt32Array","toUint16Array","toUint32Array","Uint32Array","toFloat32Array","toFloat64Array","toUint8ClampedArray","Uint8ClampedArray","ArrayCtor","wrap","buffers","toInt8ArrayIterator","toInt16ArrayIterator","toInt32ArrayIterator","toUint8ArrayIterator","toUint16ArrayIterator","toUint32ArrayIterator","toFloat32ArrayIterator","toFloat64ArrayIterator","toUint8ClampedArrayIterator","toArrayBufferViewAsyncIterator","emit","toInt8ArrayAsyncIterator","toInt16ArrayAsyncIterator","toInt32ArrayAsyncIterator","toUint8ArrayAsyncIterator","toUint16ArrayAsyncIterator","toUint32ArrayAsyncIterator","toFloat32ArrayAsyncIterator","toFloat64ArrayAsyncIterator","toUint8ClampedArrayAsyncIterator","rebaseValueOffsets","valueOffsets","compareArrayLike","fromIterable","fromAsyncIterable","fromDOMStream","fromNodeStream","byteRange","cmd","bufferLength","threw","isNaN","throw","releaseLock","byobReader","defaultReader","supportsBYOB","reader","getBYOBReader","getDefaultReader","catch","readFromBYOBReader","mode","readInto","onEvent","cleanup","events","evt","destroy","race","map","isFinite","_defineProperty","object","enumerableOnly","getOwnPropertySymbols","symbols","filter","sym","_objectSpread2","forEach","getOwnPropertyDescriptors","defineProperties","_superPropBase","property","hasOwnProperty","receiver","base","desc","flatbuf","arrow","apache","org","MetadataVersion","UnionMode","Precision","DateUnit","TimeUnit","IntervalUnit","Type","Endianness","Null","__init","builder","startNull","endNull","Struct_","startStruct_","endStruct_","List","startList","endList","LargeList","startLargeList","endLargeList","FixedSizeList","listSize","startFixedSizeList","addListSize","endFixedSizeList","keysSorted","startMap","addKeysSorted","endMap","Union","Sparse","typeIdsOffset","numElems","startUnion","addMode","addTypeIds","endUnion","Int","bitWidth","isSigned","startInt","addBitWidth","addIsSigned","endInt","FloatingPoint","HALF","precision","startFloatingPoint","addPrecision","endFloatingPoint","Utf8","startUtf8","endUtf8","Binary","startBinary","endBinary","LargeUtf8","startLargeUtf8","endLargeUtf8","LargeBinary","startLargeBinary","endLargeBinary","FixedSizeBinary","byteWidth","startFixedSizeBinary","addByteWidth","endFixedSizeBinary","Bool","startBool","endBool","Decimal","scale","startDecimal","addScale","endDecimal","MILLISECOND","unit","startDate","addUnit","endDate","Time","startTime","endTime","Timestamp","SECOND","optionalEncoding","timezoneOffset","startTimestamp","addTimezone","endTimestamp","Interval","YEAR_MONTH","startInterval","endInterval","Duration","startDuration","endDuration","KeyValue","keyOffset","valueOffset","startKeyValue","addKey","addValue","endKeyValue","DictionaryEncoding","id","indexTypeOffset","isOrdered","startDictionaryEncoding","addId","addIndexType","addIsOrdered","endDictionaryEncoding","Field","nameOffset","nullable","typeType","typeOffset","dictionaryOffset","childrenOffset","customMetadataOffset","startField","addName","addNullable","addTypeType","addType","addDictionary","addChildren","addCustomMetadata","endField","Schema","Little","endianness","fieldsOffset","startSchema","addEndianness","addFields","endSchema","MessageHeader","FieldNode","null_count","RecordBatch","nodesOffset","buffersOffset","startRecordBatch","addLength","addNodes","addBuffers","endRecordBatch","DictionaryBatch","dataOffset","isDelta","startDictionaryBatch","addData","addIsDelta","endDictionaryBatch","Message","V1","version","headerType","headerOffset","bodyLength","startMessage","addVersion","addHeaderType","addHeader","addBodyLength","endMessage","BufferType","iterateBits","getBool","_data","_index","byte","bit","getBit","setBool","truncateBitmap","bitmap","alignedSize","packBools","values","xs","begin","context","byteIndex","remaining","popcnt_bit_range","lhs","rhs","sum","rhsInside","lhsInside","popcnt_array","cnt","pos","view","DataView","popcnt_uint32","getUint32","getUint16","getUint8","uint32","_toConsumableArray","nodes","visit","getVisitFn","throwIfNotFound","_node","visitor","dtype","inferDType","visitNull","visitBool","visitInt","Int8","visitInt8","Int16","visitInt16","Int32","visitInt32","Int64","visitInt64","Uint8","visitUint8","Uint16","visitUint16","Uint32","visitUint32","Uint64","visitUint64","Float","visitFloat","Float16","visitFloat16","Float32","visitFloat32","Float64","visitFloat64","visitUtf8","visitBinary","visitFixedSizeBinary","visitDate","DateDay","visitDateDay","DateMillisecond","visitDateMillisecond","visitTimestamp","TimestampSecond","visitTimestampSecond","TimestampMillisecond","visitTimestampMillisecond","TimestampMicrosecond","visitTimestampMicrosecond","TimestampNanosecond","visitTimestampNanosecond","visitTime","TimeSecond","visitTimeSecond","TimeMillisecond","visitTimeMillisecond","TimeMicrosecond","visitTimeMicrosecond","TimeNanosecond","visitTimeNanosecond","visitDecimal","visitList","Struct","visitStruct","visitUnion","DenseUnion","visitDenseUnion","SparseUnion","visitSparseUnion","Dictionary","visitDictionary","visitInterval","IntervalDayTime","visitIntervalDayTime","IntervalYearMonth","visitIntervalYearMonth","visitFixedSizeList","visitMap","typeId","SINGLE","DOUBLE","MICROSECOND","NANOSECOND","DAY","DAY_TIME","Dense","schema","compareFields","fields","others","every","compareField","compareConstructor","compareAny","compareInt","compareFloat","compareDate","compareTimestamp","timezone","compareTime","compareUnion","typeIds","children","compareInterval","indices","dictionary","toStringTag","ArrayType","child","valueType","join","typeIdToChildIndex","idx","atomicDictionaryId","getId","strideForType","nullCount","childData","floor","_nullCount","Data","stride","nullBitmap","childStride","_sliceBuffers","clone","_sliceChildren","newLength","fill","VALIDITY","TYPE","OFFSET","DATA","valueOffsetsOrChildren","valueToString","toPrimitive","JSON","stringify","createIsValidFunction","nullValues","fnBody","noNaNs","valueToCase","Function","roundLengthUpToNearest64Bytes","BPE","_resize","extra","reserved","array","reserve","numValid","val","cur","_ArrayType64","buffer64","ArrayType64","nulls","_nulls","_isValid","new","flush","numInvalid","_offsets","_typeIds","reservedLength","reservedByteLength","setValid","isValid","setValue","_setValue","valid","numChildren","offsets","last","queueingStrategy","highWaterMark","sizeProperty","numChunks","append","toVector","opts","_pendingLength","pending","_pending","current","_flush","pendingLength","_flushPending","hashFn","_dictionaryOffset","_keysToIndices","valueToKey","keysToIndices","_dictionary","curr","concat","f64","u32","uint16ToFloat64","h","expo","sigf","sign","NaN","float64ToUint16","Parent","Class","bind","bignumToString","bignumToBigInt","isArrowBigNumSymbol","for","BigNum","SignedBigNum","UnsignedBigNum","DecimalBigNum","bignumToNumber","bn","hi","lo","signed","words","number","decimalToString","digits","base64","base32","checks","reverse","toJSON","hint","assign","memo","num","BN","toBigInt","kParent","kRowIndex","kKeyToIdx","kIdxToVal","kCustomInspect","parent","numKeys","ktoi","itov","getValue","getIndex","ki","vi","kr","vr","k","v","has","callbackfn","thisArg","callback","m","str","createRowProxy","getChildAt","defineRowProxyProperties","findIndex","tmp","row","getter","setter","getKey","RowProxyHandler","isExtensible","deleteProperty","preventExtensions","ownKeys","clampIndex","adjust","clampRange","end","big0","isNaNFast","createElementComparator","search","typeofSearch","valueOfSearch","comparators","createSubElementsComparator","creatMapComparator","createArrayLikeComparator","createVectorComparator","createObjectComparator","compareArray","compareObject","vec","compareVector","lKeyItr","rKeyItr","rValItr","rVal","lKey","rKey","calculateOffsets","_type","_chunks","_chunkOffsets","_length","_numChildren","chunk","isDictionary","_indices","Chunked","flatten","_sliceInternal","columns","_children","vector","mid","isValidInternal","getInternal","element","indexOfInternal","toArray","arraySet","typedSet","chunkIndex","fromIndex","start","found","slices","chunkOffsets","chunkLength","chunkOffset","to","vectors","selectChunkArgs","_field","metadata","Column","column","rest","some","_chunk","selectArgs","Ctor","vals","_selectArgs","selectFieldArgs","_selectChunkArgs","selectVectorChildrenArgs","_selectVectorChildrenArgs","res","entries","fieldIndex","valueIndex","dictionaries","generateDictionaryMap","compareSchemas","columnNames","names","columnIndices","curFields","mergeMaps","newFields","f2","newDictionaries","m1","m2","_run","run","childIndex","_valueToChildTypeId","childTypeId","setEpochMsToMillisecondsLong","epochMs","setVariableWidthBytes","setDateDay","setEpochMsToDays","setDateMillisecond","setNumeric","values64","long","setTimestampSecond","setTimestampMillisecond","setTimestampMicrosecond","setEpochMsToMicrosecondsLong","setTimestampNanosecond","setEpochMsToNanosecondsLong","setTimeSecond","setTimeMillisecond","setTimeMicrosecond","setTimeNanosecond","setDenseUnion","setSparseUnion","setIntervalDayTime","setIntervalYearMonth","itr","_setStructVectorValue","_setStructArrayValue","_setStructObjectValue","newBuilder","defaultOptions","getChildOptions","T","Footer","Block","schemaOffset","dictionariesOffset","recordBatchesOffset","startFooter","addSchema","addDictionaries","addRecordBatches","endFooter","metaDataLength","_Block","_Footer","V4","recordBatches","dictionaryBatches","_recordBatches","_dictionaryBatches","numRecordBatches","block","getRecordBatch","numDictionaries","getDictionaryBatch","buf","footer","getRootAsFooter","startRecordBatchesVector","rb","startDictionariesVector","db","dictionaryBatchesOffset","finishFooterBuffer","_footer","recordBatchesLength","dictionariesLength","fileBlock","FileBlock","createBlock","toUint8Array","peek","AsyncByteStream","body","closed","cancel","readAt","getInt32","nBytes","file","_handle","stat","bytesRead","intAsHex","kPowersOfTen","L","R","product","lessThan","_times","_plus","out_buffer","fromString","out","posn","group","parseInt","substr","multiple","times","plus","left","right","this_high","other_high","negate","startsWith","L0","L1","L2","L3","R0","R1","R2","R3","multiply","sums","Int128","nodesIndex","buffersIndex","nextFieldNode","readNullBitmap","readData","readOffsets","visitMany","readTypeIds","readDictionary","nextBufferRange","sources","isTimestamp","isInt","isTime","isDate","convertArray","isDecimal","isBinary","isFixedSizeBinary","binaryDataFromJSON","isBool","isUtf8","joined","startTypeIdsVector","createTypeIdsVector","indexType","recordBatchFromJSON","fieldNodesFromJSON","buffersFromJSON","schemaFieldsFromJSON","_schema","fromJSON","fieldChildrenFromJSON","fieldNodes","validity","customMetadataFromJSON","_metadata","indexTypeFromJSON","typeFromJSON","_Field","_Schema","_Message","_KeyValue","_FieldNode","_Endianness","_DictionaryBatch","header","_version","_headerType","_createHeader","_bodyLength","msg","message","messageHeaderFromJSON","_message","getRootAsMessage","decodeMessageHeader","isSchema","isRecordBatch","isDictionaryBatch","finishMessageBuffer","_nodes","_buffers","_isDelta","_id","decodeFieldNodes","batch","nodesLength","decodeBuffers","bufferRegions","buffersLength","decodeSchemaFields","fieldsLength","decodeFieldChildren","childrenLength","decodeCustomMetadata","entry","customMetadataLength","customMetadata","decodeIndexType","decodeFieldType","typeIdsArray","childOffsets","childrenVectorOffset","createChildrenVector","metadataOffset","createCustomMetadataVector","dictType","dictMeta","fieldOffsets","startFieldsVector","fieldsVectorOffset","createFieldsVector","platformIsLittleEndian","Big","recordBatch","startNodesVector","nodesVectorOffset","startBuffersVector","b_","buffersVectorOffset","dictionaryBatch","createFieldNode","createBuffer","setInt16","invalidMessageMetadata","expected","actual","invalidMessageBodyLength","readMetadataLength","readMetadata","throwIfNull","readMessage","PADDING","metadataLength","_body","_batchIndex","_dictionaryIndex","batches","flattenDataSources","MAGIC_STR","MAGIC","checkForMagicArrowString","magicLength","magicAndPadding","magicX2AndPadding","_byteLength","_bufferRegions","RangeError","isNull","addBuffer","_nullV","assembler","VectorAssembler","vectorChildren","assembleResult","assembleFlatVector","assembleFlatListVector","firstOffset","lastOffset","assembleListVector","assembleNestedVector","maxChildTypeId","childLengths","shiftedOffsets","unshiftedOffsets","childLength","_position","_started","_sink","_dictionaryBlocks","_recordBatchBlocks","_dictionaryDeltaOffsets","autoDestroy","writeLegacyIpcFormat","_autoDestroy","_writeLegacyIpcFormat","writeAll","writeAllAsync","reset","sink","objectMode","_writeFooter","compareTo","_writeSchema","payload","_writeRecordBatch","flatbufferSize","prefixSize","nPaddingBytes","_write","of","_writePadding","write","_writeMessage","assemble","_writeDictionaries","_writeBodyBuffers","padding","_writeDictionaryBatch","writableStrategy","readableStrategy","writer","RecordBatchStreamWriter","_writeMagic","RecordBatchFileWriter","noopBuf","nullBufs","bitmapLength","ensureSameLengthData","batchLength","l","batchData","_changeLengthAndBackfillNullBitmap","distributeColumnsIntoRecordBatches","distributeVectorsIntoRecordBatches","vecs","batchArgs","numBatches","numColumns","Number","POSITIVE_INFINITY","distributeChildData","uniformlyDistributeChunksAcrossRecordBatches","_objectWithoutProperties","excluded","sourceKeys","sourceSymbolKeys","propertyIsEnumerable","_bindDataAccessors","VectorName","isConcatSpreadable","vectorFromValuesWithType","ArrowType","InputType","typeCtor","dataCtor","ctor","is64bit","_values64","toBigInt64Array","toBigUint64Array","_row","bound","partial0","partial2","epochMillisecondsLongToMs","epochMillisecondsToDate","getVariableWidthBytes","getDateDay","epochDaysToMs","epochDaysToDate","getDateMillisecond","epochMillisecondsLongToDate","getNumeric","getTimestampSecond","getTimestampMillisecond","getTimestampMicrosecond","epochMicrosecondsLongToMs","getTimestampNanosecond","epochNanosecondsLongToMs","getTimeSecond","getTimeMillisecond","getDenseUnion","getSparseUnion","getIntervalDayTime","getIntervalYearMonth","interval","int32s","_vector","decimal","indexOfValue","searchElement","indexOfNull","compare","indexOfUnion","vectorIterator","getFn","nullByte","nullBit","nullableIterator","arrayOfVector","variableWidthColumnErrorMessage","____","visitFields","newDataType","throughIterable","transform","throughAsyncIterable","getByteWidth","wrapNullableSet","VectorCtor","partialType0","getColumnAt","getColumnIndex","Writer","nameToIndex","selectAt","columnName","newIdx","oldToNew","_f","_fs","empty","fromStruct","tableFromIterable","tableFromAsyncIterable","isSync","open","opening","cols","_dictionaries","collect","fs","vs","DictionaryCollector","readAllSync","impl","_impl","isFile","isAsync","isStream","readRecordBatch","RecordBatchReader","fromArrowJSON","fromFileHandle","fromAsyncByteStream","fromByteStream","readAllAsync","_recordBatchIndex","_loadVectors","_reader","shouldAutoDestroy","readSchema","_readNextMessageAndValidate","readMessageBody","_loadRecordBatch","_loadDictionaryBatch","_readFooter","_readDictionaryBatch","seek","_numChunks","_finished","_bufferedSize","builderOptions","_controller","_builder","_getSize","chunkByteLength","readableHighWaterMark","writableHighWaterMark","ReadableStream","_maybeFlush","WritableStream","_writeValueAndReturnChunkSize","bufferedSize","controller","desiredSize","_enqueue","enqueue","Value","ge","le","eq","colidx","expr","_bindLitLit","_bindLitCol","_bindColLit","_bindColCol","accum","And","Or","_batch","rtrn","left_func","right_func","col","lit","col_func","lastDictionary","reverseLookup","lastKey","func","countBy","scan","scanReverse","predicate","batchIndex","numRows","count_by","countByteLength","ceil","log","counts","_predicate","isBound","FilteredDataFrame","and","bm","hwm","pull","asyncIterableAsReadableDOMStream","iterableAsReadableDOMStream","queue","readable","ComponentMessageType","ArrowTable","indexBuffer","columnsBuffer","styler","_this","getCell","rowIndex","columnIndex","isBlankCell","headerRows","headerColumns","isIndexCell","isColumnsCell","classNames","content","dataColumnIndex","getContent","columnsTable","dataRowIndex","uuid","indexTable","displayValuesTable","dataTable","getColumnTypeId","nanosToDate","caption","displayValues","styles","numCols","rows","dataRows","dataColumns","serialize","nanos","__assign","Streamlit","API_VERSION","RENDER_EVENT","registeredMessageListener","setComponentReady","onMessageEvent","sendBackMsg","COMPONENT_READY","apiVersion","setFrameHeight","height","document","scrollHeight","lastFrameHeight","SET_FRAME_HEIGHT","setComponentValue","dataType","isBigIntArray","isTypedArray","SET_COMPONENT_VALUE","onRenderMessage","dataframeArgs","argsDataframeToObject","disabled","theme","_injectTheme","eventData","detail","argsDataframe","argsDataframeArrow","_a","toArrowTable","fromEntries","df","postMessage","isStreamlitMessage","style","createElement","head","appendChild","innerHTML","primaryColor","backgroundColor","secondaryBackgroundColor","textColor","font","__extends","extendStatics","__","_super","StreamlitComponentBase","componentDidMount","componentDidUpdate","React","PureComponent","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","KNOWN_STATICS","caller","callee","arity","MEMO_STATICS","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","getOwnPropertyNames","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","_typeof","__esModule","g","q","w","z","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Element","Fragment","Lazy","Portal","Profiler","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","B","C","encodeURIComponent","D","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","E","refs","updater","G","H","isReactComponent","setState","forceUpdate","I","isPureReactComponent","J","K","ref","__self","__source","M","_owner","O","P","Q","keyPrefix","S","U","V","replace","escape","W","aa","X","N","Y","Z","ba","ReactCurrentDispatcher","ReactCurrentBatchConfig","suspense","ReactCurrentOwner","IsSomeRendererActing","Children","only","Component","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","cloneElement","createContext","_calculateChangedBits","_currentValue","_currentValue2","_threadCount","Provider","Consumer","_context","createFactory","createRef","forwardRef","isValidElement","lazy","_ctor","_status","_result","useCallback","useContext","useDebugValue","useEffect","useImperativeHandle","useLayoutEffect","useMemo","useReducer","useRef","useState","propIsEnumerable","toObject","test1","test2","test3","split","letter","shouldUseNative","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","toStringTagSymbol","define","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","Context","state","GenStateSuspendedStart","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","resultName","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iteratorMethod","isGeneratorFunction","genFun","mark","awrap","skipTempReset","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","globalThis"],"mappings":"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","file":"static/js/2.422ca0c4.chunk.js","sourcesContent":["module.exports = require(\"regenerator-runtime\");\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","/**\n * @typedef {object} PrivateData\n * @property {EventTarget} eventTarget The event target.\n * @property {{type:string}} event The original event object.\n * @property {number} eventPhase The current event phase.\n * @property {EventTarget|null} currentTarget The current event target.\n * @property {boolean} canceled The flag to prevent default.\n * @property {boolean} stopped The flag to stop propagation.\n * @property {boolean} immediateStopped The flag to stop propagation immediately.\n * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.\n * @property {number} timeStamp The unix time.\n * @private\n */\n\n/**\n * Private data for event wrappers.\n * @type {WeakMap<Event, PrivateData>}\n * @private\n */\nconst privateData = new WeakMap()\n\n/**\n * Cache for wrapper classes.\n * @type {WeakMap<Object, Function>}\n * @private\n */\nconst wrappers = new WeakMap()\n\n/**\n * Get private data.\n * @param {Event} event The event object to get private data.\n * @returns {PrivateData} The private data of the event.\n * @private\n */\nfunction pd(event) {\n    const retv = privateData.get(event)\n    console.assert(\n        retv != null,\n        \"'this' is expected an Event object, but got\",\n        event\n    )\n    return retv\n}\n\n/**\n * https://dom.spec.whatwg.org/#set-the-canceled-flag\n * @param data {PrivateData} private data.\n */\nfunction setCancelFlag(data) {\n    if (data.passiveListener != null) {\n        if (\n            typeof console !== \"undefined\" &&\n            typeof console.error === \"function\"\n        ) {\n            console.error(\n                \"Unable to preventDefault inside passive event listener invocation.\",\n                data.passiveListener\n            )\n        }\n        return\n    }\n    if (!data.event.cancelable) {\n        return\n    }\n\n    data.canceled = true\n    if (typeof data.event.preventDefault === \"function\") {\n        data.event.preventDefault()\n    }\n}\n\n/**\n * @see https://dom.spec.whatwg.org/#interface-event\n * @private\n */\n/**\n * The event wrapper.\n * @constructor\n * @param {EventTarget} eventTarget The event target of this dispatching.\n * @param {Event|{type:string}} event The original event to wrap.\n */\nfunction Event(eventTarget, event) {\n    privateData.set(this, {\n        eventTarget,\n        event,\n        eventPhase: 2,\n        currentTarget: eventTarget,\n        canceled: false,\n        stopped: false,\n        immediateStopped: false,\n        passiveListener: null,\n        timeStamp: event.timeStamp || Date.now(),\n    })\n\n    // https://heycam.github.io/webidl/#Unforgeable\n    Object.defineProperty(this, \"isTrusted\", { value: false, enumerable: true })\n\n    // Define accessors\n    const keys = Object.keys(event)\n    for (let i = 0; i < keys.length; ++i) {\n        const key = keys[i]\n        if (!(key in this)) {\n            Object.defineProperty(this, key, defineRedirectDescriptor(key))\n        }\n    }\n}\n\n// Should be enumerable, but class methods are not enumerable.\nEvent.prototype = {\n    /**\n     * The type of this event.\n     * @type {string}\n     */\n    get type() {\n        return pd(this).event.type\n    },\n\n    /**\n     * The target of this event.\n     * @type {EventTarget}\n     */\n    get target() {\n        return pd(this).eventTarget\n    },\n\n    /**\n     * The target of this event.\n     * @type {EventTarget}\n     */\n    get currentTarget() {\n        return pd(this).currentTarget\n    },\n\n    /**\n     * @returns {EventTarget[]} The composed path of this event.\n     */\n    composedPath() {\n        const currentTarget = pd(this).currentTarget\n        if (currentTarget == null) {\n            return []\n        }\n        return [currentTarget]\n    },\n\n    /**\n     * Constant of NONE.\n     * @type {number}\n     */\n    get NONE() {\n        return 0\n    },\n\n    /**\n     * Constant of CAPTURING_PHASE.\n     * @type {number}\n     */\n    get CAPTURING_PHASE() {\n        return 1\n    },\n\n    /**\n     * Constant of AT_TARGET.\n     * @type {number}\n     */\n    get AT_TARGET() {\n        return 2\n    },\n\n    /**\n     * Constant of BUBBLING_PHASE.\n     * @type {number}\n     */\n    get BUBBLING_PHASE() {\n        return 3\n    },\n\n    /**\n     * The target of this event.\n     * @type {number}\n     */\n    get eventPhase() {\n        return pd(this).eventPhase\n    },\n\n    /**\n     * Stop event bubbling.\n     * @returns {void}\n     */\n    stopPropagation() {\n        const data = pd(this)\n\n        data.stopped = true\n        if (typeof data.event.stopPropagation === \"function\") {\n            data.event.stopPropagation()\n        }\n    },\n\n    /**\n     * Stop event bubbling.\n     * @returns {void}\n     */\n    stopImmediatePropagation() {\n        const data = pd(this)\n\n        data.stopped = true\n        data.immediateStopped = true\n        if (typeof data.event.stopImmediatePropagation === \"function\") {\n            data.event.stopImmediatePropagation()\n        }\n    },\n\n    /**\n     * The flag to be bubbling.\n     * @type {boolean}\n     */\n    get bubbles() {\n        return Boolean(pd(this).event.bubbles)\n    },\n\n    /**\n     * The flag to be cancelable.\n     * @type {boolean}\n     */\n    get cancelable() {\n        return Boolean(pd(this).event.cancelable)\n    },\n\n    /**\n     * Cancel this event.\n     * @returns {void}\n     */\n    preventDefault() {\n        setCancelFlag(pd(this))\n    },\n\n    /**\n     * The flag to indicate cancellation state.\n     * @type {boolean}\n     */\n    get defaultPrevented() {\n        return pd(this).canceled\n    },\n\n    /**\n     * The flag to be composed.\n     * @type {boolean}\n     */\n    get composed() {\n        return Boolean(pd(this).event.composed)\n    },\n\n    /**\n     * The unix time of this event.\n     * @type {number}\n     */\n    get timeStamp() {\n        return pd(this).timeStamp\n    },\n\n    /**\n     * The target of this event.\n     * @type {EventTarget}\n     * @deprecated\n     */\n    get srcElement() {\n        return pd(this).eventTarget\n    },\n\n    /**\n     * The flag to stop event bubbling.\n     * @type {boolean}\n     * @deprecated\n     */\n    get cancelBubble() {\n        return pd(this).stopped\n    },\n    set cancelBubble(value) {\n        if (!value) {\n            return\n        }\n        const data = pd(this)\n\n        data.stopped = true\n        if (typeof data.event.cancelBubble === \"boolean\") {\n            data.event.cancelBubble = true\n        }\n    },\n\n    /**\n     * The flag to indicate cancellation state.\n     * @type {boolean}\n     * @deprecated\n     */\n    get returnValue() {\n        return !pd(this).canceled\n    },\n    set returnValue(value) {\n        if (!value) {\n            setCancelFlag(pd(this))\n        }\n    },\n\n    /**\n     * Initialize this event object. But do nothing under event dispatching.\n     * @param {string} type The event type.\n     * @param {boolean} [bubbles=false] The flag to be possible to bubble up.\n     * @param {boolean} [cancelable=false] The flag to be possible to cancel.\n     * @deprecated\n     */\n    initEvent() {\n        // Do nothing.\n    },\n}\n\n// `constructor` is not enumerable.\nObject.defineProperty(Event.prototype, \"constructor\", {\n    value: Event,\n    configurable: true,\n    writable: true,\n})\n\n// Ensure `event instanceof window.Event` is `true`.\nif (typeof window !== \"undefined\" && typeof window.Event !== \"undefined\") {\n    Object.setPrototypeOf(Event.prototype, window.Event.prototype)\n\n    // Make association for wrappers.\n    wrappers.set(window.Event.prototype, Event)\n}\n\n/**\n * Get the property descriptor to redirect a given property.\n * @param {string} key Property name to define property descriptor.\n * @returns {PropertyDescriptor} The property descriptor to redirect the property.\n * @private\n */\nfunction defineRedirectDescriptor(key) {\n    return {\n        get() {\n            return pd(this).event[key]\n        },\n        set(value) {\n            pd(this).event[key] = value\n        },\n        configurable: true,\n        enumerable: true,\n    }\n}\n\n/**\n * Get the property descriptor to call a given method property.\n * @param {string} key Property name to define property descriptor.\n * @returns {PropertyDescriptor} The property descriptor to call the method property.\n * @private\n */\nfunction defineCallDescriptor(key) {\n    return {\n        value() {\n            const event = pd(this).event\n            return event[key].apply(event, arguments)\n        },\n        configurable: true,\n        enumerable: true,\n    }\n}\n\n/**\n * Define new wrapper class.\n * @param {Function} BaseEvent The base wrapper class.\n * @param {Object} proto The prototype of the original event.\n * @returns {Function} The defined wrapper class.\n * @private\n */\nfunction defineWrapper(BaseEvent, proto) {\n    const keys = Object.keys(proto)\n    if (keys.length === 0) {\n        return BaseEvent\n    }\n\n    /** CustomEvent */\n    function CustomEvent(eventTarget, event) {\n        BaseEvent.call(this, eventTarget, event)\n    }\n\n    CustomEvent.prototype = Object.create(BaseEvent.prototype, {\n        constructor: { value: CustomEvent, configurable: true, writable: true },\n    })\n\n    // Define accessors.\n    for (let i = 0; i < keys.length; ++i) {\n        const key = keys[i]\n        if (!(key in BaseEvent.prototype)) {\n            const descriptor = Object.getOwnPropertyDescriptor(proto, key)\n            const isFunc = typeof descriptor.value === \"function\"\n            Object.defineProperty(\n                CustomEvent.prototype,\n                key,\n                isFunc\n                    ? defineCallDescriptor(key)\n                    : defineRedirectDescriptor(key)\n            )\n        }\n    }\n\n    return CustomEvent\n}\n\n/**\n * Get the wrapper class of a given prototype.\n * @param {Object} proto The prototype of the original event to get its wrapper.\n * @returns {Function} The wrapper class.\n * @private\n */\nfunction getWrapper(proto) {\n    if (proto == null || proto === Object.prototype) {\n        return Event\n    }\n\n    let wrapper = wrappers.get(proto)\n    if (wrapper == null) {\n        wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto)\n        wrappers.set(proto, wrapper)\n    }\n    return wrapper\n}\n\n/**\n * Wrap a given event to management a dispatching.\n * @param {EventTarget} eventTarget The event target of this dispatching.\n * @param {Object} event The event to wrap.\n * @returns {Event} The wrapper instance.\n * @private\n */\nexport function wrapEvent(eventTarget, event) {\n    const Wrapper = getWrapper(Object.getPrototypeOf(event))\n    return new Wrapper(eventTarget, event)\n}\n\n/**\n * Get the immediateStopped flag of a given event.\n * @param {Event} event The event to get.\n * @returns {boolean} The flag to stop propagation immediately.\n * @private\n */\nexport function isStopped(event) {\n    return pd(event).immediateStopped\n}\n\n/**\n * Set the current event phase of a given event.\n * @param {Event} event The event to set current target.\n * @param {number} eventPhase New event phase.\n * @returns {void}\n * @private\n */\nexport function setEventPhase(event, eventPhase) {\n    pd(event).eventPhase = eventPhase\n}\n\n/**\n * Set the current target of a given event.\n * @param {Event} event The event to set current target.\n * @param {EventTarget|null} currentTarget New current target.\n * @returns {void}\n * @private\n */\nexport function setCurrentTarget(event, currentTarget) {\n    pd(event).currentTarget = currentTarget\n}\n\n/**\n * Set a passive listener of a given event.\n * @param {Event} event The event to set current target.\n * @param {Function|null} passiveListener New passive listener.\n * @returns {void}\n * @private\n */\nexport function setPassiveListener(event, passiveListener) {\n    pd(event).passiveListener = passiveListener\n}\n","import {\n    isStopped,\n    setCurrentTarget,\n    setEventPhase,\n    setPassiveListener,\n    wrapEvent,\n} from \"./event.mjs\"\n\n/**\n * @typedef {object} ListenerNode\n * @property {Function} listener\n * @property {1|2|3} listenerType\n * @property {boolean} passive\n * @property {boolean} once\n * @property {ListenerNode|null} next\n * @private\n */\n\n/**\n * @type {WeakMap<object, Map<string, ListenerNode>>}\n * @private\n */\nconst listenersMap = new WeakMap()\n\n// Listener types\nconst CAPTURE = 1\nconst BUBBLE = 2\nconst ATTRIBUTE = 3\n\n/**\n * Check whether a given value is an object or not.\n * @param {any} x The value to check.\n * @returns {boolean} `true` if the value is an object.\n */\nfunction isObject(x) {\n    return x !== null && typeof x === \"object\" //eslint-disable-line no-restricted-syntax\n}\n\n/**\n * Get listeners.\n * @param {EventTarget} eventTarget The event target to get.\n * @returns {Map<string, ListenerNode>} The listeners.\n * @private\n */\nfunction getListeners(eventTarget) {\n    const listeners = listenersMap.get(eventTarget)\n    if (listeners == null) {\n        throw new TypeError(\n            \"'this' is expected an EventTarget object, but got another value.\"\n        )\n    }\n    return listeners\n}\n\n/**\n * Get the property descriptor for the event attribute of a given event.\n * @param {string} eventName The event name to get property descriptor.\n * @returns {PropertyDescriptor} The property descriptor.\n * @private\n */\nfunction defineEventAttributeDescriptor(eventName) {\n    return {\n        get() {\n            const listeners = getListeners(this)\n            let node = listeners.get(eventName)\n            while (node != null) {\n                if (node.listenerType === ATTRIBUTE) {\n                    return node.listener\n                }\n                node = node.next\n            }\n            return null\n        },\n\n        set(listener) {\n            if (typeof listener !== \"function\" && !isObject(listener)) {\n                listener = null // eslint-disable-line no-param-reassign\n            }\n            const listeners = getListeners(this)\n\n            // Traverse to the tail while removing old value.\n            let prev = null\n            let node = listeners.get(eventName)\n            while (node != null) {\n                if (node.listenerType === ATTRIBUTE) {\n                    // Remove old value.\n                    if (prev !== null) {\n                        prev.next = node.next\n                    } else if (node.next !== null) {\n                        listeners.set(eventName, node.next)\n                    } else {\n                        listeners.delete(eventName)\n                    }\n                } else {\n                    prev = node\n                }\n\n                node = node.next\n            }\n\n            // Add new value.\n            if (listener !== null) {\n                const newNode = {\n                    listener,\n                    listenerType: ATTRIBUTE,\n                    passive: false,\n                    once: false,\n                    next: null,\n                }\n                if (prev === null) {\n                    listeners.set(eventName, newNode)\n                } else {\n                    prev.next = newNode\n                }\n            }\n        },\n        configurable: true,\n        enumerable: true,\n    }\n}\n\n/**\n * Define an event attribute (e.g. `eventTarget.onclick`).\n * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.\n * @param {string} eventName The event name to define.\n * @returns {void}\n */\nfunction defineEventAttribute(eventTargetPrototype, eventName) {\n    Object.defineProperty(\n        eventTargetPrototype,\n        `on${eventName}`,\n        defineEventAttributeDescriptor(eventName)\n    )\n}\n\n/**\n * Define a custom EventTarget with event attributes.\n * @param {string[]} eventNames Event names for event attributes.\n * @returns {EventTarget} The custom EventTarget.\n * @private\n */\nfunction defineCustomEventTarget(eventNames) {\n    /** CustomEventTarget */\n    function CustomEventTarget() {\n        EventTarget.call(this)\n    }\n\n    CustomEventTarget.prototype = Object.create(EventTarget.prototype, {\n        constructor: {\n            value: CustomEventTarget,\n            configurable: true,\n            writable: true,\n        },\n    })\n\n    for (let i = 0; i < eventNames.length; ++i) {\n        defineEventAttribute(CustomEventTarget.prototype, eventNames[i])\n    }\n\n    return CustomEventTarget\n}\n\n/**\n * EventTarget.\n *\n * - This is constructor if no arguments.\n * - This is a function which returns a CustomEventTarget constructor if there are arguments.\n *\n * For example:\n *\n *     class A extends EventTarget {}\n *     class B extends EventTarget(\"message\") {}\n *     class C extends EventTarget(\"message\", \"error\") {}\n *     class D extends EventTarget([\"message\", \"error\"]) {}\n */\nfunction EventTarget() {\n    /*eslint-disable consistent-return */\n    if (this instanceof EventTarget) {\n        listenersMap.set(this, new Map())\n        return\n    }\n    if (arguments.length === 1 && Array.isArray(arguments[0])) {\n        return defineCustomEventTarget(arguments[0])\n    }\n    if (arguments.length > 0) {\n        const types = new Array(arguments.length)\n        for (let i = 0; i < arguments.length; ++i) {\n            types[i] = arguments[i]\n        }\n        return defineCustomEventTarget(types)\n    }\n    throw new TypeError(\"Cannot call a class as a function\")\n    /*eslint-enable consistent-return */\n}\n\n// Should be enumerable, but class methods are not enumerable.\nEventTarget.prototype = {\n    /**\n     * Add a given listener to this event target.\n     * @param {string} eventName The event name to add.\n     * @param {Function} listener The listener to add.\n     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.\n     * @returns {void}\n     */\n    addEventListener(eventName, listener, options) {\n        if (listener == null) {\n            return\n        }\n        if (typeof listener !== \"function\" && !isObject(listener)) {\n            throw new TypeError(\"'listener' should be a function or an object.\")\n        }\n\n        const listeners = getListeners(this)\n        const optionsIsObj = isObject(options)\n        const capture = optionsIsObj\n            ? Boolean(options.capture)\n            : Boolean(options)\n        const listenerType = capture ? CAPTURE : BUBBLE\n        const newNode = {\n            listener,\n            listenerType,\n            passive: optionsIsObj && Boolean(options.passive),\n            once: optionsIsObj && Boolean(options.once),\n            next: null,\n        }\n\n        // Set it as the first node if the first node is null.\n        let node = listeners.get(eventName)\n        if (node === undefined) {\n            listeners.set(eventName, newNode)\n            return\n        }\n\n        // Traverse to the tail while checking duplication..\n        let prev = null\n        while (node != null) {\n            if (\n                node.listener === listener &&\n                node.listenerType === listenerType\n            ) {\n                // Should ignore duplication.\n                return\n            }\n            prev = node\n            node = node.next\n        }\n\n        // Add it.\n        prev.next = newNode\n    },\n\n    /**\n     * Remove a given listener from this event target.\n     * @param {string} eventName The event name to remove.\n     * @param {Function} listener The listener to remove.\n     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.\n     * @returns {void}\n     */\n    removeEventListener(eventName, listener, options) {\n        if (listener == null) {\n            return\n        }\n\n        const listeners = getListeners(this)\n        const capture = isObject(options)\n            ? Boolean(options.capture)\n            : Boolean(options)\n        const listenerType = capture ? CAPTURE : BUBBLE\n\n        let prev = null\n        let node = listeners.get(eventName)\n        while (node != null) {\n            if (\n                node.listener === listener &&\n                node.listenerType === listenerType\n            ) {\n                if (prev !== null) {\n                    prev.next = node.next\n                } else if (node.next !== null) {\n                    listeners.set(eventName, node.next)\n                } else {\n                    listeners.delete(eventName)\n                }\n                return\n            }\n\n            prev = node\n            node = node.next\n        }\n    },\n\n    /**\n     * Dispatch a given event.\n     * @param {Event|{type:string}} event The event to dispatch.\n     * @returns {boolean} `false` if canceled.\n     */\n    dispatchEvent(event) {\n        if (event == null || typeof event.type !== \"string\") {\n            throw new TypeError('\"event.type\" should be a string.')\n        }\n\n        // If listeners aren't registered, terminate.\n        const listeners = getListeners(this)\n        const eventName = event.type\n        let node = listeners.get(eventName)\n        if (node == null) {\n            return true\n        }\n\n        // Since we cannot rewrite several properties, so wrap object.\n        const wrappedEvent = wrapEvent(this, event)\n\n        // This doesn't process capturing phase and bubbling phase.\n        // This isn't participating in a tree.\n        let prev = null\n        while (node != null) {\n            // Remove this listener if it's once\n            if (node.once) {\n                if (prev !== null) {\n                    prev.next = node.next\n                } else if (node.next !== null) {\n                    listeners.set(eventName, node.next)\n                } else {\n                    listeners.delete(eventName)\n                }\n            } else {\n                prev = node\n            }\n\n            // Call this listener\n            setPassiveListener(\n                wrappedEvent,\n                node.passive ? node.listener : null\n            )\n            if (typeof node.listener === \"function\") {\n                try {\n                    node.listener.call(this, wrappedEvent)\n                } catch (err) {\n                    if (\n                        typeof console !== \"undefined\" &&\n                        typeof console.error === \"function\"\n                    ) {\n                        console.error(err)\n                    }\n                }\n            } else if (\n                node.listenerType !== ATTRIBUTE &&\n                typeof node.listener.handleEvent === \"function\"\n            ) {\n                node.listener.handleEvent(wrappedEvent)\n            }\n\n            // Break if `event.stopImmediatePropagation` was called.\n            if (isStopped(wrappedEvent)) {\n                break\n            }\n\n            node = node.next\n        }\n        setPassiveListener(wrappedEvent, null)\n        setEventPhase(wrappedEvent, 0)\n        setCurrentTarget(wrappedEvent, null)\n\n        return !wrappedEvent.defaultPrevented\n    },\n}\n\n// `constructor` is not enumerable.\nObject.defineProperty(EventTarget.prototype, \"constructor\", {\n    value: EventTarget,\n    configurable: true,\n    writable: true,\n})\n\n// Ensure `eventTarget instanceof window.EventTarget` is `true`.\nif (\n    typeof window !== \"undefined\" &&\n    typeof window.EventTarget !== \"undefined\"\n) {\n    Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype)\n}\n\nexport { defineEventAttribute, EventTarget }\nexport default EventTarget\n","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","import unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nexport default function _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n\n  if (!it) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function F() {};\n\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function s() {\n      it = it.call(o);\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","export default function _AwaitValue(value) {\n  this.wrapped = value;\n}","import AwaitValue from \"./AwaitValue.js\";\nexport default function _awaitAsyncGenerator(value) {\n  return new AwaitValue(value);\n}","import AwaitValue from \"./AwaitValue.js\";\nexport default function AsyncGenerator(gen) {\n  var front, back;\n\n  function send(key, arg) {\n    return new Promise(function (resolve, reject) {\n      var request = {\n        key: key,\n        arg: arg,\n        resolve: resolve,\n        reject: reject,\n        next: null\n      };\n\n      if (back) {\n        back = back.next = request;\n      } else {\n        front = back = request;\n        resume(key, arg);\n      }\n    });\n  }\n\n  function resume(key, arg) {\n    try {\n      var result = gen[key](arg);\n      var value = result.value;\n      var wrappedAwait = value instanceof AwaitValue;\n      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {\n        if (wrappedAwait) {\n          resume(key === \"return\" ? \"return\" : \"next\", arg);\n          return;\n        }\n\n        settle(result.done ? \"return\" : \"normal\", arg);\n      }, function (err) {\n        resume(\"throw\", err);\n      });\n    } catch (err) {\n      settle(\"throw\", err);\n    }\n  }\n\n  function settle(type, value) {\n    switch (type) {\n      case \"return\":\n        front.resolve({\n          value: value,\n          done: true\n        });\n        break;\n\n      case \"throw\":\n        front.reject(value);\n        break;\n\n      default:\n        front.resolve({\n          value: value,\n          done: false\n        });\n        break;\n    }\n\n    front = front.next;\n\n    if (front) {\n      resume(front.key, front.arg);\n    } else {\n      back = null;\n    }\n  }\n\n  this._invoke = send;\n\n  if (typeof gen[\"return\"] !== \"function\") {\n    this[\"return\"] = undefined;\n  }\n}\n\nAsyncGenerator.prototype[typeof Symbol === \"function\" && Symbol.asyncIterator || \"@@asyncIterator\"] = function () {\n  return this;\n};\n\nAsyncGenerator.prototype.next = function (arg) {\n  return this._invoke(\"next\", arg);\n};\n\nAsyncGenerator.prototype[\"throw\"] = function (arg) {\n  return this._invoke(\"throw\", arg);\n};\n\nAsyncGenerator.prototype[\"return\"] = function (arg) {\n  return this._invoke(\"return\", arg);\n};","import AsyncGenerator from \"./AsyncGenerator.js\";\nexport default function _wrapAsyncGenerator(fn) {\n  return function () {\n    return new AsyncGenerator(fn.apply(this, arguments));\n  };\n}","export default function _asyncIterator(iterable) {\n  var method,\n      async,\n      sync,\n      retry = 2;\n\n  for (\"undefined\" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {\n    if (async && null != (method = iterable[async])) return method.call(iterable);\n    if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));\n    async = \"@@asyncIterator\", sync = \"@@iterator\";\n  }\n\n  throw new TypeError(\"Object is not async iterable\");\n}\n\nfunction AsyncFromSyncIterator(s) {\n  function AsyncFromSyncIteratorContinuation(r) {\n    if (Object(r) !== r) return Promise.reject(new TypeError(r + \" is not an object.\"));\n    var done = r.done;\n    return Promise.resolve(r.value).then(function (value) {\n      return {\n        value: value,\n        done: done\n      };\n    });\n  }\n\n  return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) {\n    this.s = s, this.n = s.next;\n  }, AsyncFromSyncIterator.prototype = {\n    s: null,\n    n: null,\n    next: function next() {\n      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));\n    },\n    \"return\": function _return(value) {\n      var ret = this.s[\"return\"];\n      return void 0 === ret ? Promise.resolve({\n        value: value,\n        done: !0\n      }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));\n    },\n    \"throw\": function _throw(value) {\n      var thr = this.s[\"return\"];\n      return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));\n    }\n  }, new AsyncFromSyncIterator(s);\n}","export default function _asyncGeneratorDelegate(inner, awaitWrap) {\n  var iter = {},\n      waiting = false;\n\n  function pump(key, value) {\n    waiting = true;\n    value = new Promise(function (resolve) {\n      resolve(inner[key](value));\n    });\n    return {\n      done: false,\n      value: awaitWrap(value)\n    };\n  }\n\n  ;\n\n  iter[typeof Symbol !== \"undefined\" && Symbol.iterator || \"@@iterator\"] = function () {\n    return this;\n  };\n\n  iter.next = function (value) {\n    if (waiting) {\n      waiting = false;\n      return value;\n    }\n\n    return pump(\"next\", value);\n  };\n\n  if (typeof inner[\"throw\"] === \"function\") {\n    iter[\"throw\"] = function (value) {\n      if (waiting) {\n        waiting = false;\n        throw value;\n      }\n\n      return pump(\"throw\", value);\n    };\n  }\n\n  if (typeof inner[\"return\"] === \"function\") {\n    iter[\"return\"] = function (value) {\n      if (waiting) {\n        waiting = false;\n        return value;\n      }\n\n      return pump(\"return\", value);\n    };\n  }\n\n  return iter;\n}","/// @file\n/// @addtogroup flatbuffers_javascript_api\n/// @{\n/// @cond FLATBUFFERS_INTERNAL\n\n/**\n * @fileoverview\n *\n * Need to suppress 'global this' error so the Node.js export line doesn't cause\n * closure compile to error out.\n * @suppress {globalThis}\n */\n\n/**\n * @const\n * @namespace\n */\nvar flatbuffers = {};\n\n/**\n * @typedef {number}\n */\nflatbuffers.Offset;\n\n/**\n * @typedef {{\n *   bb: flatbuffers.ByteBuffer,\n *   bb_pos: number\n * }}\n */\nflatbuffers.Table;\n\n/**\n * @type {number}\n * @const\n */\nflatbuffers.SIZEOF_SHORT = 2;\n\n/**\n * @type {number}\n * @const\n */\nflatbuffers.SIZEOF_INT = 4;\n\n/**\n * @type {number}\n * @const\n */\nflatbuffers.FILE_IDENTIFIER_LENGTH = 4;\n\n/**\n * @enum {number}\n */\nflatbuffers.Encoding = {\n  UTF8_BYTES: 1,\n  UTF16_STRING: 2\n};\n\n/**\n * @type {Int32Array}\n * @const\n */\nflatbuffers.int32 = new Int32Array(2);\n\n/**\n * @type {Float32Array}\n * @const\n */\nflatbuffers.float32 = new Float32Array(flatbuffers.int32.buffer);\n\n/**\n * @type {Float64Array}\n * @const\n */\nflatbuffers.float64 = new Float64Array(flatbuffers.int32.buffer);\n\n/**\n * @type {boolean}\n * @const\n */\nflatbuffers.isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;\n\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @constructor\n * @param {number} low\n * @param {number} high\n */\nflatbuffers.Long = function(low, high) {\n  /**\n   * @type {number}\n   * @const\n   */\n  this.low = low | 0;\n\n  /**\n   * @type {number}\n   * @const\n   */\n  this.high = high | 0;\n};\n\n/**\n * @param {number} low\n * @param {number} high\n * @returns {flatbuffers.Long}\n */\nflatbuffers.Long.create = function(low, high) {\n  // Special-case zero to avoid GC overhead for default values\n  return low == 0 && high == 0 ? flatbuffers.Long.ZERO : new flatbuffers.Long(low, high);\n};\n\n/**\n * @returns {number}\n */\nflatbuffers.Long.prototype.toFloat64 = function() {\n  return (this.low >>> 0) + this.high * 0x100000000;\n};\n\n/**\n * @param {flatbuffers.Long} other\n * @returns {boolean}\n */\nflatbuffers.Long.prototype.equals = function(other) {\n  return this.low == other.low && this.high == other.high;\n};\n\n/**\n * @type {flatbuffers.Long}\n * @const\n */\nflatbuffers.Long.ZERO = new flatbuffers.Long(0, 0);\n\n/// @endcond\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a FlatBufferBuilder.\n *\n * @constructor\n * @param {number=} opt_initial_size\n */\nflatbuffers.Builder = function(opt_initial_size) {\n  if (!opt_initial_size) {\n    var initial_size = 1024;\n  } else {\n    var initial_size = opt_initial_size;\n  }\n\n  /**\n   * @type {flatbuffers.ByteBuffer}\n   * @private\n   */\n  this.bb = flatbuffers.ByteBuffer.allocate(initial_size);\n\n  /**\n   * Remaining space in the ByteBuffer.\n   *\n   * @type {number}\n   * @private\n   */\n  this.space = initial_size;\n\n  /**\n   * Minimum alignment encountered so far.\n   *\n   * @type {number}\n   * @private\n   */\n  this.minalign = 1;\n\n  /**\n   * The vtable for the current table.\n   *\n   * @type {Array.<number>}\n   * @private\n   */\n  this.vtable = null;\n\n  /**\n   * The amount of fields we're actually using.\n   *\n   * @type {number}\n   * @private\n   */\n  this.vtable_in_use = 0;\n\n  /**\n   * Whether we are currently serializing a table.\n   *\n   * @type {boolean}\n   * @private\n   */\n  this.isNested = false;\n\n  /**\n   * Starting offset of the current struct/table.\n   *\n   * @type {number}\n   * @private\n   */\n  this.object_start = 0;\n\n  /**\n   * List of offsets of all vtables.\n   *\n   * @type {Array.<number>}\n   * @private\n   */\n  this.vtables = [];\n\n  /**\n   * For the current vector being built.\n   *\n   * @type {number}\n   * @private\n   */\n  this.vector_num_elems = 0;\n\n  /**\n   * False omits default values from the serialized data\n   *\n   * @type {boolean}\n   * @private\n   */\n  this.force_defaults = false;\n};\n\nflatbuffers.Builder.prototype.clear = function() {\n  this.bb.clear();\n  this.space = this.bb.capacity();\n  this.minalign = 1;\n  this.vtable = null;\n  this.vtable_in_use = 0;\n  this.isNested = false;\n  this.object_start = 0;\n  this.vtables = [];\n  this.vector_num_elems = 0;\n  this.force_defaults = false;\n};\n\n/**\n * In order to save space, fields that are set to their default value\n * don't get serialized into the buffer. Forcing defaults provides a\n * way to manually disable this optimization.\n *\n * @param {boolean} forceDefaults true always serializes default values\n */\nflatbuffers.Builder.prototype.forceDefaults = function(forceDefaults) {\n  this.force_defaults = forceDefaults;\n};\n\n/**\n * Get the ByteBuffer representing the FlatBuffer. Only call this after you've\n * called finish(). The actual data starts at the ByteBuffer's current position,\n * not necessarily at 0.\n *\n * @returns {flatbuffers.ByteBuffer}\n */\nflatbuffers.Builder.prototype.dataBuffer = function() {\n  return this.bb;\n};\n\n/**\n * Get the bytes representing the FlatBuffer. Only call this after you've\n * called finish().\n *\n * @returns {Uint8Array}\n */\nflatbuffers.Builder.prototype.asUint8Array = function() {\n  return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * Prepare to write an element of `size` after `additional_bytes` have been\n * written, e.g. if you write a string, you need to align such the int length\n * field is aligned to 4 bytes, and the string data follows it directly. If all\n * you need to do is alignment, `additional_bytes` will be 0.\n *\n * @param {number} size This is the of the new element to write\n * @param {number} additional_bytes The padding size\n */\nflatbuffers.Builder.prototype.prep = function(size, additional_bytes) {\n  // Track the biggest thing we've ever aligned to.\n  if (size > this.minalign) {\n    this.minalign = size;\n  }\n\n  // Find the amount of alignment needed such that `size` is properly\n  // aligned after `additional_bytes`\n  var align_size = ((~(this.bb.capacity() - this.space + additional_bytes)) + 1) & (size - 1);\n\n  // Reallocate the buffer if needed.\n  while (this.space < align_size + size + additional_bytes) {\n    var old_buf_size = this.bb.capacity();\n    this.bb = flatbuffers.Builder.growByteBuffer(this.bb);\n    this.space += this.bb.capacity() - old_buf_size;\n  }\n\n  this.pad(align_size);\n};\n\n/**\n * @param {number} byte_size\n */\nflatbuffers.Builder.prototype.pad = function(byte_size) {\n  for (var i = 0; i < byte_size; i++) {\n    this.bb.writeInt8(--this.space, 0);\n  }\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeInt8 = function(value) {\n  this.bb.writeInt8(this.space -= 1, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeInt16 = function(value) {\n  this.bb.writeInt16(this.space -= 2, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeInt32 = function(value) {\n  this.bb.writeInt32(this.space -= 4, value);\n};\n\n/**\n * @param {flatbuffers.Long} value\n */\nflatbuffers.Builder.prototype.writeInt64 = function(value) {\n  this.bb.writeInt64(this.space -= 8, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeFloat32 = function(value) {\n  this.bb.writeFloat32(this.space -= 4, value);\n};\n\n/**\n * @param {number} value\n */\nflatbuffers.Builder.prototype.writeFloat64 = function(value) {\n  this.bb.writeFloat64(this.space -= 8, value);\n};\n/// @endcond\n\n/**\n * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `int8` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt8 = function(value) {\n  this.prep(1, 0);\n  this.writeInt8(value);\n};\n\n/**\n * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `int16` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt16 = function(value) {\n  this.prep(2, 0);\n  this.writeInt16(value);\n};\n\n/**\n * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `int32` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt32 = function(value) {\n  this.prep(4, 0);\n  this.writeInt32(value);\n};\n\n/**\n * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {flatbuffers.Long} value The `int64` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addInt64 = function(value) {\n  this.prep(8, 0);\n  this.writeInt64(value);\n};\n\n/**\n * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `float32` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addFloat32 = function(value) {\n  this.prep(4, 0);\n  this.writeFloat32(value);\n};\n\n/**\n * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).\n * @param {number} value The `float64` to add the the buffer.\n */\nflatbuffers.Builder.prototype.addFloat64 = function(value) {\n  this.prep(8, 0);\n  this.writeFloat64(value);\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt8 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addInt8(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt16 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addInt16(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt32 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addInt32(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {flatbuffers.Long} value\n * @param {flatbuffers.Long} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldInt64 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || !value.equals(defaultValue)) {\n    this.addInt64(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldFloat32 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addFloat32(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {number} value\n * @param {number} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldFloat64 = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addFloat64(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * @param {number} voffset\n * @param {flatbuffers.Offset} value\n * @param {flatbuffers.Offset} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldOffset = function(voffset, value, defaultValue) {\n  if (this.force_defaults || value != defaultValue) {\n    this.addOffset(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * Structs are stored inline, so nothing additional is being added. `d` is always 0.\n *\n * @param {number} voffset\n * @param {flatbuffers.Offset} value\n * @param {flatbuffers.Offset} defaultValue\n */\nflatbuffers.Builder.prototype.addFieldStruct = function(voffset, value, defaultValue) {\n  if (value != defaultValue) {\n    this.nested(value);\n    this.slot(voffset);\n  }\n};\n\n/**\n * Structures are always stored inline, they need to be created right\n * where they're used.  You'll get this assertion failure if you\n * created it elsewhere.\n *\n * @param {flatbuffers.Offset} obj The offset of the created object\n */\nflatbuffers.Builder.prototype.nested = function(obj) {\n  if (obj != this.offset()) {\n    throw new Error('FlatBuffers: struct must be serialized inline.');\n  }\n};\n\n/**\n * Should not be creating any other object, string or vector\n * while an object is being constructed\n */\nflatbuffers.Builder.prototype.notNested = function() {\n  if (this.isNested) {\n    throw new Error('FlatBuffers: object serialization must not be nested.');\n  }\n};\n\n/**\n * Set the current vtable at `voffset` to the current location in the buffer.\n *\n * @param {number} voffset\n */\nflatbuffers.Builder.prototype.slot = function(voffset) {\n  this.vtable[voffset] = this.offset();\n};\n\n/**\n * @returns {flatbuffers.Offset} Offset relative to the end of the buffer.\n */\nflatbuffers.Builder.prototype.offset = function() {\n  return this.bb.capacity() - this.space;\n};\n\n/**\n * Doubles the size of the backing ByteBuffer and copies the old data towards\n * the end of the new buffer (since we build the buffer backwards).\n *\n * @param {flatbuffers.ByteBuffer} bb The current buffer with the existing data\n * @returns {flatbuffers.ByteBuffer} A new byte buffer with the old data copied\n * to it. The data is located at the end of the buffer.\n *\n * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass\n * it a uint8Array we need to suppress the type check:\n * @suppress {checkTypes}\n */\nflatbuffers.Builder.growByteBuffer = function(bb) {\n  var old_buf_size = bb.capacity();\n\n  // Ensure we don't grow beyond what fits in an int.\n  if (old_buf_size & 0xC0000000) {\n    throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.');\n  }\n\n  var new_buf_size = old_buf_size << 1;\n  var nbb = flatbuffers.ByteBuffer.allocate(new_buf_size);\n  nbb.setPosition(new_buf_size - old_buf_size);\n  nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);\n  return nbb;\n};\n/// @endcond\n\n/**\n * Adds on offset, relative to where it will be written.\n *\n * @param {flatbuffers.Offset} offset The offset to add.\n */\nflatbuffers.Builder.prototype.addOffset = function(offset) {\n  this.prep(flatbuffers.SIZEOF_INT, 0); // Ensure alignment is already done.\n  this.writeInt32(this.offset() - offset + flatbuffers.SIZEOF_INT);\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * Start encoding a new object in the buffer.  Users will not usually need to\n * call this directly. The FlatBuffers compiler will generate helper methods\n * that call this method internally.\n *\n * @param {number} numfields\n */\nflatbuffers.Builder.prototype.startObject = function(numfields) {\n  this.notNested();\n  if (this.vtable == null) {\n    this.vtable = [];\n  }\n  this.vtable_in_use = numfields;\n  for (var i = 0; i < numfields; i++) {\n    this.vtable[i] = 0; // This will push additional elements as needed\n  }\n  this.isNested = true;\n  this.object_start = this.offset();\n};\n\n/**\n * Finish off writing the object that is under construction.\n *\n * @returns {flatbuffers.Offset} The offset to the object inside `dataBuffer`\n */\nflatbuffers.Builder.prototype.endObject = function() {\n  if (this.vtable == null || !this.isNested) {\n    throw new Error('FlatBuffers: endObject called without startObject');\n  }\n\n  this.addInt32(0);\n  var vtableloc = this.offset();\n\n  // Trim trailing zeroes.\n  var i = this.vtable_in_use - 1;\n  for (; i >= 0 && this.vtable[i] == 0; i--) {}\n  var trimmed_size = i + 1;\n\n  // Write out the current vtable.\n  for (; i >= 0; i--) {\n    // Offset relative to the start of the table.\n    this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);\n  }\n\n  var standard_fields = 2; // The fields below:\n  this.addInt16(vtableloc - this.object_start);\n  var len = (trimmed_size + standard_fields) * flatbuffers.SIZEOF_SHORT;\n  this.addInt16(len);\n\n  // Search for an existing vtable that matches the current one.\n  var existing_vtable = 0;\n  var vt1 = this.space;\nouter_loop:\n  for (i = 0; i < this.vtables.length; i++) {\n    var vt2 = this.bb.capacity() - this.vtables[i];\n    if (len == this.bb.readInt16(vt2)) {\n      for (var j = flatbuffers.SIZEOF_SHORT; j < len; j += flatbuffers.SIZEOF_SHORT) {\n        if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {\n          continue outer_loop;\n        }\n      }\n      existing_vtable = this.vtables[i];\n      break;\n    }\n  }\n\n  if (existing_vtable) {\n    // Found a match:\n    // Remove the current vtable.\n    this.space = this.bb.capacity() - vtableloc;\n\n    // Point table to existing vtable.\n    this.bb.writeInt32(this.space, existing_vtable - vtableloc);\n  } else {\n    // No match:\n    // Add the location of the current vtable to the list of vtables.\n    this.vtables.push(this.offset());\n\n    // Point table to current vtable.\n    this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);\n  }\n\n  this.isNested = false;\n  return vtableloc;\n};\n/// @endcond\n\n/**\n * Finalize a buffer, poiting to the given `root_table`.\n *\n * @param {flatbuffers.Offset} root_table\n * @param {string=} opt_file_identifier\n */\nflatbuffers.Builder.prototype.finish = function(root_table, opt_file_identifier) {\n  if (opt_file_identifier) {\n    var file_identifier = opt_file_identifier;\n    this.prep(this.minalign, flatbuffers.SIZEOF_INT +\n      flatbuffers.FILE_IDENTIFIER_LENGTH);\n    if (file_identifier.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {\n      throw new Error('FlatBuffers: file identifier must be length ' +\n        flatbuffers.FILE_IDENTIFIER_LENGTH);\n    }\n    for (var i = flatbuffers.FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {\n      this.writeInt8(file_identifier.charCodeAt(i));\n    }\n  }\n  this.prep(this.minalign, flatbuffers.SIZEOF_INT);\n  this.addOffset(root_table);\n  this.bb.setPosition(this.space);\n};\n\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * This checks a required field has been set in a given table that has\n * just been constructed.\n *\n * @param {flatbuffers.Offset} table\n * @param {number} field\n */\nflatbuffers.Builder.prototype.requiredField = function(table, field) {\n  var table_start = this.bb.capacity() - table;\n  var vtable_start = table_start - this.bb.readInt32(table_start);\n  var ok = this.bb.readInt16(vtable_start + field) != 0;\n\n  // If this fails, the caller will show what field needs to be set.\n  if (!ok) {\n    throw new Error('FlatBuffers: field ' + field + ' must be set');\n  }\n};\n\n/**\n * Start a new array/vector of objects.  Users usually will not call\n * this directly. The FlatBuffers compiler will create a start/end\n * method for vector types in generated code.\n *\n * @param {number} elem_size The size of each element in the array\n * @param {number} num_elems The number of elements in the array\n * @param {number} alignment The alignment of the array\n */\nflatbuffers.Builder.prototype.startVector = function(elem_size, num_elems, alignment) {\n  this.notNested();\n  this.vector_num_elems = num_elems;\n  this.prep(flatbuffers.SIZEOF_INT, elem_size * num_elems);\n  this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.\n};\n\n/**\n * Finish off the creation of an array and all its elements. The array must be\n * created with `startVector`.\n *\n * @returns {flatbuffers.Offset} The offset at which the newly created array\n * starts.\n */\nflatbuffers.Builder.prototype.endVector = function() {\n  this.writeInt32(this.vector_num_elems);\n  return this.offset();\n};\n/// @endcond\n\n/**\n * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed\n * instead of a string, it is assumed to contain valid UTF-8 encoded data.\n *\n * @param {string|Uint8Array} s The string to encode\n * @return {flatbuffers.Offset} The offset in the buffer where the encoded string starts\n */\nflatbuffers.Builder.prototype.createString = function(s) {\n  if (s instanceof Uint8Array) {\n    var utf8 = s;\n  } else {\n    var utf8 = [];\n    var i = 0;\n\n    while (i < s.length) {\n      var codePoint;\n\n      // Decode UTF-16\n      var a = s.charCodeAt(i++);\n      if (a < 0xD800 || a >= 0xDC00) {\n        codePoint = a;\n      } else {\n        var b = s.charCodeAt(i++);\n        codePoint = (a << 10) + b + (0x10000 - (0xD800 << 10) - 0xDC00);\n      }\n\n      // Encode UTF-8\n      if (codePoint < 0x80) {\n        utf8.push(codePoint);\n      } else {\n        if (codePoint < 0x800) {\n          utf8.push(((codePoint >> 6) & 0x1F) | 0xC0);\n        } else {\n          if (codePoint < 0x10000) {\n            utf8.push(((codePoint >> 12) & 0x0F) | 0xE0);\n          } else {\n            utf8.push(\n              ((codePoint >> 18) & 0x07) | 0xF0,\n              ((codePoint >> 12) & 0x3F) | 0x80);\n          }\n          utf8.push(((codePoint >> 6) & 0x3F) | 0x80);\n        }\n        utf8.push((codePoint & 0x3F) | 0x80);\n      }\n    }\n  }\n\n  this.addInt8(0);\n  this.startVector(1, utf8.length, 1);\n  this.bb.setPosition(this.space -= utf8.length);\n  for (var i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {\n    bytes[offset++] = utf8[i];\n  }\n  return this.endVector();\n};\n\n/**\n * A helper function to avoid generated code depending on this file directly.\n *\n * @param {number} low\n * @param {number} high\n * @returns {flatbuffers.Long}\n */\nflatbuffers.Builder.prototype.createLong = function(low, high) {\n  return flatbuffers.Long.create(low, high);\n};\n////////////////////////////////////////////////////////////////////////////////\n/// @cond FLATBUFFERS_INTERNAL\n/**\n * Create a new ByteBuffer with a given array of bytes (`Uint8Array`).\n *\n * @constructor\n * @param {Uint8Array} bytes\n */\nflatbuffers.ByteBuffer = function(bytes) {\n  /**\n   * @type {Uint8Array}\n   * @private\n   */\n  this.bytes_ = bytes;\n\n  /**\n   * @type {number}\n   * @private\n   */\n  this.position_ = 0;\n};\n\n/**\n * Create and allocate a new ByteBuffer with a given size.\n *\n * @param {number} byte_size\n * @returns {flatbuffers.ByteBuffer}\n */\nflatbuffers.ByteBuffer.allocate = function(byte_size) {\n  return new flatbuffers.ByteBuffer(new Uint8Array(byte_size));\n};\n\nflatbuffers.ByteBuffer.prototype.clear = function() {\n  this.position_ = 0;\n};\n\n/**\n * Get the underlying `Uint8Array`.\n *\n * @returns {Uint8Array}\n */\nflatbuffers.ByteBuffer.prototype.bytes = function() {\n  return this.bytes_;\n};\n\n/**\n * Get the buffer's position.\n *\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.position = function() {\n  return this.position_;\n};\n\n/**\n * Set the buffer's position.\n *\n * @param {number} position\n */\nflatbuffers.ByteBuffer.prototype.setPosition = function(position) {\n  this.position_ = position;\n};\n\n/**\n * Get the buffer's capacity.\n *\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.capacity = function() {\n  return this.bytes_.length;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readInt8 = function(offset) {\n  return this.readUint8(offset) << 24 >> 24;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readUint8 = function(offset) {\n  return this.bytes_[offset];\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readInt16 = function(offset) {\n  return this.readUint16(offset) << 16 >> 16;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readUint16 = function(offset) {\n  return this.bytes_[offset] | this.bytes_[offset + 1] << 8;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readInt32 = function(offset) {\n  return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readUint32 = function(offset) {\n  return this.readInt32(offset) >>> 0;\n};\n\n/**\n * @param {number} offset\n * @returns {flatbuffers.Long}\n */\nflatbuffers.ByteBuffer.prototype.readInt64 = function(offset) {\n  return new flatbuffers.Long(this.readInt32(offset), this.readInt32(offset + 4));\n};\n\n/**\n * @param {number} offset\n * @returns {flatbuffers.Long}\n */\nflatbuffers.ByteBuffer.prototype.readUint64 = function(offset) {\n  return new flatbuffers.Long(this.readUint32(offset), this.readUint32(offset + 4));\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readFloat32 = function(offset) {\n  flatbuffers.int32[0] = this.readInt32(offset);\n  return flatbuffers.float32[0];\n};\n\n/**\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.readFloat64 = function(offset) {\n  flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1] = this.readInt32(offset);\n  flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);\n  return flatbuffers.float64[0];\n};\n\n/**\n * @param {number} offset\n * @param {number|boolean} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt8 = function(offset, value) {\n  this.bytes_[offset] = /** @type {number} */(value);\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint8 = function(offset, value) {\n  this.bytes_[offset] = value;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt16 = function(offset, value) {\n  this.bytes_[offset] = value;\n  this.bytes_[offset + 1] = value >> 8;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint16 = function(offset, value) {\n    this.bytes_[offset] = value;\n    this.bytes_[offset + 1] = value >> 8;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt32 = function(offset, value) {\n  this.bytes_[offset] = value;\n  this.bytes_[offset + 1] = value >> 8;\n  this.bytes_[offset + 2] = value >> 16;\n  this.bytes_[offset + 3] = value >> 24;\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint32 = function(offset, value) {\n    this.bytes_[offset] = value;\n    this.bytes_[offset + 1] = value >> 8;\n    this.bytes_[offset + 2] = value >> 16;\n    this.bytes_[offset + 3] = value >> 24;\n};\n\n/**\n * @param {number} offset\n * @param {flatbuffers.Long} value\n */\nflatbuffers.ByteBuffer.prototype.writeInt64 = function(offset, value) {\n  this.writeInt32(offset, value.low);\n  this.writeInt32(offset + 4, value.high);\n};\n\n/**\n * @param {number} offset\n * @param {flatbuffers.Long} value\n */\nflatbuffers.ByteBuffer.prototype.writeUint64 = function(offset, value) {\n    this.writeUint32(offset, value.low);\n    this.writeUint32(offset + 4, value.high);\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeFloat32 = function(offset, value) {\n  flatbuffers.float32[0] = value;\n  this.writeInt32(offset, flatbuffers.int32[0]);\n};\n\n/**\n * @param {number} offset\n * @param {number} value\n */\nflatbuffers.ByteBuffer.prototype.writeFloat64 = function(offset, value) {\n  flatbuffers.float64[0] = value;\n  this.writeInt32(offset, flatbuffers.int32[flatbuffers.isLittleEndian ? 0 : 1]);\n  this.writeInt32(offset + 4, flatbuffers.int32[flatbuffers.isLittleEndian ? 1 : 0]);\n};\n\n/**\n * Return the file identifier.   Behavior is undefined for FlatBuffers whose\n * schema does not include a file_identifier (likely points at padding or the\n * start of a the root vtable).\n * @returns {string}\n */\nflatbuffers.ByteBuffer.prototype.getBufferIdentifier = function() {\n  if (this.bytes_.length < this.position_ + flatbuffers.SIZEOF_INT +\n      flatbuffers.FILE_IDENTIFIER_LENGTH) {\n    throw new Error(\n        'FlatBuffers: ByteBuffer is too short to contain an identifier.');\n  }\n  var result = \"\";\n  for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {\n    result += String.fromCharCode(\n        this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i));\n  }\n  return result;\n};\n\n/**\n * Look up a field in the vtable, return an offset into the object, or 0 if the\n * field is not present.\n *\n * @param {number} bb_pos\n * @param {number} vtable_offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__offset = function(bb_pos, vtable_offset) {\n  var vtable = bb_pos - this.readInt32(bb_pos);\n  return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;\n};\n\n/**\n * Initialize any Table-derived type to point to the union at the given offset.\n *\n * @param {flatbuffers.Table} t\n * @param {number} offset\n * @returns {flatbuffers.Table}\n */\nflatbuffers.ByteBuffer.prototype.__union = function(t, offset) {\n  t.bb_pos = offset + this.readInt32(offset);\n  t.bb = this;\n  return t;\n};\n\n/**\n * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.\n * This allocates a new string and converts to wide chars upon each access.\n *\n * To avoid the conversion to UTF-16, pass flatbuffers.Encoding.UTF8_BYTES as\n * the \"optionalEncoding\" argument. This is useful for avoiding conversion to\n * and from UTF-16 when the data will just be packaged back up in another\n * FlatBuffer later on.\n *\n * @param {number} offset\n * @param {flatbuffers.Encoding=} opt_encoding Defaults to UTF16_STRING\n * @returns {string|Uint8Array}\n */\nflatbuffers.ByteBuffer.prototype.__string = function(offset, opt_encoding) {\n  offset += this.readInt32(offset);\n\n  var length = this.readInt32(offset);\n  var result = '';\n  var i = 0;\n\n  offset += flatbuffers.SIZEOF_INT;\n\n  if (opt_encoding === flatbuffers.Encoding.UTF8_BYTES) {\n    return this.bytes_.subarray(offset, offset + length);\n  }\n\n  while (i < length) {\n    var codePoint;\n\n    // Decode UTF-8\n    var a = this.readUint8(offset + i++);\n    if (a < 0xC0) {\n      codePoint = a;\n    } else {\n      var b = this.readUint8(offset + i++);\n      if (a < 0xE0) {\n        codePoint =\n          ((a & 0x1F) << 6) |\n          (b & 0x3F);\n      } else {\n        var c = this.readUint8(offset + i++);\n        if (a < 0xF0) {\n          codePoint =\n            ((a & 0x0F) << 12) |\n            ((b & 0x3F) << 6) |\n            (c & 0x3F);\n        } else {\n          var d = this.readUint8(offset + i++);\n          codePoint =\n            ((a & 0x07) << 18) |\n            ((b & 0x3F) << 12) |\n            ((c & 0x3F) << 6) |\n            (d & 0x3F);\n        }\n      }\n    }\n\n    // Encode UTF-16\n    if (codePoint < 0x10000) {\n      result += String.fromCharCode(codePoint);\n    } else {\n      codePoint -= 0x10000;\n      result += String.fromCharCode(\n        (codePoint >> 10) + 0xD800,\n        (codePoint & ((1 << 10) - 1)) + 0xDC00);\n    }\n  }\n\n  return result;\n};\n\n/**\n * Retrieve the relative offset stored at \"offset\"\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__indirect = function(offset) {\n  return offset + this.readInt32(offset);\n};\n\n/**\n * Get the start of data of a vector whose offset is stored at \"offset\" in this object.\n *\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__vector = function(offset) {\n  return offset + this.readInt32(offset) + flatbuffers.SIZEOF_INT; // data starts after the length\n};\n\n/**\n * Get the length of a vector whose offset is stored at \"offset\" in this object.\n *\n * @param {number} offset\n * @returns {number}\n */\nflatbuffers.ByteBuffer.prototype.__vector_len = function(offset) {\n  return this.readInt32(offset + this.readInt32(offset));\n};\n\n/**\n * @param {string} ident\n * @returns {boolean}\n */\nflatbuffers.ByteBuffer.prototype.__has_identifier = function(ident) {\n  if (ident.length != flatbuffers.FILE_IDENTIFIER_LENGTH) {\n    throw new Error('FlatBuffers: file identifier must be length ' +\n                    flatbuffers.FILE_IDENTIFIER_LENGTH);\n  }\n  for (var i = 0; i < flatbuffers.FILE_IDENTIFIER_LENGTH; i++) {\n    if (ident.charCodeAt(i) != this.readInt8(this.position_ + flatbuffers.SIZEOF_INT + i)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * A helper function to avoid generated code depending on this file directly.\n *\n * @param {number} low\n * @param {number} high\n * @returns {flatbuffers.Long}\n */\nflatbuffers.ByteBuffer.prototype.createLong = function(low, high) {\n  return flatbuffers.Long.create(low, high);\n};\n\n// Exports for Node.js and RequireJS\nexport { flatbuffers };\n\n/// @endcond\n/// @}\n","'use strict';\n\n// This is free and unencumbered software released into the public domain.\n// See LICENSE.md for more information.\n\n//\n// Utilities\n//\n\n/**\n * @param {number} a The number to test.\n * @param {number} min The minimum value in the range, inclusive.\n * @param {number} max The maximum value in the range, inclusive.\n * @return {boolean} True if a >= min and a <= max.\n */\nfunction inRange(a, min, max) {\n  return min <= a && a <= max;\n}\n\n/**\n * @param {*} o\n * @return {Object}\n */\nfunction ToDictionary(o) {\n  if (o === undefined) return {};\n  if (o === Object(o)) return o;\n  throw TypeError('Could not convert argument to dictionary');\n}\n\n/**\n * @param {string} string Input string of UTF-16 code units.\n * @return {!Array.<number>} Code points.\n */\nfunction stringToCodePoints(string) {\n  // https://heycam.github.io/webidl/#dfn-obtain-unicode\n\n  // 1. Let S be the DOMString value.\n  var s = String(string);\n\n  // 2. Let n be the length of S.\n  var n = s.length;\n\n  // 3. Initialize i to 0.\n  var i = 0;\n\n  // 4. Initialize U to be an empty sequence of Unicode characters.\n  var u = [];\n\n  // 5. While i < n:\n  while (i < n) {\n\n    // 1. Let c be the code unit in S at index i.\n    var c = s.charCodeAt(i);\n\n    // 2. Depending on the value of c:\n\n    // c < 0xD800 or c > 0xDFFF\n    if (c < 0xD800 || c > 0xDFFF) {\n      // Append to U the Unicode character with code point c.\n      u.push(c);\n    }\n\n    // 0xDC00 ≤ c ≤ 0xDFFF\n    else if (0xDC00 <= c && c <= 0xDFFF) {\n      // Append to U a U+FFFD REPLACEMENT CHARACTER.\n      u.push(0xFFFD);\n    }\n\n    // 0xD800 ≤ c ≤ 0xDBFF\n    else if (0xD800 <= c && c <= 0xDBFF) {\n      // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT\n      // CHARACTER.\n      if (i === n - 1) {\n        u.push(0xFFFD);\n      }\n      // 2. Otherwise, i < n−1:\n      else {\n        // 1. Let d be the code unit in S at index i+1.\n        var d = string.charCodeAt(i + 1);\n\n        // 2. If 0xDC00 ≤ d ≤ 0xDFFF, then:\n        if (0xDC00 <= d && d <= 0xDFFF) {\n          // 1. Let a be c & 0x3FF.\n          var a = c & 0x3FF;\n\n          // 2. Let b be d & 0x3FF.\n          var b = d & 0x3FF;\n\n          // 3. Append to U the Unicode character with code point\n          // 2^16+2^10*a+b.\n          u.push(0x10000 + (a << 10) + b);\n\n          // 4. Set i to i+1.\n          i += 1;\n        }\n\n        // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a\n        // U+FFFD REPLACEMENT CHARACTER.\n        else  {\n          u.push(0xFFFD);\n        }\n      }\n    }\n\n    // 3. Set i to i+1.\n    i += 1;\n  }\n\n  // 6. Return U.\n  return u;\n}\n\n/**\n * @param {!Array.<number>} code_points Array of code points.\n * @return {string} string String of UTF-16 code units.\n */\nfunction codePointsToString(code_points) {\n  var s = '';\n  for (var i = 0; i < code_points.length; ++i) {\n    var cp = code_points[i];\n    if (cp <= 0xFFFF) {\n      s += String.fromCharCode(cp);\n    } else {\n      cp -= 0x10000;\n      s += String.fromCharCode((cp >> 10) + 0xD800,\n                               (cp & 0x3FF) + 0xDC00);\n    }\n  }\n  return s;\n}\n\n\n//\n// Implementation of Encoding specification\n// https://encoding.spec.whatwg.org/\n//\n\n//\n// 3. Terminology\n//\n\n/**\n * End-of-stream is a special token that signifies no more tokens\n * are in the stream.\n * @const\n */ var end_of_stream = -1;\n\n/**\n * A stream represents an ordered sequence of tokens.\n *\n * @constructor\n * @param {!(Array.<number>|Uint8Array)} tokens Array of tokens that provide the\n * stream.\n */\nfunction Stream(tokens) {\n  /** @type {!Array.<number>} */\n  this.tokens = [].slice.call(tokens);\n}\n\nStream.prototype = {\n  /**\n   * @return {boolean} True if end-of-stream has been hit.\n   */\n  endOfStream: function() {\n    return !this.tokens.length;\n  },\n\n  /**\n   * When a token is read from a stream, the first token in the\n   * stream must be returned and subsequently removed, and\n   * end-of-stream must be returned otherwise.\n   *\n   * @return {number} Get the next token from the stream, or\n   * end_of_stream.\n   */\n   read: function() {\n    if (!this.tokens.length)\n      return end_of_stream;\n     return this.tokens.shift();\n   },\n\n  /**\n   * When one or more tokens are prepended to a stream, those tokens\n   * must be inserted, in given order, before the first token in the\n   * stream.\n   *\n   * @param {(number|!Array.<number>)} token The token(s) to prepend to the stream.\n   */\n  prepend: function(token) {\n    if (Array.isArray(token)) {\n      var tokens = /**@type {!Array.<number>}*/(token);\n      while (tokens.length)\n        this.tokens.unshift(tokens.pop());\n    } else {\n      this.tokens.unshift(token);\n    }\n  },\n\n  /**\n   * When one or more tokens are pushed to a stream, those tokens\n   * must be inserted, in given order, after the last token in the\n   * stream.\n   *\n   * @param {(number|!Array.<number>)} token The tokens(s) to prepend to the stream.\n   */\n  push: function(token) {\n    if (Array.isArray(token)) {\n      var tokens = /**@type {!Array.<number>}*/(token);\n      while (tokens.length)\n        this.tokens.push(tokens.shift());\n    } else {\n      this.tokens.push(token);\n    }\n  }\n};\n\n//\n// 4. Encodings\n//\n\n// 4.1 Encoders and decoders\n\n/** @const */\nvar finished = -1;\n\n/**\n * @param {boolean} fatal If true, decoding errors raise an exception.\n * @param {number=} opt_code_point Override the standard fallback code point.\n * @return {number} The code point to insert on a decoding error.\n */\nfunction decoderError(fatal, opt_code_point) {\n  if (fatal)\n    throw TypeError('Decoder error');\n  return opt_code_point || 0xFFFD;\n}\n\n/** @interface */\nfunction Decoder() {}\nDecoder.prototype = {\n  /**\n   * @param {Stream} stream The stream of bytes being decoded.\n   * @param {number} bite The next byte read from the stream.\n   * @return {?(number|!Array.<number>)} The next code point(s)\n   *     decoded, or null if not enough data exists in the input\n   *     stream to decode a complete code point, or |finished|.\n   */\n  handler: function(stream, bite) {}\n};\n\n/** @interface */\nfunction Encoder() {}\nEncoder.prototype = {\n  /**\n   * @param {Stream} stream The stream of code points being encoded.\n   * @param {number} code_point Next code point read from the stream.\n   * @return {(number|!Array.<number>)} Byte(s) to emit, or |finished|.\n   */\n  handler: function(stream, code_point) {}\n};\n\n//\n// 7. API\n//\n\n/** @const */ var DEFAULT_ENCODING = 'utf-8';\n\n// 7.1 Interface TextDecoder\n\n/**\n * @constructor\n * @param {string=} encoding The label of the encoding;\n *     defaults to 'utf-8'.\n * @param {Object=} options\n */\nfunction TextDecoder(encoding, options) {\n  if (!(this instanceof TextDecoder)) {\n    return new TextDecoder(encoding, options);\n  }\n  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;\n  if (encoding !== DEFAULT_ENCODING) {\n    throw new Error('Encoding not supported. Only utf-8 is supported');\n  }\n  options = ToDictionary(options);\n\n  /** @private @type {boolean} */\n  this._streaming = false;\n  /** @private @type {boolean} */\n  this._BOMseen = false;\n  /** @private @type {?Decoder} */\n  this._decoder = null;\n  /** @private @type {boolean} */\n  this._fatal = Boolean(options['fatal']);\n  /** @private @type {boolean} */\n  this._ignoreBOM = Boolean(options['ignoreBOM']);\n\n  Object.defineProperty(this, 'encoding', {value: 'utf-8'});\n  Object.defineProperty(this, 'fatal', {value: this._fatal});\n  Object.defineProperty(this, 'ignoreBOM', {value: this._ignoreBOM});\n}\n\nTextDecoder.prototype = {\n  /**\n   * @param {ArrayBufferView=} input The buffer of bytes to decode.\n   * @param {Object=} options\n   * @return {string} The decoded string.\n   */\n  decode: function decode(input, options) {\n    var bytes;\n    if (typeof input === 'object' && input instanceof ArrayBuffer) {\n      bytes = new Uint8Array(input);\n    } else if (typeof input === 'object' && 'buffer' in input &&\n               input.buffer instanceof ArrayBuffer) {\n      bytes = new Uint8Array(input.buffer,\n                             input.byteOffset,\n                             input.byteLength);\n    } else {\n      bytes = new Uint8Array(0);\n    }\n\n    options = ToDictionary(options);\n\n    if (!this._streaming) {\n      this._decoder = new UTF8Decoder({fatal: this._fatal});\n      this._BOMseen = false;\n    }\n    this._streaming = Boolean(options['stream']);\n\n    var input_stream = new Stream(bytes);\n\n    var code_points = [];\n\n    /** @type {?(number|!Array.<number>)} */\n    var result;\n\n    while (!input_stream.endOfStream()) {\n      result = this._decoder.handler(input_stream, input_stream.read());\n      if (result === finished)\n        break;\n      if (result === null)\n        continue;\n      if (Array.isArray(result))\n        code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));\n      else\n        code_points.push(result);\n    }\n    if (!this._streaming) {\n      do {\n        result = this._decoder.handler(input_stream, input_stream.read());\n        if (result === finished)\n          break;\n        if (result === null)\n          continue;\n        if (Array.isArray(result))\n          code_points.push.apply(code_points, /**@type {!Array.<number>}*/(result));\n        else\n          code_points.push(result);\n      } while (!input_stream.endOfStream());\n      this._decoder = null;\n    }\n\n    if (code_points.length) {\n      // If encoding is one of utf-8, utf-16be, and utf-16le, and\n      // ignore BOM flag and BOM seen flag are unset, run these\n      // subsubsteps:\n      if (['utf-8'].indexOf(this.encoding) !== -1 &&\n          !this._ignoreBOM && !this._BOMseen) {\n        // If token is U+FEFF, set BOM seen flag.\n        if (code_points[0] === 0xFEFF) {\n          this._BOMseen = true;\n          code_points.shift();\n        } else {\n          // Otherwise, if token is not end-of-stream, set BOM seen\n          // flag and append token to output.\n          this._BOMseen = true;\n        }\n      }\n    }\n\n    return codePointsToString(code_points);\n  }\n};\n\n// 7.2 Interface TextEncoder\n\n/**\n * @constructor\n * @param {string=} encoding The label of the encoding;\n *     defaults to 'utf-8'.\n * @param {Object=} options\n */\nfunction TextEncoder(encoding, options) {\n  if (!(this instanceof TextEncoder))\n    return new TextEncoder(encoding, options);\n  encoding = encoding !== undefined ? String(encoding).toLowerCase() : DEFAULT_ENCODING;\n  if (encoding !== DEFAULT_ENCODING) {\n    throw new Error('Encoding not supported. Only utf-8 is supported');\n  }\n  options = ToDictionary(options);\n\n  /** @private @type {boolean} */\n  this._streaming = false;\n  /** @private @type {?Encoder} */\n  this._encoder = null;\n  /** @private @type {{fatal: boolean}} */\n  this._options = {fatal: Boolean(options['fatal'])};\n\n  Object.defineProperty(this, 'encoding', {value: 'utf-8'});\n}\n\nTextEncoder.prototype = {\n  /**\n   * @param {string=} opt_string The string to encode.\n   * @param {Object=} options\n   * @return {Uint8Array} Encoded bytes, as a Uint8Array.\n   */\n  encode: function encode(opt_string, options) {\n    opt_string = opt_string ? String(opt_string) : '';\n    options = ToDictionary(options);\n\n    // NOTE: This option is nonstandard. None of the encodings\n    // permitted for encoding (i.e. UTF-8, UTF-16) are stateful,\n    // so streaming is not necessary.\n    if (!this._streaming)\n      this._encoder = new UTF8Encoder(this._options);\n    this._streaming = Boolean(options['stream']);\n\n    var bytes = [];\n    var input_stream = new Stream(stringToCodePoints(opt_string));\n    /** @type {?(number|!Array.<number>)} */\n    var result;\n    while (!input_stream.endOfStream()) {\n      result = this._encoder.handler(input_stream, input_stream.read());\n      if (result === finished)\n        break;\n      if (Array.isArray(result))\n        bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));\n      else\n        bytes.push(result);\n    }\n    if (!this._streaming) {\n      while (true) {\n        result = this._encoder.handler(input_stream, input_stream.read());\n        if (result === finished)\n          break;\n        if (Array.isArray(result))\n          bytes.push.apply(bytes, /**@type {!Array.<number>}*/(result));\n        else\n          bytes.push(result);\n      }\n      this._encoder = null;\n    }\n    return new Uint8Array(bytes);\n  }\n};\n\n//\n// 8. The encoding\n//\n\n// 8.1 utf-8\n\n/**\n * @constructor\n * @implements {Decoder}\n * @param {{fatal: boolean}} options\n */\nfunction UTF8Decoder(options) {\n  var fatal = options.fatal;\n\n  // utf-8's decoder's has an associated utf-8 code point, utf-8\n  // bytes seen, and utf-8 bytes needed (all initially 0), a utf-8\n  // lower boundary (initially 0x80), and a utf-8 upper boundary\n  // (initially 0xBF).\n  var /** @type {number} */ utf8_code_point = 0,\n      /** @type {number} */ utf8_bytes_seen = 0,\n      /** @type {number} */ utf8_bytes_needed = 0,\n      /** @type {number} */ utf8_lower_boundary = 0x80,\n      /** @type {number} */ utf8_upper_boundary = 0xBF;\n\n  /**\n   * @param {Stream} stream The stream of bytes being decoded.\n   * @param {number} bite The next byte read from the stream.\n   * @return {?(number|!Array.<number>)} The next code point(s)\n   *     decoded, or null if not enough data exists in the input\n   *     stream to decode a complete code point.\n   */\n  this.handler = function(stream, bite) {\n    // 1. If byte is end-of-stream and utf-8 bytes needed is not 0,\n    // set utf-8 bytes needed to 0 and return error.\n    if (bite === end_of_stream && utf8_bytes_needed !== 0) {\n      utf8_bytes_needed = 0;\n      return decoderError(fatal);\n    }\n\n    // 2. If byte is end-of-stream, return finished.\n    if (bite === end_of_stream)\n      return finished;\n\n    // 3. If utf-8 bytes needed is 0, based on byte:\n    if (utf8_bytes_needed === 0) {\n\n      // 0x00 to 0x7F\n      if (inRange(bite, 0x00, 0x7F)) {\n        // Return a code point whose value is byte.\n        return bite;\n      }\n\n      // 0xC2 to 0xDF\n      if (inRange(bite, 0xC2, 0xDF)) {\n        // Set utf-8 bytes needed to 1 and utf-8 code point to byte\n        // − 0xC0.\n        utf8_bytes_needed = 1;\n        utf8_code_point = bite - 0xC0;\n      }\n\n      // 0xE0 to 0xEF\n      else if (inRange(bite, 0xE0, 0xEF)) {\n        // 1. If byte is 0xE0, set utf-8 lower boundary to 0xA0.\n        if (bite === 0xE0)\n          utf8_lower_boundary = 0xA0;\n        // 2. If byte is 0xED, set utf-8 upper boundary to 0x9F.\n        if (bite === 0xED)\n          utf8_upper_boundary = 0x9F;\n        // 3. Set utf-8 bytes needed to 2 and utf-8 code point to\n        // byte − 0xE0.\n        utf8_bytes_needed = 2;\n        utf8_code_point = bite - 0xE0;\n      }\n\n      // 0xF0 to 0xF4\n      else if (inRange(bite, 0xF0, 0xF4)) {\n        // 1. If byte is 0xF0, set utf-8 lower boundary to 0x90.\n        if (bite === 0xF0)\n          utf8_lower_boundary = 0x90;\n        // 2. If byte is 0xF4, set utf-8 upper boundary to 0x8F.\n        if (bite === 0xF4)\n          utf8_upper_boundary = 0x8F;\n        // 3. Set utf-8 bytes needed to 3 and utf-8 code point to\n        // byte − 0xF0.\n        utf8_bytes_needed = 3;\n        utf8_code_point = bite - 0xF0;\n      }\n\n      // Otherwise\n      else {\n        // Return error.\n        return decoderError(fatal);\n      }\n\n      // Then (byte is in the range 0xC2 to 0xF4) set utf-8 code\n      // point to utf-8 code point << (6 × utf-8 bytes needed) and\n      // return continue.\n      utf8_code_point = utf8_code_point << (6 * utf8_bytes_needed);\n      return null;\n    }\n\n    // 4. If byte is not in the range utf-8 lower boundary to utf-8\n    // upper boundary, run these substeps:\n    if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {\n\n      // 1. Set utf-8 code point, utf-8 bytes needed, and utf-8\n      // bytes seen to 0, set utf-8 lower boundary to 0x80, and set\n      // utf-8 upper boundary to 0xBF.\n      utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;\n      utf8_lower_boundary = 0x80;\n      utf8_upper_boundary = 0xBF;\n\n      // 2. Prepend byte to stream.\n      stream.prepend(bite);\n\n      // 3. Return error.\n      return decoderError(fatal);\n    }\n\n    // 5. Set utf-8 lower boundary to 0x80 and utf-8 upper boundary\n    // to 0xBF.\n    utf8_lower_boundary = 0x80;\n    utf8_upper_boundary = 0xBF;\n\n    // 6. Increase utf-8 bytes seen by one and set utf-8 code point\n    // to utf-8 code point + (byte − 0x80) << (6 × (utf-8 bytes\n    // needed − utf-8 bytes seen)).\n    utf8_bytes_seen += 1;\n    utf8_code_point += (bite - 0x80) << (6 * (utf8_bytes_needed - utf8_bytes_seen));\n\n    // 7. If utf-8 bytes seen is not equal to utf-8 bytes needed,\n    // continue.\n    if (utf8_bytes_seen !== utf8_bytes_needed)\n      return null;\n\n    // 8. Let code point be utf-8 code point.\n    var code_point = utf8_code_point;\n\n    // 9. Set utf-8 code point, utf-8 bytes needed, and utf-8 bytes\n    // seen to 0.\n    utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;\n\n    // 10. Return a code point whose value is code point.\n    return code_point;\n  };\n}\n\n/**\n * @constructor\n * @implements {Encoder}\n * @param {{fatal: boolean}} options\n */\nfunction UTF8Encoder(options) {\n  var fatal = options.fatal;\n  /**\n   * @param {Stream} stream Input stream.\n   * @param {number} code_point Next code point read from the stream.\n   * @return {(number|!Array.<number>)} Byte(s) to emit.\n   */\n  this.handler = function(stream, code_point) {\n    // 1. If code point is end-of-stream, return finished.\n    if (code_point === end_of_stream)\n      return finished;\n\n    // 2. If code point is in the range U+0000 to U+007F, return a\n    // byte whose value is code point.\n    if (inRange(code_point, 0x0000, 0x007f))\n      return code_point;\n\n    // 3. Set count and offset based on the range code point is in:\n    var count, offset;\n    // U+0080 to U+07FF:    1 and 0xC0\n    if (inRange(code_point, 0x0080, 0x07FF)) {\n      count = 1;\n      offset = 0xC0;\n    }\n    // U+0800 to U+FFFF:    2 and 0xE0\n    else if (inRange(code_point, 0x0800, 0xFFFF)) {\n      count = 2;\n      offset = 0xE0;\n    }\n    // U+10000 to U+10FFFF: 3 and 0xF0\n    else if (inRange(code_point, 0x10000, 0x10FFFF)) {\n      count = 3;\n      offset = 0xF0;\n    }\n\n    // 4.Let bytes be a byte sequence whose first byte is (code\n    // point >> (6 × count)) + offset.\n    var bytes = [(code_point >> (6 * count)) + offset];\n\n    // 5. Run these substeps while count is greater than 0:\n    while (count > 0) {\n\n      // 1. Set temp to code point >> (6 × (count − 1)).\n      var temp = code_point >> (6 * (count - 1));\n\n      // 2. Append to bytes 0x80 | (temp & 0x3F).\n      bytes.push(0x80 | (temp & 0x3F));\n\n      // 3. Decrease count by one.\n      count -= 1;\n    }\n\n    // 6. Return bytes bytes, in order.\n    return bytes;\n  };\n}\n\nexport {TextEncoder, TextDecoder};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { toUint8Array } from './buffer';\nimport {\n    TextDecoder as TextDecoderPolyfill,\n    TextEncoder as TextEncoderPolyfill,\n} from 'text-encoding-utf-8';\n\n/** @ignore @suppress {missingRequire} */\nconst _Buffer = typeof Buffer === 'function' ? Buffer : null;\n/** @ignore */\nconst useNativeEncoders = typeof TextDecoder === 'function' && typeof TextEncoder === 'function';\n\n/** @ignore */\nexport const decodeUtf8 = ((TextDecoder) => {\n    if (useNativeEncoders || !_Buffer) {\n        const decoder = new TextDecoder('utf-8');\n        return (buffer?: ArrayBuffer | ArrayBufferView) => decoder.decode(buffer);\n    }\n    return (input: ArrayBufferLike | ArrayBufferView) => {\n        const { buffer, byteOffset, length } = toUint8Array(input);\n        return _Buffer.from(buffer, byteOffset, length).toString();\n    };\n})(typeof TextDecoder !== 'undefined' ? TextDecoder : TextDecoderPolyfill);\n\n/** @ignore */\nexport const encodeUtf8 = ((TextEncoder) => {\n    if (useNativeEncoders || !_Buffer) {\n        const encoder = new TextEncoder();\n        return (value?: string) => encoder.encode(value);\n    }\n    return (input = '') => toUint8Array(_Buffer.from(input, 'utf8'));\n})(typeof TextEncoder !== 'undefined' ? TextEncoder : TextEncoderPolyfill);\n","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  Object.defineProperty(subClass, \"prototype\", {\n    value: Object.create(superClass && superClass.prototype, {\n      constructor: {\n        value: subClass,\n        writable: true,\n        configurable: true\n      }\n    }),\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","export default function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}","export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}","import _typeof from \"@babel/runtime/helpers/typeof\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n\n  return assertThisInitialized(self);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nimport possibleConstructorReturn from \"./possibleConstructorReturn.js\";\nexport default function _createSuper(Derived) {\n  var hasNativeReflectConstruct = isNativeReflectConstruct();\n  return function _createSuperInternal() {\n    var Super = getPrototypeOf(Derived),\n        result;\n\n    if (hasNativeReflectConstruct) {\n      var NewTarget = getPrototypeOf(this).constructor;\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n\n    return possibleConstructorReturn(this, result);\n  };\n}","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport streamAdapters from './adapters';\n\n/** @ignore */\nexport const ITERATOR_DONE: any = Object.freeze({ done: true, value: void (0) });\n\n/** @ignore */\nexport type FileHandle = import('fs').promises.FileHandle;\n/** @ignore */\nexport type ArrowJSONLike = { schema: any; batches?: any[]; dictionaries?: any[]; };\n/** @ignore */\nexport type ReadableDOMStreamOptions = { type: 'bytes' | undefined, autoAllocateChunkSize?: number, highWaterMark?: number };\n\n/** @ignore */\nexport class ArrowJSON {\n    // @ts-ignore\n    constructor(private _json: ArrowJSONLike) {}\n    public get schema(): any { return this._json['schema']; }\n    public get batches(): any[] { return (this._json['batches'] || []) as any[]; }\n    public get dictionaries(): any[] { return (this._json['dictionaries'] || []) as any[]; }\n}\n\n/** @ignore */\nexport interface Readable<T> {\n\n    readonly closed: Promise<void>;\n    cancel(reason?: any): Promise<void>;\n\n    read(size?: number | null): Promise<T | null>;\n    peek(size?: number | null): Promise<T | null>;\n    throw(value?: any): Promise<IteratorResult<any>>;\n    return(value?: any): Promise<IteratorResult<any>>;\n    next(size?: number | null): Promise<IteratorResult<T>>;\n}\n\n/** @ignore */\nexport interface Writable<T> {\n    readonly closed: Promise<void>;\n    close(): void;\n    write(chunk: T): void;\n    abort(reason?: any): void;\n}\n\n/** @ignore */\nexport interface ReadableWritable<TReadable, TWritable> extends Readable<TReadable>, Writable<TWritable> {\n    [Symbol.asyncIterator](): AsyncIterableIterator<TReadable>;\n    toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<TReadable>;\n    toNodeStream(options?: import('stream').ReadableOptions): import('stream').Readable;\n}\n\n/** @ignore */\nexport abstract class ReadableInterop<T> {\n\n    public abstract toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<T>;\n    public abstract toNodeStream(options?: import('stream').ReadableOptions): import('stream').Readable;\n\n    public tee(): [ReadableStream<T>, ReadableStream<T>] {\n        return this._getDOMStream().tee();\n    }\n    public pipe<R extends NodeJS.WritableStream>(writable: R, options?: { end?: boolean; }) {\n        return this._getNodeStream().pipe(writable, options);\n    }\n    public pipeTo(writable: WritableStream<T>, options?: PipeOptions) { return this._getDOMStream().pipeTo(writable, options); }\n    public pipeThrough<R extends ReadableStream<any>>(duplex: { writable: WritableStream<T>, readable: R }, options?: PipeOptions) {\n        return this._getDOMStream().pipeThrough(duplex, options);\n    }\n\n    protected _DOMStream?: ReadableStream<T>;\n    private _getDOMStream() {\n        return this._DOMStream || (this._DOMStream = this.toDOMStream());\n    }\n\n    protected _nodeStream?: import('stream').Readable;\n    private _getNodeStream() {\n        return this._nodeStream || (this._nodeStream = this.toNodeStream());\n    }\n}\n\n/** @ignore */\ntype Resolution<T> = { resolve: (value?: T | PromiseLike<T>) => void; reject: (reason?: any) => void; };\n\n/** @ignore */\nexport class AsyncQueue<TReadable = Uint8Array, TWritable = TReadable> extends ReadableInterop<TReadable>\n    implements AsyncIterableIterator<TReadable>, ReadableWritable<TReadable, TWritable> {\n\n    protected _values: TWritable[] = [];\n    protected _error?: { error: any; };\n    protected _closedPromise: Promise<void>;\n    protected _closedPromiseResolve?: (value?: any) => void;\n    protected resolvers: Resolution<IteratorResult<TReadable>>[] = [];\n\n    constructor() {\n        super();\n        this._closedPromise = new Promise((r) => this._closedPromiseResolve = r);\n    }\n\n    public get closed(): Promise<void> { return this._closedPromise; }\n    public async cancel(reason?: any) { await this.return(reason); }\n    public write(value: TWritable) {\n        if (this._ensureOpen()) {\n            this.resolvers.length <= 0\n                ? (this._values.push(value))\n                : (this.resolvers.shift()!.resolve({ done: false, value } as any));\n        }\n    }\n    public abort(value?: any) {\n        if (this._closedPromiseResolve) {\n            this.resolvers.length <= 0\n                ? (this._error = { error: value })\n                : (this.resolvers.shift()!.reject({ done: true, value }));\n        }\n    }\n    public close() {\n        if (this._closedPromiseResolve) {\n            const { resolvers } = this;\n            while (resolvers.length > 0) {\n                resolvers.shift()!.resolve(ITERATOR_DONE);\n            }\n            this._closedPromiseResolve();\n            this._closedPromiseResolve = undefined;\n        }\n    }\n\n    public [Symbol.asyncIterator]() { return this; }\n    public toDOMStream(options?: ReadableDOMStreamOptions) {\n        return streamAdapters.toDOMStream(\n            (this._closedPromiseResolve || this._error)\n                ? (this as AsyncIterable<TReadable>)\n                : (this._values as any) as Iterable<TReadable>,\n            options);\n    }\n    public toNodeStream(options?: import('stream').ReadableOptions) {\n        return streamAdapters.toNodeStream(\n            (this._closedPromiseResolve || this._error)\n                ? (this as AsyncIterable<TReadable>)\n                : (this._values as any) as Iterable<TReadable>,\n            options);\n    }\n    public async throw(_?: any) { await this.abort(_); return ITERATOR_DONE; }\n    public async return(_?: any) { await this.close(); return ITERATOR_DONE; }\n\n    public async read(size?: number | null): Promise<TReadable | null> { return (await this.next(size, 'read')).value; }\n    public async peek(size?: number | null): Promise<TReadable | null> { return (await this.next(size, 'peek')).value; }\n    public next(..._args: any[]): Promise<IteratorResult<TReadable>> {\n        if (this._values.length > 0) {\n            return Promise.resolve({ done: false, value: this._values.shift()! } as any);\n        } else if (this._error) {\n            return Promise.reject({ done: true, value: this._error.error });\n        } else if (!this._closedPromiseResolve) {\n            return Promise.resolve(ITERATOR_DONE);\n        } else {\n            return new Promise<IteratorResult<TReadable>>((resolve, reject) => {\n                this.resolvers.push({ resolve, reject });\n            });\n        }\n    }\n\n    protected _ensureOpen() {\n        if (this._closedPromiseResolve) {\n            return true;\n        }\n        throw new Error(`${this} is closed`);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { ReadableInterop, ArrowJSONLike } from '../io/interfaces';\n\n/** @ignore */\ntype FSReadStream = import('fs').ReadStream;\n/** @ignore */\ntype FileHandle = import('fs').promises.FileHandle;\n\n/** @ignore */\nexport interface Subscription {\n    unsubscribe: () => void;\n}\n\n/** @ignore */\nexport interface Observer<T> {\n    closed?: boolean;\n    next: (value: T) => void;\n    error: (err: any) => void;\n    complete: () => void;\n}\n\n/** @ignore */\nexport interface Observable<T> {\n    subscribe: (observer: Observer<T>) => Subscription;\n}\n\n/** @ignore */\nconst [BigIntCtor, BigIntAvailable] = (() => {\n    const BigIntUnavailableError = () => { throw new Error('BigInt is not available in this environment'); };\n    function BigIntUnavailable() { throw BigIntUnavailableError(); }\n    BigIntUnavailable.asIntN = () => { throw BigIntUnavailableError(); };\n    BigIntUnavailable.asUintN = () => { throw BigIntUnavailableError(); };\n    return typeof BigInt !== 'undefined' ? [BigInt, true] : [<any> BigIntUnavailable, false];\n})() as [BigIntConstructor, boolean];\n\n/** @ignore */\nconst [BigInt64ArrayCtor, BigInt64ArrayAvailable] = (() => {\n    const BigInt64ArrayUnavailableError = () => { throw new Error('BigInt64Array is not available in this environment'); };\n    class BigInt64ArrayUnavailable {\n        static get BYTES_PER_ELEMENT() { return 8; }\n        static of() { throw BigInt64ArrayUnavailableError(); }\n        static from() { throw BigInt64ArrayUnavailableError(); }\n        constructor() { throw BigInt64ArrayUnavailableError(); }\n    }\n    return typeof BigInt64Array !== 'undefined' ? [BigInt64Array, true] : [<any> BigInt64ArrayUnavailable, false];\n})() as [BigInt64ArrayConstructor, boolean];\n\n/** @ignore */\nconst [BigUint64ArrayCtor, BigUint64ArrayAvailable] = (() => {\n    const BigUint64ArrayUnavailableError = () => { throw new Error('BigUint64Array is not available in this environment'); };\n    class BigUint64ArrayUnavailable {\n        static get BYTES_PER_ELEMENT() { return 8; }\n        static of() { throw BigUint64ArrayUnavailableError(); }\n        static from() { throw BigUint64ArrayUnavailableError(); }\n        constructor() { throw BigUint64ArrayUnavailableError(); }\n    }\n    return typeof BigUint64Array !== 'undefined' ? [BigUint64Array, true] : [<any> BigUint64ArrayUnavailable, false];\n})() as [BigUint64ArrayConstructor, boolean];\n\nexport { BigIntCtor as BigInt, BigIntAvailable };\nexport { BigInt64ArrayCtor as BigInt64Array, BigInt64ArrayAvailable };\nexport { BigUint64ArrayCtor as BigUint64Array, BigUint64ArrayAvailable };\n\n/** @ignore */ const isNumber = (x: any) => typeof x === 'number';\n/** @ignore */ const isBoolean = (x: any) => typeof x === 'boolean';\n/** @ignore */ const isFunction = (x: any) => typeof x === 'function';\n/** @ignore */\nexport const isObject = (x: any): x is Object => x != null && Object(x) === x;\n\n/** @ignore */\nexport const isPromise = <T = any>(x: any): x is PromiseLike<T> => {\n    return isObject(x) && isFunction(x.then);\n};\n\n/** @ignore */\nexport const isObservable = <T = any>(x: any): x is Observable<T> => {\n    return isObject(x) && isFunction(x.subscribe);\n};\n\n/** @ignore */\nexport const isIterable = <T = any>(x: any): x is Iterable<T> => {\n    return isObject(x) && isFunction(x[Symbol.iterator]);\n};\n\n/** @ignore */\nexport const isAsyncIterable = <T = any>(x: any): x is AsyncIterable<T> => {\n    return isObject(x) && isFunction(x[Symbol.asyncIterator]);\n};\n\n/** @ignore */\nexport const isArrowJSON = (x: any): x is ArrowJSONLike  => {\n    return isObject(x) && isObject(x['schema']);\n};\n\n/** @ignore */\nexport const isArrayLike = <T = any>(x: any): x is ArrayLike<T> => {\n    return isObject(x) && isNumber(x['length']);\n};\n\n/** @ignore */\nexport const isIteratorResult = <T = any>(x: any): x is IteratorResult<T> => {\n    return isObject(x) && ('done' in x) && ('value' in x);\n};\n\n/** @ignore */\nexport const isUnderlyingSink = <T = any>(x: any): x is UnderlyingSink<T> => {\n    return isObject(x) &&\n        isFunction(x['abort']) &&\n        isFunction(x['close']) &&\n        isFunction(x['start']) &&\n        isFunction(x['write']);\n};\n\n/** @ignore */\nexport const isFileHandle = (x: any): x is FileHandle => {\n    return isObject(x) && isFunction(x['stat']) && isNumber(x['fd']);\n};\n\n/** @ignore */\nexport const isFSReadStream = (x: any): x is FSReadStream => {\n    return isReadableNodeStream(x) && isNumber((<any> x)['bytesRead']);\n};\n\n/** @ignore */\nexport const isFetchResponse = (x: any): x is Response => {\n    return isObject(x) && isReadableDOMStream(x['body']);\n};\n\n/** @ignore */\nexport const isWritableDOMStream = <T = any>(x: any): x is WritableStream<T> => {\n    return isObject(x) &&\n        isFunction(x['abort']) &&\n        isFunction(x['getWriter']) &&\n        !(x instanceof ReadableInterop);\n};\n\n/** @ignore */\nexport const isReadableDOMStream = <T = any>(x: any): x is ReadableStream<T> => {\n    return isObject(x) &&\n        isFunction(x['cancel']) &&\n        isFunction(x['getReader']) &&\n        !(x instanceof ReadableInterop);\n};\n\n/** @ignore */\nexport const isWritableNodeStream = (x: any): x is NodeJS.WritableStream => {\n    return isObject(x) &&\n        isFunction(x['end']) &&\n        isFunction(x['write']) &&\n        isBoolean(x['writable']) &&\n        !(x instanceof ReadableInterop);\n};\n\n/** @ignore */\nexport const isReadableNodeStream = (x: any): x is NodeJS.ReadableStream => {\n    return isObject(x) &&\n        isFunction(x['read']) &&\n        isFunction(x['pipe']) &&\n        isBoolean(x['readable']) &&\n        !(x instanceof ReadableInterop);\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { flatbuffers } from 'flatbuffers';\nimport { encodeUtf8 } from '../util/utf8';\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport { TypedArray, TypedArrayConstructor } from '../interfaces';\nimport { BigIntArray, BigIntArrayConstructor } from '../interfaces';\nimport { isPromise, isIterable, isAsyncIterable, isIteratorResult, BigInt64Array, BigUint64Array } from './compat';\n\n/** @ignore */\nconst SharedArrayBuf = (typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : ArrayBuffer);\n\n/** @ignore */\nfunction collapseContiguousByteRanges(chunks: Uint8Array[]) {\n    let result = chunks[0] ? [chunks[0]] : [];\n    let xOffset: number, yOffset: number, xLen: number, yLen: number;\n    for (let x, y, i = 0, j = 0, n = chunks.length; ++i < n;) {\n        x = result[j];\n        y = chunks[i];\n        // continue if x and y don't share the same underlying ArrayBuffer, or if x isn't before y\n        if (!x || !y || x.buffer !== y.buffer || y.byteOffset < x.byteOffset) {\n            y && (result[++j] = y);\n            continue;\n        }\n        ({ byteOffset: xOffset, byteLength: xLen } = x);\n        ({ byteOffset: yOffset, byteLength: yLen } = y);\n        // continue if the byte ranges of x and y aren't contiguous\n        if ((xOffset + xLen) < yOffset || (yOffset + yLen) < xOffset) {\n            y && (result[++j] = y);\n            continue;\n        }\n        result[j] = new Uint8Array(x.buffer, xOffset, yOffset - xOffset + yLen);\n    }\n    return result;\n}\n\n/** @ignore */\nexport function memcpy<TTarget extends ArrayBufferView, TSource extends ArrayBufferView>(target: TTarget, source: TSource, targetByteOffset = 0, sourceByteLength = source.byteLength) {\n    const targetByteLength = target.byteLength;\n    const dst = new Uint8Array(target.buffer, target.byteOffset, targetByteLength);\n    const src = new Uint8Array(source.buffer, source.byteOffset, Math.min(sourceByteLength, targetByteLength));\n    dst.set(src, targetByteOffset);\n    return target;\n}\n\n/** @ignore */\nexport function joinUint8Arrays(chunks: Uint8Array[], size?: number | null): [Uint8Array, Uint8Array[], number] {\n    // collapse chunks that share the same underlying ArrayBuffer and whose byte ranges overlap,\n    // to avoid unnecessarily copying the bytes to do this buffer join. This is a common case during\n    // streaming, where we may be reading partial byte ranges out of the same underlying ArrayBuffer\n    let result = collapseContiguousByteRanges(chunks);\n    let byteLength = result.reduce((x, b) => x + b.byteLength, 0);\n    let source: Uint8Array, sliced: Uint8Array, buffer: Uint8Array | void;\n    let offset = 0, index = -1, length = Math.min(size || Infinity, byteLength);\n    for (let n = result.length; ++index < n;) {\n        source = result[index];\n        sliced = source.subarray(0, Math.min(source.length, length - offset));\n        if (length <= (offset + sliced.length)) {\n            if (sliced.length < source.length) {\n                result[index] = source.subarray(sliced.length);\n            } else if (sliced.length === source.length) { index++; }\n            buffer ? memcpy(buffer, sliced, offset) : (buffer = sliced);\n            break;\n        }\n        memcpy(buffer || (buffer = new Uint8Array(length)), sliced, offset);\n        offset += sliced.length;\n    }\n    return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];\n}\n\n/** @ignore */\nexport type ArrayBufferViewInput = ArrayBufferView | ArrayBufferLike | ArrayBufferView | Iterable<number> | ArrayLike<number> | ByteBuffer | string | null | undefined  |\n                    IteratorResult<ArrayBufferView | ArrayBufferLike | ArrayBufferView | Iterable<number> | ArrayLike<number> | ByteBuffer | string | null | undefined> |\n          ReadableStreamReadResult<ArrayBufferView | ArrayBufferLike | ArrayBufferView | Iterable<number> | ArrayLike<number> | ByteBuffer | string | null | undefined> ;\n\n/** @ignore */\nexport function toArrayBufferView<T extends TypedArray>(ArrayBufferViewCtor: TypedArrayConstructor<T>, input: ArrayBufferViewInput): T;\nexport function toArrayBufferView<T extends BigIntArray>(ArrayBufferViewCtor: BigIntArrayConstructor<T>, input: ArrayBufferViewInput): T;\nexport function toArrayBufferView(ArrayBufferViewCtor: any, input: ArrayBufferViewInput) {\n\n    let value: any = isIteratorResult(input) ? input.value : input;\n\n    if (value instanceof ArrayBufferViewCtor) {\n        if (ArrayBufferViewCtor === Uint8Array) {\n            // Node's `Buffer` class passes the `instanceof Uint8Array` check, but we need\n            // a real Uint8Array, since Buffer#slice isn't the same as Uint8Array#slice :/\n            return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);\n        }\n        return value;\n    }\n    if (!value) { return new ArrayBufferViewCtor(0); }\n    if (typeof value === 'string') { value = encodeUtf8(value); }\n    if (value instanceof ArrayBuffer) { return new ArrayBufferViewCtor(value); }\n    if (value instanceof SharedArrayBuf) { return new ArrayBufferViewCtor(value); }\n    if (value instanceof ByteBuffer) { return toArrayBufferView(ArrayBufferViewCtor, value.bytes()); }\n    return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0)\n        : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);\n}\n\n/** @ignore */ export const toInt8Array = (input: ArrayBufferViewInput) => toArrayBufferView(Int8Array, input);\n/** @ignore */ export const toInt16Array = (input: ArrayBufferViewInput) => toArrayBufferView(Int16Array, input);\n/** @ignore */ export const toInt32Array = (input: ArrayBufferViewInput) => toArrayBufferView(Int32Array, input);\n/** @ignore */ export const toBigInt64Array = (input: ArrayBufferViewInput) => toArrayBufferView(BigInt64Array, input);\n/** @ignore */ export const toUint8Array = (input: ArrayBufferViewInput) => toArrayBufferView(Uint8Array, input);\n/** @ignore */ export const toUint16Array = (input: ArrayBufferViewInput) => toArrayBufferView(Uint16Array, input);\n/** @ignore */ export const toUint32Array = (input: ArrayBufferViewInput) => toArrayBufferView(Uint32Array, input);\n/** @ignore */ export const toBigUint64Array = (input: ArrayBufferViewInput) => toArrayBufferView(BigUint64Array, input);\n/** @ignore */ export const toFloat32Array = (input: ArrayBufferViewInput) => toArrayBufferView(Float32Array, input);\n/** @ignore */ export const toFloat64Array = (input: ArrayBufferViewInput) => toArrayBufferView(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArray = (input: ArrayBufferViewInput) => toArrayBufferView(Uint8ClampedArray, input);\n\n/** @ignore */\ntype ArrayBufferViewIteratorInput = Iterable<ArrayBufferViewInput> | ArrayBufferViewInput;\n\n/** @ignore */\nconst pump = <T extends Iterator<any> | AsyncIterator<any>>(iterator: T) => { iterator.next(); return iterator; };\n\n/** @ignore */\nexport function* toArrayBufferViewIterator<T extends TypedArray>(ArrayCtor: TypedArrayConstructor<T>, source: ArrayBufferViewIteratorInput) {\n\n    const wrap = function*<T>(x: T) { yield x; };\n    const buffers: Iterable<ArrayBufferViewInput> =\n                   (typeof source === 'string') ? wrap(source)\n                 : (ArrayBuffer.isView(source)) ? wrap(source)\n              : (source instanceof ArrayBuffer) ? wrap(source)\n           : (source instanceof SharedArrayBuf) ? wrap(source)\n    : !isIterable<ArrayBufferViewInput>(source) ? wrap(source) : source;\n\n    yield* pump((function* (it) {\n        let r: IteratorResult<any> = <any> null;\n        do {\n            r = it.next(yield toArrayBufferView(ArrayCtor, r));\n        } while (!r.done);\n    })(buffers[Symbol.iterator]()));\n}\n\n/** @ignore */ export const toInt8ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Int8Array, input);\n/** @ignore */ export const toInt16ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Int16Array, input);\n/** @ignore */ export const toInt32ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Int32Array, input);\n/** @ignore */ export const toUint8ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint8Array, input);\n/** @ignore */ export const toUint16ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint16Array, input);\n/** @ignore */ export const toUint32ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint32Array, input);\n/** @ignore */ export const toFloat32ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Float32Array, input);\n/** @ignore */ export const toFloat64ArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArrayIterator = (input: ArrayBufferViewIteratorInput) => toArrayBufferViewIterator(Uint8ClampedArray, input);\n\n/** @ignore */\ntype ArrayBufferViewAsyncIteratorInput = AsyncIterable<ArrayBufferViewInput> | Iterable<ArrayBufferViewInput> | PromiseLike<ArrayBufferViewInput> | ArrayBufferViewInput;\n\n/** @ignore */\nexport async function* toArrayBufferViewAsyncIterator<T extends TypedArray>(ArrayCtor: TypedArrayConstructor<T>, source: ArrayBufferViewAsyncIteratorInput): AsyncIterableIterator<T> {\n\n    // if a Promise, unwrap the Promise and iterate the resolved value\n    if (isPromise<ArrayBufferViewInput>(source)) {\n        return yield* toArrayBufferViewAsyncIterator(ArrayCtor, await source);\n    }\n\n    const wrap = async function*<T>(x: T) { yield await x; };\n    const emit = async function* <T extends Iterable<any>>(source: T) {\n        yield* pump((function*(it: Iterator<any>) {\n            let r: IteratorResult<any> = <any> null;\n            do {\n                r = it.next(yield r && r.value);\n            } while (!r.done);\n        })(source[Symbol.iterator]()));\n    };\n\n    const buffers: AsyncIterable<ArrayBufferViewInput> =\n                        (typeof source === 'string') ? wrap(source) // if string, wrap in an AsyncIterableIterator\n                      : (ArrayBuffer.isView(source)) ? wrap(source) // if TypedArray, wrap in an AsyncIterableIterator\n                   : (source instanceof ArrayBuffer) ? wrap(source) // if ArrayBuffer, wrap in an AsyncIterableIterator\n                : (source instanceof SharedArrayBuf) ? wrap(source) // if SharedArrayBuffer, wrap in an AsyncIterableIterator\n          : isIterable<ArrayBufferViewInput>(source) ? emit(source) // If Iterable, wrap in an AsyncIterableIterator and compose the `next` values\n    : !isAsyncIterable<ArrayBufferViewInput>(source) ? wrap(source) // If not an AsyncIterable, treat as a sentinel and wrap in an AsyncIterableIterator\n                                                     : source; // otherwise if AsyncIterable, use it\n\n    yield* pump((async function* (it) {\n        let r: IteratorResult<any> = <any> null;\n        do {\n            r = await it.next(yield toArrayBufferView(ArrayCtor, r));\n        } while (!r.done);\n    })(buffers[Symbol.asyncIterator]()));\n}\n\n/** @ignore */ export const toInt8ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Int8Array, input);\n/** @ignore */ export const toInt16ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Int16Array, input);\n/** @ignore */ export const toInt32ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Int32Array, input);\n/** @ignore */ export const toUint8ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint8Array, input);\n/** @ignore */ export const toUint16ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint16Array, input);\n/** @ignore */ export const toUint32ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint32Array, input);\n/** @ignore */ export const toFloat32ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Float32Array, input);\n/** @ignore */ export const toFloat64ArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Float64Array, input);\n/** @ignore */ export const toUint8ClampedArrayAsyncIterator = (input: ArrayBufferViewAsyncIteratorInput) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);\n\n/** @ignore */\nexport function rebaseValueOffsets(offset: number, length: number, valueOffsets: Int32Array) {\n    // If we have a non-zero offset, create a new offsets array with the values\n    // shifted by the start offset, such that the new start offset is 0\n    if (offset !== 0) {\n        valueOffsets = valueOffsets.slice(0, length + 1);\n        for (let i = -1; ++i <= length;) {\n            valueOffsets[i] += offset;\n        }\n    }\n    return valueOffsets;\n}\n\n/** @ignore */\nexport function compareArrayLike<T extends ArrayLike<any>>(a: T, b: T) {\n    let i = 0, n = a.length;\n    if (n !== b.length) { return false; }\n    if (n > 0) {\n        do { if (a[i] !== b[i]) { return false; } } while (++i < n);\n    }\n    return true;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport {\n    toUint8Array,\n    joinUint8Arrays,\n    ArrayBufferViewInput,\n    toUint8ArrayIterator,\n    toUint8ArrayAsyncIterator\n} from '../util/buffer';\n\nimport { ReadableDOMStreamOptions } from './interfaces';\n\n/** @ignore */\nexport default {\n    fromIterable<T extends ArrayBufferViewInput>(source: Iterable<T> | T): IterableIterator<Uint8Array> {\n        return pump(fromIterable<T>(source));\n    },\n    fromAsyncIterable<T extends ArrayBufferViewInput>(source: AsyncIterable<T> | PromiseLike<T>): AsyncIterableIterator<Uint8Array> {\n        return pump(fromAsyncIterable<T>(source));\n    },\n    fromDOMStream<T extends ArrayBufferViewInput>(source: ReadableStream<T>): AsyncIterableIterator<Uint8Array> {\n        return pump(fromDOMStream<T>(source));\n    },\n    fromNodeStream(stream: NodeJS.ReadableStream): AsyncIterableIterator<Uint8Array> {\n        return pump(fromNodeStream(stream));\n    },\n    // @ts-ignore\n    toDOMStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: ReadableDOMStreamOptions): ReadableStream<T> {\n        throw new Error(`\"toDOMStream\" not available in this environment`);\n    },\n    // @ts-ignore\n    toNodeStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: import('stream').ReadableOptions): import('stream').Readable {\n        throw new Error(`\"toNodeStream\" not available in this environment`);\n    },\n};\n\n/** @ignore */\nconst pump = <T extends Iterator<any> | AsyncIterator<any>>(iterator: T) => { iterator.next(); return iterator; };\n\n/** @ignore */\nfunction* fromIterable<T extends ArrayBufferViewInput>(source: Iterable<T> | T): IterableIterator<Uint8Array> {\n\n    let done: boolean, threw = false;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before creating the source Iterator\n    ({ cmd, size } = yield <any> null);\n\n    // initialize the iterator\n    let it = toUint8ArrayIterator(source)[Symbol.iterator]();\n\n    try {\n        do {\n            // read the next value\n            ({ done, value: buffer } = isNaN(size - bufferLength) ?\n                it.next(undefined) : it.next(size - bufferLength));\n            // if chunk is not null or empty, push it onto the queue\n            if (!done && buffer.byteLength > 0) {\n                buffers.push(buffer);\n                bufferLength += buffer.byteLength;\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } catch (e) {\n        (threw = true) && (typeof it.throw === 'function') && (it.throw(e));\n    } finally {\n        (threw === false) && (typeof it.return === 'function') && (it.return());\n    }\n}\n\n/** @ignore */\nasync function* fromAsyncIterable<T extends ArrayBufferViewInput>(source: AsyncIterable<T> | PromiseLike<T>): AsyncIterableIterator<Uint8Array> {\n\n    let done: boolean, threw = false;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before creating the source AsyncIterator\n    ({ cmd, size } = yield <any> null);\n\n    // initialize the iterator\n    let it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();\n\n    try {\n        do {\n            // read the next value\n            ({ done, value: buffer } = isNaN(size - bufferLength)\n                ? await it.next(undefined)\n                : await it.next(size - bufferLength));\n            // if chunk is not null or empty, push it onto the queue\n            if (!done && buffer.byteLength > 0) {\n                buffers.push(buffer);\n                bufferLength += buffer.byteLength;\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } catch (e) {\n        (threw = true) && (typeof it.throw === 'function') && (await it.throw(e));\n    } finally {\n        (threw === false) && (typeof it.return === 'function') && (await it.return());\n    }\n}\n\n// All this manual Uint8Array chunk management can be avoided if/when engines\n// add support for ArrayBuffer.transfer() or ArrayBuffer.prototype.realloc():\n// https://github.com/domenic/proposal-arraybuffer-transfer\n/** @ignore */\nasync function* fromDOMStream<T extends ArrayBufferViewInput>(source: ReadableStream<T>): AsyncIterableIterator<Uint8Array> {\n\n    let done = false, threw = false;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before we establish the ReadableStream lock\n    ({ cmd, size } = yield <any> null);\n\n    // initialize the reader and lock the stream\n    let it = new AdaptiveByteReader(source);\n\n    try {\n        do {\n            // read the next value\n            ({ done, value: buffer } = isNaN(size - bufferLength)\n                ? await it['read'](undefined)\n                : await it['read'](size - bufferLength));\n            // if chunk is not null or empty, push it onto the queue\n            if (!done && buffer.byteLength > 0) {\n                buffers.push(toUint8Array(buffer));\n                bufferLength += buffer.byteLength;\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } catch (e) {\n        (threw = true) && (await it['cancel'](e));\n    } finally {\n        (threw === false) ? (await it['cancel']())\n            : source['locked'] && it.releaseLock();\n    }\n}\n\n/** @ignore */\nclass AdaptiveByteReader<T extends ArrayBufferViewInput> {\n\n    private supportsBYOB: boolean;\n    private byobReader: ReadableStreamBYOBReader | null = null;\n    private defaultReader: ReadableStreamDefaultReader<T> | null = null;\n    private reader: ReadableStreamBYOBReader | ReadableStreamDefaultReader<T> | null;\n\n    constructor(private source: ReadableStream<T>) {\n        try {\n            this.supportsBYOB = !!(this.reader = this.getBYOBReader());\n        } catch (e) {\n            this.supportsBYOB = !!!(this.reader = this.getDefaultReader());\n        }\n    }\n\n    get closed(): Promise<void> {\n        return this.reader ? this.reader['closed'].catch(() => {}) : Promise.resolve();\n    }\n\n    releaseLock(): void {\n        if (this.reader) {\n            this.reader.releaseLock();\n        }\n        this.reader = this.byobReader = this.defaultReader = null;\n    }\n\n    async cancel(reason?: any): Promise<void> {\n        const { reader, source } = this;\n        reader && (await reader['cancel'](reason).catch(() => {}));\n        source && (source['locked'] && this.releaseLock());\n    }\n\n    async read(size?: number): Promise<ReadableStreamReadResult<Uint8Array>> {\n        if (size === 0) {\n            return { done: this.reader == null, value: new Uint8Array(0) };\n        }\n        const result = !this.supportsBYOB || typeof size !== 'number'\n            ? await this.getDefaultReader().read()\n            : await this.readFromBYOBReader(size);\n        !result.done && (result.value = toUint8Array(result as ReadableStreamReadResult<Uint8Array>));\n        return result as ReadableStreamReadResult<Uint8Array>;\n    }\n\n    private getDefaultReader() {\n        if (this.byobReader) { this.releaseLock(); }\n        if (!this.defaultReader) {\n            this.defaultReader = this.source['getReader']();\n            // We have to catch and swallow errors here to avoid uncaught promise rejection exceptions\n            // that seem to be raised when we call `releaseLock()` on this reader. I'm still mystified\n            // about why these errors are raised, but I'm sure there's some important spec reason that\n            // I haven't considered. I hate to employ such an anti-pattern here, but it seems like the\n            // only solution in this case :/\n            this.defaultReader['closed'].catch(() => {});\n        }\n        return (this.reader = this.defaultReader);\n    }\n\n    private getBYOBReader() {\n        if (this.defaultReader) { this.releaseLock(); }\n        if (!this.byobReader) {\n            this.byobReader = this.source['getReader']({ mode: 'byob' });\n            // We have to catch and swallow errors here to avoid uncaught promise rejection exceptions\n            // that seem to be raised when we call `releaseLock()` on this reader. I'm still mystified\n            // about why these errors are raised, but I'm sure there's some important spec reason that\n            // I haven't considered. I hate to employ such an anti-pattern here, but it seems like the\n            // only solution in this case :/\n            this.byobReader['closed'].catch(() => {});\n        }\n        return (this.reader = this.byobReader);\n    }\n\n    // This strategy plucked from the example in the streams spec:\n    // https://streams.spec.whatwg.org/#example-manual-read-bytes\n    private async readFromBYOBReader(size: number) {\n        return await readInto(this.getBYOBReader(), new ArrayBuffer(size), 0, size);\n    }\n}\n\n/** @ignore */\nasync function readInto(reader: ReadableStreamBYOBReader, buffer: ArrayBufferLike, offset: number, size: number): Promise<ReadableStreamReadResult<Uint8Array>> {\n    if (offset >= size) {\n        return { done: false, value: new Uint8Array(buffer, 0, size) };\n    }\n    const { done, value } = await reader.read(new Uint8Array(buffer, offset, size - offset));\n    if (((offset += value.byteLength) < size) && !done) {\n        return await readInto(reader, value.buffer, offset, size);\n    }\n    return { done, value: new Uint8Array(value.buffer, 0, offset) };\n}\n\n/** @ignore */\ntype EventName = 'end' | 'error' | 'readable';\n/** @ignore */\ntype Event = [EventName, (_: any) => void, Promise<[EventName, Error | null]>];\n/** @ignore */\nconst onEvent = <T extends string>(stream: NodeJS.ReadableStream, event: T) => {\n    let handler = (_: any) => resolve([event, _]);\n    let resolve: (value?: [T, any] | PromiseLike<[T, any]>) => void;\n    return [event, handler, new Promise<[T, any]>(\n        (r) => (resolve = r) && stream['once'](event, handler)\n    )] as Event;\n};\n\n/** @ignore */\nasync function* fromNodeStream(stream: NodeJS.ReadableStream): AsyncIterableIterator<Uint8Array> {\n\n    let events: Event[] = [];\n    let event: EventName = 'error';\n    let done = false, err: Error | null = null;\n    let cmd: 'peek' | 'read', size: number, bufferLength = 0;\n    let buffers: Uint8Array[] = [], buffer: Uint8Array | Buffer | string;\n\n    function byteRange() {\n        if (cmd === 'peek') {\n            return joinUint8Arrays(buffers, size)[0];\n        }\n        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);\n        return buffer;\n    }\n\n    // Yield so the caller can inject the read command before we\n    // add the listener for the source stream's 'readable' event.\n    ({ cmd, size } = yield <any> null);\n\n    // ignore stdin if it's a TTY\n    if ((stream as any)['isTTY']) { return yield new Uint8Array(0); }\n\n    try {\n        // initialize the stream event handlers\n        events[0] = onEvent(stream, 'end');\n        events[1] = onEvent(stream, 'error');\n\n        do {\n            events[2] = onEvent(stream, 'readable');\n\n            // wait on the first message event from the stream\n            [event, err] = await Promise.race(events.map((x) => x[2]));\n\n            // if the stream emitted an Error, rethrow it\n            if (event === 'error') { break; }\n            if (!(done = event === 'end')) {\n                // If the size is NaN, request to read everything in the stream's internal buffer\n                if (!isFinite(size - bufferLength)) {\n                    buffer = toUint8Array(stream['read'](undefined));\n                } else {\n                    buffer = toUint8Array(stream['read'](size - bufferLength));\n                    // If the byteLength is 0, then the requested amount is more than the stream has\n                    // in its internal buffer. In this case the stream needs a \"kick\" to tell it to\n                    // continue emitting readable events, so request to read everything the stream\n                    // has in its internal buffer right now.\n                    if (buffer.byteLength < (size - bufferLength)) {\n                        buffer = toUint8Array(stream['read'](undefined));\n                    }\n                }\n                // if chunk is not null or empty, push it onto the queue\n                if (buffer.byteLength > 0) {\n                    buffers.push(buffer);\n                    bufferLength += buffer.byteLength;\n                }\n            }\n            // If we have enough bytes in our buffer, yield chunks until we don't\n            if (done || size <= bufferLength) {\n                do {\n                    ({ cmd, size } = yield byteRange());\n                } while (size < bufferLength);\n            }\n        } while (!done);\n    } finally {\n        await cleanup(events, event === 'error' ? err : null);\n    }\n\n    function cleanup<T extends Error | null | void>(events: Event[], err?: T) {\n        buffer = buffers = <any> null;\n        return new Promise<T>(async (resolve, reject) => {\n            for (const [evt, fn] of events) {\n                stream['off'](evt, fn);\n            }\n            try {\n                // Some stream implementations don't call the destroy callback,\n                // because it's really a node-internal API. Just calling `destroy`\n                // here should be enough to conform to the ReadableStream contract\n                const destroy = (stream as any)['destroy'];\n                destroy && destroy.call(stream, err);\n                err = undefined;\n            } catch (e) { err = e || err; } finally {\n                err != null ? reject(err) : resolve();\n            }\n        });\n    }\n}\n","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","import defineProperty from \"./defineProperty.js\";\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nexport default function _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n\n  return target;\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nexport default function _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}","import superPropBase from \"./superPropBase.js\";\nexport default function _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    _get = Reflect.get;\n  } else {\n    _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get.apply(this, arguments);\n}","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { DataType } from './type';\nimport { Chunked } from './vector/chunked';\n\n/** @ignore */\nexport interface Clonable<R extends AbstractVector> {\n    clone(...args: any[]): R;\n}\n\n/** @ignore */\nexport interface Sliceable<R extends AbstractVector> {\n    slice(begin?: number, end?: number): R;\n}\n\n/** @ignore */\nexport interface Applicative<T extends DataType, R extends Chunked> {\n    concat(...others: Vector<T>[]): R;\n    readonly [Symbol.isConcatSpreadable]: boolean;\n}\n\nexport interface AbstractVector<T extends DataType = any>\n    extends Clonable<Vector<T>>,\n            Sliceable<Vector<T>>,\n            Applicative<T, Chunked<T>> {\n\n    readonly TType: T['TType'];\n    readonly TArray: T['TArray'];\n    readonly TValue: T['TValue'];\n}\n\nexport abstract class AbstractVector<T extends DataType = any> implements Iterable<T['TValue'] | null> {\n\n    public abstract readonly data: Data<T>;\n    public abstract readonly type: T;\n    public abstract readonly typeId: T['TType'];\n    public abstract readonly length: number;\n    public abstract readonly stride: number;\n    public abstract readonly nullCount: number;\n    public abstract readonly byteLength: number;\n    public abstract readonly numChildren: number;\n\n    public abstract readonly ArrayType: T['ArrayType'];\n\n    public abstract isValid(index: number): boolean;\n    public abstract get(index: number): T['TValue'] | null;\n    public abstract set(index: number, value: T['TValue'] | null): void;\n    public abstract indexOf(value: T['TValue'] | null, fromIndex?: number): number;\n    public abstract [Symbol.iterator](): IterableIterator<T['TValue'] | null>;\n\n    public abstract toArray(): T['TArray'];\n    public abstract getChildAt<R extends DataType = any>(index: number): Vector<R> | null;\n}\n\nexport { AbstractVector as Vector };\n","/* tslint:disable:class-name */\n\n// automatically generated by the FlatBuffers compiler, do not modify\n\nimport { flatbuffers } from 'flatbuffers';\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum MetadataVersion {\n        /**\n         * 0.1.0\n         */\n        V1 = 0,\n\n        /**\n         * 0.2.0\n         */\n        V2 = 1,\n\n        /**\n         * 0.3.0 -> 0.7.1\n         */\n        V3 = 2,\n\n        /**\n         * >= 0.8.0\n         */\n        V4 = 3\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum UnionMode {\n        Sparse = 0,\n        Dense = 1\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum Precision {\n        HALF = 0,\n        SINGLE = 1,\n        DOUBLE = 2\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum DateUnit {\n        DAY = 0,\n        MILLISECOND = 1\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum TimeUnit {\n        SECOND = 0,\n        MILLISECOND = 1,\n        MICROSECOND = 2,\n        NANOSECOND = 3\n    }\n}\n\n/**\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum IntervalUnit {\n        YEAR_MONTH = 0,\n        DAY_TIME = 1\n    }\n}\n\n/**\n * ----------------------------------------------------------------------\n * Top-level Type value, enabling extensible type-specific metadata. We can\n * add new logical types to Type without breaking backwards compatibility\n *\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum Type {\n        NONE = 0,\n        Null = 1,\n        Int = 2,\n        FloatingPoint = 3,\n        Binary = 4,\n        Utf8 = 5,\n        Bool = 6,\n        Decimal = 7,\n        Date = 8,\n        Time = 9,\n        Timestamp = 10,\n        Interval = 11,\n        List = 12,\n        Struct_ = 13,\n        Union = 14,\n        FixedSizeBinary = 15,\n        FixedSizeList = 16,\n        Map = 17,\n        Duration = 18,\n        LargeBinary = 19,\n        LargeUtf8 = 20,\n        LargeList = 21\n    }\n}\n\n/**\n * ----------------------------------------------------------------------\n * Endianness of the platform producing the data\n *\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum Endianness {\n        Little = 0,\n        Big = 1\n    }\n}\n\n/**\n * These are stored in the flatbuffer in the Type union below\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Null {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Null\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Null {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Null= obj\n         * @returns Null\n         */\n        static getRootAsNull(bb: flatbuffers.ByteBuffer, obj?: Null): Null {\n            return (obj || new Null).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startNull(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endNull(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createNull(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Null.startNull(builder);\n            return Null.endNull(builder);\n        }\n    }\n}\n/**\n * A Struct_ in the flatbuffer metadata is the same as an Arrow Struct\n * (according to the physical memory layout). We used Struct_ here as\n * Struct is a reserved word in Flatbuffers\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Struct_ {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Struct_\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Struct_ {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Struct_= obj\n         * @returns Struct_\n         */\n        static getRootAsStruct_(bb: flatbuffers.ByteBuffer, obj?: Struct_): Struct_ {\n            return (obj || new Struct_).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startStruct_(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endStruct_(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createStruct_(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Struct_.startStruct_(builder);\n            return Struct_.endStruct_(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class List {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns List\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): List {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param List= obj\n         * @returns List\n         */\n        static getRootAsList(bb: flatbuffers.ByteBuffer, obj?: List): List {\n            return (obj || new List).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startList(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            List.startList(builder);\n            return List.endList(builder);\n        }\n    }\n}\n/**\n * Same as List, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class LargeList {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns LargeList\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): LargeList {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param LargeList= obj\n         * @returns LargeList\n         */\n        static getRootAsLargeList(bb: flatbuffers.ByteBuffer, obj?: LargeList): LargeList {\n            return (obj || new LargeList).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startLargeList(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endLargeList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createLargeList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            LargeList.startLargeList(builder);\n            return LargeList.endLargeList(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FixedSizeList {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FixedSizeList\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FixedSizeList {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param FixedSizeList= obj\n         * @returns FixedSizeList\n         */\n        static getRootAsFixedSizeList(bb: flatbuffers.ByteBuffer, obj?: FixedSizeList): FixedSizeList {\n            return (obj || new FixedSizeList).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Number of list items per value\n         *\n         * @returns number\n         */\n        listSize(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFixedSizeList(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number listSize\n         */\n        static addListSize(builder: flatbuffers.Builder, listSize: number) {\n            builder.addFieldInt32(0, listSize, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFixedSizeList(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createFixedSizeList(builder: flatbuffers.Builder, listSize: number): flatbuffers.Offset {\n            FixedSizeList.startFixedSizeList(builder);\n            FixedSizeList.addListSize(builder, listSize);\n            return FixedSizeList.endFixedSizeList(builder);\n        }\n    }\n}\n/**\n * A Map is a logical nested type that is represented as\n *\n * List<entry: Struct<key: K, value: V>>\n *\n * In this layout, the keys and values are each respectively contiguous. We do\n * not constrain the key and value types, so the application is responsible\n * for ensuring that the keys are hashable and unique. Whether the keys are sorted\n * may be set in the metadata for this field\n *\n * In a Field with Map type, the Field has a child Struct field, which then\n * has two children: key type and the second the value type. The names of the\n * child fields may be respectively \"entry\", \"key\", and \"value\", but this is\n * not enforced\n *\n * Map\n *   - child[0] entry: Struct\n *     - child[0] key: K\n *     - child[1] value: V\n *\n * Neither the \"entry\" field nor the \"key\" field may be nullable.\n *\n * The metadata is structured so that Arrow systems without special handling\n * for Map can make Map an alias for List. The \"layout\" attribute for the Map\n * field must have the same contents as a List.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Map {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Map\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Map {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Map= obj\n         * @returns Map\n         */\n        static getRootAsMap(bb: flatbuffers.ByteBuffer, obj?: Map): Map {\n            return (obj || new Map).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Set to true if the keys within each value are sorted\n         *\n         * @returns boolean\n         */\n        keysSorted(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startMap(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean keysSorted\n         */\n        static addKeysSorted(builder: flatbuffers.Builder, keysSorted: boolean) {\n            builder.addFieldInt8(0, +keysSorted, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endMap(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createMap(builder: flatbuffers.Builder, keysSorted: boolean): flatbuffers.Offset {\n            Map.startMap(builder);\n            Map.addKeysSorted(builder, keysSorted);\n            return Map.endMap(builder);\n        }\n    }\n}\n/**\n * A union is a complex type with children in Field\n * By default ids in the type vector refer to the offsets in the children\n * optionally typeIds provides an indirection between the child offset and the type id\n * for each child typeIds[offset] is the id used in the type vector\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Union {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Union\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Union {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Union= obj\n         * @returns Union\n         */\n        static getRootAsUnion(bb: flatbuffers.ByteBuffer, obj?: Union): Union {\n            return (obj || new Union).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.UnionMode\n         */\n        mode(): org.apache.arrow.flatbuf.UnionMode {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.UnionMode.Sparse;\n        }\n\n        /**\n         * @param number index\n         * @returns number\n         */\n        typeIds(index: number): number | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.readInt32(this.bb!.__vector(this.bb_pos + offset) + index * 4) : 0;\n        }\n\n        /**\n         * @returns number\n         */\n        typeIdsLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @returns Int32Array\n         */\n        typeIdsArray(): Int32Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? new Int32Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startUnion(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.UnionMode mode\n         */\n        static addMode(builder: flatbuffers.Builder, mode: org.apache.arrow.flatbuf.UnionMode) {\n            builder.addFieldInt16(0, mode, org.apache.arrow.flatbuf.UnionMode.Sparse);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset typeIdsOffset\n         */\n        static addTypeIds(builder: flatbuffers.Builder, typeIdsOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, typeIdsOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<number> data\n         * @returns flatbuffers.Offset\n         */\n        static createTypeIdsVector(builder: flatbuffers.Builder, data: number[] | Int32Array): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addInt32(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startTypeIdsVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endUnion(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createUnion(builder: flatbuffers.Builder, mode: org.apache.arrow.flatbuf.UnionMode, typeIdsOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Union.startUnion(builder);\n            Union.addMode(builder, mode);\n            Union.addTypeIds(builder, typeIdsOffset);\n            return Union.endUnion(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Int {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Int\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Int {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Int= obj\n         * @returns Int\n         */\n        static getRootAsInt(bb: flatbuffers.ByteBuffer, obj?: Int): Int {\n            return (obj || new Int).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns number\n         */\n        bitWidth(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @returns boolean\n         */\n        isSigned(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startInt(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number bitWidth\n         */\n        static addBitWidth(builder: flatbuffers.Builder, bitWidth: number) {\n            builder.addFieldInt32(0, bitWidth, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean isSigned\n         */\n        static addIsSigned(builder: flatbuffers.Builder, isSigned: boolean) {\n            builder.addFieldInt8(1, +isSigned, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endInt(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createInt(builder: flatbuffers.Builder, bitWidth: number, isSigned: boolean): flatbuffers.Offset {\n            Int.startInt(builder);\n            Int.addBitWidth(builder, bitWidth);\n            Int.addIsSigned(builder, isSigned);\n            return Int.endInt(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FloatingPoint {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FloatingPoint\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FloatingPoint {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param FloatingPoint= obj\n         * @returns FloatingPoint\n         */\n        static getRootAsFloatingPoint(bb: flatbuffers.ByteBuffer, obj?: FloatingPoint): FloatingPoint {\n            return (obj || new FloatingPoint).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.Precision\n         */\n        precision(): org.apache.arrow.flatbuf.Precision {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.Precision.HALF;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFloatingPoint(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.Precision precision\n         */\n        static addPrecision(builder: flatbuffers.Builder, precision: org.apache.arrow.flatbuf.Precision) {\n            builder.addFieldInt16(0, precision, org.apache.arrow.flatbuf.Precision.HALF);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFloatingPoint(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createFloatingPoint(builder: flatbuffers.Builder, precision: org.apache.arrow.flatbuf.Precision): flatbuffers.Offset {\n            FloatingPoint.startFloatingPoint(builder);\n            FloatingPoint.addPrecision(builder, precision);\n            return FloatingPoint.endFloatingPoint(builder);\n        }\n    }\n}\n/**\n * Unicode with UTF-8 encoding\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Utf8 {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Utf8\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Utf8 {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Utf8= obj\n         * @returns Utf8\n         */\n        static getRootAsUtf8(bb: flatbuffers.ByteBuffer, obj?: Utf8): Utf8 {\n            return (obj || new Utf8).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startUtf8(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Utf8.startUtf8(builder);\n            return Utf8.endUtf8(builder);\n        }\n    }\n}\n/**\n * Opaque binary data\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Binary {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Binary\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Binary {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Binary= obj\n         * @returns Binary\n         */\n        static getRootAsBinary(bb: flatbuffers.ByteBuffer, obj?: Binary): Binary {\n            return (obj || new Binary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startBinary(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Binary.startBinary(builder);\n            return Binary.endBinary(builder);\n        }\n    }\n}\n/**\n * Same as Utf8, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class LargeUtf8 {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns LargeUtf8\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): LargeUtf8 {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param LargeUtf8= obj\n         * @returns LargeUtf8\n         */\n        static getRootAsLargeUtf8(bb: flatbuffers.ByteBuffer, obj?: LargeUtf8): LargeUtf8 {\n            return (obj || new LargeUtf8).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startLargeUtf8(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endLargeUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createLargeUtf8(builder: flatbuffers.Builder): flatbuffers.Offset {\n            LargeUtf8.startLargeUtf8(builder);\n            return LargeUtf8.endLargeUtf8(builder);\n        }\n    }\n}\n/**\n * Same as Binary, but with 64-bit offsets, allowing to represent\n * extremely large data values.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class LargeBinary {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns LargeBinary\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): LargeBinary {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param LargeBinary= obj\n         * @returns LargeBinary\n         */\n        static getRootAsLargeBinary(bb: flatbuffers.ByteBuffer, obj?: LargeBinary): LargeBinary {\n            return (obj || new LargeBinary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startLargeBinary(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endLargeBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createLargeBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            LargeBinary.startLargeBinary(builder);\n            return LargeBinary.endLargeBinary(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FixedSizeBinary {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FixedSizeBinary\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FixedSizeBinary {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param FixedSizeBinary= obj\n         * @returns FixedSizeBinary\n         */\n        static getRootAsFixedSizeBinary(bb: flatbuffers.ByteBuffer, obj?: FixedSizeBinary): FixedSizeBinary {\n            return (obj || new FixedSizeBinary).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Number of bytes per value\n         *\n         * @returns number\n         */\n        byteWidth(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFixedSizeBinary(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number byteWidth\n         */\n        static addByteWidth(builder: flatbuffers.Builder, byteWidth: number) {\n            builder.addFieldInt32(0, byteWidth, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFixedSizeBinary(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createFixedSizeBinary(builder: flatbuffers.Builder, byteWidth: number): flatbuffers.Offset {\n            FixedSizeBinary.startFixedSizeBinary(builder);\n            FixedSizeBinary.addByteWidth(builder, byteWidth);\n            return FixedSizeBinary.endFixedSizeBinary(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Bool {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Bool\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Bool {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Bool= obj\n         * @returns Bool\n         */\n        static getRootAsBool(bb: flatbuffers.ByteBuffer, obj?: Bool): Bool {\n            return (obj || new Bool).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startBool(builder: flatbuffers.Builder) {\n            builder.startObject(0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endBool(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createBool(builder: flatbuffers.Builder): flatbuffers.Offset {\n            Bool.startBool(builder);\n            return Bool.endBool(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Decimal {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Decimal\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Decimal {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Decimal= obj\n         * @returns Decimal\n         */\n        static getRootAsDecimal(bb: flatbuffers.ByteBuffer, obj?: Decimal): Decimal {\n            return (obj || new Decimal).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Total number of decimal digits\n         *\n         * @returns number\n         */\n        precision(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * Number of digits after the decimal point \".\"\n         *\n         * @returns number\n         */\n        scale(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDecimal(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number precision\n         */\n        static addPrecision(builder: flatbuffers.Builder, precision: number) {\n            builder.addFieldInt32(0, precision, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number scale\n         */\n        static addScale(builder: flatbuffers.Builder, scale: number) {\n            builder.addFieldInt32(1, scale, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDecimal(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDecimal(builder: flatbuffers.Builder, precision: number, scale: number): flatbuffers.Offset {\n            Decimal.startDecimal(builder);\n            Decimal.addPrecision(builder, precision);\n            Decimal.addScale(builder, scale);\n            return Decimal.endDecimal(builder);\n        }\n    }\n}\n/**\n * Date is either a 32-bit or 64-bit type representing elapsed time since UNIX\n * epoch (1970-01-01), stored in either of two units:\n *\n * * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no\n *   leap seconds), where the values are evenly divisible by 86400000\n * * Days (32 bits) since the UNIX epoch\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Date {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Date\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Date {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Date= obj\n         * @returns Date\n         */\n        static getRootAsDate(bb: flatbuffers.ByteBuffer, obj?: Date): Date {\n            return (obj || new Date).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.DateUnit\n         */\n        unit(): org.apache.arrow.flatbuf.DateUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.DateUnit.MILLISECOND;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDate(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.DateUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.DateUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.DateUnit.MILLISECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDate(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDate(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.DateUnit): flatbuffers.Offset {\n            Date.startDate(builder);\n            Date.addUnit(builder, unit);\n            return Date.endDate(builder);\n        }\n    }\n}\n/**\n * Time type. The physical storage type depends on the unit\n * - SECOND and MILLISECOND: 32 bits\n * - MICROSECOND and NANOSECOND: 64 bits\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Time {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Time\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Time {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Time= obj\n         * @returns Time\n         */\n        static getRootAsTime(bb: flatbuffers.ByteBuffer, obj?: Time): Time {\n            return (obj || new Time).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.TimeUnit\n         */\n        unit(): org.apache.arrow.flatbuf.TimeUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.TimeUnit.MILLISECOND;\n        }\n\n        /**\n         * @returns number\n         */\n        bitWidth(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.readInt32(this.bb_pos + offset) : 32;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startTime(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.TimeUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.MILLISECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number bitWidth\n         */\n        static addBitWidth(builder: flatbuffers.Builder, bitWidth: number) {\n            builder.addFieldInt32(1, bitWidth, 32);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endTime(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createTime(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit, bitWidth: number): flatbuffers.Offset {\n            Time.startTime(builder);\n            Time.addUnit(builder, unit);\n            Time.addBitWidth(builder, bitWidth);\n            return Time.endTime(builder);\n        }\n    }\n}\n/**\n * Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding\n * leap seconds, as a 64-bit integer. Note that UNIX time does not include\n * leap seconds.\n *\n * The Timestamp metadata supports both \"time zone naive\" and \"time zone\n * aware\" timestamps. Read about the timezone attribute for more detail\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Timestamp {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Timestamp\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Timestamp {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Timestamp= obj\n         * @returns Timestamp\n         */\n        static getRootAsTimestamp(bb: flatbuffers.ByteBuffer, obj?: Timestamp): Timestamp {\n            return (obj || new Timestamp).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.TimeUnit\n         */\n        unit(): org.apache.arrow.flatbuf.TimeUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.TimeUnit.SECOND;\n        }\n\n        /**\n         * The time zone is a string indicating the name of a time zone, one of:\n         *\n         * * As used in the Olson time zone database (the \"tz database\" or\n         *   \"tzdata\"), such as \"America/New_York\"\n         * * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30\n         *\n         * Whether a timezone string is present indicates different semantics about\n         * the data:\n         *\n         * * If the time zone is null or equal to an empty string, the data is \"time\n         *   zone naive\" and shall be displayed *as is* to the user, not localized\n         *   to the locale of the user. This data can be though of as UTC but\n         *   without having \"UTC\" as the time zone, it is not considered to be\n         *   localized to any time zone\n         *\n         * * If the time zone is set to a valid value, values can be displayed as\n         *   \"localized\" to that time zone, even though the underlying 64-bit\n         *   integers are identical to the same data stored in UTC. Converting\n         *   between time zones is a metadata-only operation and does not change the\n         *   underlying values\n         *\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        timezone(): string | null;\n        timezone(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        timezone(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startTimestamp(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.TimeUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.SECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset timezoneOffset\n         */\n        static addTimezone(builder: flatbuffers.Builder, timezoneOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, timezoneOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endTimestamp(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createTimestamp(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit, timezoneOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Timestamp.startTimestamp(builder);\n            Timestamp.addUnit(builder, unit);\n            Timestamp.addTimezone(builder, timezoneOffset);\n            return Timestamp.endTimestamp(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Interval {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Interval\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Interval {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Interval= obj\n         * @returns Interval\n         */\n        static getRootAsInterval(bb: flatbuffers.ByteBuffer, obj?: Interval): Interval {\n            return (obj || new Interval).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.IntervalUnit\n         */\n        unit(): org.apache.arrow.flatbuf.IntervalUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.IntervalUnit.YEAR_MONTH;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startInterval(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.IntervalUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.IntervalUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.IntervalUnit.YEAR_MONTH);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endInterval(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createInterval(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.IntervalUnit): flatbuffers.Offset {\n            Interval.startInterval(builder);\n            Interval.addUnit(builder, unit);\n            return Interval.endInterval(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Duration {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Duration\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Duration {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Duration= obj\n         * @returns Duration\n         */\n        static getRootAsDuration(bb: flatbuffers.ByteBuffer, obj?: Duration): Duration {\n            return (obj || new Duration).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.TimeUnit\n         */\n        unit(): org.apache.arrow.flatbuf.TimeUnit {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.TimeUnit.MILLISECOND;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDuration(builder: flatbuffers.Builder) {\n            builder.startObject(1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.TimeUnit unit\n         */\n        static addUnit(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit) {\n            builder.addFieldInt16(0, unit, org.apache.arrow.flatbuf.TimeUnit.MILLISECOND);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDuration(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDuration(builder: flatbuffers.Builder, unit: org.apache.arrow.flatbuf.TimeUnit): flatbuffers.Offset {\n            Duration.startDuration(builder);\n            Duration.addUnit(builder, unit);\n            return Duration.endDuration(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * user defined key value pairs to add custom metadata to arrow\n * key namespacing is the responsibility of the user\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class KeyValue {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns KeyValue\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): KeyValue {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param KeyValue= obj\n         * @returns KeyValue\n         */\n        static getRootAsKeyValue(bb: flatbuffers.ByteBuffer, obj?: KeyValue): KeyValue {\n            return (obj || new KeyValue).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        key(): string | null;\n        key(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        key(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        value(): string | null;\n        value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        value(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startKeyValue(builder: flatbuffers.Builder) {\n            builder.startObject(2);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset keyOffset\n         */\n        static addKey(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(0, keyOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset valueOffset\n         */\n        static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, valueOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endKeyValue(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createKeyValue(builder: flatbuffers.Builder, keyOffset: flatbuffers.Offset, valueOffset: flatbuffers.Offset): flatbuffers.Offset {\n            KeyValue.startKeyValue(builder);\n            KeyValue.addKey(builder, keyOffset);\n            KeyValue.addValue(builder, valueOffset);\n            return KeyValue.endKeyValue(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * Dictionary encoding metadata\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class DictionaryEncoding {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns DictionaryEncoding\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): DictionaryEncoding {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param DictionaryEncoding= obj\n         * @returns DictionaryEncoding\n         */\n        static getRootAsDictionaryEncoding(bb: flatbuffers.ByteBuffer, obj?: DictionaryEncoding): DictionaryEncoding {\n            return (obj || new DictionaryEncoding).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * The known dictionary id in the application where this data is used. In\n         * the file or streaming formats, the dictionary ids are found in the\n         * DictionaryBatch messages\n         *\n         * @returns flatbuffers.Long\n         */\n        id(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * The dictionary indices are constrained to be positive integers. If this\n         * field is null, the indices must be signed int32\n         *\n         * @param org.apache.arrow.flatbuf.Int= obj\n         * @returns org.apache.arrow.flatbuf.Int|null\n         */\n        indexType(obj?: org.apache.arrow.flatbuf.Int): org.apache.arrow.flatbuf.Int | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Int).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * By default, dictionaries are not ordered, or the order does not have\n         * semantic meaning. In some statistical, applications, dictionary-encoding\n         * is used to represent ordered categorical data, and we provide a way to\n         * preserve that metadata here\n         *\n         * @returns boolean\n         */\n        isOrdered(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDictionaryEncoding(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long id\n         */\n        static addId(builder: flatbuffers.Builder, id: flatbuffers.Long) {\n            builder.addFieldInt64(0, id, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset indexTypeOffset\n         */\n        static addIndexType(builder: flatbuffers.Builder, indexTypeOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, indexTypeOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean isOrdered\n         */\n        static addIsOrdered(builder: flatbuffers.Builder, isOrdered: boolean) {\n            builder.addFieldInt8(2, +isOrdered, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDictionaryEncoding(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDictionaryEncoding(builder: flatbuffers.Builder, id: flatbuffers.Long, indexTypeOffset: flatbuffers.Offset, isOrdered: boolean): flatbuffers.Offset {\n            DictionaryEncoding.startDictionaryEncoding(builder);\n            DictionaryEncoding.addId(builder, id);\n            DictionaryEncoding.addIndexType(builder, indexTypeOffset);\n            DictionaryEncoding.addIsOrdered(builder, isOrdered);\n            return DictionaryEncoding.endDictionaryEncoding(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * A field represents a named column in a record / row batch or child of a\n * nested type.\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Field {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Field\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Field {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Field= obj\n         * @returns Field\n         */\n        static getRootAsField(bb: flatbuffers.ByteBuffer, obj?: Field): Field {\n            return (obj || new Field).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * Name is not required, in i.e. a List\n         *\n         * @param flatbuffers.Encoding= optionalEncoding\n         * @returns string|Uint8Array|null\n         */\n        name(): string | null;\n        name(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;\n        name(optionalEncoding?: any): string | Uint8Array | null {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;\n        }\n\n        /**\n         * Whether or not this field can contain nulls. Should be true in general.\n         *\n         * @returns boolean\n         */\n        nullable(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.Type\n         */\n        typeType(): org.apache.arrow.flatbuf.Type {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? /**  */ (this.bb!.readUint8(this.bb_pos + offset)) : org.apache.arrow.flatbuf.Type.NONE;\n        }\n\n        /**\n         * This is the type of the decoded value if the field is dictionary encoded.\n         *\n         * @param flatbuffers.Table obj\n         * @returns ?flatbuffers.Table\n         */\n        type<T extends flatbuffers.Table>(obj: T): T | null {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;\n        }\n\n        /**\n         * Present only if the field is dictionary encoded.\n         *\n         * @param org.apache.arrow.flatbuf.DictionaryEncoding= obj\n         * @returns org.apache.arrow.flatbuf.DictionaryEncoding|null\n         */\n        dictionary(obj?: org.apache.arrow.flatbuf.DictionaryEncoding): org.apache.arrow.flatbuf.DictionaryEncoding | null {\n            let offset = this.bb!.__offset(this.bb_pos, 12);\n            return offset ? (obj || new org.apache.arrow.flatbuf.DictionaryEncoding).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * children apply only to nested data types like Struct, List and Union. For\n         * primitive types children will have length 0.\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Field= obj\n         * @returns org.apache.arrow.flatbuf.Field\n         */\n        children(index: number, obj?: org.apache.arrow.flatbuf.Field): org.apache.arrow.flatbuf.Field | null {\n            let offset = this.bb!.__offset(this.bb_pos, 14);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Field).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        childrenLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 14);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * User-defined metadata\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.KeyValue= obj\n         * @returns org.apache.arrow.flatbuf.KeyValue\n         */\n        customMetadata(index: number, obj?: org.apache.arrow.flatbuf.KeyValue): org.apache.arrow.flatbuf.KeyValue | null {\n            let offset = this.bb!.__offset(this.bb_pos, 16);\n            return offset ? (obj || new org.apache.arrow.flatbuf.KeyValue).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        customMetadataLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 16);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startField(builder: flatbuffers.Builder) {\n            builder.startObject(7);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset nameOffset\n         */\n        static addName(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(0, nameOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean nullable\n         */\n        static addNullable(builder: flatbuffers.Builder, nullable: boolean) {\n            builder.addFieldInt8(1, +nullable, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.Type typeType\n         */\n        static addTypeType(builder: flatbuffers.Builder, typeType: org.apache.arrow.flatbuf.Type) {\n            builder.addFieldInt8(2, typeType, org.apache.arrow.flatbuf.Type.NONE);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset typeOffset\n         */\n        static addType(builder: flatbuffers.Builder, typeOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(3, typeOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset dictionaryOffset\n         */\n        static addDictionary(builder: flatbuffers.Builder, dictionaryOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(4, dictionaryOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset childrenOffset\n         */\n        static addChildren(builder: flatbuffers.Builder, childrenOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(5, childrenOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createChildrenVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startChildrenVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset customMetadataOffset\n         */\n        static addCustomMetadata(builder: flatbuffers.Builder, customMetadataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(6, customMetadataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createCustomMetadataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startCustomMetadataVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endField(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createField(builder: flatbuffers.Builder, nameOffset: flatbuffers.Offset, nullable: boolean, typeType: org.apache.arrow.flatbuf.Type, typeOffset: flatbuffers.Offset, dictionaryOffset: flatbuffers.Offset, childrenOffset: flatbuffers.Offset, customMetadataOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Field.startField(builder);\n            Field.addName(builder, nameOffset);\n            Field.addNullable(builder, nullable);\n            Field.addTypeType(builder, typeType);\n            Field.addType(builder, typeOffset);\n            Field.addDictionary(builder, dictionaryOffset);\n            Field.addChildren(builder, childrenOffset);\n            Field.addCustomMetadata(builder, customMetadataOffset);\n            return Field.endField(builder);\n        }\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * A Buffer represents a single contiguous memory segment\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Buffer {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Buffer\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Buffer {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * The relative offset into the shared memory page where the bytes for this\n         * buffer starts\n         *\n         * @returns flatbuffers.Long\n         */\n        offset(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos);\n        }\n\n        /**\n         * The absolute length (in bytes) of the memory buffer. The memory is found\n         * from offset (inclusive) to offset + length (non-inclusive).\n         *\n         * @returns flatbuffers.Long\n         */\n        length(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos + 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long offset\n         * @param flatbuffers.Long length\n         * @returns flatbuffers.Offset\n         */\n        static createBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Long, length: flatbuffers.Long): flatbuffers.Offset {\n            builder.prep(8, 16);\n            builder.writeInt64(length);\n            builder.writeInt64(offset);\n            return builder.offset();\n        }\n\n    }\n}\n/**\n * ----------------------------------------------------------------------\n * A Schema describes the columns in a row batch\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Schema {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Schema\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Schema {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Schema= obj\n         * @returns Schema\n         */\n        static getRootAsSchema(bb: flatbuffers.ByteBuffer, obj?: Schema): Schema {\n            return (obj || new Schema).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * endianness of the buffer\n         * it is Little Endian by default\n         * if endianness doesn't match the underlying system then the vectors need to be converted\n         *\n         * @returns org.apache.arrow.flatbuf.Endianness\n         */\n        endianness(): org.apache.arrow.flatbuf.Endianness {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : org.apache.arrow.flatbuf.Endianness.Little;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Field= obj\n         * @returns org.apache.arrow.flatbuf.Field\n         */\n        fields(index: number, obj?: org.apache.arrow.flatbuf.Field): org.apache.arrow.flatbuf.Field | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Field).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        fieldsLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.KeyValue= obj\n         * @returns org.apache.arrow.flatbuf.KeyValue\n         */\n        customMetadata(index: number, obj?: org.apache.arrow.flatbuf.KeyValue): org.apache.arrow.flatbuf.KeyValue | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? (obj || new org.apache.arrow.flatbuf.KeyValue).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        customMetadataLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startSchema(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.Endianness endianness\n         */\n        static addEndianness(builder: flatbuffers.Builder, endianness: org.apache.arrow.flatbuf.Endianness) {\n            builder.addFieldInt16(0, endianness, org.apache.arrow.flatbuf.Endianness.Little);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset fieldsOffset\n         */\n        static addFields(builder: flatbuffers.Builder, fieldsOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, fieldsOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createFieldsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startFieldsVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset customMetadataOffset\n         */\n        static addCustomMetadata(builder: flatbuffers.Builder, customMetadataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, customMetadataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createCustomMetadataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startCustomMetadataVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endSchema(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset offset\n         */\n        static finishSchemaBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n            builder.finish(offset);\n        }\n\n        static createSchema(builder: flatbuffers.Builder, endianness: org.apache.arrow.flatbuf.Endianness, fieldsOffset: flatbuffers.Offset, customMetadataOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Schema.startSchema(builder);\n            Schema.addEndianness(builder, endianness);\n            Schema.addFields(builder, fieldsOffset);\n            Schema.addCustomMetadata(builder, customMetadataOffset);\n            return Schema.endSchema(builder);\n        }\n    }\n}\n","// automatically generated by the FlatBuffers compiler, do not modify\n\nimport { flatbuffers } from 'flatbuffers';\nimport * as NS7624605610262437867 from './Schema';\nexport namespace org.apache.arrow.flatbuf {\n    export import Schema = NS7624605610262437867.org.apache.arrow.flatbuf.Schema;\n}\n/**\n * ----------------------------------------------------------------------\n * The root Message type\n * This union enables us to easily send different message types without\n * redundant storage, and in the future we can easily add new message types.\n *\n * Arrow implementations do not need to implement all of the message types,\n * which may include experimental metadata types. For maximum compatibility,\n * it is best to send data using RecordBatch\n *\n * @enum {number}\n */\nexport namespace org.apache.arrow.flatbuf {\n    export enum MessageHeader {\n        NONE = 0,\n        Schema = 1,\n        DictionaryBatch = 2,\n        RecordBatch = 3,\n        Tensor = 4,\n        SparseTensor = 5\n    }\n}\n\n/**\n * ----------------------------------------------------------------------\n * Data structures for describing a table row batch (a collection of\n * equal-length Arrow arrays)\n * Metadata about a field at some level of a nested type tree (but not\n * its children).\n *\n * For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null]\n * would have {length: 5, null_count: 2} for its List node, and {length: 6,\n * null_count: 0} for its Int16 node, as separate FieldNode structs\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class FieldNode {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns FieldNode\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): FieldNode {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * The number of value slots in the Arrow array at this level of a nested\n         * tree\n         *\n         * @returns flatbuffers.Long\n         */\n        length(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos);\n        }\n\n        /**\n         * The number of observed nulls. Fields with null_count == 0 may choose not\n         * to write their physical validity bitmap out as a materialized buffer,\n         * instead setting the length of the bitmap buffer to 0.\n         *\n         * @returns flatbuffers.Long\n         */\n        nullCount(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos + 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long length\n         * @param flatbuffers.Long null_count\n         * @returns flatbuffers.Offset\n         */\n        static createFieldNode(builder: flatbuffers.Builder, length: flatbuffers.Long, null_count: flatbuffers.Long): flatbuffers.Offset {\n            builder.prep(8, 16);\n            builder.writeInt64(null_count);\n            builder.writeInt64(length);\n            return builder.offset();\n        }\n\n    }\n}\n/**\n * A data header describing the shared memory layout of a \"record\" or \"row\"\n * batch. Some systems call this a \"row batch\" internally and others a \"record\n * batch\".\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class RecordBatch {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns RecordBatch\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): RecordBatch {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param RecordBatch= obj\n         * @returns RecordBatch\n         */\n        static getRootAsRecordBatch(bb: flatbuffers.ByteBuffer, obj?: RecordBatch): RecordBatch {\n            return (obj || new RecordBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * number of records / rows. The arrays in the batch should all have this\n         * length\n         *\n         * @returns flatbuffers.Long\n         */\n        length(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * Nodes correspond to the pre-ordered flattened logical schema\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.FieldNode= obj\n         * @returns org.apache.arrow.flatbuf.FieldNode\n         */\n        nodes(index: number, obj?: org.apache.arrow.flatbuf.FieldNode): org.apache.arrow.flatbuf.FieldNode | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.FieldNode).__init(this.bb!.__vector(this.bb_pos + offset) + index * 16, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        nodesLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * Buffers correspond to the pre-ordered flattened buffer tree\n         *\n         * The number of buffers appended to this list depends on the schema. For\n         * example, most primitive arrays will have 2 buffers, 1 for the validity\n         * bitmap and 1 for the values. For struct arrays, there will only be a\n         * single buffer for the validity (nulls) bitmap\n         *\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Buffer= obj\n         * @returns org.apache.arrow.flatbuf.Buffer\n         */\n        buffers(index: number, obj?: NS7624605610262437867.org.apache.arrow.flatbuf.Buffer): NS7624605610262437867.org.apache.arrow.flatbuf.Buffer | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? (obj || new NS7624605610262437867.org.apache.arrow.flatbuf.Buffer).__init(this.bb!.__vector(this.bb_pos + offset) + index * 16, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        buffersLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startRecordBatch(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long length\n         */\n        static addLength(builder: flatbuffers.Builder, length: flatbuffers.Long) {\n            builder.addFieldInt64(0, length, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset nodesOffset\n         */\n        static addNodes(builder: flatbuffers.Builder, nodesOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, nodesOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startNodesVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(16, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset buffersOffset\n         */\n        static addBuffers(builder: flatbuffers.Builder, buffersOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, buffersOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startBuffersVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(16, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endRecordBatch(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createRecordBatch(builder: flatbuffers.Builder, length: flatbuffers.Long, nodesOffset: flatbuffers.Offset, buffersOffset: flatbuffers.Offset): flatbuffers.Offset {\n            RecordBatch.startRecordBatch(builder);\n            RecordBatch.addLength(builder, length);\n            RecordBatch.addNodes(builder, nodesOffset);\n            RecordBatch.addBuffers(builder, buffersOffset);\n            return RecordBatch.endRecordBatch(builder);\n        }\n    }\n}\n/**\n * For sending dictionary encoding information. Any Field can be\n * dictionary-encoded, but in this case none of its children may be\n * dictionary-encoded.\n * There is one vector / column per dictionary, but that vector / column\n * may be spread across multiple dictionary batches by using the isDelta\n * flag\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class DictionaryBatch {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns DictionaryBatch\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): DictionaryBatch {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param DictionaryBatch= obj\n         * @returns DictionaryBatch\n         */\n        static getRootAsDictionaryBatch(bb: flatbuffers.ByteBuffer, obj?: DictionaryBatch): DictionaryBatch {\n            return (obj || new DictionaryBatch).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns flatbuffers.Long\n         */\n        id(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * @param org.apache.arrow.flatbuf.RecordBatch= obj\n         * @returns org.apache.arrow.flatbuf.RecordBatch|null\n         */\n        data(obj?: org.apache.arrow.flatbuf.RecordBatch): org.apache.arrow.flatbuf.RecordBatch | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new org.apache.arrow.flatbuf.RecordBatch).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * If isDelta is true the values in the dictionary are to be appended to a\n         * dictionary with the indicated id\n         *\n         * @returns boolean\n         */\n        isDelta(): boolean {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startDictionaryBatch(builder: flatbuffers.Builder) {\n            builder.startObject(3);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long id\n         */\n        static addId(builder: flatbuffers.Builder, id: flatbuffers.Long) {\n            builder.addFieldInt64(0, id, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset dataOffset\n         */\n        static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, dataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param boolean isDelta\n         */\n        static addIsDelta(builder: flatbuffers.Builder, isDelta: boolean) {\n            builder.addFieldInt8(2, +isDelta, +false);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endDictionaryBatch(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        static createDictionaryBatch(builder: flatbuffers.Builder, id: flatbuffers.Long, dataOffset: flatbuffers.Offset, isDelta: boolean): flatbuffers.Offset {\n            DictionaryBatch.startDictionaryBatch(builder);\n            DictionaryBatch.addId(builder, id);\n            DictionaryBatch.addData(builder, dataOffset);\n            DictionaryBatch.addIsDelta(builder, isDelta);\n            return DictionaryBatch.endDictionaryBatch(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Message {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Message\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Message {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Message= obj\n         * @returns Message\n         */\n        static getRootAsMessage(bb: flatbuffers.ByteBuffer, obj?: Message): Message {\n            return (obj || new Message).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.MetadataVersion\n         */\n        version(): NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1;\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.MessageHeader\n         */\n        headerType(): org.apache.arrow.flatbuf.MessageHeader {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? /**  */ (this.bb!.readUint8(this.bb_pos + offset)) : org.apache.arrow.flatbuf.MessageHeader.NONE;\n        }\n\n        /**\n         * @param flatbuffers.Table obj\n         * @returns ?flatbuffers.Table\n         */\n        header<T extends flatbuffers.Table>(obj: T): T | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;\n        }\n\n        /**\n         * @returns flatbuffers.Long\n         */\n        bodyLength(): flatbuffers.Long {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.KeyValue= obj\n         * @returns org.apache.arrow.flatbuf.KeyValue\n         */\n        customMetadata(index: number, obj?: NS7624605610262437867.org.apache.arrow.flatbuf.KeyValue): NS7624605610262437867.org.apache.arrow.flatbuf.KeyValue | null {\n            let offset = this.bb!.__offset(this.bb_pos, 12);\n            return offset ? (obj || new NS7624605610262437867.org.apache.arrow.flatbuf.KeyValue).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        customMetadataLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 12);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startMessage(builder: flatbuffers.Builder) {\n            builder.startObject(5);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.MetadataVersion version\n         */\n        static addVersion(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion) {\n            builder.addFieldInt16(0, version, NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.MessageHeader headerType\n         */\n        static addHeaderType(builder: flatbuffers.Builder, headerType: org.apache.arrow.flatbuf.MessageHeader) {\n            builder.addFieldInt8(1, headerType, org.apache.arrow.flatbuf.MessageHeader.NONE);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset headerOffset\n         */\n        static addHeader(builder: flatbuffers.Builder, headerOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, headerOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long bodyLength\n         */\n        static addBodyLength(builder: flatbuffers.Builder, bodyLength: flatbuffers.Long) {\n            builder.addFieldInt64(3, bodyLength, builder.createLong(0, 0));\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset customMetadataOffset\n         */\n        static addCustomMetadata(builder: flatbuffers.Builder, customMetadataOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(4, customMetadataOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param Array.<flatbuffers.Offset> data\n         * @returns flatbuffers.Offset\n         */\n        static createCustomMetadataVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset {\n            builder.startVector(4, data.length, 4);\n            for (let i = data.length - 1; i >= 0; i--) {\n                builder.addOffset(data[i]);\n            }\n            return builder.endVector();\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startCustomMetadataVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(4, numElems, 4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endMessage(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset offset\n         */\n        static finishMessageBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n            builder.finish(offset);\n        }\n\n        static createMessage(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion, headerType: org.apache.arrow.flatbuf.MessageHeader, headerOffset: flatbuffers.Offset, bodyLength: flatbuffers.Long, customMetadataOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Message.startMessage(builder);\n            Message.addVersion(builder, version);\n            Message.addHeaderType(builder, headerType);\n            Message.addHeader(builder, headerOffset);\n            Message.addBodyLength(builder, bodyLength);\n            Message.addCustomMetadata(builder, customMetadataOffset);\n            return Message.endMessage(builder);\n        }\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport * as Schema_ from './fb/Schema';\nimport * as Message_ from './fb/Message';\n\nexport import ArrowType = Schema_.org.apache.arrow.flatbuf.Type;\nexport import DateUnit = Schema_.org.apache.arrow.flatbuf.DateUnit;\nexport import TimeUnit = Schema_.org.apache.arrow.flatbuf.TimeUnit;\nexport import Precision = Schema_.org.apache.arrow.flatbuf.Precision;\nexport import UnionMode = Schema_.org.apache.arrow.flatbuf.UnionMode;\nexport import IntervalUnit = Schema_.org.apache.arrow.flatbuf.IntervalUnit;\nexport import MessageHeader = Message_.org.apache.arrow.flatbuf.MessageHeader;\nexport import MetadataVersion = Schema_.org.apache.arrow.flatbuf.MetadataVersion;\n\n/**\n * Main data type enumeration.\n *\n * Data types in this library are all *logical*. They can be expressed as\n * either a primitive physical type (bytes or bits of some fixed size), a\n * nested type consisting of other data types, or another data type (e.g. a\n * timestamp encoded as an int64).\n *\n * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow\n * IPC payload.\n *\n * The rest of the values are specified here so TypeScript can narrow the type\n * signatures further beyond the base Arrow Types. The Arrow DataTypes include\n * metadata like `bitWidth` that impact the type signatures of the values we\n * accept and return.\n *\n * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an\n * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`\n * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the\n * underlying `Int32Array`.\n *\n * Library consumers benefit by knowing the narrowest type, since we can ensure\n * the types across all public methods are propagated, and never bail to `any`.\n * These values are _never_ used at runtime, and they will _never_ be written\n * to the flatbuffers metadata of serialized Arrow IPC payloads.\n */\nexport enum Type {\n    /** The default placeholder type */\n    NONE            =  0,\n    /** A NULL type having no physical storage */\n    Null            =  1,\n    /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */\n    Int             =  2,\n    /** 2, 4, or 8-byte floating point value */\n    Float           =  3,\n    /** Variable-length bytes (no guarantee of UTF8-ness) */\n    Binary          =  4,\n    /** UTF8 variable-length string as List<Char> */\n    Utf8            =  5,\n    /** Boolean as 1 bit, LSB bit-packed ordering */\n    Bool            =  6,\n    /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */\n    Decimal         =  7,\n    /** int32_t days or int64_t milliseconds since the UNIX epoch */\n    Date            =  8,\n    /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */\n    Time            =  9,\n    /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */\n    Timestamp       = 10,\n    /** YEAR_MONTH or DAY_TIME interval in SQL style */\n    Interval        = 11,\n    /** A list of some logical data type */\n    List            = 12,\n    /** Struct of logical types */\n    Struct          = 13,\n    /** Union of logical types */\n    Union           = 14,\n    /** Fixed-size binary. Each value occupies the same number of bytes */\n    FixedSizeBinary = 15,\n    /** Fixed-size list. Each value occupies the same number of bytes */\n    FixedSizeList   = 16,\n    /** Map of named logical types */\n    Map             = 17,\n\n    /** Dictionary aka Category type */\n    Dictionary            = -1,\n    Int8                  = -2,\n    Int16                 = -3,\n    Int32                 = -4,\n    Int64                 = -5,\n    Uint8                 = -6,\n    Uint16                = -7,\n    Uint32                = -8,\n    Uint64                = -9,\n    Float16               = -10,\n    Float32               = -11,\n    Float64               = -12,\n    DateDay               = -13,\n    DateMillisecond       = -14,\n    TimestampSecond       = -15,\n    TimestampMillisecond  = -16,\n    TimestampMicrosecond  = -17,\n    TimestampNanosecond   = -18,\n    TimeSecond            = -19,\n    TimeMillisecond       = -20,\n    TimeMicrosecond       = -21,\n    TimeNanosecond        = -22,\n    DenseUnion            = -23,\n    SparseUnion           = -24,\n    IntervalDayTime       = -25,\n    IntervalYearMonth     = -26,\n}\n\nexport enum BufferType {\n    /**\n     * used in List type, Dense Union and variable length primitive types (String, Binary)\n     */\n    OFFSET = 0,\n\n    /**\n     * actual data, either wixed width primitive types in slots or variable width delimited by an OFFSET vector\n     */\n    DATA = 1,\n\n    /**\n     * Bit vector indicating if each value is null\n     */\n    VALIDITY = 2,\n\n    /**\n     * Type vector used in Union type\n     */\n    TYPE = 3\n  }\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nexport function getBool(_data: any, _index: number, byte: number, bit: number) {\n    return (byte & 1 << bit) !== 0;\n}\n\n/** @ignore */\nexport function getBit(_data: any, _index: number, byte: number, bit: number): 0 | 1 {\n    return (byte & 1 << bit) >> bit as (0 | 1);\n}\n\n/** @ignore */\nexport function setBool(bytes: Uint8Array, index: number, value: any) {\n    return value ?\n        !!(bytes[index >> 3] |=  (1 << (index % 8))) || true :\n        !(bytes[index >> 3] &= ~(1 << (index % 8))) && false ;\n}\n\n/** @ignore */\nexport function truncateBitmap(offset: number, length: number, bitmap: Uint8Array) {\n    const alignedSize = (bitmap.byteLength + 7) & ~7;\n    if (offset > 0 || bitmap.byteLength < alignedSize) {\n        const bytes = new Uint8Array(alignedSize);\n        // If the offset is a multiple of 8 bits, it's safe to slice the bitmap\n        bytes.set(offset % 8 === 0 ? bitmap.subarray(offset >> 3) :\n            // Otherwise iterate each bit from the offset and return a new one\n            packBools(iterateBits(bitmap, offset, length, null, getBool)).subarray(0, alignedSize));\n        return bytes;\n    }\n    return bitmap;\n}\n\n/** @ignore */\nexport function packBools(values: Iterable<any>) {\n    let xs: number[] = [];\n    let i = 0, bit = 0, byte = 0;\n    for (const value of values) {\n        value && (byte |= 1 << bit);\n        if (++bit === 8) {\n            xs[i++] = byte;\n            byte = bit = 0;\n        }\n    }\n    if (i === 0 || bit > 0) { xs[i++] = byte; }\n    let b = new Uint8Array((xs.length + 7) & ~7);\n    b.set(xs);\n    return b;\n}\n\n/** @ignore */\nexport function* iterateBits<T>(bytes: Uint8Array, begin: number, length: number, context: any,\n                                get: (context: any, index: number, byte: number, bit: number) => T) {\n    let bit = begin % 8;\n    let byteIndex = begin >> 3;\n    let index = 0, remaining = length;\n    for (; remaining > 0; bit = 0) {\n        let byte = bytes[byteIndex++];\n        do {\n            yield get(context, index++, byte, bit);\n        } while (--remaining > 0 && ++bit < 8);\n    }\n}\n\n/**\n * Compute the population count (the number of bits set to 1) for a range of bits in a Uint8Array.\n * @param vector The Uint8Array of bits for which to compute the population count.\n * @param lhs The range's left-hand side (or start) bit\n * @param rhs The range's right-hand side (or end) bit\n */\n/** @ignore */\nexport function popcnt_bit_range(data: Uint8Array, lhs: number, rhs: number): number {\n    if (rhs - lhs <= 0) { return 0; }\n    // If the bit range is less than one byte, sum the 1 bits in the bit range\n    if (rhs - lhs < 8) {\n        let sum = 0;\n        for (const bit of iterateBits(data, lhs, rhs - lhs, data, getBit)) {\n            sum += bit;\n        }\n        return sum;\n    }\n    // Get the next lowest multiple of 8 from the right hand side\n    const rhsInside = rhs >> 3 << 3;\n    // Get the next highest multiple of 8 from the left hand side\n    const lhsInside = lhs + (lhs % 8 === 0 ? 0 : 8 - lhs % 8);\n    return (\n        // Get the popcnt of bits between the left hand side, and the next highest multiple of 8\n        popcnt_bit_range(data, lhs, lhsInside) +\n        // Get the popcnt of bits between the right hand side, and the next lowest multiple of 8\n        popcnt_bit_range(data, rhsInside, rhs) +\n        // Get the popcnt of all bits between the left and right hand sides' multiples of 8\n        popcnt_array(data, lhsInside >> 3, (rhsInside - lhsInside) >> 3)\n    );\n}\n\n/** @ignore */\nexport function popcnt_array(arr: ArrayBufferView, byteOffset?: number, byteLength?: number) {\n    let cnt = 0, pos = byteOffset! | 0;\n    const view = new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n    const len =  byteLength === void 0 ? arr.byteLength : pos + byteLength;\n    while (len - pos >= 4) {\n        cnt += popcnt_uint32(view.getUint32(pos));\n        pos += 4;\n    }\n    while (len - pos >= 2) {\n        cnt += popcnt_uint32(view.getUint16(pos));\n        pos += 2;\n    }\n    while (len - pos >= 1) {\n        cnt += popcnt_uint32(view.getUint8(pos));\n        pos += 1;\n    }\n    return cnt;\n}\n\n/** @ignore */\nexport function popcnt_uint32(uint32: number): number {\n    let i = uint32 | 0;\n    i = i - ((i >>> 1) & 0x55555555);\n    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);\n    return (((i + (i >>> 4)) & 0x0F0F0F0F) * 0x01010101) >>> 24;\n}\n","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Vector } from './vector';\nimport { Type, Precision, DateUnit, TimeUnit, IntervalUnit, UnionMode } from './enum';\nimport { DataType, Float, Int, Date_, Interval, Time, Timestamp, Union, } from './type';\n\nexport abstract class Visitor {\n    public visitMany(nodes: any[], ...args: any[][]) {\n        return nodes.map((node, i) => this.visit(node, ...args.map((x) => x[i])));\n    }\n    public visit(...args: any[]) {\n        return this.getVisitFn(args[0], false).apply(this, args);\n    }\n    public getVisitFn(node: any, throwIfNotFound = true) {\n        return getVisitFn(this, node, throwIfNotFound);\n    }\n    public visitNull            (_node: any, ..._args: any[]): any { return null; }\n    public visitBool            (_node: any, ..._args: any[]): any { return null; }\n    public visitInt             (_node: any, ..._args: any[]): any { return null; }\n    public visitFloat           (_node: any, ..._args: any[]): any { return null; }\n    public visitUtf8            (_node: any, ..._args: any[]): any { return null; }\n    public visitBinary          (_node: any, ..._args: any[]): any { return null; }\n    public visitFixedSizeBinary (_node: any, ..._args: any[]): any { return null; }\n    public visitDate            (_node: any, ..._args: any[]): any { return null; }\n    public visitTimestamp       (_node: any, ..._args: any[]): any { return null; }\n    public visitTime            (_node: any, ..._args: any[]): any { return null; }\n    public visitDecimal         (_node: any, ..._args: any[]): any { return null; }\n    public visitList            (_node: any, ..._args: any[]): any { return null; }\n    public visitStruct          (_node: any, ..._args: any[]): any { return null; }\n    public visitUnion           (_node: any, ..._args: any[]): any { return null; }\n    public visitDictionary      (_node: any, ..._args: any[]): any { return null; }\n    public visitInterval        (_node: any, ..._args: any[]): any { return null; }\n    public visitFixedSizeList   (_node: any, ..._args: any[]): any { return null; }\n    public visitMap             (_node: any, ..._args: any[]): any { return null; }\n}\n\n/** @ignore */\nfunction getVisitFn<T extends DataType>(visitor: Visitor, node: any, throwIfNotFound = true) {\n    let fn: any = null;\n    let dtype: T['TType'] = Type.NONE;\n    // tslint:disable\n    if      (node instanceof Data    ) { dtype = inferDType(node.type as T); }\n    else if (node instanceof Vector  ) { dtype = inferDType(node.type as T); }\n    else if (node instanceof DataType) { dtype = inferDType(node      as T); }\n    else if (typeof (dtype = node) !== 'number') { dtype = Type[node] as any as T['TType']; }\n\n    switch (dtype) {\n        case Type.Null:                 fn = visitor.visitNull; break;\n        case Type.Bool:                 fn = visitor.visitBool; break;\n        case Type.Int:                  fn = visitor.visitInt; break;\n        case Type.Int8:                 fn = visitor.visitInt8 || visitor.visitInt; break;\n        case Type.Int16:                fn = visitor.visitInt16 || visitor.visitInt; break;\n        case Type.Int32:                fn = visitor.visitInt32 || visitor.visitInt; break;\n        case Type.Int64:                fn = visitor.visitInt64 || visitor.visitInt; break;\n        case Type.Uint8:                fn = visitor.visitUint8 || visitor.visitInt; break;\n        case Type.Uint16:               fn = visitor.visitUint16 || visitor.visitInt; break;\n        case Type.Uint32:               fn = visitor.visitUint32 || visitor.visitInt; break;\n        case Type.Uint64:               fn = visitor.visitUint64 || visitor.visitInt; break;\n        case Type.Float:                fn = visitor.visitFloat; break;\n        case Type.Float16:              fn = visitor.visitFloat16 || visitor.visitFloat; break;\n        case Type.Float32:              fn = visitor.visitFloat32 || visitor.visitFloat; break;\n        case Type.Float64:              fn = visitor.visitFloat64 || visitor.visitFloat; break;\n        case Type.Utf8:                 fn = visitor.visitUtf8; break;\n        case Type.Binary:               fn = visitor.visitBinary; break;\n        case Type.FixedSizeBinary:      fn = visitor.visitFixedSizeBinary; break;\n        case Type.Date:                 fn = visitor.visitDate; break;\n        case Type.DateDay:              fn = visitor.visitDateDay || visitor.visitDate; break;\n        case Type.DateMillisecond:      fn = visitor.visitDateMillisecond || visitor.visitDate; break;\n        case Type.Timestamp:            fn = visitor.visitTimestamp; break;\n        case Type.TimestampSecond:      fn = visitor.visitTimestampSecond || visitor.visitTimestamp; break;\n        case Type.TimestampMillisecond: fn = visitor.visitTimestampMillisecond || visitor.visitTimestamp; break;\n        case Type.TimestampMicrosecond: fn = visitor.visitTimestampMicrosecond || visitor.visitTimestamp; break;\n        case Type.TimestampNanosecond:  fn = visitor.visitTimestampNanosecond || visitor.visitTimestamp; break;\n        case Type.Time:                 fn = visitor.visitTime; break;\n        case Type.TimeSecond:           fn = visitor.visitTimeSecond || visitor.visitTime; break;\n        case Type.TimeMillisecond:      fn = visitor.visitTimeMillisecond || visitor.visitTime; break;\n        case Type.TimeMicrosecond:      fn = visitor.visitTimeMicrosecond || visitor.visitTime; break;\n        case Type.TimeNanosecond:       fn = visitor.visitTimeNanosecond || visitor.visitTime; break;\n        case Type.Decimal:              fn = visitor.visitDecimal; break;\n        case Type.List:                 fn = visitor.visitList; break;\n        case Type.Struct:               fn = visitor.visitStruct; break;\n        case Type.Union:                fn = visitor.visitUnion; break;\n        case Type.DenseUnion:           fn = visitor.visitDenseUnion || visitor.visitUnion; break;\n        case Type.SparseUnion:          fn = visitor.visitSparseUnion || visitor.visitUnion; break;\n        case Type.Dictionary:           fn = visitor.visitDictionary; break;\n        case Type.Interval:             fn = visitor.visitInterval; break;\n        case Type.IntervalDayTime:      fn = visitor.visitIntervalDayTime || visitor.visitInterval; break;\n        case Type.IntervalYearMonth:    fn = visitor.visitIntervalYearMonth || visitor.visitInterval; break;\n        case Type.FixedSizeList:        fn = visitor.visitFixedSizeList; break;\n        case Type.Map:                  fn = visitor.visitMap; break;\n    }\n    if (typeof fn === 'function') return fn;\n    if (!throwIfNotFound) return () => null;\n    throw new Error(`Unrecognized type '${Type[dtype]}'`);\n}\n\n/** @ignore */\nfunction inferDType<T extends DataType>(type: T): Type {\n    switch (type.typeId) {\n        case Type.Null: return Type.Null;\n        case Type.Int:\n            const { bitWidth, isSigned } = (type as any as Int);\n            switch (bitWidth) {\n                case  8: return isSigned ? Type.Int8  : Type.Uint8 ;\n                case 16: return isSigned ? Type.Int16 : Type.Uint16;\n                case 32: return isSigned ? Type.Int32 : Type.Uint32;\n                case 64: return isSigned ? Type.Int64 : Type.Uint64;\n            }\n            return Type.Int;\n        case Type.Float:\n            switch((type as any as Float).precision) {\n                case Precision.HALF: return Type.Float16;\n                case Precision.SINGLE: return Type.Float32;\n                case Precision.DOUBLE: return Type.Float64;\n            }\n            return Type.Float;\n        case Type.Binary: return Type.Binary;\n        case Type.Utf8: return Type.Utf8;\n        case Type.Bool: return Type.Bool;\n        case Type.Decimal: return Type.Decimal;\n        case Type.Time:\n            switch ((type as any as Time).unit) {\n                case TimeUnit.SECOND: return Type.TimeSecond;\n                case TimeUnit.MILLISECOND: return Type.TimeMillisecond;\n                case TimeUnit.MICROSECOND: return Type.TimeMicrosecond;\n                case TimeUnit.NANOSECOND: return Type.TimeNanosecond;\n            }\n            return Type.Time;\n        case Type.Timestamp:\n            switch ((type as any as Timestamp).unit) {\n                case TimeUnit.SECOND: return Type.TimestampSecond;\n                case TimeUnit.MILLISECOND: return Type.TimestampMillisecond;\n                case TimeUnit.MICROSECOND: return Type.TimestampMicrosecond;\n                case TimeUnit.NANOSECOND: return Type.TimestampNanosecond;\n            }\n            return Type.Timestamp;\n        case Type.Date:\n            switch ((type as any as Date_).unit) {\n                case DateUnit.DAY: return Type.DateDay;\n                case DateUnit.MILLISECOND: return Type.DateMillisecond;\n            }\n            return Type.Date;\n        case Type.Interval:\n            switch ((type as any as Interval).unit) {\n                case IntervalUnit.DAY_TIME: return Type.IntervalDayTime;\n                case IntervalUnit.YEAR_MONTH: return Type.IntervalYearMonth;\n            }\n            return Type.Interval;\n        case Type.Map: return Type.Map;\n        case Type.List: return Type.List;\n        case Type.Struct: return Type.Struct;\n        case Type.Union:\n            switch ((type as any as Union).mode) {\n                case UnionMode.Dense: return Type.DenseUnion;\n                case UnionMode.Sparse: return Type.SparseUnion;\n            }\n            return Type.Union;\n        case Type.FixedSizeBinary: return Type.FixedSizeBinary;\n        case Type.FixedSizeList: return Type.FixedSizeList;\n        case Type.Dictionary: return Type.Dictionary;\n    }\n    throw new Error(`Unrecognized type '${Type[type.typeId]}'`);\n}\n\nexport interface Visitor {\n    visitNull                  (node: any, ...args: any[]): any;\n    visitBool                  (node: any, ...args: any[]): any;\n    visitInt                   (node: any, ...args: any[]): any;\n    visitInt8?                 (node: any, ...args: any[]): any;\n    visitInt16?                (node: any, ...args: any[]): any;\n    visitInt32?                (node: any, ...args: any[]): any;\n    visitInt64?                (node: any, ...args: any[]): any;\n    visitUint8?                (node: any, ...args: any[]): any;\n    visitUint16?               (node: any, ...args: any[]): any;\n    visitUint32?               (node: any, ...args: any[]): any;\n    visitUint64?               (node: any, ...args: any[]): any;\n    visitFloat                 (node: any, ...args: any[]): any;\n    visitFloat16?              (node: any, ...args: any[]): any;\n    visitFloat32?              (node: any, ...args: any[]): any;\n    visitFloat64?              (node: any, ...args: any[]): any;\n    visitUtf8                  (node: any, ...args: any[]): any;\n    visitBinary                (node: any, ...args: any[]): any;\n    visitFixedSizeBinary       (node: any, ...args: any[]): any;\n    visitDate                  (node: any, ...args: any[]): any;\n    visitDateDay?              (node: any, ...args: any[]): any;\n    visitDateMillisecond?      (node: any, ...args: any[]): any;\n    visitTimestamp             (node: any, ...args: any[]): any;\n    visitTimestampSecond?      (node: any, ...args: any[]): any;\n    visitTimestampMillisecond? (node: any, ...args: any[]): any;\n    visitTimestampMicrosecond? (node: any, ...args: any[]): any;\n    visitTimestampNanosecond?  (node: any, ...args: any[]): any;\n    visitTime                  (node: any, ...args: any[]): any;\n    visitTimeSecond?           (node: any, ...args: any[]): any;\n    visitTimeMillisecond?      (node: any, ...args: any[]): any;\n    visitTimeMicrosecond?      (node: any, ...args: any[]): any;\n    visitTimeNanosecond?       (node: any, ...args: any[]): any;\n    visitDecimal               (node: any, ...args: any[]): any;\n    visitList                  (node: any, ...args: any[]): any;\n    visitStruct                (node: any, ...args: any[]): any;\n    visitUnion                 (node: any, ...args: any[]): any;\n    visitDenseUnion?           (node: any, ...args: any[]): any;\n    visitSparseUnion?          (node: any, ...args: any[]): any;\n    visitDictionary            (node: any, ...args: any[]): any;\n    visitInterval              (node: any, ...args: any[]): any;\n    visitIntervalDayTime?      (node: any, ...args: any[]): any;\n    visitIntervalYearMonth?    (node: any, ...args: any[]): any;\n    visitFixedSizeList         (node: any, ...args: any[]): any;\n    visitMap                   (node: any, ...args: any[]): any;\n}\n\n// Add these here so they're picked up by the externs creator\n// in the build, and closure-compiler doesn't minify them away\n(Visitor.prototype as any).visitInt8 = null;\n(Visitor.prototype as any).visitInt16 = null;\n(Visitor.prototype as any).visitInt32 = null;\n(Visitor.prototype as any).visitInt64 = null;\n(Visitor.prototype as any).visitUint8 = null;\n(Visitor.prototype as any).visitUint16 = null;\n(Visitor.prototype as any).visitUint32 = null;\n(Visitor.prototype as any).visitUint64 = null;\n(Visitor.prototype as any).visitFloat16 = null;\n(Visitor.prototype as any).visitFloat32 = null;\n(Visitor.prototype as any).visitFloat64 = null;\n(Visitor.prototype as any).visitDateDay = null;\n(Visitor.prototype as any).visitDateMillisecond = null;\n(Visitor.prototype as any).visitTimestampSecond = null;\n(Visitor.prototype as any).visitTimestampMillisecond = null;\n(Visitor.prototype as any).visitTimestampMicrosecond = null;\n(Visitor.prototype as any).visitTimestampNanosecond = null;\n(Visitor.prototype as any).visitTimeSecond = null;\n(Visitor.prototype as any).visitTimeMillisecond = null;\n(Visitor.prototype as any).visitTimeMicrosecond = null;\n(Visitor.prototype as any).visitTimeNanosecond = null;\n(Visitor.prototype as any).visitDenseUnion = null;\n(Visitor.prototype as any).visitSparseUnion = null;\n(Visitor.prototype as any).visitIntervalDayTime = null;\n(Visitor.prototype as any).visitIntervalYearMonth = null;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { Schema, Field } from '../schema';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface TypeComparator extends Visitor {\n    visit<T extends DataType>(type: T, other?: DataType | null): other is T;\n    visitMany<T extends DataType>(nodes: T[], others?: DataType[] | null): boolean[];\n    getVisitFn<T extends DataType>(node: VectorType<T> |  Data<T> | T): (other?: DataType | null) => other is T;\n    visitNull                 <T extends Null>                 (type: T, other?: DataType | null): other is T;\n    visitBool                 <T extends Bool>                 (type: T, other?: DataType | null): other is T;\n    visitInt                  <T extends Int>                  (type: T, other?: DataType | null): other is T;\n    visitInt8                 <T extends Int8>                 (type: T, other?: DataType | null): other is T;\n    visitInt16                <T extends Int16>                (type: T, other?: DataType | null): other is T;\n    visitInt32                <T extends Int32>                (type: T, other?: DataType | null): other is T;\n    visitInt64                <T extends Int64>                (type: T, other?: DataType | null): other is T;\n    visitUint8                <T extends Uint8>                (type: T, other?: DataType | null): other is T;\n    visitUint16               <T extends Uint16>               (type: T, other?: DataType | null): other is T;\n    visitUint32               <T extends Uint32>               (type: T, other?: DataType | null): other is T;\n    visitUint64               <T extends Uint64>               (type: T, other?: DataType | null): other is T;\n    visitFloat                <T extends Float>                (type: T, other?: DataType | null): other is T;\n    visitFloat16              <T extends Float16>              (type: T, other?: DataType | null): other is T;\n    visitFloat32              <T extends Float32>              (type: T, other?: DataType | null): other is T;\n    visitFloat64              <T extends Float64>              (type: T, other?: DataType | null): other is T;\n    visitUtf8                 <T extends Utf8>                 (type: T, other?: DataType | null): other is T;\n    visitBinary               <T extends Binary>               (type: T, other?: DataType | null): other is T;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>      (type: T, other?: DataType | null): other is T;\n    visitDate                 <T extends Date_>                (type: T, other?: DataType | null): other is T;\n    visitDateDay              <T extends DateDay>              (type: T, other?: DataType | null): other is T;\n    visitDateMillisecond      <T extends DateMillisecond>      (type: T, other?: DataType | null): other is T;\n    visitTimestamp            <T extends Timestamp>            (type: T, other?: DataType | null): other is T;\n    visitTimestampSecond      <T extends TimestampSecond>      (type: T, other?: DataType | null): other is T;\n    visitTimestampMillisecond <T extends TimestampMillisecond> (type: T, other?: DataType | null): other is T;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond> (type: T, other?: DataType | null): other is T;\n    visitTimestampNanosecond  <T extends TimestampNanosecond>  (type: T, other?: DataType | null): other is T;\n    visitTime                 <T extends Time>                 (type: T, other?: DataType | null): other is T;\n    visitTimeSecond           <T extends TimeSecond>           (type: T, other?: DataType | null): other is T;\n    visitTimeMillisecond      <T extends TimeMillisecond>      (type: T, other?: DataType | null): other is T;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>      (type: T, other?: DataType | null): other is T;\n    visitTimeNanosecond       <T extends TimeNanosecond>       (type: T, other?: DataType | null): other is T;\n    visitDecimal              <T extends Decimal>              (type: T, other?: DataType | null): other is T;\n    visitList                 <T extends List>                 (type: T, other?: DataType | null): other is T;\n    visitStruct               <T extends Struct>               (type: T, other?: DataType | null): other is T;\n    visitUnion                <T extends Union>                (type: T, other?: DataType | null): other is T;\n    visitDenseUnion           <T extends DenseUnion>           (type: T, other?: DataType | null): other is T;\n    visitSparseUnion          <T extends SparseUnion>          (type: T, other?: DataType | null): other is T;\n    visitDictionary           <T extends Dictionary>           (type: T, other?: DataType | null): other is T;\n    visitInterval             <T extends Interval>             (type: T, other?: DataType | null): other is T;\n    visitIntervalDayTime      <T extends IntervalDayTime>      (type: T, other?: DataType | null): other is T;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>    (type: T, other?: DataType | null): other is T;\n    visitFixedSizeList        <T extends FixedSizeList>        (type: T, other?: DataType | null): other is T;\n    visitMap                  <T extends Map_>                 (type: T, other?: DataType | null): other is T;\n}\n\n/** @ignore */\nexport class TypeComparator extends Visitor {\n    compareSchemas<T extends { [key: string]: DataType }>(schema: Schema<T>, other?: Schema | null): other is Schema<T> {\n        return (schema === other) || (\n            other instanceof schema.constructor &&\n            instance.compareFields(schema.fields, other.fields)\n        );\n    }\n    compareFields<T extends { [key: string]: DataType }>(fields: Field<T[keyof T]>[], others?: Field[] | null): others is Field<T[keyof T]>[] {\n        return (fields === others) || (\n            Array.isArray(fields) &&\n            Array.isArray(others) &&\n            fields.length === others.length &&\n            fields.every((f, i) => instance.compareField(f, others[i]))\n        );\n    }\n    compareField<T extends DataType = any>(field: Field<T>, other?: Field | null): other is Field<T> {\n        return (field === other) || (\n            other instanceof field.constructor &&\n            field.name === other.name &&\n            field.nullable === other.nullable &&\n            instance.visit(field.type, other.type)\n        );\n    }\n}\n\nfunction compareConstructor<T extends DataType>(type: T, other?: DataType | null): other is T {\n    return other instanceof type.constructor;\n}\n\nfunction compareAny<T extends DataType>(type: T, other?: DataType | null): other is T {\n    return (type === other) || compareConstructor(type, other);\n}\n\nfunction compareInt<T extends Int>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.bitWidth === other.bitWidth &&\n        type.isSigned === other.isSigned\n    );\n}\n\nfunction compareFloat<T extends Float>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.precision === other.precision\n    );\n}\n\nfunction compareFixedSizeBinary<T extends FixedSizeBinary>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.byteWidth === other.byteWidth\n    );\n}\n\nfunction compareDate<T extends Date_>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit\n    );\n}\n\nfunction compareTimestamp<T extends Timestamp>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit &&\n        type.timezone === other.timezone\n    );\n}\n\nfunction compareTime<T extends Time>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit &&\n        type.bitWidth === other.bitWidth\n    );\n}\n\nfunction compareList<T extends List>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareStruct<T extends Struct>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareUnion<T extends Union>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.mode === other.mode &&\n        type.typeIds.every((x, i) => x === other.typeIds[i]) &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareDictionary<T extends Dictionary>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.id === other.id &&\n        type.isOrdered === other.isOrdered &&\n        instance.visit(<any> type.indices, other.indices) &&\n        instance.visit(type.dictionary, other.dictionary)\n    );\n}\n\nfunction compareInterval<T extends Interval>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.unit === other.unit\n    );\n}\n\nfunction compareFixedSizeList<T extends FixedSizeList>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.listSize === other.listSize &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nfunction compareMap<T extends Map_>(type: T, other?: DataType | null): other is T {\n    return (type === other) || (\n        compareConstructor(type, other) &&\n        type.keysSorted === other.keysSorted &&\n        type.children.length === other.children.length &&\n        instance.compareFields(type.children, other.children)\n    );\n}\n\nTypeComparator.prototype.visitNull                 =             compareAny;\nTypeComparator.prototype.visitBool                 =             compareAny;\nTypeComparator.prototype.visitInt                  =             compareInt;\nTypeComparator.prototype.visitInt8                 =             compareInt;\nTypeComparator.prototype.visitInt16                =             compareInt;\nTypeComparator.prototype.visitInt32                =             compareInt;\nTypeComparator.prototype.visitInt64                =             compareInt;\nTypeComparator.prototype.visitUint8                =             compareInt;\nTypeComparator.prototype.visitUint16               =             compareInt;\nTypeComparator.prototype.visitUint32               =             compareInt;\nTypeComparator.prototype.visitUint64               =             compareInt;\nTypeComparator.prototype.visitFloat                =           compareFloat;\nTypeComparator.prototype.visitFloat16              =           compareFloat;\nTypeComparator.prototype.visitFloat32              =           compareFloat;\nTypeComparator.prototype.visitFloat64              =           compareFloat;\nTypeComparator.prototype.visitUtf8                 =             compareAny;\nTypeComparator.prototype.visitBinary               =             compareAny;\nTypeComparator.prototype.visitFixedSizeBinary      = compareFixedSizeBinary;\nTypeComparator.prototype.visitDate                 =            compareDate;\nTypeComparator.prototype.visitDateDay              =            compareDate;\nTypeComparator.prototype.visitDateMillisecond      =            compareDate;\nTypeComparator.prototype.visitTimestamp            =       compareTimestamp;\nTypeComparator.prototype.visitTimestampSecond      =       compareTimestamp;\nTypeComparator.prototype.visitTimestampMillisecond =       compareTimestamp;\nTypeComparator.prototype.visitTimestampMicrosecond =       compareTimestamp;\nTypeComparator.prototype.visitTimestampNanosecond  =       compareTimestamp;\nTypeComparator.prototype.visitTime                 =            compareTime;\nTypeComparator.prototype.visitTimeSecond           =            compareTime;\nTypeComparator.prototype.visitTimeMillisecond      =            compareTime;\nTypeComparator.prototype.visitTimeMicrosecond      =            compareTime;\nTypeComparator.prototype.visitTimeNanosecond       =            compareTime;\nTypeComparator.prototype.visitDecimal              =             compareAny;\nTypeComparator.prototype.visitList                 =            compareList;\nTypeComparator.prototype.visitStruct               =          compareStruct;\nTypeComparator.prototype.visitUnion                =           compareUnion;\nTypeComparator.prototype.visitDenseUnion           =           compareUnion;\nTypeComparator.prototype.visitSparseUnion          =           compareUnion;\nTypeComparator.prototype.visitDictionary           =      compareDictionary;\nTypeComparator.prototype.visitInterval             =        compareInterval;\nTypeComparator.prototype.visitIntervalDayTime      =        compareInterval;\nTypeComparator.prototype.visitIntervalYearMonth    =        compareInterval;\nTypeComparator.prototype.visitFixedSizeList        =   compareFixedSizeList;\nTypeComparator.prototype.visitMap                  =             compareMap;\n\n/** @ignore */\nexport const instance = new TypeComparator();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/* tslint:disable:class-name */\n\nimport { Field } from './schema';\nimport { flatbuffers } from 'flatbuffers';\nimport { TypedArrayConstructor } from './interfaces';\nimport { VectorType as V, TypeToDataType } from './interfaces';\nimport { instance as comparer } from './visitor/typecomparator';\n\nimport Long = flatbuffers.Long;\nimport {\n    Type,\n    Precision, UnionMode,\n    DateUnit, TimeUnit, IntervalUnit\n} from './enum';\n\n/** @ignore */\nexport type TimeBitWidth = 32 | 64;\n/** @ignore */\nexport type IntBitWidth = 8 | 16 | 32 | 64;\n/** @ignore */\nexport type IsSigned = { 'true': true; 'false': false };\n/** @ignore */\nexport type RowLike<T extends { [key: string]: DataType }> =\n      ( Iterable<[string, T[keyof T]['TValue'] | null]> )\n    & { [P in keyof T]: T[P]['TValue'] | null }\n    & { get<K extends keyof T>(key: K): T[K]['TValue'] | null; }\n    & { set<K extends keyof T>(key: K, val: T[K]['TValue'] | null): void; }\n    ;\n\n/** @ignore */\nexport type MapLike<K extends DataType = any, V extends DataType = any> =\n      { [P in K['TValue']]: V['TValue'] | null }\n    & ( Map<K['TValue'], V['TValue'] | null> )\n    ;\n\nexport interface DataType<TType extends Type = Type, TChildren extends { [key: string]: DataType } = any> {\n    readonly TType: TType;\n    readonly TArray: any;\n    readonly TValue: any;\n    readonly ArrayType: any;\n    readonly children: Field<TChildren[keyof TChildren]>[];\n}\n\n/**\n * An abstract base class for classes that encapsulate metadata about each of\n * the logical types that Arrow can represent.\n */\nexport abstract class DataType<TType extends Type = Type, TChildren extends { [key: string]: DataType } = any> {\n\n    // @ts-ignore\n    public [Symbol.toStringTag]: string;\n\n    /** @nocollapse */ static            isNull (x: any): x is Null            { return x && x.typeId === Type.Null;            }\n    /** @nocollapse */ static             isInt (x: any): x is Int_            { return x && x.typeId === Type.Int;             }\n    /** @nocollapse */ static           isFloat (x: any): x is Float           { return x && x.typeId === Type.Float;           }\n    /** @nocollapse */ static          isBinary (x: any): x is Binary          { return x && x.typeId === Type.Binary;          }\n    /** @nocollapse */ static            isUtf8 (x: any): x is Utf8            { return x && x.typeId === Type.Utf8;            }\n    /** @nocollapse */ static            isBool (x: any): x is Bool            { return x && x.typeId === Type.Bool;            }\n    /** @nocollapse */ static         isDecimal (x: any): x is Decimal         { return x && x.typeId === Type.Decimal;         }\n    /** @nocollapse */ static            isDate (x: any): x is Date_           { return x && x.typeId === Type.Date;            }\n    /** @nocollapse */ static            isTime (x: any): x is Time_           { return x && x.typeId === Type.Time;            }\n    /** @nocollapse */ static       isTimestamp (x: any): x is Timestamp_      { return x && x.typeId === Type.Timestamp;       }\n    /** @nocollapse */ static        isInterval (x: any): x is Interval_       { return x && x.typeId === Type.Interval;        }\n    /** @nocollapse */ static            isList (x: any): x is List            { return x && x.typeId === Type.List;            }\n    /** @nocollapse */ static          isStruct (x: any): x is Struct          { return x && x.typeId === Type.Struct;          }\n    /** @nocollapse */ static           isUnion (x: any): x is Union_          { return x && x.typeId === Type.Union;           }\n    /** @nocollapse */ static isFixedSizeBinary (x: any): x is FixedSizeBinary { return x && x.typeId === Type.FixedSizeBinary; }\n    /** @nocollapse */ static   isFixedSizeList (x: any): x is FixedSizeList   { return x && x.typeId === Type.FixedSizeList;   }\n    /** @nocollapse */ static             isMap (x: any): x is Map_            { return x && x.typeId === Type.Map;             }\n    /** @nocollapse */ static      isDictionary (x: any): x is Dictionary      { return x && x.typeId === Type.Dictionary;      }\n\n    public get typeId(): TType { return <any> Type.NONE; }\n    public compareTo(other: DataType): other is TypeToDataType<TType> {\n        return comparer.visit(this, other);\n    }\n\n    protected static [Symbol.toStringTag] = ((proto: DataType) => {\n        (<any> proto).children = null;\n        (<any> proto).ArrayType = Array;\n        return proto[Symbol.toStringTag] = 'DataType';\n    })(DataType.prototype);\n}\n\n/** @ignore */\nexport interface Null extends DataType<Type.Null> { TArray: void; TValue: null; }\n/** @ignore */\nexport class Null extends DataType<Type.Null> {\n    public toString() { return `Null`; }\n    public get typeId() { return Type.Null as Type.Null; }\n    protected static [Symbol.toStringTag] = ((proto: Null) => {\n        return proto[Symbol.toStringTag] = 'Null';\n    })(Null.prototype);\n}\n\n/** @ignore */\ntype Ints = Type.Int | Type.Int8 | Type.Int16 | Type.Int32 | Type.Int64 | Type.Uint8 | Type.Uint16 | Type.Uint32 | Type.Uint64;\n/** @ignore */\ntype IType = {\n    [Type.Int   ]: { bitWidth: IntBitWidth; isSigned: true | false; TArray: IntArray;    TValue: number | bigint | Int32Array | Uint32Array; };\n    [Type.Int8  ]: { bitWidth:           8; isSigned: true;         TArray: Int8Array;   TValue: number; };\n    [Type.Int16 ]: { bitWidth:          16; isSigned: true;         TArray: Int16Array;  TValue: number; };\n    [Type.Int32 ]: { bitWidth:          32; isSigned: true;         TArray: Int32Array;  TValue: number; };\n    [Type.Int64 ]: { bitWidth:          64; isSigned: true;         TArray: Int32Array;  TValue: bigint | Int32Array | Uint32Array; };\n    [Type.Uint8 ]: { bitWidth:           8; isSigned: false;        TArray: Uint8Array;  TValue: number; };\n    [Type.Uint16]: { bitWidth:          16; isSigned: false;        TArray: Uint16Array; TValue: number; };\n    [Type.Uint32]: { bitWidth:          32; isSigned: false;        TArray: Uint32Array; TValue: number; };\n    [Type.Uint64]: { bitWidth:          64; isSigned: false;        TArray: Uint32Array; TValue: bigint | Int32Array | Uint32Array; };\n};\n\n/** @ignore */\ninterface Int_<T extends Ints = Ints> extends DataType<T> { TArray: IType[T]['TArray']; TValue: IType[T]['TValue']; }\n/** @ignore */\nclass Int_<T extends Ints = Ints> extends DataType<T> {\n    constructor(public readonly isSigned: IType[T]['isSigned'],\n                public readonly bitWidth: IType[T]['bitWidth']) {\n        super();\n    }\n    public get typeId() { return Type.Int as T; }\n    public get ArrayType(): TypedArrayConstructor<IType[T]['TArray']> {\n        switch (this.bitWidth) {\n            case  8: return this.isSigned ?  Int8Array :  Uint8Array;\n            case 16: return this.isSigned ? Int16Array : Uint16Array;\n            case 32: return this.isSigned ? Int32Array : Uint32Array;\n            case 64: return this.isSigned ? Int32Array : Uint32Array;\n        }\n        throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n    }\n    public toString() { return `${this.isSigned ? `I` : `Ui`}nt${this.bitWidth}`; }\n    protected static [Symbol.toStringTag] = ((proto: Int_) => {\n        (<any> proto).isSigned = null;\n        (<any> proto).bitWidth = null;\n        return proto[Symbol.toStringTag] = 'Int';\n    })(Int_.prototype);\n}\n\nexport { Int_ as Int };\n\n/** @ignore */\nexport class Int8 extends Int_<Type.Int8> { constructor() { super(true, 8); } }\n/** @ignore */\nexport class Int16 extends Int_<Type.Int16> { constructor() { super(true, 16); } }\n/** @ignore */\nexport class Int32 extends Int_<Type.Int32> { constructor() { super(true, 32); } }\n/** @ignore */\nexport class Int64 extends Int_<Type.Int64> { constructor() { super(true, 64); } }\n/** @ignore */\nexport class Uint8 extends Int_<Type.Uint8> { constructor() { super(false, 8); } }\n/** @ignore */\nexport class Uint16 extends Int_<Type.Uint16> { constructor() { super(false, 16); } }\n/** @ignore */\nexport class Uint32 extends Int_<Type.Uint32> { constructor() { super(false, 32); } }\n/** @ignore */\nexport class Uint64 extends Int_<Type.Uint64> { constructor() { super(false, 64); } }\n\nObject.defineProperty(Int8.prototype, 'ArrayType', { value: Int8Array });\nObject.defineProperty(Int16.prototype, 'ArrayType', { value: Int16Array });\nObject.defineProperty(Int32.prototype, 'ArrayType', { value: Int32Array });\nObject.defineProperty(Int64.prototype, 'ArrayType', { value: Int32Array });\nObject.defineProperty(Uint8.prototype, 'ArrayType', { value: Uint8Array });\nObject.defineProperty(Uint16.prototype, 'ArrayType', { value: Uint16Array });\nObject.defineProperty(Uint32.prototype, 'ArrayType', { value: Uint32Array });\nObject.defineProperty(Uint64.prototype, 'ArrayType', { value: Uint32Array });\n\n/** @ignore */\ntype Floats = Type.Float | Type.Float16 | Type.Float32 | Type.Float64;\n/** @ignore */\ntype FType = {\n    [Type.Float  ]: { precision: Precision;        TArray: FloatArray;    TValue: number; };\n    [Type.Float16]: { precision: Precision.HALF;   TArray: Uint16Array;   TValue: number; };\n    [Type.Float32]: { precision: Precision.SINGLE; TArray: Float32Array;  TValue: number; };\n    [Type.Float64]: { precision: Precision.DOUBLE; TArray: Float64Array;  TValue: number; };\n};\n\n/** @ignore */\nexport interface Float<T extends Floats = Floats> extends DataType<T> { TArray: FType[T]['TArray']; TValue: number; }\n/** @ignore */\nexport class Float<T extends Floats = Floats> extends DataType<T> {\n    constructor(public readonly precision: Precision) {\n        super();\n    }\n    public get typeId() { return Type.Float as T; }\n    public get ArrayType(): TypedArrayConstructor<FType[T]['TArray']> {\n        switch (this.precision) {\n            case Precision.HALF: return Uint16Array;\n            case Precision.SINGLE: return Float32Array;\n            case Precision.DOUBLE: return Float64Array;\n        }\n        throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);\n    }\n    public toString() { return `Float${(this.precision << 5) || 16}`; }\n    protected static [Symbol.toStringTag] = ((proto: Float) => {\n        (<any> proto).precision = null;\n        return proto[Symbol.toStringTag] = 'Float';\n    })(Float.prototype);\n}\n\n/** @ignore */\nexport class Float16 extends Float<Type.Float16> { constructor() { super(Precision.HALF); } }\n/** @ignore */\nexport class Float32 extends Float<Type.Float32> { constructor() { super(Precision.SINGLE); } }\n/** @ignore */\nexport class Float64 extends Float<Type.Float64> { constructor() { super(Precision.DOUBLE); } }\n\nObject.defineProperty(Float16.prototype, 'ArrayType', { value: Uint16Array });\nObject.defineProperty(Float32.prototype, 'ArrayType', { value: Float32Array });\nObject.defineProperty(Float64.prototype, 'ArrayType', { value: Float64Array });\n\n/** @ignore */\nexport interface Binary extends DataType<Type.Binary> { TArray: Uint8Array; TValue: Uint8Array; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class Binary extends DataType<Type.Binary> {\n    constructor() {\n        super();\n    }\n    public get typeId() { return Type.Binary as Type.Binary; }\n    public toString() { return `Binary`; }\n    protected static [Symbol.toStringTag] = ((proto: Binary) => {\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'Binary';\n    })(Binary.prototype);\n}\n\n/** @ignore */\nexport interface Utf8 extends DataType<Type.Utf8> { TArray: Uint8Array; TValue: string; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class Utf8 extends DataType<Type.Utf8> {\n    constructor() {\n        super();\n    }\n    public get typeId() { return Type.Utf8 as Type.Utf8; }\n    public toString() { return `Utf8`; }\n    protected static [Symbol.toStringTag] = ((proto: Utf8) => {\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'Utf8';\n    })(Utf8.prototype);\n}\n\n/** @ignore */\nexport interface Bool extends DataType<Type.Bool> { TArray: Uint8Array; TValue: boolean; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class Bool extends DataType<Type.Bool> {\n    constructor() {\n        super();\n    }\n    public get typeId() { return Type.Bool as Type.Bool; }\n    public toString() { return `Bool`; }\n    protected static [Symbol.toStringTag] = ((proto: Bool) => {\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'Bool';\n    })(Bool.prototype);\n}\n\n/** @ignore */\nexport interface Decimal extends DataType<Type.Decimal> { TArray: Uint32Array; TValue: Uint32Array; ArrayType: TypedArrayConstructor<Uint32Array>; }\n/** @ignore */\nexport class Decimal extends DataType<Type.Decimal> {\n    constructor(public readonly scale: number,\n                public readonly precision: number) {\n        super();\n    }\n    public get typeId() { return Type.Decimal as Type.Decimal; }\n    public toString() { return `Decimal[${this.precision}e${this.scale > 0 ? `+` : ``}${this.scale}]`; }\n    protected static [Symbol.toStringTag] = ((proto: Decimal) => {\n        (<any> proto).scale = null;\n        (<any> proto).precision = null;\n        (<any> proto).ArrayType = Uint32Array;\n        return proto[Symbol.toStringTag] = 'Decimal';\n    })(Decimal.prototype);\n}\n\n/** @ignore */\nexport type Dates = Type.Date | Type.DateDay | Type.DateMillisecond;\n/** @ignore */\nexport interface Date_<T extends Dates = Dates> extends DataType<T> { TArray: Int32Array; TValue: Date; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nexport class Date_<T extends Dates = Dates> extends DataType<T> {\n    constructor(public readonly unit: DateUnit) {\n        super();\n    }\n    public get typeId() { return Type.Date as T; }\n    public toString() { return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Date_) => {\n        (<any> proto).unit = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Date';\n    })(Date_.prototype);\n}\n\n/** @ignore */\nexport class DateDay extends Date_<Type.DateDay> { constructor() { super(DateUnit.DAY); } }\n/** @ignore */\nexport class DateMillisecond extends Date_<Type.DateMillisecond> { constructor() { super(DateUnit.MILLISECOND); } }\n\n/** @ignore */\ntype Times = Type.Time | Type.TimeSecond | Type.TimeMillisecond | Type.TimeMicrosecond | Type.TimeNanosecond;\n/** @ignore */\ntype TimesType = {\n    [Type.Time           ]: { unit: TimeUnit;             TValue: number | Int32Array };\n    [Type.TimeSecond     ]: { unit: TimeUnit.SECOND;      TValue: number;             };\n    [Type.TimeMillisecond]: { unit: TimeUnit.MILLISECOND; TValue: number;             };\n    [Type.TimeMicrosecond]: { unit: TimeUnit.MICROSECOND; TValue: Int32Array;         };\n    [Type.TimeNanosecond ]: { unit: TimeUnit.NANOSECOND;  TValue: Int32Array;         };\n};\n\n/** @ignore */\ninterface Time_<T extends Times = Times> extends DataType<T> { TArray: Int32Array; TValue: TimesType[T]['TValue']; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nclass Time_<T extends Times = Times> extends DataType<T> {\n    constructor(public readonly unit: TimesType[T]['unit'],\n                public readonly bitWidth: TimeBitWidth) {\n        super();\n    }\n    public get typeId() { return Type.Time as T; }\n    public toString() { return `Time${this.bitWidth}<${TimeUnit[this.unit]}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Time_) => {\n        (<any> proto).unit = null;\n        (<any> proto).bitWidth = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Time';\n    })(Time_.prototype);\n}\n\nexport { Time_ as Time };\n\n/** @ignore */\nexport class TimeSecond extends Time_<Type.TimeSecond> { constructor() { super(TimeUnit.SECOND, 32); } }\n/** @ignore */\nexport class TimeMillisecond extends Time_<Type.TimeMillisecond> { constructor() { super(TimeUnit.MILLISECOND, 32); } }\n/** @ignore */\nexport class TimeMicrosecond extends Time_<Type.TimeMicrosecond> { constructor() { super(TimeUnit.MICROSECOND, 64); } }\n/** @ignore */\nexport class TimeNanosecond extends Time_<Type.TimeNanosecond> { constructor() { super(TimeUnit.NANOSECOND, 64); } }\n\n/** @ignore */\ntype Timestamps = Type.Timestamp | Type.TimestampSecond | Type.TimestampMillisecond | Type.TimestampMicrosecond | Type.TimestampNanosecond;\n/** @ignore */\ninterface Timestamp_<T extends Timestamps = Timestamps> extends DataType<T> { TArray: Int32Array; TValue: number; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nclass Timestamp_<T extends Timestamps = Timestamps> extends DataType<T> {\n    constructor(public readonly unit: TimeUnit,\n                public readonly timezone?: string | null) {\n        super();\n    }\n    public get typeId() { return Type.Timestamp as T; }\n    public toString() { return `Timestamp<${TimeUnit[this.unit]}${this.timezone ? `, ${this.timezone}` : ``}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Timestamp_) => {\n        (<any> proto).unit = null;\n        (<any> proto).timezone = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Timestamp';\n    })(Timestamp_.prototype);\n}\n\nexport { Timestamp_ as Timestamp };\n\n/** @ignore */\nexport class TimestampSecond extends Timestamp_<Type.TimestampSecond> { constructor(timezone?: string | null) { super(TimeUnit.SECOND, timezone); } }\n/** @ignore */\nexport class TimestampMillisecond extends Timestamp_<Type.TimestampMillisecond> { constructor(timezone?: string | null) { super(TimeUnit.MILLISECOND, timezone); } }\n/** @ignore */\nexport class TimestampMicrosecond extends Timestamp_<Type.TimestampMicrosecond> { constructor(timezone?: string | null) { super(TimeUnit.MICROSECOND, timezone); } }\n/** @ignore */\nexport class TimestampNanosecond extends Timestamp_<Type.TimestampNanosecond> { constructor(timezone?: string | null) { super(TimeUnit.NANOSECOND, timezone); } }\n\n/** @ignore */\ntype Intervals = Type.Interval | Type.IntervalDayTime | Type.IntervalYearMonth;\n/** @ignore */\ninterface Interval_<T extends Intervals = Intervals> extends DataType<T> { TArray: Int32Array; TValue: Int32Array; ArrayType: TypedArrayConstructor<Int32Array>; }\n/** @ignore */\nclass Interval_<T extends Intervals = Intervals> extends DataType<T> {\n    constructor(public readonly unit: IntervalUnit) {\n        super();\n    }\n    public get typeId() { return Type.Interval as T; }\n    public toString() { return `Interval<${IntervalUnit[this.unit]}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Interval_) => {\n        (<any> proto).unit = null;\n        (<any> proto).ArrayType = Int32Array;\n        return proto[Symbol.toStringTag] = 'Interval';\n    })(Interval_.prototype);\n}\n\nexport { Interval_ as Interval };\n\n/** @ignore */\nexport class IntervalDayTime extends Interval_<Type.IntervalDayTime> { constructor() { super(IntervalUnit.DAY_TIME); } }\n/** @ignore */\nexport class IntervalYearMonth extends Interval_<Type.IntervalYearMonth> { constructor() { super(IntervalUnit.YEAR_MONTH); } }\n\n/** @ignore */\nexport interface List<T extends DataType = any> extends DataType<Type.List, { [0]: T }>  { TArray: IterableArrayLike<T>; TValue: V<T>; }\n/** @ignore */\nexport class List<T extends DataType = any> extends DataType<Type.List, { [0]: T }> {\n    constructor(child: Field<T>) {\n        super();\n        this.children = [child];\n    }\n    public readonly children: Field<T>[];\n    public get typeId() { return Type.List as Type.List; }\n    public toString() { return `List<${this.valueType}>`; }\n    public get valueType(): T { return this.children[0].type as T; }\n    public get valueField(): Field<T> { return this.children[0] as Field<T>; }\n    public get ArrayType(): T['ArrayType'] { return this.valueType.ArrayType; }\n    protected static [Symbol.toStringTag] = ((proto: List) => {\n        (<any> proto).children = null;\n        return proto[Symbol.toStringTag] = 'List';\n    })(List.prototype);\n}\n\n/** @ignore */\nexport interface Struct<T extends { [key: string]: DataType } = any> extends DataType<Type.Struct> { TArray: IterableArrayLike<RowLike<T>>; TValue: RowLike<T>; dataTypes: T; }\n/** @ignore */\nexport class Struct<T extends { [key: string]: DataType } = any> extends DataType<Type.Struct, T> {\n    public readonly children: Field<T[keyof T]>[];\n    constructor(children: Field<T[keyof T]>[]) {\n        super();\n        this.children = children;\n    }\n    public get typeId() { return Type.Struct as Type.Struct; }\n    public toString() { return `Struct<{${this.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Struct) => {\n        (<any> proto).children = null;\n        return proto[Symbol.toStringTag] = 'Struct';\n    })(Struct.prototype);\n}\n\n/** @ignore */\ntype Unions = Type.Union | Type.DenseUnion | Type.SparseUnion;\n/** @ignore */\ninterface Union_<T extends Unions = Unions> extends DataType<T> { TArray: Int8Array; TValue: any; ArrayType: TypedArrayConstructor<Int8Array>; }\n/** @ignore */\nclass Union_<T extends Unions = Unions> extends DataType<T> {\n    public readonly mode: UnionMode;\n    public readonly typeIds: Int32Array;\n    public readonly children: Field<any>[];\n    public readonly typeIdToChildIndex: { [key: number]: number };\n    constructor(mode: UnionMode,\n                typeIds: number[] | Int32Array,\n                children: Field<any>[]) {\n        super();\n        this.mode = mode;\n        this.children = children;\n        this.typeIds = typeIds = Int32Array.from(typeIds);\n        this.typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => {\n            return (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex;\n        }, Object.create(null) as { [key: number]: number });\n    }\n    public get typeId() { return Type.Union as T; }\n    public toString() { return `${this[Symbol.toStringTag]}<${\n        this.children.map((x) => `${x.type}`).join(` | `)\n    }>`; }\n    protected static [Symbol.toStringTag] = ((proto: Union_) => {\n        (<any> proto).mode = null;\n        (<any> proto).typeIds = null;\n        (<any> proto).children = null;\n        (<any> proto).typeIdToChildIndex = null;\n        (<any> proto).ArrayType = Int8Array;\n        return proto[Symbol.toStringTag] = 'Union';\n    })(Union_.prototype);\n}\n\nexport { Union_ as Union };\n\n/** @ignore */\nexport class DenseUnion extends Union_<Type.DenseUnion> {\n    constructor(typeIds: number[] | Int32Array, children: Field[]) {\n        super(UnionMode.Dense, typeIds, children);\n    }\n}\n\n/** @ignore */\nexport class SparseUnion extends Union_<Type.SparseUnion> {\n    constructor(typeIds: number[] | Int32Array, children: Field[]) {\n        super(UnionMode.Sparse, typeIds, children);\n    }\n}\n\n/** @ignore */\nexport interface FixedSizeBinary extends DataType<Type.FixedSizeBinary> { TArray: Uint8Array; TValue: Uint8Array; ArrayType: TypedArrayConstructor<Uint8Array>; }\n/** @ignore */\nexport class FixedSizeBinary extends DataType<Type.FixedSizeBinary> {\n    constructor(public readonly byteWidth: number) {\n        super();\n    }\n    public get typeId() { return Type.FixedSizeBinary as Type.FixedSizeBinary; }\n    public toString() { return `FixedSizeBinary[${this.byteWidth}]`; }\n    protected static [Symbol.toStringTag] = ((proto: FixedSizeBinary) => {\n        (<any> proto).byteWidth = null;\n        (<any> proto).ArrayType = Uint8Array;\n        return proto[Symbol.toStringTag] = 'FixedSizeBinary';\n    })(FixedSizeBinary.prototype);\n}\n\n/** @ignore */\nexport interface FixedSizeList<T extends DataType = any> extends DataType<Type.FixedSizeList> { TArray: IterableArrayLike<T['TArray']>; TValue: V<T>; }\n/** @ignore */\nexport class FixedSizeList<T extends DataType = any> extends DataType<Type.FixedSizeList, { [0]: T }> {\n    public readonly children: Field<T>[];\n    constructor(public readonly listSize: number, child: Field<T>) {\n        super();\n        this.children = [child];\n    }\n    public get typeId() { return Type.FixedSizeList as Type.FixedSizeList; }\n    public get valueType(): T { return this.children[0].type as T; }\n    public get valueField(): Field<T> { return this.children[0] as Field<T>; }\n    public get ArrayType(): T['ArrayType'] { return this.valueType.ArrayType; }\n    public toString() { return `FixedSizeList[${this.listSize}]<${this.valueType}>`; }\n    protected static [Symbol.toStringTag] = ((proto: FixedSizeList) => {\n        (<any> proto).children = null;\n        (<any> proto).listSize = null;\n        return proto[Symbol.toStringTag] = 'FixedSizeList';\n    })(FixedSizeList.prototype);\n}\n\n/** @ignore */\nexport interface Map_<TKey extends DataType = any, TValue extends DataType = any> extends DataType<Type.Map> {\n    TArray: IterableArrayLike<Map<TKey['TValue'], TValue['TValue'] | null>>;\n    TChild: Struct<{ key: TKey, value: TValue }>;\n    TValue: MapLike<TKey, TValue>;\n}\n\n/** @ignore */\nexport class Map_<TKey extends DataType = any, TValue extends DataType = any> extends DataType<Type.Map> {\n    constructor(child: Field<Struct<{ key: TKey, value: TValue }>>, keysSorted = false) {\n        super();\n        this.children = [child];\n        this.keysSorted = keysSorted;\n    }\n    public readonly keysSorted: boolean;\n    public readonly children: Field<Struct<{ key: TKey, value: TValue }>>[];\n    public get typeId() { return Type.Map as Type.Map; }\n    public get keyType(): TKey { return this.children[0].type.children[0].type as TKey; }\n    public get valueType(): TValue { return this.children[0].type.children[1].type as TValue; }\n    public toString() { return `Map<{${this.children[0].type.children.map((f) => `${f.name}:${f.type}`).join(`, `)}}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Map_) => {\n        (<any> proto).children = null;\n        (<any> proto).keysSorted = null;\n        return proto[Symbol.toStringTag] = 'Map_';\n    })(Map_.prototype);\n}\n\n/** @ignore */\nconst getId = ((atomicDictionaryId) => () => ++atomicDictionaryId)(-1);\n\n/** @ignore */\nexport type TKeys = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32;\n\n/** @ignore */\nexport interface Dictionary<T extends DataType = any, TKey extends TKeys = TKeys> extends DataType<Type.Dictionary> { TArray: TKey['TArray']; TValue: T['TValue']; }\n/** @ignore */\nexport class Dictionary<T extends DataType = any, TKey extends TKeys = TKeys> extends DataType<Type.Dictionary> {\n    public readonly id: number;\n    public readonly indices: TKey;\n    public readonly dictionary: T;\n    public readonly isOrdered: boolean;\n    constructor(dictionary: T, indices: TKey, id?: Long | number | null, isOrdered?: boolean | null) {\n        super();\n        this.indices = indices;\n        this.dictionary = dictionary;\n        this.isOrdered = isOrdered || false;\n        this.id = id == null ? getId() : typeof id === 'number' ? id : id.low;\n    }\n    public get typeId() { return Type.Dictionary as Type.Dictionary; }\n    public get children() { return this.dictionary.children; }\n    public get valueType(): T { return this.dictionary as T; }\n    public get ArrayType(): T['ArrayType'] { return this.dictionary.ArrayType; }\n    public toString() { return `Dictionary<${this.indices}, ${this.dictionary}>`; }\n    protected static [Symbol.toStringTag] = ((proto: Dictionary) => {\n        (<any> proto).id = null;\n        (<any> proto).indices = null;\n        (<any> proto).isOrdered = null;\n        (<any> proto).dictionary = null;\n        return proto[Symbol.toStringTag] = 'Dictionary';\n    })(Dictionary.prototype);\n}\n\n/** @ignore */\nexport interface IterableArrayLike<T = any> extends ArrayLike<T>, Iterable<T> {}\n/** @ignore */\nexport type FloatArray = Uint16Array | Float32Array | Float64Array;\n/** @ignore */\nexport type IntArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array;\n\n/** @ignore */\nexport function strideForType(type: DataType) {\n    let t: any = type;\n    switch (type.typeId) {\n        case Type.Decimal: return 4;\n        case Type.Timestamp: return 2;\n        case Type.Date: return 1 + (t as Date_).unit;\n        case Type.Interval: return 1 + (t as Interval_).unit;\n        case Type.Int: return 1 + +((t as Int_).bitWidth > 32);\n        case Type.Time: return 1 + +((t as Time_).bitWidth > 32);\n        case Type.FixedSizeList: return (t as FixedSizeList).listSize;\n        case Type.FixedSizeBinary: return (t as FixedSizeBinary).byteWidth;\n        default: return 1;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from './vector';\nimport { truncateBitmap } from './util/bit';\nimport { popcnt_bit_range } from './util/bit';\nimport { BufferType, UnionMode, Type } from './enum';\nimport { DataType, SparseUnion, DenseUnion, strideForType } from './type';\nimport { toArrayBufferView, toUint8Array, toInt32Array } from './util/buffer';\nimport {\n    Dictionary,\n    Null, Int, Float,\n    Binary, Bool, Utf8, Decimal,\n    Date_, Time, Timestamp, Interval,\n    List, Struct, Union, FixedSizeBinary, FixedSizeList, Map_,\n} from './type';\n\n// When slicing, we do not know the null count of the sliced range without\n// doing some computation. To avoid doing this eagerly, we set the null count\n// to -1 (any negative number will do). When Vector.nullCount is called the\n// first time, the null count will be computed. See ARROW-33\n/** @ignore */ export type kUnknownNullCount = -1;\n/** @ignore */ export const kUnknownNullCount = -1;\n\n/** @ignore */ export type NullBuffer = Uint8Array | null | undefined;\n/** @ignore */ export type TypeIdsBuffer = Int8Array  | ArrayLike<number> | Iterable<number> | undefined;\n/** @ignore */ export type ValueOffsetsBuffer = Int32Array  | ArrayLike<number> | Iterable<number> | undefined;\n/** @ignore */ export type DataBuffer<T extends DataType> = T['TArray'] | ArrayLike<number> | Iterable<number> | undefined;\n\n/** @ignore */\nexport interface Buffers<T extends DataType> {\n      [BufferType.OFFSET]: Int32Array;\n        [BufferType.DATA]: T['TArray'];\n    [BufferType.VALIDITY]: Uint8Array;\n        [BufferType.TYPE]: T['TArray'];\n}\n\n/** @ignore */\nexport interface Data<T extends DataType = DataType> {\n    readonly TType: T['TType'];\n    readonly TArray: T['TArray'];\n    readonly TValue: T['TValue'];\n}\n\n/** @ignore */\nexport class Data<T extends DataType = DataType> {\n\n    public readonly type: T;\n    public readonly length: number;\n    public readonly offset: number;\n    public readonly stride: number;\n    public readonly childData: Data[];\n\n    /**\n     * The dictionary for this Vector, if any. Only used for Dictionary type.\n     */\n    public dictionary?: Vector;\n\n    public readonly values: Buffers<T>[BufferType.DATA];\n    // @ts-ignore\n    public readonly typeIds: Buffers<T>[BufferType.TYPE];\n    // @ts-ignore\n    public readonly nullBitmap: Buffers<T>[BufferType.VALIDITY];\n    // @ts-ignore\n    public readonly valueOffsets: Buffers<T>[BufferType.OFFSET];\n\n    public get typeId(): T['TType'] { return this.type.typeId; }\n    public get ArrayType(): T['ArrayType'] { return this.type.ArrayType; }\n    public get buffers() {\n        return [this.valueOffsets, this.values, this.nullBitmap, this.typeIds] as Buffers<T>;\n    }\n    public get byteLength(): number {\n        let byteLength = 0;\n        let { valueOffsets, values, nullBitmap, typeIds } = this;\n        valueOffsets && (byteLength += valueOffsets.byteLength);\n        values       && (byteLength += values.byteLength);\n        nullBitmap   && (byteLength += nullBitmap.byteLength);\n        typeIds      && (byteLength += typeIds.byteLength);\n        return this.childData.reduce((byteLength, child) => byteLength + child.byteLength, byteLength);\n    }\n\n    protected _nullCount: number | kUnknownNullCount;\n\n    public get nullCount() {\n        let nullCount = this._nullCount;\n        let nullBitmap: Uint8Array | undefined;\n        if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {\n            this._nullCount = nullCount = this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);\n        }\n        return nullCount;\n    }\n\n    constructor(type: T, offset: number, length: number, nullCount?: number, buffers?: Partial<Buffers<T>> | Data<T>, childData?: (Data | Vector)[], dictionary?: Vector) {\n        this.type = type;\n        this.dictionary = dictionary;\n        this.offset = Math.floor(Math.max(offset || 0, 0));\n        this.length = Math.floor(Math.max(length || 0, 0));\n        this._nullCount = Math.floor(Math.max(nullCount || 0, -1));\n        this.childData = (childData || []).map((x) => x instanceof Data ? x : x.data) as Data[];\n        let buffer: Buffers<T>[keyof Buffers<T>];\n        if (buffers instanceof Data) {\n            this.stride = buffers.stride;\n            this.values = buffers.values;\n            this.typeIds = buffers.typeIds;\n            this.nullBitmap = buffers.nullBitmap;\n            this.valueOffsets = buffers.valueOffsets;\n        } else {\n            this.stride = strideForType(type);\n            if (buffers) {\n                (buffer = (buffers as Buffers<T>)[0]) && (this.valueOffsets = buffer);\n                (buffer = (buffers as Buffers<T>)[1]) && (this.values = buffer);\n                (buffer = (buffers as Buffers<T>)[2]) && (this.nullBitmap = buffer);\n                (buffer = (buffers as Buffers<T>)[3]) && (this.typeIds = buffer);\n            }\n        }\n    }\n\n    public clone<R extends DataType>(type: R, offset = this.offset, length = this.length, nullCount = this._nullCount, buffers: Buffers<R> = <any> this, childData: (Data | Vector)[] = this.childData) {\n        return new Data(type, offset, length, nullCount, buffers, childData, this.dictionary);\n    }\n\n    public slice(offset: number, length: number): Data<T> {\n        const { stride, typeId, childData } = this;\n        // +true === 1, +false === 0, so this means\n        // we keep nullCount at 0 if it's already 0,\n        // otherwise set to the invalidated flag -1\n        const nullCount = +(this._nullCount === 0) - 1;\n        const childStride = typeId === 16 /* FixedSizeList */ ? stride : 1;\n        const buffers = this._sliceBuffers(offset, length, stride, typeId);\n        return this.clone<T>(this.type, this.offset + offset, length, nullCount, buffers,\n            // Don't slice children if we have value offsets (the variable-width types)\n            (!childData.length || this.valueOffsets) ? childData : this._sliceChildren(childData, childStride * offset, childStride * length));\n    }\n\n    public _changeLengthAndBackfillNullBitmap(newLength: number): Data<T> {\n        if (this.typeId === Type.Null) {\n            return this.clone(this.type, 0, newLength, 0);\n        }\n        const { length, nullCount } = this;\n        // start initialized with 0s (nulls), then fill from 0 to length with 1s (not null)\n        const bitmap = new Uint8Array(((newLength + 63) & ~63) >> 3).fill(255, 0, length >> 3);\n        // set all the bits in the last byte (up to bit `length - length % 8`) to 1 (not null)\n        bitmap[length >> 3] = (1 << (length - (length & ~7))) - 1;\n        // if we have a nullBitmap, truncate + slice and set it over the pre-filled 1s\n        if (nullCount > 0) {\n            bitmap.set(truncateBitmap(this.offset, length, this.nullBitmap), 0);\n        }\n        const buffers = this.buffers;\n        buffers[BufferType.VALIDITY] = bitmap;\n        return this.clone(this.type, 0, newLength, nullCount + (newLength - length), buffers);\n    }\n\n    protected _sliceBuffers(offset: number, length: number, stride: number, typeId: T['TType']): Buffers<T> {\n        let arr: any, { buffers } = this;\n        // If typeIds exist, slice the typeIds buffer\n        (arr = buffers[BufferType.TYPE]) && (buffers[BufferType.TYPE] = arr.subarray(offset, offset + length));\n        // If offsets exist, only slice the offsets buffer\n        (arr = buffers[BufferType.OFFSET]) && (buffers[BufferType.OFFSET] = arr.subarray(offset, offset + length + 1)) ||\n        // Otherwise if no offsets, slice the data buffer. Don't slice the data vector for Booleans, since the offset goes by bits not bytes\n        (arr = buffers[BufferType.DATA]) && (buffers[BufferType.DATA] = typeId === 6 ? arr : arr.subarray(stride * offset, stride * (offset + length)));\n        return buffers;\n    }\n\n    protected _sliceChildren(childData: Data[], offset: number, length: number): Data[] {\n        return childData.map((child) => child.slice(offset, length));\n    }\n\n    //\n    // Convenience methods for creating Data instances for each of the Arrow Vector types\n    //\n    /** @nocollapse */\n    public static new<T extends DataType>(type: T, offset: number, length: number, nullCount?: number, buffers?: Partial<Buffers<T>> | Data<T>, childData?: (Data | Vector)[], dictionary?: Vector): Data<T> {\n        if (buffers instanceof Data) { buffers = buffers.buffers; } else if (!buffers) { buffers = [] as Partial<Buffers<T>>; }\n        switch (type.typeId) {\n            case Type.Null:            return <unknown> Data.Null(            <unknown> type as Null,            offset, length) as Data<T>;\n            case Type.Int:             return <unknown> Data.Int(             <unknown> type as Int,             offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Dictionary:      return <unknown> Data.Dictionary(      <unknown> type as Dictionary,      offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || [], dictionary!) as Data<T>;\n            case Type.Float:           return <unknown> Data.Float(           <unknown> type as Float,           offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Bool:            return <unknown> Data.Bool(            <unknown> type as Bool,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Decimal:         return <unknown> Data.Decimal(         <unknown> type as Decimal,         offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Date:            return <unknown> Data.Date(            <unknown> type as Date_,           offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Time:            return <unknown> Data.Time(            <unknown> type as Time,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Timestamp:       return <unknown> Data.Timestamp(       <unknown> type as Timestamp,       offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Interval:        return <unknown> Data.Interval(        <unknown> type as Interval,        offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.FixedSizeBinary: return <unknown> Data.FixedSizeBinary( <unknown> type as FixedSizeBinary, offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Binary:          return <unknown> Data.Binary(          <unknown> type as Binary,          offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.Utf8:            return <unknown> Data.Utf8(            <unknown> type as Utf8,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], buffers[BufferType.DATA] || []) as Data<T>;\n            case Type.List:            return <unknown> Data.List(            <unknown> type as List,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], (childData || [])[0]) as Data<T>;\n            case Type.FixedSizeList:   return <unknown> Data.FixedSizeList(   <unknown> type as FixedSizeList,   offset, length, nullCount || 0, buffers[BufferType.VALIDITY], (childData || [])[0]) as Data<T>;\n            case Type.Struct:          return <unknown> Data.Struct(          <unknown> type as Struct,          offset, length, nullCount || 0, buffers[BufferType.VALIDITY], childData || []) as Data<T>;\n            case Type.Map:             return <unknown> Data.Map(             <unknown> type as Map_,            offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.OFFSET] || [], (childData || [])[0]) as Data<T>;\n            case Type.Union:           return <unknown> Data.Union(           <unknown> type as Union,           offset, length, nullCount || 0, buffers[BufferType.VALIDITY], buffers[BufferType.TYPE] || [], buffers[BufferType.OFFSET] || childData, childData) as Data<T>;\n        }\n        throw new Error(`Unrecognized typeId ${type.typeId}`);\n    }\n\n    /** @nocollapse */\n    public static Null<T extends Null>(type: T, offset: number, length: number) {\n        return new Data(type, offset, length, 0);\n    }\n    /** @nocollapse */\n    public static Int<T extends Int>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Dictionary<T extends Dictionary>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>, dictionary: Vector<T['dictionary']>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView<T['TArray']>(type.indices.ArrayType, data), toUint8Array(nullBitmap)], [], dictionary);\n    }\n    /** @nocollapse */\n    public static Float<T extends Float>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Bool<T extends Bool>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Decimal<T extends Decimal>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Date<T extends Date_>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Time<T extends Time>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Timestamp<T extends Timestamp>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Interval<T extends Interval>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static FixedSizeBinary<T extends FixedSizeBinary>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, data: DataBuffer<T>) {\n        return new Data(type, offset, length, nullCount, [undefined, toArrayBufferView(type.ArrayType, data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Binary<T extends Binary>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, data: Uint8Array) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), toUint8Array(data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static Utf8<T extends Utf8>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, data: Uint8Array) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), toUint8Array(data), toUint8Array(nullBitmap)]);\n    }\n    /** @nocollapse */\n    public static List<T extends List>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, child: Data<T['valueType']> | Vector<T['valueType']>) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    public static FixedSizeList<T extends FixedSizeList>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, child: Data<T['valueType']> | Vector<T['valueType']>) {\n        return new Data(type, offset, length, nullCount, [undefined, undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    /** @nocollapse */\n    public static Struct<T extends Struct>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, children: (Data | Vector)[]) {\n        return new Data(type, offset, length, nullCount, [undefined, undefined, toUint8Array(nullBitmap)], children);\n    }\n    /** @nocollapse */\n    public static Map<T extends Map_>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, valueOffsets: ValueOffsetsBuffer, child: (Data | Vector)) {\n        return new Data(type, offset, length, nullCount, [toInt32Array(valueOffsets), undefined, toUint8Array(nullBitmap)], [child]);\n    }\n    public static Union<T extends SparseUnion>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, children: (Data | Vector)[], _?: any): Data<T>;\n    public static Union<T extends DenseUnion>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, valueOffsets: ValueOffsetsBuffer, children: (Data | Vector)[]): Data<T>;\n    public static Union<T extends Union>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, valueOffsetsOrChildren: ValueOffsetsBuffer | (Data | Vector)[], children?: (Data | Vector)[]): Data<T>;\n    /** @nocollapse */\n    public static Union<T extends Union>(type: T, offset: number, length: number, nullCount: number, nullBitmap: NullBuffer, typeIds: TypeIdsBuffer, valueOffsetsOrChildren: ValueOffsetsBuffer | (Data | Vector)[], children?: (Data | Vector)[]) {\n        const buffers = <unknown> [\n            undefined, undefined,\n            toUint8Array(nullBitmap),\n            toArrayBufferView(type.ArrayType, typeIds)\n        ] as Partial<Buffers<T>>;\n        if (type.mode === UnionMode.Sparse) {\n            return new Data(type, offset, length, nullCount, buffers, valueOffsetsOrChildren as (Data | Vector)[]);\n        }\n        buffers[BufferType.OFFSET] = toInt32Array(<ValueOffsetsBuffer> valueOffsetsOrChildren);\n        return new Data(type, offset, length, nullCount, buffers, children);\n    }\n}\n\n(Data.prototype as any).childData = Object.freeze([]);\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */ const undf = void (0);\n\n/** @ignore */\nexport function valueToString(x: any) {\n    if (x === null) { return 'null'; }\n    if (x === undf) { return 'undefined'; }\n    switch (typeof x) {\n        case 'number': return `${x}`;\n        case 'bigint': return `${x}`;\n        case 'string': return `\"${x}\"`;\n    }\n    // If [Symbol.toPrimitive] is implemented (like in BN)\n    // use it instead of JSON.stringify(). This ensures we\n    // print BigInts, Decimals, and Binary in their native\n    // representation\n    if (typeof x[Symbol.toPrimitive] === 'function') {\n        return x[Symbol.toPrimitive]('string');\n    }\n    return ArrayBuffer.isView(x) ? `[${x}]` : JSON.stringify(x);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../type';\nimport { valueToString } from '../util/pretty';\nimport { BigIntAvailable } from '../util/compat';\n\n/**\n * Dynamically compile the null values into an `isValid()` function whose\n * implementation is a switch statement. Microbenchmarks in v8 indicate\n * this approach is 25% faster than using an ES6 Map.\n *\n * @example\n * console.log(createIsValidFunction([null, 'N/A', NaN]));\n * `function (x) {\n *     if (x !== x) return false;\n *     switch (x) {\n *         case null:\n *         case \"N/A\":\n *             return false;\n *     }\n *     return true;\n * }`\n *\n * @ignore\n * @param nullValues\n */\nexport function createIsValidFunction<T extends DataType = any, TNull = any>(nullValues?: ReadonlyArray<TNull>) {\n\n    if (!nullValues || nullValues.length <= 0) {\n        // @ts-ignore\n        return function isValid(value: any) { return true; };\n    }\n\n    let fnBody = '';\n    let noNaNs = nullValues.filter((x) => x === x);\n\n    if (noNaNs.length > 0) {\n        fnBody = `\n    switch (x) {${noNaNs.map((x) => `\n        case ${valueToCase(x)}:`).join('')}\n            return false;\n    }`;\n    }\n\n    // NaN doesn't equal anything including itself, so it doesn't work as a\n    // switch case. Instead we must explicitly check for NaN before the switch.\n    if (nullValues.length !== noNaNs.length) {\n        fnBody = `if (x !== x) return false;\\n${fnBody}`;\n    }\n\n    return new Function(`x`, `${fnBody}\\nreturn true;`) as (value: T['TValue'] | TNull) => boolean;\n}\n\n/** @ignore */\nfunction valueToCase(x: any) {\n    if (typeof x !== 'bigint') {\n        return valueToString(x);\n    } else if (BigIntAvailable) {\n        return `${valueToString(x)}n`;\n    }\n    return `\"${valueToString(x)}\"`;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { memcpy } from '../util/buffer';\nimport { BigIntAvailable, BigInt64Array, BigUint64Array } from '../util/compat';\nimport {\n    TypedArray, TypedArrayConstructor,\n    BigIntArray, BigIntArrayConstructor\n} from '../interfaces';\n\n/** @ignore */ type DataValue<T> = T extends TypedArray ? number : T extends BigIntArray ? WideValue<T> : T;\n/** @ignore */ type WideValue<T extends BigIntArray> = T extends BigIntArray ? bigint | Int32Array | Uint32Array : never;\n/** @ignore */ type ArrayCtor<T extends TypedArray | BigIntArray> =\n    T extends TypedArray  ? TypedArrayConstructor<T>  :\n    T extends BigIntArray ? BigIntArrayConstructor<T> :\n    any;\n\n/** @ignore */\nconst roundLengthUpToNearest64Bytes = (len: number, BPE: number) => ((((len * BPE) + 63) & ~63) || 64) / BPE;\n/** @ignore */\nconst sliceOrExtendArray = <T extends TypedArray | BigIntArray>(arr: T, len = 0) => (\n    arr.length >= len ? arr.subarray(0, len) : memcpy(new (arr.constructor as any)(len), arr, 0)\n) as T;\n\n/** @ignore */\nexport interface BufferBuilder<T extends TypedArray | BigIntArray = any, TValue = DataValue<T>> {\n    readonly offset: number;\n}\n\n/** @ignore */\nexport class BufferBuilder<T extends TypedArray | BigIntArray = any, TValue = DataValue<T>> {\n\n    constructor(buffer: T, stride = 1) {\n        this.buffer = buffer;\n        this.stride = stride;\n        this.BYTES_PER_ELEMENT = buffer.BYTES_PER_ELEMENT;\n        this.ArrayType = buffer.constructor as ArrayCtor<T>;\n        this._resize(this.length = buffer.length / stride | 0);\n    }\n\n    public buffer: T;\n    public length: number;\n    public readonly stride: number;\n    public readonly ArrayType: ArrayCtor<T>;\n    public readonly BYTES_PER_ELEMENT: number;\n\n    public get byteLength() { return this.length * this.stride * this.BYTES_PER_ELEMENT | 0; }\n    public get reservedLength() { return this.buffer.length / this.stride; }\n    public get reservedByteLength() { return this.buffer.byteLength; }\n\n    // @ts-ignore\n    public set(index: number, value: TValue) { return this; }\n    public append(value: TValue) { return this.set(this.length, value); }\n    public reserve(extra: number) {\n        if (extra > 0) {\n            this.length += extra;\n            const stride = this.stride;\n            const length = this.length * stride;\n            const reserved = this.buffer.length;\n            if (length >= reserved) {\n                this._resize(reserved === 0\n                    ? roundLengthUpToNearest64Bytes(length * 1, this.BYTES_PER_ELEMENT)\n                    : roundLengthUpToNearest64Bytes(length * 2, this.BYTES_PER_ELEMENT)\n                );\n            }\n        }\n        return this;\n    }\n    public flush(length = this.length) {\n        length = roundLengthUpToNearest64Bytes(length * this.stride, this.BYTES_PER_ELEMENT);\n        const array = sliceOrExtendArray<T>(this.buffer, length);\n        this.clear();\n        return array;\n    }\n    public clear() {\n        this.length = 0;\n        this._resize(0);\n        return this;\n    }\n    protected _resize(newLength: number) {\n        return this.buffer = <T> memcpy(new this.ArrayType(newLength), this.buffer);\n    }\n}\n\n(BufferBuilder.prototype as any).offset = 0;\n\n/** @ignore */\nexport class DataBufferBuilder<T extends TypedArray> extends BufferBuilder<T, number> {\n    public last() { return this.get(this.length - 1); }\n    public get(index: number) { return this.buffer[index]; }\n    public set(index: number, value: number) {\n        this.reserve(index - this.length + 1);\n        this.buffer[index * this.stride] = value;\n        return this;\n    }\n}\n\n/** @ignore */\nexport class BitmapBufferBuilder extends DataBufferBuilder<Uint8Array> {\n\n    constructor(data = new Uint8Array(0)) { super(data, 1 / 8); }\n\n    public numValid = 0;\n    public get numInvalid() { return this.length - this.numValid; }\n    public get(idx: number) { return this.buffer[idx >> 3] >> idx % 8 & 1; }\n    public set(idx: number, val: number) {\n        const { buffer } = this.reserve(idx - this.length + 1);\n        const byte = idx >> 3, bit = idx % 8, cur = buffer[byte] >> bit & 1;\n        // If `val` is truthy and the current bit is 0, flip it to 1 and increment `numValid`.\n        // If `val` is falsey and the current bit is 1, flip it to 0 and decrement `numValid`.\n        val ? cur === 0 && ((buffer[byte] |=  (1 << bit)), ++this.numValid)\n            : cur === 1 && ((buffer[byte] &= ~(1 << bit)), --this.numValid);\n        return this;\n    }\n    public clear() {\n        this.numValid = 0;\n        return super.clear();\n    }\n}\n\n/** @ignore */\nexport class OffsetsBufferBuilder extends DataBufferBuilder<Int32Array> {\n    constructor(data = new Int32Array(1)) { super(data, 1); }\n    public append(value: number) {\n        return this.set(this.length - 1, value);\n    }\n    public set(index: number, value: number) {\n        const offset = this.length - 1;\n        const buffer = this.reserve(index - offset + 1).buffer;\n        if (offset < index++) {\n            buffer.fill(buffer[offset], offset, index);\n        }\n        buffer[index] = buffer[index - 1] + value;\n        return this;\n    }\n    public flush(length = this.length - 1) {\n        if (length > this.length) {\n            this.set(length - 1, 0);\n        }\n        return super.flush(length + 1);\n    }\n}\n\n/** @ignore */\nexport class WideBufferBuilder<T extends TypedArray, R extends BigIntArray> extends BufferBuilder<T, DataValue<T>> {\n    // @ts-ignore\n    public buffer64: R;\n    // @ts-ignore\n    protected _ArrayType64: BigIntArrayConstructor<R>;\n    public get ArrayType64() {\n        return this._ArrayType64 || (this._ArrayType64 = <BigIntArrayConstructor<R>> (this.buffer instanceof Int32Array ? BigInt64Array : BigUint64Array));\n    }\n    public set(index: number, value: DataValue<T>) {\n        this.reserve(index - this.length + 1);\n        switch (typeof value) {\n            case 'bigint': this.buffer64[index] = value; break;\n            case 'number': this.buffer[index * this.stride] = value; break;\n            default: this.buffer.set(value as TypedArray, index * this.stride);\n        }\n        return this;\n    }\n    protected _resize(newLength: number) {\n        const data = super._resize(newLength);\n        const length = data.byteLength / (this.BYTES_PER_ELEMENT * this.stride);\n        if (BigIntAvailable) {\n            this.buffer64 = new this.ArrayType64(data.buffer, data.byteOffset, length);\n        }\n        return data;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from './vector';\nimport { BufferType } from './enum';\nimport { Data, Buffers } from './data';\nimport { createIsValidFunction } from './builder/valid';\nimport { BuilderType as B, VectorType as V} from './interfaces';\nimport { BufferBuilder, BitmapBufferBuilder, DataBufferBuilder, OffsetsBufferBuilder } from './builder/buffer';\nimport {\n    DataType, strideForType,\n    Float, Int, Decimal, FixedSizeBinary,\n    Date_, Time, Timestamp, Interval,\n    Utf8, Binary, List, Map_\n} from './type';\n\n/**\n * A set of options required to create a `Builder` instance for a given `DataType`.\n * @see {@link Builder}\n */\nexport interface BuilderOptions<T extends DataType = any, TNull = any> {\n    type: T;\n    nullValues?: TNull[] | ReadonlyArray<TNull> | null;\n    children?: { [key: string]: BuilderOptions; } | BuilderOptions[];\n}\n\n/**\n * A set of options to create an Iterable or AsyncIterable `Builder` transform function.\n * @see {@link Builder.throughIterable}\n * @see {@link Builder.throughAsyncIterable}\n */\n\nexport interface IterableBuilderOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    highWaterMark?: number;\n    queueingStrategy?: 'bytes' | 'count';\n    dictionaryHashFunction?: (value: any) => string | number;\n    valueToChildTypeId?: (builder: Builder<T, TNull>, value: any, offset: number) => number;\n}\n\n/**\n * An abstract base class for types that construct Arrow Vectors from arbitrary JavaScript values.\n *\n * A `Builder` is responsible for writing arbitrary JavaScript values\n * to ArrayBuffers and/or child Builders according to the Arrow specification\n * for each DataType, creating or resizing the underlying ArrayBuffers as necessary.\n *\n * The `Builder` for each Arrow `DataType` handles converting and appending\n * values for a given `DataType`. The high-level {@link Builder.new `Builder.new()`} convenience\n * method creates the specific `Builder` subclass for the supplied `DataType`.\n *\n * Once created, `Builder` instances support both appending values to the end\n * of the `Builder`, and random-access writes to specific indices\n * (`Builder.prototype.append(value)` is a convenience method for\n * `builder.set(builder.length, value)`). Appending or setting values beyond the\n * Builder's current length may cause the builder to grow its underlying buffers\n * or child Builders (if applicable) to accommodate the new values.\n *\n * After enough values have been written to a `Builder`, `Builder.prototype.flush()`\n * will commit the values to the underlying ArrayBuffers (or child Builders). The\n * internal Builder state will be reset, and an instance of `Data<T>` is returned.\n * Alternatively, `Builder.prototype.toVector()` will flush the `Builder` and return\n * an instance of `Vector<T>` instead.\n *\n * When there are no more values to write, use `Builder.prototype.finish()` to\n * finalize the `Builder`. This does not reset the internal state, so it is\n * necessary to call `Builder.prototype.flush()` or `toVector()` one last time\n * if there are still values queued to be flushed.\n *\n * Note: calling `Builder.prototype.finish()` is required when using a `DictionaryBuilder`,\n * because this is when it flushes the values that have been enqueued in its internal\n * dictionary's `Builder`, and creates the `dictionaryVector` for the `Dictionary` `DataType`.\n *\n * ```ts\n * import { Builder, Utf8 } from 'apache-arrow';\n *\n * const utf8Builder = Builder.new({\n *     type: new Utf8(),\n *     nullValues: [null, 'n/a']\n * });\n *\n * utf8Builder\n *     .append('hello')\n *     .append('n/a')\n *     .append('world')\n *     .append(null);\n *\n * const utf8Vector = utf8Builder.finish().toVector();\n *\n * console.log(utf8Vector.toJSON());\n * // > [\"hello\", null, \"world\", null]\n * ```\n *\n * @typeparam T The `DataType` of this `Builder`.\n * @typeparam TNull The type(s) of values which will be considered null-value sentinels.\n */\nexport abstract class Builder<T extends DataType = any, TNull = any> {\n\n    /**\n     * Create a `Builder` instance based on the `type` property of the supplied `options` object.\n     * @param {BuilderOptions<T, TNull>} options An object with a required `DataType` instance\n     * and other optional parameters to be passed to the `Builder` subclass for the given `type`.\n     *\n     * @typeparam T The `DataType` of the `Builder` to create.\n     * @typeparam TNull The type(s) of values which will be considered null-value sentinels.\n     * @nocollapse\n     */\n    // @ts-ignore\n    public static new<T extends DataType = any, TNull = any>(options: BuilderOptions<T, TNull>): B<T, TNull> {}\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode<T extends DataType = any, TNull = any>(options: import('./io/node/builder').BuilderDuplexOptions<T, TNull>): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughDOM<T extends DataType = any, TNull = any>(options: import('./io/whatwg/builder').BuilderTransformOptions<T, TNull>): import('./io/whatwg/builder').BuilderTransform<T, TNull> {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    /**\n     * Transform a synchronous `Iterable` of arbitrary JavaScript values into a\n     * sequence of Arrow Vector<T> following the chunking semantics defined in\n     * the supplied `options` argument.\n     *\n     * This function returns a function that accepts an `Iterable` of values to\n     * transform. When called, this function returns an Iterator of `Vector<T>`.\n     *\n     * The resulting `Iterator<Vector<T>>` yields Vectors based on the\n     * `queueingStrategy` and `highWaterMark` specified in the `options` argument.\n     *\n     * * If `queueingStrategy` is `\"count\"` (or omitted), The `Iterator<Vector<T>>`\n     *   will flush the underlying `Builder` (and yield a new `Vector<T>`) once the\n     *   Builder's `length` reaches or exceeds the supplied `highWaterMark`.\n     * * If `queueingStrategy` is `\"bytes\"`, the `Iterator<Vector<T>>` will flush\n     *   the underlying `Builder` (and yield a new `Vector<T>`) once its `byteLength`\n     *   reaches or exceeds the supplied `highWaterMark`.\n     *\n     * @param {IterableBuilderOptions<T, TNull>} options An object of properties which determine the `Builder` to create and the chunking semantics to use.\n     * @returns A function which accepts a JavaScript `Iterable` of values to\n     *          write, and returns an `Iterator` that yields Vectors according\n     *          to the chunking semantics defined in the `options` argument.\n     * @nocollapse\n     */\n    public static throughIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>) {\n        return throughIterable(options);\n    }\n\n    /**\n     * Transform an `AsyncIterable` of arbitrary JavaScript values into a\n     * sequence of Arrow Vector<T> following the chunking semantics defined in\n     * the supplied `options` argument.\n     *\n     * This function returns a function that accepts an `AsyncIterable` of values to\n     * transform. When called, this function returns an AsyncIterator of `Vector<T>`.\n     *\n     * The resulting `AsyncIterator<Vector<T>>` yields Vectors based on the\n     * `queueingStrategy` and `highWaterMark` specified in the `options` argument.\n     *\n     * * If `queueingStrategy` is `\"count\"` (or omitted), The `AsyncIterator<Vector<T>>`\n     *   will flush the underlying `Builder` (and yield a new `Vector<T>`) once the\n     *   Builder's `length` reaches or exceeds the supplied `highWaterMark`.\n     * * If `queueingStrategy` is `\"bytes\"`, the `AsyncIterator<Vector<T>>` will flush\n     *   the underlying `Builder` (and yield a new `Vector<T>`) once its `byteLength`\n     *   reaches or exceeds the supplied `highWaterMark`.\n     *\n     * @param {IterableBuilderOptions<T, TNull>} options An object of properties which determine the `Builder` to create and the chunking semantics to use.\n     * @returns A function which accepts a JavaScript `AsyncIterable` of values\n     *          to write, and returns an `AsyncIterator` that yields Vectors\n     *          according to the chunking semantics defined in the `options`\n     *          argument.\n     * @nocollapse\n     */\n    public static throughAsyncIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>) {\n        return throughAsyncIterable(options);\n    }\n\n    /**\n     * Construct a builder with the given Arrow DataType with optional null values,\n     * which will be interpreted as \"null\" when set or appended to the `Builder`.\n     * @param {{ type: T, nullValues?: any[] }} options A `BuilderOptions` object used to create this `Builder`.\n     */\n    constructor({ 'type': type, 'nullValues': nulls }: BuilderOptions<T, TNull>) {\n        this.type = type;\n        this.children = [];\n        this.nullValues = nulls;\n        this.stride = strideForType(type);\n        this._nulls = new BitmapBufferBuilder();\n        if (nulls && nulls.length > 0) {\n            this._isValid = createIsValidFunction(nulls);\n        }\n    }\n\n    /**\n     * The Builder's `DataType` instance.\n     * @readonly\n     */\n    public type: T;\n    /**\n     * The number of values written to the `Builder` that haven't been flushed yet.\n     * @readonly\n     */\n    public length = 0;\n    /**\n     * A boolean indicating whether `Builder.prototype.finish()` has been called on this `Builder`.\n     * @readonly\n     */\n    public finished = false;\n    /**\n     * The number of elements in the underlying values TypedArray that\n     * represent a single logical element, determined by this Builder's\n     * `DataType`. This is 1 for most types, but is larger when the `DataType`\n     * is `Int64`, `Uint64`, `Decimal`, `DateMillisecond`, certain variants of\n     * `Interval`, `Time`, or `Timestamp`, `FixedSizeBinary`, and `FixedSizeList`.\n     * @readonly\n     */\n    public readonly stride: number;\n    public readonly children: Builder[];\n    /**\n     * The list of null-value sentinels for this `Builder`. When one of these values\n     * is written to the `Builder` (either via `Builder.prototype.set()` or `Builder.prototype.append()`),\n     * a 1-bit is written to this Builder's underlying null BitmapBufferBuilder.\n     * @readonly\n     */\n    public readonly nullValues?: TNull[] | ReadonlyArray<TNull> | null;\n\n    /**\n     * Flush the `Builder` and return a `Vector<T>`.\n     * @returns {Vector<T>} A `Vector<T>` of the flushed values.\n     */\n    public toVector() { return Vector.new(this.flush()); }\n\n    public get ArrayType() { return this.type.ArrayType; }\n    public get nullCount() { return this._nulls.numInvalid; }\n    public get numChildren() { return this.children.length; }\n\n    /**\n     * @returns The aggregate length (in bytes) of the values that have been written.\n     */\n    public get byteLength(): number {\n        let size = 0;\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        this._typeIds && (size += this._typeIds.byteLength);\n        return this.children.reduce((size, child) => size + child.byteLength, size);\n    }\n\n    /**\n     * @returns The aggregate number of rows that have been reserved to write new values.\n     */\n    public get reservedLength(): number {\n        return this._nulls.reservedLength;\n    }\n\n    /**\n     * @returns The aggregate length (in bytes) that has been reserved to write new values.\n     */\n    public get reservedByteLength(): number {\n        let size = 0;\n        this._offsets && (size += this._offsets.reservedByteLength);\n        this._values && (size += this._values.reservedByteLength);\n        this._nulls && (size += this._nulls.reservedByteLength);\n        this._typeIds && (size += this._typeIds.reservedByteLength);\n        return this.children.reduce((size, child) => size + child.reservedByteLength, size);\n    }\n\n    // @ts-ignore\n    protected _offsets: DataBufferBuilder<Int32Array>;\n    public get valueOffsets() { return this._offsets ? this._offsets.buffer : null; }\n\n    // @ts-ignore\n    protected _values: BufferBuilder<T['TArray'], any>;\n    public get values() { return this._values ? this._values.buffer : null; }\n\n    protected _nulls: BitmapBufferBuilder;\n    public get nullBitmap() { return this._nulls ? this._nulls.buffer : null; }\n\n    // @ts-ignore\n    protected _typeIds: DataBufferBuilder<Int8Array>;\n    public get typeIds() { return this._typeIds ? this._typeIds.buffer : null; }\n\n    // @ts-ignore\n    protected _isValid: (value: T['TValue'] | TNull) => boolean;\n    // @ts-ignore\n    protected _setValue: (inst: Builder<T>, index: number, value: T['TValue']) => void;\n\n    /**\n     * Appends a value (or null) to this `Builder`.\n     * This is equivalent to `builder.set(builder.length, value)`.\n     * @param {T['TValue'] | TNull } value The value to append.\n     */\n    public append(value: T['TValue'] | TNull) { return this.set(this.length, value); }\n\n    /**\n     * Validates whether a value is valid (true), or null (false)\n     * @param {T['TValue'] | TNull } value The value to compare against null the value representations\n     */\n    // @ts-ignore\n    public isValid(value: T['TValue'] | TNull): boolean { return this._isValid(value); }\n\n    /**\n     * Write a value (or null-value sentinel) at the supplied index.\n     * If the value matches one of the null-value representations, a 1-bit is\n     * written to the null `BitmapBufferBuilder`. Otherwise, a 0 is written to\n     * the null `BitmapBufferBuilder`, and the value is passed to\n     * `Builder.prototype.setValue()`.\n     * @param {number} index The index of the value to write.\n     * @param {T['TValue'] | TNull } value The value to write at the supplied index.\n     * @returns {this} The updated `Builder` instance.\n     */\n    public set(index: number, value: T['TValue'] | TNull) {\n        if (this.setValid(index, this.isValid(value))) {\n            this.setValue(index, value);\n        }\n        return this;\n    }\n\n    /**\n     * Write a value to the underlying buffers at the supplied index, bypassing\n     * the null-value check. This is a low-level method that\n     * @param {number} index\n     * @param {T['TValue'] | TNull } value\n     */\n    // @ts-ignore\n    public setValue(index: number, value: T['TValue']) { this._setValue(this, index, value); }\n    public setValid(index: number, valid: boolean) {\n        this.length = this._nulls.set(index, +valid).length;\n        return valid;\n    }\n\n    // @ts-ignore\n    public addChild(child: Builder, name = `${this.numChildren}`) {\n        throw new Error(`Cannot append children to non-nested type \"${this.type}\"`);\n    }\n\n    /**\n     * Retrieve the child `Builder` at the supplied `index`, or null if no child\n     * exists at that index.\n     * @param {number} index The index of the child `Builder` to retrieve.\n     * @returns {Builder | null} The child Builder at the supplied index or null.\n     */\n    public getChildAt<R extends DataType = any>(index: number): Builder<R> | null {\n        return this.children[index] || null;\n    }\n\n    /**\n     * Commit all the values that have been written to their underlying\n     * ArrayBuffers, including any child Builders if applicable, and reset\n     * the internal `Builder` state.\n     * @returns A `Data<T>` of the buffers and childData representing the values written.\n     */\n    public flush() {\n\n        const buffers: any = [];\n        const values =  this._values;\n        const offsets =  this._offsets;\n        const typeIds =  this._typeIds;\n        const { length, nullCount } = this;\n\n        if (typeIds) { /* Unions */\n            buffers[BufferType.TYPE] = typeIds.flush(length);\n            // DenseUnions\n            offsets && (buffers[BufferType.OFFSET] = offsets.flush(length));\n        } else if (offsets) { /* Variable-width primitives (Binary, Utf8) and Lists */\n            // Binary, Utf8\n            values && (buffers[BufferType.DATA] = values.flush(offsets.last()));\n            buffers[BufferType.OFFSET] = offsets.flush(length);\n        } else if (values) { /* Fixed-width primitives (Int, Float, Decimal, Time, Timestamp, and Interval) */\n            buffers[BufferType.DATA] = values.flush(length);\n        }\n\n        nullCount > 0 && (buffers[BufferType.VALIDITY] = this._nulls.flush(length));\n\n        const data = Data.new<T>(\n            this.type, 0, length, nullCount, buffers as Buffers<T>,\n            this.children.map((child) => child.flush())) as Data<T>;\n\n        this.clear();\n\n        return data;\n    }\n\n    /**\n     * Finalize this `Builder`, and child builders if applicable.\n     * @returns {this} The finalized `Builder` instance.\n     */\n    public finish() {\n        this.finished = true;\n        this.children.forEach((child) => child.finish());\n        return this;\n    }\n\n    /**\n     * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.\n     * @returns {this} The cleared `Builder` instance.\n     */\n    public clear() {\n        this.length = 0;\n        this._offsets && (this._offsets.clear());\n        this._values && (this._values.clear());\n        this._nulls && (this._nulls.clear());\n        this._typeIds && (this._typeIds.clear());\n        this.children.forEach((child) => child.clear());\n        return this;\n    }\n}\n\n(Builder.prototype as any).length = 1;\n(Builder.prototype as any).stride = 1;\n(Builder.prototype as any).children = null;\n(Builder.prototype as any).finished = false;\n(Builder.prototype as any).nullValues = null;\n(Builder.prototype as any)._isValid = () => true;\n\n/** @ignore */\nexport abstract class FixedWidthBuilder<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval = any, TNull = any> extends Builder<T, TNull> {\n    constructor(opts: BuilderOptions<T, TNull>) {\n        super(opts);\n        this._values = new DataBufferBuilder(new this.ArrayType(0), this.stride);\n    }\n    public setValue(index: number, value: T['TValue']) {\n        const values = this._values;\n        values.reserve(index - values.length + 1);\n        return super.setValue(index, value);\n    }\n}\n\n/** @ignore */\nexport abstract class VariableWidthBuilder<T extends Binary | Utf8 | List | Map_, TNull = any> extends Builder<T, TNull> {\n    protected _pendingLength: number = 0;\n    protected _offsets: OffsetsBufferBuilder;\n    protected _pending: Map<number, any> | undefined;\n    constructor(opts: BuilderOptions<T, TNull>) {\n        super(opts);\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    public setValue(index: number, value: T['TValue']) {\n        const pending = this._pending || (this._pending = new Map());\n        const current = pending.get(index);\n        current && (this._pendingLength -= current.length);\n        this._pendingLength += value.length;\n        pending.set(index, value);\n    }\n    public setValid(index: number, isValid: boolean) {\n        if (!super.setValid(index, isValid)) {\n            (this._pending || (this._pending = new Map())).set(index, undefined);\n            return false;\n        }\n        return true;\n    }\n    public clear() {\n        this._pendingLength = 0;\n        this._pending = undefined;\n        return super.clear();\n    }\n    public flush() {\n        this._flush();\n        return super.flush();\n    }\n    public finish() {\n        this._flush();\n        return super.finish();\n    }\n    protected _flush() {\n        const pending = this._pending;\n        const pendingLength = this._pendingLength;\n        this._pendingLength = 0;\n        this._pending = undefined;\n        if (pending && pending.size > 0) {\n            this._flushPending(pending, pendingLength);\n        }\n        return this;\n    }\n    protected abstract _flushPending(pending: Map<number, any>, pendingLength: number): void;\n}\n\n/** @ignore */\ntype ThroughIterable<T extends DataType = any, TNull = any> = (source: Iterable<T['TValue'] | TNull>) => IterableIterator<V<T>>;\n\n/** @ignore */\nfunction throughIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>): ThroughIterable<T, TNull> {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty: 'length' | 'byteLength' = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return function*(source: Iterable<T['TValue'] | TNull>) {\n        let numChunks = 0;\n        let builder = Builder.new(options);\n        for (const value of source) {\n            if (builder.append(value)[sizeProperty] >= highWaterMark) {\n                ++numChunks && (yield builder.toVector());\n            }\n        }\n        if (builder.finish().length > 0 || numChunks === 0) {\n            yield builder.toVector();\n        }\n    };\n}\n\n/** @ignore */\ntype ThroughAsyncIterable<T extends DataType = any, TNull = any> = (source: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull>) => AsyncIterableIterator<V<T>>;\n\n/** @ignore */\nfunction throughAsyncIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>): ThroughAsyncIterable<T, TNull> {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty: 'length' | 'byteLength' = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return async function* (source: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull>) {\n        let numChunks = 0;\n        let builder = Builder.new(options);\n        for await (const value of source) {\n            if (builder.append(value)[sizeProperty] >= highWaterMark) {\n                ++numChunks && (yield builder.toVector());\n            }\n        }\n        if (builder.finish().length > 0 || numChunks === 0) {\n            yield builder.toVector();\n        }\n    };\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Bool } from '../type';\nimport { BitmapBufferBuilder } from './buffer';\nimport { Builder, BuilderOptions } from '../builder';\n\n/** @ignore */\nexport class BoolBuilder<TNull = any> extends Builder<Bool, TNull> {\n    constructor(options: BuilderOptions<Bool, TNull>) {\n        super(options);\n        this._values = new BitmapBufferBuilder();\n    }\n    public setValue(index: number, value: boolean) {\n        this._values.set(index, +value);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Null } from '../type';\nimport { Builder } from '../builder';\n\n/** @ignore */\nexport class NullBuilder<TNull = any> extends Builder<Null, TNull> {\n    // @ts-ignore\n    public setValue(index: number, value: null) {}\n    public setValid(index: number, valid: boolean) {\n        this.length = Math.max(index + 1, this.length);\n        return valid;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Date_, DateDay, DateMillisecond } from '../type';\n\n/** @ignore */\nexport class DateBuilder<T extends Date_ = Date_, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class DateDayBuilder<TNull = any> extends DateBuilder<DateDay, TNull> {}\n/** @ignore */\nexport class DateMillisecondBuilder<TNull = any> extends DateBuilder<DateMillisecond, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Decimal } from '../type';\nimport { FixedWidthBuilder } from '../builder';\n\n/** @ignore */\nexport class DecimalBuilder<TNull = any> extends FixedWidthBuilder<Decimal, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { IntBuilder } from './int';\nimport { Dictionary, DataType } from '../type';\nimport { Builder, BuilderOptions } from '../builder';\n\ntype DictionaryHashFunction = (x: any) => string | number;\n\nexport interface DictionaryBuilderOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    dictionaryHashFunction?: DictionaryHashFunction;\n}\n\n/** @ignore */\nexport class DictionaryBuilder<T extends Dictionary, TNull = any> extends Builder<T, TNull> {\n\n    protected _dictionaryOffset: number;\n    protected _dictionary?: Vector<T['dictionary']>;\n    protected _keysToIndices: { [key: string]: number };\n    public readonly indices: IntBuilder<T['indices']>;\n    public readonly dictionary: Builder<T['dictionary']>;\n\n    constructor({ 'type': type, 'nullValues': nulls, 'dictionaryHashFunction': hashFn }: DictionaryBuilderOptions<T, TNull>) {\n        super({ type: new Dictionary(type.dictionary, type.indices, type.id, type.isOrdered) as T });\n        this._nulls = <any> null;\n        this._dictionaryOffset = 0;\n        this._keysToIndices = Object.create(null);\n        this.indices = Builder.new({ 'type': this.type.indices, 'nullValues': nulls }) as IntBuilder<T['indices']>;\n        this.dictionary = Builder.new({ 'type': this.type.dictionary, 'nullValues': null }) as Builder<T['dictionary']>;\n        if (typeof hashFn === 'function') {\n            this.valueToKey = hashFn;\n        }\n    }\n\n    public get values() { return this.indices.values; }\n    public get nullCount() { return this.indices.nullCount; }\n    public get nullBitmap() { return this.indices.nullBitmap; }\n    public get byteLength() { return this.indices.byteLength + this.dictionary.byteLength; }\n    public get reservedLength() { return this.indices.reservedLength + this.dictionary.reservedLength; }\n    public get reservedByteLength() { return this.indices.reservedByteLength + this.dictionary.reservedByteLength; }\n    public isValid(value: T['TValue'] | TNull) { return this.indices.isValid(value); }\n    public setValid(index: number, valid: boolean) {\n        const indices = this.indices;\n        valid = indices.setValid(index, valid);\n        this.length = indices.length;\n        return valid;\n    }\n    public setValue(index: number, value: T['TValue']) {\n        let keysToIndices = this._keysToIndices;\n        let key = this.valueToKey(value);\n        let idx = keysToIndices[key];\n        if (idx === undefined) {\n            keysToIndices[key] = idx = this._dictionaryOffset + this.dictionary.append(value).length - 1;\n        }\n        return this.indices.setValue(index, idx);\n    }\n    public flush() {\n        const type = this.type;\n        const prev = this._dictionary;\n        const curr = this.dictionary.toVector();\n        const data = this.indices.flush().clone(type);\n        data.dictionary = prev ? prev.concat(curr) : curr;\n        this.finished || (this._dictionaryOffset += curr.length);\n        this._dictionary = data.dictionary as Vector<T['dictionary']>;\n        this.clear();\n        return data;\n    }\n    public finish() {\n        this.indices.finish();\n        this.dictionary.finish();\n        this._dictionaryOffset = 0;\n        this._keysToIndices = Object.create(null);\n        return super.finish();\n    }\n    public clear() {\n        this.indices.clear();\n        this.dictionary.clear();\n        return super.clear();\n    }\n    public valueToKey(val: any): string | number {\n        return typeof val === 'string' ? val : `${val}`;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedSizeBinary } from '../type';\nimport { FixedWidthBuilder } from '../builder';\n\n/** @ignore */\nexport class FixedSizeBinaryBuilder<TNull = any> extends FixedWidthBuilder<FixedSizeBinary, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nconst f64 = new Float64Array(1);\nconst u32 = new Uint32Array(f64.buffer);\n\n/**\n * Convert uint16 (logically a float16) to a JS float64. Inspired by numpy's `npy_half_to_double`:\n * https://github.com/numpy/numpy/blob/5a5987291dc95376bb098be8d8e5391e89e77a2c/numpy/core/src/npymath/halffloat.c#L29\n * @param h {number} the uint16 to convert\n * @private\n * @ignore\n */\nexport function uint16ToFloat64(h: number) {\n    let expo = (h & 0x7C00) >> 10;\n    let sigf = (h & 0x03FF) / 1024;\n    let sign = (-1) ** ((h & 0x8000) >> 15);\n    switch (expo) {\n        case 0x1F: return sign * (sigf ? NaN : 1 / 0);\n        case 0x00: return sign * (sigf ? 6.103515625e-5 * sigf : 0);\n    }\n    return sign * (2 ** (expo - 15)) * (1 + sigf);\n}\n\n/**\n * Convert a float64 to uint16 (assuming the float64 is logically a float16). Inspired by numpy's `npy_double_to_half`:\n * https://github.com/numpy/numpy/blob/5a5987291dc95376bb098be8d8e5391e89e77a2c/numpy/core/src/npymath/halffloat.c#L43\n * @param d {number} The float64 to convert\n * @private\n * @ignore\n */\nexport function float64ToUint16(d: number) {\n\n    if (d !== d) { return 0x7E00; } // NaN\n\n    f64[0] = d;\n\n    // Magic numbers:\n    // 0x80000000 = 10000000 00000000 00000000 00000000 -- masks the 32nd bit\n    // 0x7ff00000 = 01111111 11110000 00000000 00000000 -- masks the 21st-31st bits\n    // 0x000fffff = 00000000 00001111 11111111 11111111 -- masks the 1st-20th bit\n\n    let sign = (u32[1] & 0x80000000) >> 16 & 0xFFFF;\n    let expo = (u32[1] & 0x7ff00000), sigf = 0x0000;\n\n    if (expo >= 0x40f00000) {\n        //\n        // If exponent overflowed, the float16 is either NaN or Infinity.\n        // Rules to propagate the sign bit: mantissa > 0 ? NaN : +/-Infinity\n        //\n        // Magic numbers:\n        // 0x40F00000 = 01000000 11110000 00000000 00000000 -- 6-bit exponent overflow\n        // 0x7C000000 = 01111100 00000000 00000000 00000000 -- masks the 27th-31st bits\n        //\n        // returns:\n        // qNaN, aka 32256 decimal, 0x7E00 hex, or 01111110 00000000 binary\n        // sNaN, aka 32000 decimal, 0x7D00 hex, or 01111101 00000000 binary\n        // +inf, aka 31744 decimal, 0x7C00 hex, or 01111100 00000000 binary\n        // -inf, aka 64512 decimal, 0xFC00 hex, or 11111100 00000000 binary\n        //\n        // If mantissa is greater than 23 bits, set to +Infinity like numpy\n        if (u32[0] > 0) {\n            expo = 0x7C00;\n        } else {\n            expo = (expo & 0x7C000000) >> 16;\n            sigf = (u32[1] & 0x000fffff) >> 10;\n        }\n    } else if (expo <= 0x3f000000) {\n        //\n        // If exponent underflowed, the float is either signed zero or subnormal.\n        //\n        // Magic numbers:\n        // 0x3F000000 = 00111111 00000000 00000000 00000000 -- 6-bit exponent underflow\n        //\n        sigf = 0x100000 + (u32[1] & 0x000fffff);\n        sigf = 0x100000 + (sigf << ((expo >> 20) - 998)) >> 21;\n        expo = 0;\n    } else {\n        //\n        // No overflow or underflow, rebase the exponent and round the mantissa\n        // Magic numbers:\n        // 0x200 = 00000010 00000000 -- masks off the 10th bit\n        //\n\n        // Ensure the first mantissa bit (the 10th one) is 1 and round\n        expo = (expo - 0x3f000000) >> 10;\n        sigf = ((u32[1] & 0x000fffff) + 0x200) >> 10;\n    }\n\n    return sign | expo | sigf & 0xFFFF;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { float64ToUint16 } from '../util/math';\nimport { FixedWidthBuilder } from '../builder';\nimport { Float, Float16, Float32, Float64 } from '../type';\n\n/** @ignore */\nexport class FloatBuilder<T extends Float = Float, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n\n/** @ignore */\nexport class Float16Builder<TNull = any> extends FloatBuilder<Float16, TNull> {\n    public setValue(index: number, value: number) {\n        // convert JS float64 to a uint16\n        this._values.set(index, float64ToUint16(value));\n    }\n}\n\n/** @ignore */\nexport class Float32Builder<TNull = any> extends FloatBuilder<Float32, TNull> {\n    public setValue(index: number, value: number) {\n        this._values.set(index, value);\n    }\n}\n\n/** @ignore */\nexport class Float64Builder<TNull = any> extends FloatBuilder<Float64, TNull> {\n    public setValue(index: number, value: number) {\n        this._values.set(index, value);\n    }\n}\n","import setPrototypeOf from \"./setPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nexport default function _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { ArrayBufferViewInput, toArrayBufferView } from './buffer';\nimport { TypedArray, TypedArrayConstructor } from '../interfaces';\nimport { BigIntArray, BigIntArrayConstructor } from '../interfaces';\nimport { BigIntAvailable, BigInt64Array, BigUint64Array } from './compat';\n\n/** @ignore */\nexport const isArrowBigNumSymbol = Symbol.for('isArrowBigNum');\n\n/** @ignore */ type BigNumArray = IntArray | UintArray;\n/** @ignore */ type IntArray = Int8Array | Int16Array | Int32Array;\n/** @ignore */ type UintArray = Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray;\n\n/** @ignore */\nfunction BigNum(this: any, x: any, ...xs: any) {\n    if (xs.length === 0) {\n        return Object.setPrototypeOf(toArrayBufferView(this['TypedArray'], x), this.constructor.prototype);\n    }\n    return Object.setPrototypeOf(new this['TypedArray'](x, ...xs), this.constructor.prototype);\n}\n\nBigNum.prototype[isArrowBigNumSymbol] = true;\nBigNum.prototype.toJSON = function<T extends BN<BigNumArray>>(this: T) { return `\"${bignumToString(this)}\"`; };\nBigNum.prototype.valueOf = function<T extends BN<BigNumArray>>(this: T) { return bignumToNumber(this); };\nBigNum.prototype.toString = function<T extends BN<BigNumArray>>(this: T) { return bignumToString(this); };\nBigNum.prototype[Symbol.toPrimitive] = function<T extends BN<BigNumArray>>(this: T, hint: 'string' | 'number' | 'default' = 'default') {\n    switch (hint) {\n        case 'number': return bignumToNumber(this);\n        case 'string': return bignumToString(this);\n        case 'default': return bignumToBigInt(this);\n    }\n    return bignumToString(this);\n};\n\n/** @ignore */\ntype TypedArrayConstructorArgs =\n    [number | void] |\n    [Iterable<number> | Iterable<bigint>] |\n    [ArrayBufferLike, number | void, number | void] ;\n\n/** @ignore */\nfunction SignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }\n/** @ignore */\nfunction UnsignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }\n/** @ignore */\nfunction DecimalBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }\n\nObject.setPrototypeOf(SignedBigNum.prototype,   Object.create(Int32Array.prototype));\nObject.setPrototypeOf(UnsignedBigNum.prototype, Object.create(Uint32Array.prototype));\nObject.setPrototypeOf(DecimalBigNum.prototype,  Object.create(Uint32Array.prototype));\nObject.assign(SignedBigNum.prototype,   BigNum.prototype, { 'constructor': SignedBigNum,   'signed': true,  'TypedArray': Int32Array,  'BigIntArray': BigInt64Array  });\nObject.assign(UnsignedBigNum.prototype, BigNum.prototype, { 'constructor': UnsignedBigNum, 'signed': false, 'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });\nObject.assign(DecimalBigNum.prototype,  BigNum.prototype, { 'constructor': DecimalBigNum,  'signed': true,  'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });\n\n/** @ignore */\nfunction bignumToNumber<T extends BN<BigNumArray>>(bn: T) {\n    let { buffer, byteOffset, length, 'signed': signed } = bn;\n    let words = new Int32Array(buffer, byteOffset, length);\n    let number = 0, i = 0, n = words.length, hi, lo;\n    while (i < n) {\n        lo = words[i++];\n        hi = words[i++];\n        signed || (hi = hi >>> 0);\n        number += (lo >>> 0) + (hi * (i ** 32));\n    }\n    return number;\n}\n\n/** @ignore */\nexport let bignumToString: { <T extends BN<BigNumArray>>(a: T): string; };\n/** @ignore */\nexport let bignumToBigInt: { <T extends BN<BigNumArray>>(a: T): bigint; };\n\nif (!BigIntAvailable) {\n    bignumToString = decimalToString;\n    bignumToBigInt = <any> bignumToString;\n} else {\n    bignumToBigInt = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0] : <any>decimalToString(a));\n    bignumToString = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? `${new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0]}` : decimalToString(a));\n}\n\n/** @ignore */\nfunction decimalToString<T extends BN<BigNumArray>>(a: T) {\n    let digits = '';\n    let base64 = new Uint32Array(2);\n    let base32 = new Uint16Array(a.buffer, a.byteOffset, a.byteLength / 2);\n    let checks = new Uint32Array((base32 = new Uint16Array(base32).reverse()).buffer);\n    let i = -1, n = base32.length - 1;\n    do {\n        for (base64[0] = base32[i = 0]; i < n;) {\n            base32[i++] = base64[1] = base64[0] / 10;\n            base64[0] = ((base64[0] - base64[1] * 10) << 16) + base32[i];\n        }\n        base32[i] = base64[1] = base64[0] / 10;\n        base64[0] = base64[0] - base64[1] * 10;\n        digits = `${base64[0]}${digits}`;\n    } while (checks[0] || checks[1] || checks[2] || checks[3]);\n    return digits ? digits : `0`;\n}\n\n/** @ignore */\nexport class BN<T extends BigNumArray> {\n    /** @nocollapse */\n    public static new<T extends BigNumArray>(num: T, isSigned?: boolean): (T & BN<T>) {\n        switch (isSigned) {\n            case true: return new (<any> SignedBigNum)(num) as (T & BN<T>);\n            case false: return new (<any> UnsignedBigNum)(num) as (T & BN<T>);\n        }\n        switch (num.constructor) {\n            case Int8Array:\n            case Int16Array:\n            case Int32Array:\n            case BigInt64Array:\n                return new (<any> SignedBigNum)(num) as (T & BN<T>);\n        }\n        if (num.byteLength === 16) {\n            return new (<any> DecimalBigNum)(num) as (T & BN<T>);\n        }\n        return new (<any> UnsignedBigNum)(num) as (T & BN<T>);\n    }\n    /** @nocollapse */\n    public static signed<T extends IntArray>(num: T): (T & BN<T>) {\n        return new (<any> SignedBigNum)(num) as (T & BN<T>);\n    }\n    /** @nocollapse */\n    public static unsigned<T extends UintArray>(num: T): (T & BN<T>) {\n        return new (<any> UnsignedBigNum)(num) as (T & BN<T>);\n    }\n    /** @nocollapse */\n    public static decimal<T extends UintArray>(num: T): (T & BN<T>) {\n        return new (<any> DecimalBigNum)(num) as (T & BN<T>);\n    }\n    constructor(num: T, isSigned?: boolean) {\n        return BN.new(num, isSigned) as any;\n    }\n}\n\n/** @ignore */\nexport interface BN<T extends BigNumArray> extends TypedArrayLike<T> {\n\n    new<T extends ArrayBufferViewInput>(buffer: T, signed?: boolean): T;\n\n    readonly signed: boolean;\n    readonly TypedArray: TypedArrayConstructor<TypedArray>;\n    readonly BigIntArray: BigIntArrayConstructor<BigIntArray>;\n\n    [Symbol.toStringTag]:\n        'Int8Array'         |\n        'Int16Array'        |\n        'Int32Array'        |\n        'Uint8Array'        |\n        'Uint16Array'       |\n        'Uint32Array'       |\n        'Uint8ClampedArray';\n\n    /**\n     * Convert the bytes to their (positive) decimal representation for printing\n     */\n    toString(): string;\n    /**\n     * Down-convert the bytes to a 53-bit precision integer. Invoked by JS for\n     * arithmetic operators, like `+`. Easy (and unsafe) way to convert BN to\n     * number via `+bn_inst`\n     */\n    valueOf(): number;\n    /**\n     * Return the JSON representation of the bytes. Must be wrapped in double-quotes,\n     * so it's compatible with JSON.stringify().\n     */\n    toJSON(): string;\n    [Symbol.toPrimitive](hint?: any): number | string | bigint;\n}\n\n/** @ignore */\ninterface TypedArrayLike<T extends BigNumArray> {\n\n    readonly length: number;\n    readonly buffer: ArrayBuffer;\n    readonly byteLength: number;\n    readonly byteOffset: number;\n    readonly BYTES_PER_ELEMENT: number;\n\n    includes(searchElement: number, fromIndex?: number | undefined): boolean;\n    copyWithin(target: number, start: number, end?: number | undefined): this;\n    every(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): boolean;\n    fill(value: number, start?: number | undefined, end?: number | undefined): this;\n    filter(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): T;\n    find(predicate: (value: number, index: number, obj: T) => boolean, thisArg?: any): number | undefined;\n    findIndex(predicate: (value: number, index: number, obj: T) => boolean, thisArg?: any): number;\n    forEach(callbackfn: (value: number, index: number, array: T) => void, thisArg?: any): void;\n    indexOf(searchElement: number, fromIndex?: number | undefined): number;\n    join(separator?: string | undefined): string;\n    lastIndexOf(searchElement: number, fromIndex?: number | undefined): number;\n    map(callbackfn: (value: number, index: number, array: T) => number, thisArg?: any): T;\n    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number): number;\n    reduce(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number, initialValue: number): number;\n    reduce<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: T) => U, initialValue: U): U;\n    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number): number;\n    reduceRight(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: T) => number, initialValue: number): number;\n    reduceRight<U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: T) => U, initialValue: U): U;\n    reverse(): T;\n    set(array: ArrayLike<number>, offset?: number | undefined): void;\n    slice(start?: number | undefined, end?: number | undefined): T;\n    some(callbackfn: (value: number, index: number, array: T) => boolean, thisArg?: any): boolean;\n    sort(compareFn?: ((a: number, b: number) => number) | undefined): this;\n    subarray(begin: number, end?: number | undefined): T;\n    toLocaleString(): string;\n    entries(): IterableIterator<[number, number]>;\n    keys(): IterableIterator<number>;\n    values(): IterableIterator<number>;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { bignumToBigInt } from '../util/bn';\nimport { WideBufferBuilder } from './buffer';\nimport { BigInt64Array } from '../util/compat';\nimport { FixedWidthBuilder, BuilderOptions } from '../builder';\nimport { Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64 } from '../type';\n\n/** @ignore */\nexport class IntBuilder<T extends Int = Int, TNull = any> extends FixedWidthBuilder<T, TNull> {\n    public setValue(index: number, value: T['TValue']) {\n        this._values.set(index, value);\n    }\n}\n\n/** @ignore */\nexport class Int8Builder<TNull = any> extends IntBuilder<Int8, TNull> {}\n/** @ignore */\nexport class Int16Builder<TNull = any> extends IntBuilder<Int16, TNull> {}\n/** @ignore */\nexport class Int32Builder<TNull = any> extends IntBuilder<Int32, TNull> {}\n/** @ignore */\nexport class Int64Builder<TNull = any> extends IntBuilder<Int64, TNull> {\n    protected _values: WideBufferBuilder<Int32Array, BigInt64Array>;\n    constructor(options: BuilderOptions<Int64, TNull>) {\n        if (options['nullValues']) {\n            options['nullValues'] = (options['nullValues'] as TNull[]).map(toBigInt);\n        }\n        super(options);\n        this._values = new WideBufferBuilder(new Int32Array(0), 2);\n    }\n    public get values64() { return this._values.buffer64; }\n    public isValid(value: Int32Array | bigint | TNull) { return super.isValid(toBigInt(value)); }\n}\n\n/** @ignore */\nexport class Uint8Builder<TNull = any> extends IntBuilder<Uint8, TNull> {}\n/** @ignore */\nexport class Uint16Builder<TNull = any> extends IntBuilder<Uint16, TNull> {}\n/** @ignore */\nexport class Uint32Builder<TNull = any> extends IntBuilder<Uint32, TNull> {}\n/** @ignore */\nexport class Uint64Builder<TNull = any> extends IntBuilder<Uint64, TNull> {\n    protected _values: WideBufferBuilder<Uint32Array, BigUint64Array>;\n    constructor(options: BuilderOptions<Uint64, TNull>) {\n        if (options['nullValues']) {\n            options['nullValues'] = (options['nullValues'] as TNull[]).map(toBigInt);\n        }\n        super(options);\n        this._values = new WideBufferBuilder(new Uint32Array(0), 2);\n    }\n    public get values64() { return this._values.buffer64; }\n    public isValid(value: Uint32Array | bigint | TNull) { return super.isValid(toBigInt(value)); }\n}\n\nconst toBigInt = ((memo: any) => (value: any) => {\n    if (ArrayBuffer.isView(value)) {\n        memo.buffer = value.buffer;\n        memo.byteOffset = value.byteOffset;\n        memo.byteLength = value.byteLength;\n        value = bignumToBigInt(memo);\n        memo.buffer = null;\n    }\n    return value;\n})({ 'BigIntArray': BigInt64Array });\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond } from '../type';\n\n/** @ignore */\nexport class TimeBuilder<T extends Time = Time, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class TimeSecondBuilder<TNull = any> extends TimeBuilder<TimeSecond, TNull> {}\n/** @ignore */\nexport class TimeMillisecondBuilder<TNull = any> extends TimeBuilder<TimeMillisecond, TNull> {}\n/** @ignore */\nexport class TimeMicrosecondBuilder<TNull = any> extends TimeBuilder<TimeMicrosecond, TNull> {}\n/** @ignore */\nexport class TimeNanosecondBuilder<TNull = any> extends TimeBuilder<TimeNanosecond, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond } from '../type';\n\n/** @ignore */\nexport class TimestampBuilder<T extends Timestamp = Timestamp, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class TimestampSecondBuilder<TNull = any> extends TimestampBuilder<TimestampSecond, TNull> {}\n/** @ignore */\nexport class TimestampMillisecondBuilder<TNull = any> extends TimestampBuilder<TimestampMillisecond, TNull> {}\n/** @ignore */\nexport class TimestampMicrosecondBuilder<TNull = any> extends TimestampBuilder<TimestampMicrosecond, TNull> {}\n/** @ignore */\nexport class TimestampNanosecondBuilder<TNull = any> extends TimestampBuilder<TimestampNanosecond, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FixedWidthBuilder } from '../builder';\nimport { Interval, IntervalDayTime, IntervalYearMonth } from '../type';\n\n/** @ignore */\nexport class IntervalBuilder<T extends Interval = Interval, TNull = any> extends FixedWidthBuilder<T, TNull> {}\n/** @ignore */\nexport class IntervalDayTimeBuilder<TNull = any> extends IntervalBuilder<IntervalDayTime, TNull> {}\n/** @ignore */\nexport class IntervalYearMonthBuilder<TNull = any> extends IntervalBuilder<IntervalYearMonth, TNull> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Binary } from '../type';\nimport { toUint8Array } from '../util/buffer';\nimport { BufferBuilder } from './buffer';\nimport { VariableWidthBuilder, BuilderOptions } from '../builder';\n\n/** @ignore */\nexport class BinaryBuilder<TNull = any> extends VariableWidthBuilder<Binary, TNull> {\n    constructor(opts: BuilderOptions<Binary, TNull>) {\n        super(opts);\n        this._values = new BufferBuilder(new Uint8Array(0));\n    }\n    public get byteLength(): number {\n        let size = this._pendingLength + (this.length * 4);\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        return size;\n    }\n    public setValue(index: number, value: Uint8Array) {\n        return super.setValue(index, toUint8Array(value));\n    }\n    protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number) {\n        const offsets = this._offsets;\n        const data = this._values.reserve(pendingLength).buffer;\n        let index = 0, length = 0, offset = 0, value: Uint8Array | undefined;\n        for ([index, value] of pending) {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            } else {\n                length = value.length;\n                data.set(value, offset);\n                offsets.set(index, length);\n                offset += length;\n            }\n        }\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Utf8 } from '../type';\nimport { encodeUtf8 } from '../util/utf8';\nimport { BinaryBuilder } from './binary';\nimport { BufferBuilder } from './buffer';\nimport { VariableWidthBuilder, BuilderOptions } from '../builder';\n\n/** @ignore */\nexport class Utf8Builder<TNull = any> extends VariableWidthBuilder<Utf8, TNull> {\n    constructor(opts: BuilderOptions<Utf8, TNull>) {\n        super(opts);\n        this._values = new BufferBuilder(new Uint8Array(0));\n    }\n    public get byteLength(): number {\n        let size = this._pendingLength + (this.length * 4);\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        return size;\n    }\n    public setValue(index: number, value: string) {\n        return super.setValue(index, encodeUtf8(value) as any);\n    }\n    // @ts-ignore\n    protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number): void {}\n}\n\n(Utf8Builder.prototype as any)._flushPending = (BinaryBuilder.prototype as any)._flushPending;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\n\n/** @ignore */\nexport class Run<T extends DataType = any, TNull = any> {\n    // @ts-ignore\n    protected _values: ArrayLike<T['TValue'] | TNull>;\n    public get length() { return this._values.length; }\n    public get(index: number) { return this._values[index]; }\n    public clear() { this._values = <any> null; return this; }\n    public bind(values: Vector<T> | ArrayLike<T['TValue'] | TNull>) {\n        if (values instanceof Vector) {\n            return values;\n        }\n        this._values = values;\n        return this as any;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { StructVector } from './struct';\nimport { valueToString } from '../util/pretty';\nimport { DataType, Struct, RowLike } from '../type';\n\n/** @ignore */ const kParent = Symbol.for('parent');\n/** @ignore */ const kRowIndex = Symbol.for('rowIndex');\n/** @ignore */ const kKeyToIdx = Symbol.for('keyToIdx');\n/** @ignore */ const kIdxToVal = Symbol.for('idxToVal');\n/** @ignore */ const kCustomInspect = Symbol.for('nodejs.util.inspect.custom');\n\nabstract class Row<K extends PropertyKey = any, V = any> implements Map<K, V> {\n\n    public readonly size: number;\n    public readonly [Symbol.toStringTag]: string;\n\n    protected [kRowIndex]: number;\n    protected [kParent]: Vector<Struct>;\n    protected [kKeyToIdx]: Map<K, number>;\n    protected [kIdxToVal]: V[];\n\n    constructor(parent: Vector<Struct>, numKeys: number) {\n        this[kParent] = parent;\n        this.size = numKeys;\n    }\n\n    public abstract keys(): IterableIterator<K>;\n    public abstract values(): IterableIterator<V>;\n    public abstract getKey(idx: number): K;\n    public abstract getIndex(key: K): number;\n    public abstract getValue(idx: number): V;\n    public abstract setValue(idx: number, val: V): void;\n\n    public entries() { return this[Symbol.iterator](); }\n\n    public has(key: K) { return this.get(key) !== undefined; }\n\n    public get(key: K) {\n        let val = undefined;\n        if (key !== null && key !== undefined) {\n            const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n            let idx = ktoi.get(key);\n            if (idx !== undefined) {\n                const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n                ((val = itov[idx]) !== undefined) || (itov[idx] = val = this.getValue(idx));\n            } else if ((idx = this.getIndex(key)) > -1) {\n                ktoi.set(key, idx);\n                const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n                ((val = itov[idx]) !== undefined) || (itov[idx] = val = this.getValue(idx));\n            }\n        }\n        return val;\n    }\n\n    public set(key: K, val: V) {\n        if (key !== null && key !== undefined) {\n            const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n            let idx = ktoi.get(key);\n            if (idx === undefined) {\n                ktoi.set(key, idx = this.getIndex(key));\n            }\n            if (idx > -1) {\n                const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n                itov[idx] = <any> this.setValue(idx, val);\n            }\n        }\n        return this;\n    }\n\n    public clear(): void { throw new Error(`Clearing ${this[Symbol.toStringTag]} not supported.`); }\n\n    public delete(_: K): boolean { throw new Error(`Deleting ${this[Symbol.toStringTag]} values not supported.`); }\n\n    public *[Symbol.iterator](): IterableIterator<[K, V]> {\n\n        const ki = this.keys();\n        const vi = this.values();\n        const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n        const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n\n        for (let k: K, v: V, i = 0, kr: IteratorResult<K>, vr: IteratorResult<V>;\n            !((kr = ki.next()).done || (vr = vi.next()).done);\n            ++i\n        ) {\n            k = kr.value;\n            v = vr.value;\n            itov[i] = v;\n            ktoi.has(k) || ktoi.set(k, i);\n            yield [k, v];\n        }\n    }\n\n    public forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {\n\n        const ki = this.keys();\n        const vi = this.values();\n        const callback = thisArg === undefined ? callbackfn :\n            (v: V, k: K, m: Map<K, V>) => callbackfn.call(thisArg, v, k, m);\n        const ktoi = this[kKeyToIdx] || (this[kKeyToIdx] = new Map());\n        const itov = this[kIdxToVal] || (this[kIdxToVal] = new Array(this.size));\n\n        for (let k: K, v: V, i = 0, kr: IteratorResult<K>, vr: IteratorResult<V>;\n            !((kr = ki.next()).done || (vr = vi.next()).done);\n            ++i\n        ) {\n            k = kr.value;\n            v = vr.value;\n            itov[i] = v;\n            ktoi.has(k) || ktoi.set(k, i);\n            callback(v, k, this);\n        }\n    }\n\n    public toArray() { return [...this.values()]; }\n    public toJSON() {\n        const obj = {} as any;\n        this.forEach((val, key) => obj[key] = val);\n        return obj;\n    }\n\n    public inspect() { return this.toString(); }\n    public [kCustomInspect]() { return this.toString(); }\n    public toString() {\n        const str: string[] = [];\n        this.forEach((val, key) => {\n            key = valueToString(key);\n            val = valueToString(val);\n            str.push(`${key}: ${val}`);\n        });\n        return `{ ${str.join(', ')} }`;\n    }\n\n    protected static [Symbol.toStringTag] = ((proto: Row) => {\n        Object.defineProperties(proto, {\n            'size': { writable: true, enumerable: false, configurable: false, value: 0 },\n            [kParent]: { writable: true, enumerable: false, configurable: false, value: null },\n            [kRowIndex]: { writable: true, enumerable: false, configurable: false, value: -1 },\n        });\n        return (proto as any)[Symbol.toStringTag] = 'Row';\n    })(Row.prototype);\n}\n\nexport class MapRow<K extends DataType = any, V extends DataType = any> extends Row<K['TValue'], V['TValue'] | null> {\n    constructor(slice: Vector<Struct<{ key: K, value: V }>>) {\n        super(slice, slice.length);\n        return createRowProxy(this);\n    }\n    public keys() {\n        return this[kParent].getChildAt(0)![Symbol.iterator]();\n    }\n    public values() {\n        return this[kParent].getChildAt(1)![Symbol.iterator]();\n    }\n    public getKey(idx: number): K['TValue'] {\n        return this[kParent].getChildAt(0)!.get(idx);\n    }\n    public getIndex(key: K['TValue']): number {\n        return this[kParent].getChildAt(0)!.indexOf(key);\n    }\n    public getValue(index: number): V['TValue'] | null {\n        return this[kParent].getChildAt(1)!.get(index);\n    }\n    public setValue(index: number, value: V['TValue'] | null): void {\n        this[kParent].getChildAt(1)!.set(index, value);\n    }\n}\n\nexport class StructRow<T extends { [key: string]: DataType } = any> extends Row<keyof T, T[keyof T]['TValue'] | null> {\n    constructor(parent: StructVector<T>) {\n        super(parent, parent.type.children.length);\n        return defineRowProxyProperties(this);\n    }\n    public *keys() {\n        for (const field of this[kParent].type.children) {\n            yield field.name as keyof T;\n        }\n    }\n    public *values() {\n        for (const field of this[kParent].type.children) {\n            yield (this as RowLike<T>)[field.name];\n        }\n    }\n    public getKey(idx: number): keyof T {\n        return this[kParent].type.children[idx].name as keyof T;\n    }\n    public getIndex(key: keyof T): number {\n        return this[kParent].type.children.findIndex((f) => f.name === key);\n    }\n    public getValue(index: number): T[keyof T]['TValue'] | null {\n        return this[kParent].getChildAt(index)!.get(this[kRowIndex]);\n    }\n    public setValue(index: number, value: T[keyof T]['TValue'] | null): void {\n        return this[kParent].getChildAt(index)!.set(this[kRowIndex], value);\n    }\n}\n\nObject.setPrototypeOf(Row.prototype, Map.prototype);\n\n/** @ignore */\nconst defineRowProxyProperties = (() => {\n    const desc = { enumerable: true, configurable: false, get: null as any, set: null as any };\n    return <T extends Row>(row: T) => {\n        let idx = -1, ktoi = row[kKeyToIdx] || (row[kKeyToIdx] = new Map());\n        const getter = (key: any) => function(this: T) { return this.get(key); };\n        const setter = (key: any) => function(this: T, val: any) { return this.set(key, val); };\n        for (const key of row.keys()) {\n            ktoi.set(key, ++idx);\n            desc.get = getter(key);\n            desc.set = setter(key);\n            row.hasOwnProperty(key) || (desc.enumerable = true, Object.defineProperty(row, key, desc));\n            row.hasOwnProperty(idx) || (desc.enumerable = false, Object.defineProperty(row, idx, desc));\n        }\n        desc.get = desc.set = null;\n        return row;\n    };\n})();\n\n/** @ignore */\nconst createRowProxy = (() => {\n    if (typeof Proxy === 'undefined') {\n        return defineRowProxyProperties;\n    }\n    const has = Row.prototype.has;\n    const get = Row.prototype.get;\n    const set = Row.prototype.set;\n    const getKey = Row.prototype.getKey;\n    const RowProxyHandler: ProxyHandler<Row> = {\n        isExtensible() { return false; },\n        deleteProperty() { return false; },\n        preventExtensions() { return true; },\n        ownKeys(row: Row) { return [...row.keys()].map((x) => `${x}`); },\n        has(row: Row, key: PropertyKey) {\n            switch (key) {\n                case 'getKey': case 'getIndex': case 'getValue': case 'setValue': case 'toArray': case 'toJSON': case 'inspect':\n                case 'constructor': case 'isPrototypeOf': case 'propertyIsEnumerable': case 'toString': case 'toLocaleString': case 'valueOf':\n                case 'size': case 'has': case 'get': case 'set': case 'clear': case 'delete': case 'keys': case 'values': case 'entries': case 'forEach':\n                case '__proto__': case '__defineGetter__': case '__defineSetter__': case 'hasOwnProperty': case '__lookupGetter__': case '__lookupSetter__':\n                case Symbol.iterator: case Symbol.toStringTag: case kParent: case kRowIndex: case kIdxToVal: case kKeyToIdx: case kCustomInspect:\n                    return true;\n            }\n            if (typeof key === 'number' && !row.has(key)) {\n                key = row.getKey(key);\n            }\n            return row.has(key);\n        },\n        get(row: Row, key: PropertyKey, receiver: any) {\n            switch (key) {\n                case 'getKey': case 'getIndex': case 'getValue': case 'setValue': case 'toArray': case 'toJSON': case 'inspect':\n                case 'constructor': case 'isPrototypeOf': case 'propertyIsEnumerable': case 'toString': case 'toLocaleString': case 'valueOf':\n                case 'size': case 'has': case 'get': case 'set': case 'clear': case 'delete': case 'keys': case 'values': case 'entries': case 'forEach':\n                case '__proto__': case '__defineGetter__': case '__defineSetter__': case 'hasOwnProperty': case '__lookupGetter__': case '__lookupSetter__':\n                case Symbol.iterator: case Symbol.toStringTag: case kParent: case kRowIndex: case kIdxToVal: case kKeyToIdx: case kCustomInspect:\n                    return Reflect.get(row, key, receiver);\n            }\n            if (typeof key === 'number' && !has.call(receiver, key)) {\n                key = getKey.call(receiver, key);\n            }\n            return get.call(receiver, key);\n        },\n        set(row: Row, key: PropertyKey, val: any, receiver: any) {\n            switch (key) {\n                case kParent: case kRowIndex: case kIdxToVal: case kKeyToIdx:\n                    return Reflect.set(row, key, val, receiver);\n                case 'getKey': case 'getIndex': case 'getValue': case 'setValue': case 'toArray': case 'toJSON': case 'inspect':\n                case 'constructor': case 'isPrototypeOf': case 'propertyIsEnumerable': case 'toString': case 'toLocaleString': case 'valueOf':\n                case 'size': case 'has': case 'get': case 'set': case 'clear': case 'delete': case 'keys': case 'values': case 'entries': case 'forEach':\n                case '__proto__': case '__defineGetter__': case '__defineSetter__': case 'hasOwnProperty': case '__lookupGetter__': case '__lookupSetter__':\n                case Symbol.iterator: case Symbol.toStringTag:\n                    return false;\n            }\n            if (typeof key === 'number' && !has.call(receiver, key)) {\n                key = getKey.call(receiver, key);\n            }\n            return has.call(receiver, key) ? !!set.call(receiver, key, val) : false;\n        },\n    };\n    return <T extends Row>(row: T) => new Proxy(row, RowProxyHandler) as T;\n})();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { MapRow, StructRow } from '../vector/row';\nimport { compareArrayLike } from '../util/buffer';\nimport { BigInt, BigIntAvailable } from './compat';\n\n/** @ignore */\ntype RangeLike = { length: number; stride?: number };\n/** @ignore */\ntype ClampThen<T extends RangeLike> = (source: T, index: number) => any;\n/** @ignore */\ntype ClampRangeThen<T extends RangeLike> = (source: T, offset: number, length: number) => any;\n\nexport function clampIndex<T extends RangeLike>(source: T, index: number): number;\nexport function clampIndex<T extends RangeLike, N extends ClampThen<T> = ClampThen<T>>(source: T, index: number, then: N): ReturnType<N>;\n/** @ignore */\nexport function clampIndex<T extends RangeLike, N extends ClampThen<T> = ClampThen<T>>(source: T, index: number, then?: N) {\n    const length = source.length;\n    const adjust = index > -1 ? index : (length + (index % length));\n    return then ? then(source, adjust) : adjust;\n}\n\n/** @ignore */\nlet tmp: number;\nexport function clampRange<T extends RangeLike>(source: T, begin: number | undefined, end: number | undefined): [number, number];\nexport function clampRange<T extends RangeLike, N extends ClampRangeThen<T> = ClampRangeThen<T>>(source: T, begin: number | undefined, end: number | undefined, then: N): ReturnType<N>;\n/** @ignore */\nexport function clampRange<T extends RangeLike, N extends ClampRangeThen<T> = ClampRangeThen<T>>(source: T, begin: number | undefined, end: number | undefined, then?: N) {\n\n    // Adjust args similar to Array.prototype.slice. Normalize begin/end to\n    // clamp between 0 and length, and wrap around on negative indices, e.g.\n    // slice(-1, 5) or slice(5, -1)\n    let { length: len = 0 } = source;\n    let lhs = typeof begin !== 'number' ? 0 : begin;\n    let rhs = typeof end !== 'number' ? len : end;\n    // wrap around on negative start/end positions\n    (lhs < 0) && (lhs = ((lhs % len) + len) % len);\n    (rhs < 0) && (rhs = ((rhs % len) + len) % len);\n    // ensure lhs <= rhs\n    (rhs < lhs) && (tmp = lhs, lhs = rhs, rhs = tmp);\n     // ensure rhs <= length\n    (rhs > len) && (rhs = len);\n\n    return then ? then(source, lhs, rhs) : [lhs, rhs];\n}\n\nconst big0 = BigIntAvailable ? BigInt(0) : 0;\nconst isNaNFast = (value: any) => value !== value;\n\n/** @ignore */\nexport function createElementComparator(search: any) {\n    let typeofSearch = typeof search;\n    // Compare primitives\n    if (typeofSearch !== 'object' || search === null) {\n        // Compare NaN\n        if (isNaNFast(search)) {\n            return isNaNFast;\n        }\n        return typeofSearch !== 'bigint'\n            ? (value: any) => value === search\n            : (value: any) => (big0 + value) === search;\n    }\n    // Compare Dates\n    if (search instanceof Date) {\n        const valueOfSearch = search.valueOf();\n        return (value: any) => value instanceof Date ? (value.valueOf() === valueOfSearch) : false;\n    }\n    // Compare TypedArrays\n    if (ArrayBuffer.isView(search)) {\n        return (value: any) => value ? compareArrayLike(search, value) : false;\n    }\n    // Compare Maps and Rows\n    if (search instanceof Map) { return creatMapComparator(search); }\n    // Compare Array-likes\n    if (Array.isArray(search)) { return createArrayLikeComparator(search); }\n    // Compare Vectors\n    if (search instanceof Vector) { return createVectorComparator(search); }\n    // Compare non-empty Objects\n    return createObjectComparator(search);\n}\n\n/** @ignore */\nfunction createArrayLikeComparator(lhs: ArrayLike<any>) {\n    const comparators = [] as ((x: any) => boolean)[];\n    for (let i = -1, n = lhs.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs[i]);\n    }\n    return createSubElementsComparator(comparators);\n}\n\n/** @ignore */\nfunction creatMapComparator(lhs: Map<any, any>) {\n    let i = -1;\n    const comparators = [] as ((x: any) => boolean)[];\n    lhs.forEach((v) => comparators[++i] = createElementComparator(v));\n    return createSubElementsComparator(comparators);\n}\n\n/** @ignore */\nfunction createVectorComparator(lhs: Vector<any>) {\n    const comparators = [] as ((x: any) => boolean)[];\n    for (let i = -1, n = lhs.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs.get(i));\n    }\n    return createSubElementsComparator(comparators);\n}\n\n/** @ignore */\nfunction createObjectComparator(lhs: any) {\n    const keys = Object.keys(lhs);\n    // Only compare non-empty Objects\n    if (keys.length === 0) { return () => false; }\n    const comparators = [] as ((x: any) => boolean)[];\n    for (let i = -1, n = keys.length; ++i < n;) {\n        comparators[i] = createElementComparator(lhs[keys[i]]);\n    }\n    return createSubElementsComparator(comparators, keys);\n}\n\nfunction createSubElementsComparator(comparators: ((x: any) => boolean)[], keys?: Iterable<string>) {\n    return (rhs: any) => {\n        if (!rhs || typeof rhs !== 'object') {\n            return false;\n        }\n        switch (rhs.constructor) {\n            case Array: return compareArray(comparators, rhs);\n            case Map:\n            case MapRow:\n            case StructRow:\n                return compareObject(comparators, rhs, rhs.keys());\n            case Object:\n            case undefined: // support `Object.create(null)` objects\n                return compareObject(comparators, rhs, keys || Object.keys(rhs));\n        }\n        return rhs instanceof Vector ? compareVector(comparators, rhs) : false;\n    };\n}\n\nfunction compareArray(comparators: ((x: any) => boolean)[], arr: any[]) {\n    const n = comparators.length;\n    if (arr.length !== n) { return false; }\n    for (let i = -1; ++i < n;) {\n        if (!(comparators[i](arr[i]))) { return false; }\n    }\n    return true;\n}\n\nfunction compareVector(comparators: ((x: any) => boolean)[], vec: Vector) {\n    const n = comparators.length;\n    if (vec.length !== n) { return false; }\n    for (let i = -1; ++i < n;) {\n        if (!(comparators[i](vec.get(i)))) { return false; }\n    }\n    return true;\n}\n\nfunction compareObject(comparators: ((x: any) => boolean)[], obj: Map<any, any>, keys: Iterable<string>) {\n\n    const lKeyItr = keys[Symbol.iterator]();\n    const rKeyItr = obj instanceof Map ? obj.keys() : Object.keys(obj)[Symbol.iterator]();\n    const rValItr = obj instanceof Map ? obj.values() : Object.values(obj)[Symbol.iterator]();\n\n    let i = 0;\n    let n = comparators.length;\n    let rVal = rValItr.next();\n    let lKey = lKeyItr.next();\n    let rKey = rKeyItr.next();\n\n    for (; i < n && !lKey.done && !rKey.done && !rVal.done;\n         ++i, lKey = lKeyItr.next(), rKey = rKeyItr.next(), rVal = rValItr.next()) {\n        if (lKey.value !== rKey.value || !comparators[i](rVal.value)) {\n            break;\n        }\n    }\n    if (i === n && lKey.done && rKey.done && rVal.done) {\n        return true;\n    }\n    lKeyItr.return && lKeyItr.return();\n    rKeyItr.return && rKeyItr.return();\n    rValItr.return && rValItr.return();\n    return false;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Field } from '../schema';\nimport { clampRange } from '../util/vector';\nimport { DataType, Dictionary } from '../type';\nimport { selectChunkArgs } from '../util/args';\nimport { DictionaryVector } from './dictionary';\nimport { AbstractVector, Vector } from '../vector';\nimport { Clonable, Sliceable, Applicative } from '../vector';\n\n/** @ignore */\ntype ChunkedDict<T extends DataType> = T extends Dictionary ? Vector<T['dictionary']> : null | never;\n/** @ignore */\ntype ChunkedKeys<T extends DataType> = T extends Dictionary ? Vector<T['indices']> | Chunked<T['indices']> : null | never;\n\n/** @ignore */\nexport type SearchContinuation<T extends Chunked> = (column: T, chunkIndex: number, valueIndex: number) => any;\n\n/** @ignore */\nexport class Chunked<T extends DataType = any>\n    extends AbstractVector<T>\n    implements Clonable<Chunked<T>>,\n               Sliceable<Chunked<T>>,\n               Applicative<T, Chunked<T>> {\n\n    /** @nocollapse */\n    public static flatten<T extends DataType>(...vectors: (Vector<T> | Vector<T>[])[]) {\n        return selectChunkArgs<Vector<T>>(Vector, vectors);\n    }\n\n    /** @nocollapse */\n    public static concat<T extends DataType>(...vectors: (Vector<T> | Vector<T>[])[]) {\n        const chunks = Chunked.flatten<T>(...vectors);\n        return new Chunked<T>(chunks[0].type, chunks);\n    }\n\n    protected _type: T;\n    protected _length: number;\n    protected _chunks: Vector<T>[];\n    protected _numChildren: number;\n    protected _children?: Chunked[];\n    protected _nullCount: number = -1;\n    protected _chunkOffsets: Uint32Array;\n\n    constructor(type: T, chunks: Vector<T>[] = [], offsets = calculateOffsets(chunks)) {\n        super();\n        this._type = type;\n        this._chunks = chunks;\n        this._chunkOffsets = offsets;\n        this._length = offsets[offsets.length - 1];\n        this._numChildren = (this._type.children || []).length;\n    }\n\n    public get type() { return this._type; }\n    public get length() { return this._length; }\n    public get chunks() { return this._chunks; }\n    public get typeId(): T['TType'] { return this._type.typeId; }\n    public get VectorName() { return `Chunked<${this._type}>`; }\n    public get data(): Data<T> {\n        return this._chunks[0] ? this._chunks[0].data : <any> null;\n    }\n\n    public get ArrayType() { return this._type.ArrayType; }\n    public get numChildren() { return this._numChildren; }\n    public get stride() { return this._chunks[0] ? this._chunks[0].stride : 1; }\n    public get byteLength(): number {\n        return this._chunks.reduce((byteLength, chunk) => byteLength + chunk.byteLength, 0);\n    }\n    public get nullCount() {\n        let nullCount = this._nullCount;\n        if (nullCount < 0) {\n            this._nullCount = nullCount = this._chunks.reduce((x, { nullCount }) => x + nullCount, 0);\n        }\n        return nullCount;\n    }\n\n    protected _indices?: ChunkedKeys<T>;\n    public get indices(): ChunkedKeys<T> | null {\n        if (DataType.isDictionary(this._type)) {\n            if (!this._indices) {\n                const chunks = (<any> this._chunks) as DictionaryVector<T, any>[];\n                this._indices = (chunks.length === 1\n                    ? chunks[0].indices\n                    : Chunked.concat(...chunks.map((x) => x.indices))) as ChunkedKeys<T>;\n            }\n            return this._indices;\n        }\n        return null;\n    }\n    public get dictionary(): ChunkedDict<T> | null {\n        if (DataType.isDictionary(this._type)) {\n            return this._chunks[this._chunks.length - 1].data.dictionary as ChunkedDict<T>;\n        }\n        return null;\n    }\n\n    public *[Symbol.iterator](): IterableIterator<T['TValue'] | null> {\n        for (const chunk of this._chunks) {\n            yield* chunk;\n        }\n    }\n\n    public clone(chunks = this._chunks): Chunked<T> {\n        return new Chunked(this._type, chunks);\n    }\n\n    public concat(...others: Vector<T>[]): Chunked<T> {\n        return this.clone(Chunked.flatten(this, ...others));\n    }\n\n    public slice(begin?: number, end?: number): Chunked<T> {\n        return clampRange(this, begin, end, this._sliceInternal);\n    }\n\n    public getChildAt<R extends DataType = any>(index: number): Chunked<R> | null {\n\n        if (index < 0 || index >= this._numChildren) { return null; }\n\n        let columns = this._children || (this._children = []);\n        let child: Chunked<R>, field: Field<R>, chunks: Vector<R>[];\n\n        if (child = columns[index]) { return child; }\n        if (field = ((this._type.children || [])[index] as Field<R>)) {\n            chunks = this._chunks\n                .map((vector) => vector.getChildAt<R>(index))\n                .filter((vec): vec is Vector<R> => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Chunked<R>(field.type, chunks));\n            }\n        }\n\n        return null;\n    }\n\n    public search(index: number): [number, number] | null;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N): ReturnType<N>;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N) {\n        let idx = index;\n        // binary search to find the child vector and value indices\n        let offsets = this._chunkOffsets, rhs = offsets.length - 1;\n        // return early if out of bounds, or if there's just one child\n        if (idx < 0            ) { return null; }\n        if (idx >= offsets[rhs]) { return null; }\n        if (rhs <= 1           ) { return then ? then(this, 0, idx) : [0, idx]; }\n        let lhs = 0, pos = 0, mid = 0;\n        do {\n            if (lhs + 1 === rhs) {\n                return then ? then(this, lhs, idx - pos) : [lhs, idx - pos];\n            }\n            mid = lhs + ((rhs - lhs) / 2) | 0;\n            idx >= offsets[mid] ? (lhs = mid) : (rhs = mid);\n        } while (idx < offsets[rhs] && idx >= (pos = offsets[lhs]));\n        return null;\n    }\n\n    public isValid(index: number): boolean {\n        return !!this.search(index, this.isValidInternal);\n    }\n\n    public get(index: number): T['TValue'] | null {\n        return this.search(index, this.getInternal);\n    }\n\n    public set(index: number, value: T['TValue'] | null): void {\n        this.search(index, ({ chunks }, i, j) => chunks[i].set(j, value));\n    }\n\n    public indexOf(element: T['TValue'], offset?: number): number {\n        if (offset && typeof offset === 'number') {\n            return this.search(offset, (self, i, j) => this.indexOfInternal(self, i, j, element))!;\n        }\n        return this.indexOfInternal(this, 0, Math.max(0, offset || 0), element);\n    }\n\n    public toArray(): T['TArray'] {\n        const { chunks } = this;\n        const n = chunks.length;\n        let ArrayType: any = this._type.ArrayType;\n        if (n <= 0) { return new ArrayType(0); }\n        if (n <= 1) { return chunks[0].toArray(); }\n        let len = 0, src = new Array(n);\n        for (let i = -1; ++i < n;) {\n            len += (src[i] = chunks[i].toArray()).length;\n        }\n        if (ArrayType !== src[0].constructor) {\n            ArrayType = src[0].constructor;\n        }\n        let dst = new ArrayType(len);\n        let set: any = ArrayType === Array ? arraySet : typedSet;\n        for (let i = -1, idx = 0; ++i < n;) {\n            idx = set(src[i], dst, idx);\n        }\n        return dst;\n    }\n\n    protected getInternal({ _chunks }: Chunked<T>, i: number, j: number) { return _chunks[i].get(j); }\n    protected isValidInternal({ _chunks }: Chunked<T>, i: number, j: number) { return _chunks[i].isValid(j); }\n    protected indexOfInternal({ _chunks }: Chunked<T>, chunkIndex: number, fromIndex: number, element: T['TValue']) {\n        let i = chunkIndex - 1, n = _chunks.length;\n        let start = fromIndex, offset = 0, found = -1;\n        while (++i < n) {\n            if (~(found = _chunks[i].indexOf(element, start))) {\n                return offset + found;\n            }\n            start = 0;\n            offset += _chunks[i].length;\n        }\n        return -1;\n    }\n\n    protected _sliceInternal(self: Chunked<T>, begin: number, end: number) {\n        const slices: Vector<T>[] = [];\n        const { chunks, _chunkOffsets: chunkOffsets } = self;\n        for (let i = -1, n = chunks.length; ++i < n;) {\n            const chunk = chunks[i];\n            const chunkLength = chunk.length;\n            const chunkOffset = chunkOffsets[i];\n            // If the child is to the right of the slice boundary, we can stop\n            if (chunkOffset >= end) { break; }\n            // If the child is to the left of of the slice boundary, exclude\n            if (begin >= chunkOffset + chunkLength) { continue; }\n            // If the child is between both left and right boundaries, include w/o slicing\n            if (chunkOffset >= begin && (chunkOffset + chunkLength) <= end) {\n                slices.push(chunk);\n                continue;\n            }\n            // If the child overlaps one of the slice boundaries, include that slice\n            const from = Math.max(0, begin - chunkOffset);\n            const to = Math.min(end - chunkOffset, chunkLength);\n            slices.push(chunk.slice(from, to) as Vector<T>);\n        }\n        return self.clone(slices);\n    }\n}\n\n/** @ignore */\nfunction calculateOffsets<T extends DataType>(vectors: Vector<T>[]) {\n    let offsets = new Uint32Array((vectors || []).length + 1);\n    let offset = offsets[0] = 0, length = offsets.length;\n    for (let index = 0; ++index < length;) {\n        offsets[index] = (offset += vectors[index - 1].length);\n    }\n    return offsets;\n}\n\n/** @ignore */\nconst typedSet = (src: TypedArray, dst: TypedArray, offset: number) => {\n    dst.set(src, offset);\n    return (offset + src.length);\n};\n\n/** @ignore */\nconst arraySet = (src: any[], dst: any[], offset: number) => {\n    let idx = offset;\n    for (let i = -1, n = src.length; ++i < n;) {\n        dst[idx++] = src[i];\n    }\n    return idx;\n};\n\n/** @ignore */\ninterface TypedArray extends ArrayBufferView {\n    readonly length: number;\n    readonly [n: number]: number;\n    set(array: ArrayLike<number>, offset?: number): void;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Field } from './schema';\nimport { DataType } from './type';\nimport { Vector } from './vector';\nimport { Clonable, Sliceable, Applicative } from './vector';\nimport { VectorCtorArgs, VectorType as V } from './interfaces';\nimport { Chunked, SearchContinuation } from './vector/chunked';\n\nexport interface Column<T extends DataType = any> {\n    typeId: T['TType'];\n    concat(...others: Vector<T>[]): Column<T>;\n    slice(begin?: number, end?: number): Column<T>;\n    clone(chunks?: Vector<T>[], offsets?: Uint32Array): Column<T>;\n}\n\nexport class Column<T extends DataType = any>\n    extends Chunked<T>\n    implements Clonable<Column<T>>,\n               Sliceable<Column<T>>,\n               Applicative<T, Column<T>> {\n\n    public static new<T extends DataType>(field: string | Field<T>, ...chunks: (Vector<T> | Vector<T>[])[]): Column<T>;\n    public static new<T extends DataType>(field: string | Field<T>, data: Data<T>, ...args: VectorCtorArgs<V<T>>): Column<T>;\n    /** @nocollapse */\n    public static new<T extends DataType = any>(field: string | Field<T>, data: Data<T> | Vector<T> | (Data<T> | Vector<T>)[], ...rest: any[]) {\n\n        const chunks = Chunked.flatten<T>(\n            Array.isArray(data) ? [...data, ...rest] :\n            data instanceof Vector ? [data, ...rest] :\n            [Vector.new(data, ...rest)]\n        );\n\n        if (typeof field === 'string') {\n            const type = chunks[0].data.type;\n            field = new Field(field, type, true);\n        } else if (!field.nullable && chunks.some(({ nullCount }) => nullCount > 0)) {\n            field = field.clone({ nullable: true });\n        }\n        return new Column(field, chunks);\n    }\n\n    constructor(field: Field<T>, vectors: Vector<T>[] = [], offsets?: Uint32Array) {\n        vectors = Chunked.flatten<T>(...vectors);\n        super(field.type, vectors, offsets);\n        this._field = field;\n        if (vectors.length === 1 && !(this instanceof SingleChunkColumn)) {\n            return new SingleChunkColumn(field, vectors[0], this._chunkOffsets);\n        }\n    }\n\n    protected _field: Field<T>;\n    protected _children?: Column[];\n\n    public get field() { return this._field; }\n    public get name() { return this._field.name; }\n    public get nullable() { return this._field.nullable; }\n    public get metadata() { return this._field.metadata; }\n\n    public clone(chunks = this._chunks) {\n        return new Column(this._field, chunks);\n    }\n\n    public getChildAt<R extends DataType = any>(index: number): Column<R> | null {\n\n        if (index < 0 || index >= this.numChildren) { return null; }\n\n        let columns = this._children || (this._children = []);\n        let column: Column<R>, field: Field<R>, chunks: Vector<R>[];\n\n        if (column = columns[index]) { return column; }\n        if (field = ((this.type.children || [])[index] as Field<R>)) {\n            chunks = this._chunks\n                .map((vector) => vector.getChildAt<R>(index))\n                .filter((vec): vec is Vector<R> => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Column<R>(field, chunks));\n            }\n        }\n\n        return null;\n    }\n}\n\n/** @ignore */\nclass SingleChunkColumn<T extends DataType = any> extends Column<T> {\n    protected _chunk: Vector<T>;\n    constructor(field: Field<T>, vector: Vector<T>, offsets?: Uint32Array) {\n        super(field, [vector], offsets);\n        this._chunk = vector;\n    }\n    public search(index: number): [number, number] | null;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N): ReturnType<N>;\n    public search<N extends SearchContinuation<Chunked<T>>>(index: number, then?: N) {\n        return then ? then(this, 0, index) : [0, index];\n    }\n    public isValid(index: number): boolean {\n        return this._chunk.isValid(index);\n    }\n    public get(index: number): T['TValue'] | null {\n        return this._chunk.get(index);\n    }\n    public set(index: number, value: T['TValue'] | null): void {\n        this._chunk.set(index, value);\n    }\n    public indexOf(element: T['TValue'], offset?: number): number {\n        return this._chunk.indexOf(element, offset);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Field } from '../schema';\nimport { Column } from '../column';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Chunked } from '../vector/chunked';\n\ntype RecordBatchCtor = typeof import('../recordbatch').RecordBatch;\n\nconst isArray = Array.isArray;\n\n/** @ignore */\nexport const selectArgs = <T>(Ctor: any, vals: any[]) => _selectArgs(Ctor, vals, [], 0) as T[];\n/** @ignore */\nexport const selectColumnArgs = <T extends { [key: string]: DataType }>(args: any[]) => {\n    const [fields, values] = _selectFieldArgs<T>(args, [[], []]);\n    return values.map((x, i) =>\n        x instanceof Column ? Column.new(x.field.clone(fields[i]), x) :\n        x instanceof Vector ? Column.new(fields[i], x) as Column<T[keyof T]> :\n                              Column.new(fields[i], [] as Vector<T[keyof T]>[]));\n};\n\n/** @ignore */\nexport const selectFieldArgs = <T extends { [key: string]: DataType }>(args: any[]) => _selectFieldArgs<T>(args, [[], []]);\n/** @ignore */\nexport const selectChunkArgs = <T>(Ctor: any, vals: any[]) => _selectChunkArgs(Ctor, vals, [], 0) as T[];\n/** @ignore */\nexport const selectVectorChildrenArgs = <T extends Vector>(Ctor: RecordBatchCtor, vals: any[]) => _selectVectorChildrenArgs(Ctor, vals, [], 0) as T[];\n/** @ignore */\nexport const selectColumnChildrenArgs = <T extends Column>(Ctor: RecordBatchCtor, vals: any[]) => _selectColumnChildrenArgs(Ctor, vals, [], 0) as T[];\n\n/** @ignore */\nfunction _selectArgs<T>(Ctor: any, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Ctor) { res[j++] = value; }\n    }\n    return res;\n}\n\n/** @ignore */\nfunction _selectChunkArgs<T>(Ctor: any, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectChunkArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Chunked) {\n            j = _selectChunkArgs(Ctor, value.chunks, res, j).length;\n        } else if (value instanceof Ctor) { res[j++] = value; }\n    }\n    return res;\n}\n\n/** @ignore */\nfunction _selectVectorChildrenArgs<T extends Vector>(Ctor: RecordBatchCtor, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectVectorChildrenArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Ctor) {\n            j = _selectArgs(Vector, value.schema.fields.map((_, i) => value.getChildAt(i)!), res, j).length;\n        } else if (value instanceof Vector) { res[j++] = value as T; }\n    }\n    return res;\n}\n\n/** @ignore */\nfunction _selectColumnChildrenArgs<T extends Column>(Ctor: RecordBatchCtor, vals: any[], res: T[], idx: number) {\n    let value: any, j = idx;\n    let i = -1, n = vals.length;\n    while (++i < n) {\n        if (isArray(value = vals[i])) {\n            j = _selectColumnChildrenArgs(Ctor, value, res, j).length;\n        } else if (value instanceof Ctor) {\n            j = _selectArgs(Column, value.schema.fields.map((f, i) => Column.new(f, value.getChildAt(i)!)), res, j).length;\n        } else if (value instanceof Column) { res[j++] = value as T; }\n    }\n    return res;\n}\n\n/** @ignore */\nconst toKeysAndValues = (xs: [any[], any[]], [k, v]: [any, any], i: number) => (xs[0][i] = k, xs[1][i] = v, xs);\n\n/** @ignore */\nfunction _selectFieldArgs<T extends { [key: string]: DataType }>(vals: any[], ret: [Field<T[keyof T]>[], Vector<T[keyof T]>[]]): [Field<T[keyof T]>[], (T[keyof T] | Vector<T[keyof T]>)[]] {\n    let keys: any[], n: number;\n    switch (n = vals.length) {\n        case 0: return ret;\n        case 1:\n            keys = ret[0];\n            if (!(vals[0])) { return ret; }\n            if (isArray(vals[0])) { return _selectFieldArgs(vals[0], ret); }\n            if (!(vals[0] instanceof Data || vals[0] instanceof Vector || vals[0] instanceof DataType)) {\n                [keys, vals] = Object.entries(vals[0]).reduce(toKeysAndValues, ret);\n            }\n            break;\n        default:\n            !isArray(keys = vals[n - 1])\n                ? (vals = isArray(vals[0]) ? vals[0] : vals, keys = [])\n                : (vals = isArray(vals[0]) ? vals[0] : vals.slice(0, n - 1));\n    }\n\n    let fieldIndex = -1;\n    let valueIndex = -1;\n    let idx = -1, len = vals.length;\n    let field: number | string | Field<T[keyof T]>;\n    let val: Vector<T[keyof T]> | Data<T[keyof T]>;\n    let [fields, values] = ret as [Field<T[keyof T]>[], any[]];\n\n    while (++idx < len) {\n        val = vals[idx];\n        if (val instanceof Column && (values[++valueIndex] = val)) {\n            fields[++fieldIndex] = val.field.clone(keys[idx], val.type, true);\n        } else {\n            ({ [idx]: field = idx } = keys);\n            if (val instanceof DataType && (values[++valueIndex] = val)) {\n                fields[++fieldIndex] = Field.new(field, val as DataType, true) as Field<T[keyof T]>;\n            } else if (val && val.type && (values[++valueIndex] = val)) {\n                val instanceof Data && (values[valueIndex] = val = Vector.new(val) as Vector);\n                fields[++fieldIndex] = Field.new(field, val.type, true) as Field<T[keyof T]>;\n            }\n        }\n    }\n    return ret;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Vector } from './vector';\nimport { DataType } from './type';\nimport { selectArgs } from './util/args';\nimport { selectFieldArgs } from './util/args';\nimport { instance as comparer } from './visitor/typecomparator';\n\ntype VectorMap = { [key: string]: Vector };\ntype Fields<T extends { [key: string]: DataType }> = (keyof T)[] | Field<T[keyof T]>[];\ntype ChildData<T extends { [key: string]: DataType }> = T[keyof T][] | Data<T[keyof T]>[] | Vector<T[keyof T]>[];\n\nexport class Schema<T extends { [key: string]: DataType } = any> {\n\n    public static from<T extends { [key: string]: DataType } = any>(children: T): Schema<T>;\n    public static from<T extends VectorMap = any>(children: T): Schema<{ [P in keyof T]: T[P]['type'] }>;\n    public static from<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): Schema<T>;\n    /** @nocollapse */\n    public static from(...args: any[]) {\n        return Schema.new(args[0], args[1]);\n    }\n\n    public static new<T extends { [key: string]: DataType } = any>(children: T): Schema<T>;\n    public static new<T extends VectorMap = any>(children: T): Schema<{ [P in keyof T]: T[P]['type'] }>;\n    public static new<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): Schema<T>;\n    /** @nocollapse */\n    public static new(...args: any[]) {\n        return new Schema(selectFieldArgs(args)[0]);\n    }\n\n    public readonly fields: Field<T[keyof T]>[];\n    public readonly metadata: Map<string, string>;\n    public readonly dictionaries: Map<number, DataType>;\n\n    constructor(fields: Field[] = [],\n                metadata?: Map<string, string> | null,\n                dictionaries?: Map<number, DataType> | null) {\n        this.fields = (fields || []) as Field<T[keyof T]>[];\n        this.metadata = metadata || new Map();\n        if (!dictionaries) {\n            dictionaries = generateDictionaryMap(fields);\n        }\n        this.dictionaries = dictionaries;\n    }\n    public get [Symbol.toStringTag]() { return 'Schema'; }\n    public toString() {\n        return `Schema<{ ${this.fields.map((f, i) => `${i}: ${f}`).join(', ')} }>`;\n    }\n\n    public compareTo(other?: Schema | null): other is Schema<T> {\n        return comparer.compareSchemas(this, other);\n    }\n\n    public select<K extends keyof T = any>(...columnNames: K[]) {\n        const names = columnNames.reduce((xs, x) => (xs[x] = true) && xs, Object.create(null));\n        return new Schema<{ [P in K]: T[P] }>(this.fields.filter((f) => names[f.name]), this.metadata);\n    }\n    public selectAt<K extends T[keyof T] = any>(...columnIndices: number[]) {\n        return new Schema<{ [key: string]: K }>(columnIndices.map((i) => this.fields[i]).filter(Boolean), this.metadata);\n    }\n\n    public assign<R extends { [key: string]: DataType } = any>(schema: Schema<R>): Schema<T & R>;\n    public assign<R extends { [key: string]: DataType } = any>(...fields: (Field<R[keyof R]> | Field<R[keyof R]>[])[]): Schema<T & R>;\n    public assign<R extends { [key: string]: DataType } = any>(...args: (Schema<R> | Field<R[keyof R]> | Field<R[keyof R]>[])[]) {\n\n        const other = args[0] instanceof Schema ? args[0] as Schema<R>\n            : new Schema<R>(selectArgs<Field<R[keyof R]>>(Field, args));\n\n        const curFields = [...this.fields] as Field[];\n        const metadata = mergeMaps(mergeMaps(new Map(), this.metadata), other.metadata);\n        const newFields = other.fields.filter((f2) => {\n            const i = curFields.findIndex((f) => f.name === f2.name);\n            return ~i ? (curFields[i] = f2.clone({\n                metadata: mergeMaps(mergeMaps(new Map(), curFields[i].metadata), f2.metadata)\n            })) && false : true;\n        }) as Field[];\n\n        const newDictionaries = generateDictionaryMap(newFields, new Map());\n\n        return new Schema<T & R>(\n            [...curFields, ...newFields], metadata,\n            new Map([...this.dictionaries, ...newDictionaries])\n        );\n    }\n}\n\nexport class Field<T extends DataType = any> {\n\n    public static new<T extends DataType = any>(props: { name: string | number, type: T, nullable?: boolean, metadata?: Map<string, string> | null }): Field<T>;\n    public static new<T extends DataType = any>(name: string | number | Field<T>, type: T, nullable?: boolean, metadata?: Map<string, string> | null): Field<T>;\n    /** @nocollapse */\n    public static new<T extends DataType = any>(...args: any[]) {\n        let [name, type, nullable, metadata] = args;\n        if (args[0] && typeof args[0] === 'object') {\n            ({ name } = args[0]);\n            (type === undefined) && (type = args[0].type);\n            (nullable === undefined) && (nullable = args[0].nullable);\n            (metadata === undefined) && (metadata = args[0].metadata);\n        }\n        return new Field<T>(`${name}`, type, nullable, metadata);\n    }\n\n    public readonly type: T;\n    public readonly name: string;\n    public readonly nullable: boolean;\n    public readonly metadata: Map<string, string>;\n\n    constructor(name: string, type: T, nullable = false, metadata?: Map<string, string> | null) {\n        this.name = name;\n        this.type = type;\n        this.nullable = nullable;\n        this.metadata = metadata || new Map();\n    }\n\n    public get typeId() { return this.type.typeId; }\n    public get [Symbol.toStringTag]() { return 'Field'; }\n    public toString() { return `${this.name}: ${this.type}`; }\n    public compareTo(other?: Field | null): other is Field<T> {\n        return comparer.compareField(this, other);\n    }\n    public clone<R extends DataType = T>(props: { name?: string | number, type?: R, nullable?: boolean, metadata?: Map<string, string> | null }): Field<R>;\n    public clone<R extends DataType = T>(name?: string | number | Field<T>, type?: R, nullable?: boolean, metadata?: Map<string, string> | null): Field<R>;\n    public clone<R extends DataType = T>(...args: any[]) {\n        let [name, type, nullable, metadata] = args;\n        (!args[0] || typeof args[0] !== 'object')\n            ? ([name = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata] = args)\n            : ({name = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata} = args[0]);\n        return Field.new<R>(name, type, nullable, metadata);\n    }\n}\n\n/** @ignore */\nfunction mergeMaps<TKey, TVal>(m1?: Map<TKey, TVal> | null, m2?: Map<TKey, TVal> | null): Map<TKey, TVal> {\n    return new Map([...(m1 || new Map()), ...(m2 || new Map())]);\n}\n\n/** @ignore */\nfunction generateDictionaryMap(fields: Field[], dictionaries = new Map<number, DataType>()): Map<number, DataType> {\n\n    for (let i = -1, n = fields.length; ++i < n;) {\n        const field = fields[i];\n        const type = field.type;\n        if (DataType.isDictionary(type)) {\n            if (!dictionaries.has(type.id)) {\n                dictionaries.set(type.id, type.dictionary);\n            } else if (dictionaries.get(type.id) !== type.dictionary) {\n                throw new Error(`Cannot create Schema containing two different dictionaries with the same Id`);\n            }\n        }\n        if (type.children && type.children.length > 0) {\n            generateDictionaryMap(type.children, dictionaries);\n        }\n    }\n\n    return dictionaries;\n}\n\n// Add these here so they're picked up by the externs creator\n// in the build, and closure-compiler doesn't minify them away\n(Schema.prototype as any).fields = null;\n(Schema.prototype as any).metadata = null;\n(Schema.prototype as any).dictionaries = null;\n\n(Field.prototype as any).type = null;\n(Field.prototype as any).name = null;\n(Field.prototype as any).nullable = null;\n(Field.prototype as any).metadata = null;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Run } from './run';\nimport { Field } from '../schema';\nimport { DataType, List } from '../type';\nimport { OffsetsBufferBuilder } from './buffer';\nimport { Builder, BuilderOptions, VariableWidthBuilder } from '../builder';\n\n/** @ignore */\nexport class ListBuilder<T extends DataType = any, TNull = any> extends VariableWidthBuilder<List<T>, TNull> {\n    protected _run = new Run<T, TNull>();\n    protected _offsets: OffsetsBufferBuilder;\n    constructor(opts: BuilderOptions<List<T>, TNull>) {\n        super(opts);\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    public addChild(child: Builder<T>, name = '0') {\n        if (this.numChildren > 0) {\n            throw new Error('ListBuilder can only have one child.');\n        }\n        this.children[this.numChildren] = child;\n        this.type = new List(new Field(name, child.type, true));\n        return this.numChildren - 1;\n    }\n    public clear() {\n        this._run.clear();\n        return super.clear();\n    }\n    protected _flushPending(pending: Map<number, T['TValue'] | undefined>) {\n        const run = this._run;\n        const offsets = this._offsets;\n        const setValue = this._setValue;\n        let index = 0, value: Uint8Array | undefined;\n        for ([index, value] of pending) {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            } else {\n                offsets.set(index, value.length);\n                setValue(this, index, run.bind(value));\n            }\n        }\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Run } from './run';\nimport { Field } from '../schema';\nimport { Builder } from '../builder';\nimport { DataType, FixedSizeList } from '../type';\n\n/** @ignore */\nexport class FixedSizeListBuilder<T extends DataType = any, TNull = any> extends Builder<FixedSizeList<T>, TNull> {\n    protected _run = new Run<T, TNull>();\n    public setValue(index: number, value: T['TValue']) {\n        super.setValue(index, this._run.bind(value));\n    }\n    public addChild(child: Builder<T>, name = '0') {\n        if (this.numChildren > 0) {\n            throw new Error('FixedSizeListBuilder can only have one child.');\n        }\n        const childIndex = this.children.push(child);\n        this.type = new FixedSizeList(this.type.listSize, new Field(name, child.type, true));\n        return childIndex;\n    }\n    public clear() {\n        this._run.clear();\n        return super.clear();\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Field } from '../schema';\nimport { DataType, Map_, Struct } from '../type';\nimport { Builder, VariableWidthBuilder } from '../builder';\n\n/** @ignore */ type MapValue<K extends DataType = any, V extends DataType = any> = Map_<K, V>['TValue'];\n/** @ignore */ type MapValues<K extends DataType = any, V extends DataType = any> = Map<number, MapValue<K, V> | undefined>;\n/** @ignore */ type MapValueExt<K extends DataType = any, V extends DataType = any> = MapValue<K, V> | { [key: string]: V } | { [key: number]: V } ;\n\n/** @ignore */\nexport class MapBuilder<K extends DataType = any, V extends DataType = any, TNull = any> extends VariableWidthBuilder<Map_<K, V>, TNull> {\n\n    protected _pending: MapValues<K, V> | undefined;\n    public set(index: number, value: MapValueExt<K, V> | TNull) {\n        return super.set(index, value as MapValue<K, V> | TNull);\n    }\n\n    public setValue(index: number, value: MapValueExt<K, V>) {\n        value = value instanceof Map ? value : new Map(Object.entries(value));\n        const pending = this._pending || (this._pending = new Map() as MapValues<K, V>);\n        const current = pending.get(index);\n        current && (this._pendingLength -= current.size);\n        this._pendingLength += value.size;\n        pending.set(index, value);\n    }\n\n    public addChild(child: Builder<Struct<{ key: K, value: V }>>, name = `${this.numChildren}`) {\n        if (this.numChildren > 0) {\n            throw new Error('ListBuilder can only have one child.');\n        }\n        this.children[this.numChildren] = child;\n        this.type = new Map_<K, V>(new Field(name, child.type, true), this.type.keysSorted);\n        return this.numChildren - 1;\n    }\n\n    protected _flushPending(pending: MapValues<K, V>) {\n        const offsets = this._offsets;\n        const setValue = this._setValue;\n        pending.forEach((value, index) => {\n            if (value === undefined) {\n                offsets.set(index, 0);\n            } else {\n                offsets.set(index, value.size);\n                setValue(this, index, value);\n            }\n        });\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Field } from '../schema';\nimport { Builder } from '../builder';\nimport { DataType, Struct } from '../type';\n\n/** @ignore */\nexport class StructBuilder<T extends { [key: string]: DataType } = any, TNull = any> extends Builder<Struct<T>, TNull> {\n    public addChild(child: Builder, name = `${this.numChildren}`) {\n        const childIndex = this.children.push(child);\n        this.type = new Struct([...this.type.children, new Field(name, child.type, true)]);\n        return childIndex;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Field } from '../schema';\nimport { DataBufferBuilder } from './buffer';\nimport { Builder, BuilderOptions } from '../builder';\nimport { Union, SparseUnion, DenseUnion } from '../type';\n\nexport interface UnionBuilderOptions<T extends Union = any, TNull = any> extends BuilderOptions<T, TNull> {\n    valueToChildTypeId?: (builder: UnionBuilder<T, TNull>, value: any, offset: number) => number;\n}\n\n/** @ignore */\nexport abstract class UnionBuilder<T extends Union, TNull = any> extends Builder<T, TNull> {\n\n    protected _typeIds: DataBufferBuilder<Int8Array>;\n\n    constructor(options: UnionBuilderOptions<T, TNull>) {\n        super(options);\n        this._typeIds = new DataBufferBuilder(new Int8Array(0), 1);\n        if (typeof options['valueToChildTypeId'] === 'function') {\n            this._valueToChildTypeId = options['valueToChildTypeId'];\n        }\n    }\n\n    public get typeIdToChildIndex() { return this.type.typeIdToChildIndex; }\n\n    public append(value: T['TValue'] | TNull, childTypeId?: number) {\n        return this.set(this.length, value, childTypeId);\n    }\n\n    public set(index: number, value: T['TValue'] | TNull, childTypeId?: number) {\n        if (childTypeId === undefined) {\n            childTypeId = this._valueToChildTypeId(this, value, index);\n        }\n        if (this.setValid(index, this.isValid(value))) {\n            this.setValue(index, value, childTypeId);\n        }\n        return this;\n    }\n\n    // @ts-ignore\n    public setValue(index: number, value: T['TValue'], childTypeId?: number) {\n        this._typeIds.set(index, childTypeId!);\n        super.setValue(index, value);\n    }\n\n    // @ts-ignore\n    public addChild(child: Builder, name = `${this.children.length}`) {\n        const childTypeId = this.children.push(child);\n        const { type: { children, mode, typeIds } } = this;\n        const fields = [...children, new Field(name, child.type)];\n        this.type = <T> new Union(mode, [...typeIds, childTypeId], fields);\n        return childTypeId;\n    }\n\n    /** @ignore */\n    // @ts-ignore\n    protected _valueToChildTypeId(builder: UnionBuilder<T, TNull>, value: any, offset: number): number {\n        throw new Error(`Cannot map UnionBuilder value to child typeId. \\\nPass the \\`childTypeId\\` as the second argument to unionBuilder.append(), \\\nor supply a \\`valueToChildTypeId\\` function as part of the UnionBuilder constructor options.`);\n    }\n}\n\n/** @ignore */\nexport class SparseUnionBuilder<T extends SparseUnion, TNull = any> extends UnionBuilder<T, TNull> {}\n/** @ignore */\nexport class DenseUnionBuilder<T extends DenseUnion, TNull = any> extends UnionBuilder<T, TNull> {\n\n    protected _offsets: DataBufferBuilder<Int32Array>;\n\n    constructor(options: UnionBuilderOptions<T, TNull>) {\n        super(options);\n        this._offsets = new DataBufferBuilder(new Int32Array(0));\n    }\n\n    /** @ignore */\n    public setValue(index: number, value: T['TValue'], childTypeId?: number) {\n        const childIndex = this.type.typeIdToChildIndex[childTypeId!];\n        this._offsets.set(index, this.getChildAt(childIndex)!.length);\n        return super.setValue(index, value, childTypeId);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Field } from '../schema';\nimport { Vector } from '../vector';\nimport { Visitor } from '../visitor';\nimport { encodeUtf8 } from '../util/utf8';\nimport { VectorType } from '../interfaces';\nimport { float64ToUint16 } from '../util/math';\nimport { toArrayBufferView } from '../util/buffer';\nimport { Type, UnionMode, Precision, DateUnit, TimeUnit, IntervalUnit } from '../enum';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface SetVisitor extends Visitor {\n    visit<T extends VectorType>(node: T, index: number, value: T['TValue']): void;\n    visitMany<T extends VectorType>(nodes: T[], indices: number[], values: T['TValue'][]): void[];\n    getVisitFn<T extends Type>(node: T): (vector: VectorType<T>, index: number, value: VectorType<T>['TValue']) => void;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>, index: number, value: VectorType<T>['TValue']) => void;\n    visitNull                 <T extends Null>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitBool                 <T extends Bool>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt                  <T extends Int>                 (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt8                 <T extends Int8>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt16                <T extends Int16>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt32                <T extends Int32>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInt64                <T extends Int64>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint8                <T extends Uint8>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint16               <T extends Uint16>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint32               <T extends Uint32>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUint64               <T extends Uint64>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat                <T extends Float>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat16              <T extends Float16>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat32              <T extends Float32>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFloat64              <T extends Float64>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUtf8                 <T extends Utf8>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitBinary               <T extends Binary>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDate                 <T extends Date_>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDateDay              <T extends DateDay>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDateMillisecond      <T extends DateMillisecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestamp            <T extends Timestamp>           (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampSecond      <T extends TimestampSecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampMillisecond <T extends TimestampMillisecond>(vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond>(vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimestampNanosecond  <T extends TimestampNanosecond> (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTime                 <T extends Time>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeSecond           <T extends TimeSecond>          (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeMillisecond      <T extends TimeMillisecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitTimeNanosecond       <T extends TimeNanosecond>      (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDecimal              <T extends Decimal>             (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitList                 <T extends List>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitStruct               <T extends Struct>              (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitUnion                <T extends Union>               (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDenseUnion           <T extends DenseUnion>          (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitSparseUnion          <T extends SparseUnion>         (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitDictionary           <T extends Dictionary>          (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitInterval             <T extends Interval>            (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitIntervalDayTime      <T extends IntervalDayTime>     (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>   (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitFixedSizeList        <T extends FixedSizeList>       (vector: VectorType<T>, index: number, value: T['TValue']): void;\n    visitMap                  <T extends Map_>                (vector: VectorType<T>, index: number, value: T['TValue']): void;\n}\n\n/** @ignore */\nexport class SetVisitor extends Visitor {}\n\n/** @ignore */\nconst setEpochMsToDays = (data: Int32Array, index: number, epochMs: number) => { data[index] = (epochMs / 86400000) | 0; };\n/** @ignore */\nconst setEpochMsToMillisecondsLong = (data: Int32Array, index: number, epochMs: number) => {\n    data[index] = (epochMs % 4294967296) | 0;\n    data[index + 1] = (epochMs / 4294967296) | 0;\n};\n/** @ignore */\nconst setEpochMsToMicrosecondsLong = (data: Int32Array, index: number, epochMs: number) => {\n    data[index] = ((epochMs * 1000) % 4294967296) | 0;\n    data[index + 1] = ((epochMs * 1000) / 4294967296) | 0;\n};\n/** @ignore */\nconst setEpochMsToNanosecondsLong = (data: Int32Array, index: number, epochMs: number) => {\n    data[index] = ((epochMs * 1000000) % 4294967296) | 0;\n    data[index + 1] = ((epochMs * 1000000) / 4294967296) | 0;\n};\n\n/** @ignore */\nconst setVariableWidthBytes = (values: Uint8Array, valueOffsets: Int32Array, index: number, value: Uint8Array) => {\n    const { [index]: x, [index + 1]: y } = valueOffsets;\n    if (x != null && y != null) {\n        values.set(value.subarray(0, y - x), x);\n    }\n};\n\n/** @ignore */\nconst setBool = <T extends Bool>({ offset, values }: VectorType<T>, index: number, val: boolean) => {\n    const idx = offset + index;\n    val ? (values[idx >> 3] |=  (1 << (idx % 8)))  // true\n        : (values[idx >> 3] &= ~(1 << (idx % 8))); // false\n\n};\n\n/** @ignore */ type Numeric1X = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32 | Float32 | Float64;\n/** @ignore */ type Numeric2X = Int64 | Uint64;\n\n/** @ignore */\nconst setDateDay         = <T extends DateDay>        ({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { setEpochMsToDays(values, index, value.valueOf()); };\n/** @ignore */\nconst setDateMillisecond = <T extends DateMillisecond>({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { setEpochMsToMillisecondsLong(values, index * 2, value.valueOf()); };\n/** @ignore */\nconst setNumeric         = <T extends Numeric1X>      ({ stride, values }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = value; };\n/** @ignore */\nconst setFloat16         = <T extends Float16>        ({ stride, values }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = float64ToUint16(value); };\n/** @ignore */\nconst setNumericX2       = <T extends Numeric2X>      (vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    switch (typeof value) {\n        case 'bigint': vector.values64[index] = value; break;\n        case 'number': vector.values[index * vector.stride] = value; break;\n        default:\n            const val = value as T['TArray'];\n            const { stride, ArrayType } = vector;\n            const long = toArrayBufferView<T['TArray']>(ArrayType, val);\n            vector.values.set(long.subarray(0, stride), stride * index);\n    }\n};\n/** @ignore */\nconst setFixedSizeBinary = <T extends FixedSizeBinary>({ stride, values }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, stride), stride * index); };\n\n/** @ignore */\nconst setBinary = <T extends Binary>({ values, valueOffsets }: VectorType<T>, index: number, value: T['TValue']) => setVariableWidthBytes(values, valueOffsets, index, value);\n/** @ignore */\nconst setUtf8 = <T extends Utf8>({ values, valueOffsets }: VectorType<T>, index: number, value: T['TValue']) => {\n    setVariableWidthBytes(values, valueOffsets, index, encodeUtf8(value));\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setInt = <T extends Int>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    vector.type.bitWidth < 64\n        ? setNumeric(vector as VectorType<Numeric1X>, index, value as Numeric1X['TValue'])\n        : setNumericX2(vector as VectorType<Numeric2X>, index, value as Numeric2X['TValue']);\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setFloat = <T extends Float>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    vector.type.precision !== Precision.HALF\n        ? setNumeric(vector as VectorType<Numeric1X>, index, value)\n        : setFloat16(vector as VectorType<Float16>, index, value);\n};\n\n/* istanbul ignore next */\nconst setDate = <T extends Date_> (vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    vector.type.unit === DateUnit.DAY\n        ? setDateDay(vector as VectorType<DateDay>, index, value)\n        : setDateMillisecond(vector as VectorType<DateMillisecond>, index, value);\n};\n\n/** @ignore */\nconst setTimestampSecond      = <T extends TimestampSecond>     ({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToMillisecondsLong(values, index * 2, value / 1000);\n/** @ignore */\nconst setTimestampMillisecond = <T extends TimestampMillisecond>({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToMillisecondsLong(values, index * 2, value);\n/** @ignore */\nconst setTimestampMicrosecond = <T extends TimestampMicrosecond>({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToMicrosecondsLong(values, index * 2, value);\n/** @ignore */\nconst setTimestampNanosecond  = <T extends TimestampNanosecond> ({ values }: VectorType<T>, index: number, value: T['TValue']): void => setEpochMsToNanosecondsLong(values, index * 2, value);\n/* istanbul ignore next */\n/** @ignore */\nconst setTimestamp            = <T extends Timestamp>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      setTimestampSecond(vector as VectorType<TimestampSecond>, index, value);\n        case TimeUnit.MILLISECOND: return setTimestampMillisecond(vector as VectorType<TimestampMillisecond>, index, value);\n        case TimeUnit.MICROSECOND: return setTimestampMicrosecond(vector as VectorType<TimestampMicrosecond>, index, value);\n        case TimeUnit.NANOSECOND:  return  setTimestampNanosecond(vector as VectorType<TimestampNanosecond>, index, value);\n    }\n};\n\n/** @ignore */\nconst setTimeSecond      = <T extends TimeSecond>     ({ values, stride }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = value; };\n/** @ignore */\nconst setTimeMillisecond = <T extends TimeMillisecond>({ values, stride }: VectorType<T>, index: number, value: T['TValue']): void => { values[stride * index] = value; };\n/** @ignore */\nconst setTimeMicrosecond = <T extends TimeMicrosecond>({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 2), 2 * index); };\n/** @ignore */\nconst setTimeNanosecond  = <T extends TimeNanosecond> ({ values         }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 2), 2 * index); };\n/* istanbul ignore next */\n/** @ignore */\nconst setTime            = <T extends Time>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      setTimeSecond(vector as VectorType<TimeSecond>, index, value as TimeSecond['TValue']);\n        case TimeUnit.MILLISECOND: return setTimeMillisecond(vector as VectorType<TimeMillisecond>, index, value as TimeMillisecond['TValue']);\n        case TimeUnit.MICROSECOND: return setTimeMicrosecond(vector as VectorType<TimeMicrosecond>, index, value as TimeMicrosecond['TValue']);\n        case TimeUnit.NANOSECOND:  return  setTimeNanosecond(vector as VectorType<TimeNanosecond>, index, value as TimeNanosecond['TValue']);\n    }\n};\n\n/** @ignore */\nconst setDecimal = <T extends Decimal>({ values }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 4), 4 * index); };\n\n/** @ignore */\nconst setList = <T extends List>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const values = vector.getChildAt(0)!, valueOffsets = vector.valueOffsets;\n    for (let idx = -1, itr = valueOffsets[index], end = valueOffsets[index + 1]; itr < end;) {\n        values.set(itr++, value.get(++idx));\n    }\n};\n\n/** @ignore */\nconst setMap = <T extends Map_>(vector: VectorType<T>, index: number, value: T['TValue']) => {\n    const values = vector.getChildAt(0)!, valueOffsets = vector.valueOffsets;\n    const entries = value instanceof Map ? [...value] : Object.entries(value);\n    for (let idx = -1, itr = valueOffsets[index], end = valueOffsets[index + 1]; itr < end;) {\n        values.set(itr++, entries[++idx]);\n    }\n};\n\n/** @ignore */ const _setStructArrayValue = (o: number, v: any[]) => (c: Vector | null, _: Field, i: number) => c && c.set(o, v[i]);\n/** @ignore */ const _setStructVectorValue = (o: number, v: Vector) => (c: Vector | null, _: Field, i: number) => c && c.set(o, v.get(i));\n/** @ignore */ const _setStructMapValue = (o: number, v: Map<string, any>) => (c: Vector | null, f: Field, _: number) => c && c.set(o, v.get(f.name));\n/** @ignore */ const _setStructObjectValue = (o: number, v: { [key: string]: any }) => (c: Vector | null, f: Field, _: number) => c && c.set(o, v[f.name]);\n/** @ignore */\nconst setStruct = <T extends Struct>(vector: VectorType<T>, index: number, value: T['TValue']) => {\n\n    const setValue = value instanceof Map    ? _setStructMapValue(index, value)    :\n                     value instanceof Vector ? _setStructVectorValue(index, value) :\n                     Array.isArray(value)    ? _setStructArrayValue(index, value)  :\n                                               _setStructObjectValue(index, value) ;\n\n    vector.type.children.forEach((f: Field, i: number) => setValue(vector.getChildAt(i), f, i));\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setUnion = <\n    V extends VectorType<Union> | VectorType<DenseUnion> | VectorType<SparseUnion>\n>(vector: V, index: number, value: V['TValue']) => {\n    vector.type.mode === UnionMode.Dense ?\n        setDenseUnion(vector as VectorType<DenseUnion>, index, value) :\n        setSparseUnion(vector as VectorType<SparseUnion>, index, value);\n};\n\n/** @ignore */\nconst setDenseUnion = <T extends DenseUnion>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    child && child.set(vector.valueOffsets[index], value);\n};\n\n/** @ignore */\nconst setSparseUnion = <T extends SparseUnion>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    child && child.set(index, value);\n};\n\n/** @ignore */\nconst setDictionary = <T extends Dictionary>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const key = vector.getKey(index);\n    if (key !== null) {\n        vector.setValue(key, value);\n    }\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst setIntervalValue = <T extends Interval>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    (vector.type.unit === IntervalUnit.DAY_TIME)\n        ? setIntervalDayTime(vector as VectorType<IntervalDayTime>, index, value)\n        : setIntervalYearMonth(vector as VectorType<IntervalYearMonth>, index, value);\n};\n\n/** @ignore */\nconst setIntervalDayTime = <T extends IntervalDayTime>({ values }: VectorType<T>, index: number, value: T['TValue']): void => { values.set(value.subarray(0, 2), 2 * index); };\n/** @ignore */\nconst setIntervalYearMonth = <T extends IntervalYearMonth>({ values }: VectorType<T>, index: number, value: T['TValue']): void => { values[index] = (value[0] * 12) + (value[1] % 12); };\n\n/** @ignore */\nconst setFixedSizeList = <T extends FixedSizeList>(vector: VectorType<T>, index: number, value: T['TValue']): void => {\n    const child = vector.getChildAt(0)!, { stride } = vector;\n    for (let idx = -1, offset = index * stride; ++idx < stride;) {\n        child.set(offset + idx, value.get(idx));\n    }\n};\n\nSetVisitor.prototype.visitBool                 =                 setBool;\nSetVisitor.prototype.visitInt                  =                  setInt;\nSetVisitor.prototype.visitInt8                 =              setNumeric;\nSetVisitor.prototype.visitInt16                =              setNumeric;\nSetVisitor.prototype.visitInt32                =              setNumeric;\nSetVisitor.prototype.visitInt64                =            setNumericX2;\nSetVisitor.prototype.visitUint8                =              setNumeric;\nSetVisitor.prototype.visitUint16               =              setNumeric;\nSetVisitor.prototype.visitUint32               =              setNumeric;\nSetVisitor.prototype.visitUint64               =            setNumericX2;\nSetVisitor.prototype.visitFloat                =                setFloat;\nSetVisitor.prototype.visitFloat16              =              setFloat16;\nSetVisitor.prototype.visitFloat32              =              setNumeric;\nSetVisitor.prototype.visitFloat64              =              setNumeric;\nSetVisitor.prototype.visitUtf8                 =                 setUtf8;\nSetVisitor.prototype.visitBinary               =               setBinary;\nSetVisitor.prototype.visitFixedSizeBinary      =      setFixedSizeBinary;\nSetVisitor.prototype.visitDate                 =                 setDate;\nSetVisitor.prototype.visitDateDay              =              setDateDay;\nSetVisitor.prototype.visitDateMillisecond      =      setDateMillisecond;\nSetVisitor.prototype.visitTimestamp            =            setTimestamp;\nSetVisitor.prototype.visitTimestampSecond      =      setTimestampSecond;\nSetVisitor.prototype.visitTimestampMillisecond = setTimestampMillisecond;\nSetVisitor.prototype.visitTimestampMicrosecond = setTimestampMicrosecond;\nSetVisitor.prototype.visitTimestampNanosecond  =  setTimestampNanosecond;\nSetVisitor.prototype.visitTime                 =                 setTime;\nSetVisitor.prototype.visitTimeSecond           =           setTimeSecond;\nSetVisitor.prototype.visitTimeMillisecond      =      setTimeMillisecond;\nSetVisitor.prototype.visitTimeMicrosecond      =      setTimeMicrosecond;\nSetVisitor.prototype.visitTimeNanosecond       =       setTimeNanosecond;\nSetVisitor.prototype.visitDecimal              =              setDecimal;\nSetVisitor.prototype.visitList                 =                 setList;\nSetVisitor.prototype.visitStruct               =               setStruct;\nSetVisitor.prototype.visitUnion                =                setUnion;\nSetVisitor.prototype.visitDenseUnion           =           setDenseUnion;\nSetVisitor.prototype.visitSparseUnion          =          setSparseUnion;\nSetVisitor.prototype.visitDictionary           =           setDictionary;\nSetVisitor.prototype.visitInterval             =        setIntervalValue;\nSetVisitor.prototype.visitIntervalDayTime      =      setIntervalDayTime;\nSetVisitor.prototype.visitIntervalYearMonth    =    setIntervalYearMonth;\nSetVisitor.prototype.visitFixedSizeList        =        setFixedSizeList;\nSetVisitor.prototype.visitMap                  =                  setMap;\n\n/** @ignore */\nexport const instance = new SetVisitor();\n","// automatically generated by the FlatBuffers compiler, do not modify\n\nimport { flatbuffers } from 'flatbuffers';\nimport * as NS7624605610262437867 from './Schema';\n/**\n * ----------------------------------------------------------------------\n * Arrow File metadata\n *\n *\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Footer {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Footer\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Footer {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * @param flatbuffers.ByteBuffer bb\n         * @param Footer= obj\n         * @returns Footer\n         */\n        static getRootAsFooter(bb: flatbuffers.ByteBuffer, obj?: Footer): Footer {\n            return (obj || new Footer).__init(bb.readInt32(bb.position()) + bb.position(), bb);\n        }\n\n        /**\n         * @returns org.apache.arrow.flatbuf.MetadataVersion\n         */\n        version(): NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion {\n            let offset = this.bb!.__offset(this.bb_pos, 4);\n            return offset ? /**  */ (this.bb!.readInt16(this.bb_pos + offset)) : NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1;\n        }\n\n        /**\n         * @param org.apache.arrow.flatbuf.Schema= obj\n         * @returns org.apache.arrow.flatbuf.Schema|null\n         */\n        schema(obj?: NS7624605610262437867.org.apache.arrow.flatbuf.Schema): NS7624605610262437867.org.apache.arrow.flatbuf.Schema | null {\n            let offset = this.bb!.__offset(this.bb_pos, 6);\n            return offset ? (obj || new NS7624605610262437867.org.apache.arrow.flatbuf.Schema).__init(this.bb!.__indirect(this.bb_pos + offset), this.bb!) : null;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Block= obj\n         * @returns org.apache.arrow.flatbuf.Block\n         */\n        dictionaries(index: number, obj?: org.apache.arrow.flatbuf.Block): org.apache.arrow.flatbuf.Block | null {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Block).__init(this.bb!.__vector(this.bb_pos + offset) + index * 24, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        dictionariesLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 8);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param number index\n         * @param org.apache.arrow.flatbuf.Block= obj\n         * @returns org.apache.arrow.flatbuf.Block\n         */\n        recordBatches(index: number, obj?: org.apache.arrow.flatbuf.Block): org.apache.arrow.flatbuf.Block | null {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? (obj || new org.apache.arrow.flatbuf.Block).__init(this.bb!.__vector(this.bb_pos + offset) + index * 24, this.bb!) : null;\n        }\n\n        /**\n         * @returns number\n         */\n        recordBatchesLength(): number {\n            let offset = this.bb!.__offset(this.bb_pos, 10);\n            return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         */\n        static startFooter(builder: flatbuffers.Builder) {\n            builder.startObject(4);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param org.apache.arrow.flatbuf.MetadataVersion version\n         */\n        static addVersion(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion) {\n            builder.addFieldInt16(0, version, NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion.V1);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset schemaOffset\n         */\n        static addSchema(builder: flatbuffers.Builder, schemaOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(1, schemaOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset dictionariesOffset\n         */\n        static addDictionaries(builder: flatbuffers.Builder, dictionariesOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(2, dictionariesOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startDictionariesVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(24, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset recordBatchesOffset\n         */\n        static addRecordBatches(builder: flatbuffers.Builder, recordBatchesOffset: flatbuffers.Offset) {\n            builder.addFieldOffset(3, recordBatchesOffset, 0);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param number numElems\n         */\n        static startRecordBatchesVector(builder: flatbuffers.Builder, numElems: number) {\n            builder.startVector(24, numElems, 8);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @returns flatbuffers.Offset\n         */\n        static endFooter(builder: flatbuffers.Builder): flatbuffers.Offset {\n            let offset = builder.endObject();\n            return offset;\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Offset offset\n         */\n        static finishFooterBuffer(builder: flatbuffers.Builder, offset: flatbuffers.Offset) {\n            builder.finish(offset);\n        }\n\n        static createFooter(builder: flatbuffers.Builder, version: NS7624605610262437867.org.apache.arrow.flatbuf.MetadataVersion, schemaOffset: flatbuffers.Offset, dictionariesOffset: flatbuffers.Offset, recordBatchesOffset: flatbuffers.Offset): flatbuffers.Offset {\n            Footer.startFooter(builder);\n            Footer.addVersion(builder, version);\n            Footer.addSchema(builder, schemaOffset);\n            Footer.addDictionaries(builder, dictionariesOffset);\n            Footer.addRecordBatches(builder, recordBatchesOffset);\n            return Footer.endFooter(builder);\n        }\n    }\n}\n/**\n * @constructor\n */\nexport namespace org.apache.arrow.flatbuf {\n    export class Block {\n        bb: flatbuffers.ByteBuffer | null = null;\n\n        bb_pos: number = 0;\n        /**\n         * @param number i\n         * @param flatbuffers.ByteBuffer bb\n         * @returns Block\n         */\n        __init(i: number, bb: flatbuffers.ByteBuffer): Block {\n            this.bb_pos = i;\n            this.bb = bb;\n            return this;\n        }\n\n        /**\n         * Index to the start of the RecordBlock (note this is past the Message header)\n         *\n         * @returns flatbuffers.Long\n         */\n        offset(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos);\n        }\n\n        /**\n         * Length of the metadata\n         *\n         * @returns number\n         */\n        metaDataLength(): number {\n            return this.bb!.readInt32(this.bb_pos + 8);\n        }\n\n        /**\n         * Length of the data (this is aligned so there can be a gap between this and\n         * the metatdata).\n         *\n         * @returns flatbuffers.Long\n         */\n        bodyLength(): flatbuffers.Long {\n            return this.bb!.readInt64(this.bb_pos + 16);\n        }\n\n        /**\n         * @param flatbuffers.Builder builder\n         * @param flatbuffers.Long offset\n         * @param number metaDataLength\n         * @param flatbuffers.Long bodyLength\n         * @returns flatbuffers.Offset\n         */\n        static createBlock(builder: flatbuffers.Builder, offset: flatbuffers.Long, metaDataLength: number, bodyLength: flatbuffers.Long): flatbuffers.Offset {\n            builder.prep(8, 24);\n            builder.writeInt64(bodyLength);\n            builder.pad(4);\n            builder.writeInt32(metaDataLength);\n            builder.writeInt64(offset);\n            return builder.offset();\n        }\n\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { DataType } from '../type';\nimport { Visitor } from '../visitor';\nimport { VectorType, BuilderCtor } from '../interfaces';\nimport { BinaryBuilder } from '../builder/binary';\nimport { BoolBuilder } from '../builder/bool';\nimport { DateBuilder, DateDayBuilder, DateMillisecondBuilder } from '../builder/date';\nimport { DecimalBuilder } from '../builder/decimal';\nimport { DictionaryBuilder } from '../builder/dictionary';\nimport { FixedSizeBinaryBuilder } from '../builder/fixedsizebinary';\nimport { FixedSizeListBuilder } from '../builder/fixedsizelist';\nimport { FloatBuilder, Float16Builder, Float32Builder, Float64Builder } from '../builder/float';\nimport { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from '../builder/interval';\nimport { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder } from '../builder/int';\nimport { ListBuilder } from '../builder/list';\nimport { MapBuilder } from '../builder/map';\nimport { NullBuilder } from '../builder/null';\nimport { StructBuilder } from '../builder/struct';\nimport { TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder } from '../builder/timestamp';\nimport { TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder } from '../builder/time';\nimport { UnionBuilder, DenseUnionBuilder, SparseUnionBuilder } from '../builder/union';\nimport { Utf8Builder } from '../builder/utf8';\n\n/** @ignore */\nexport interface GetBuilderCtor extends Visitor {\n    visit<T extends Type>(type: T): BuilderCtor<T>;\n    visitMany<T extends Type>(types: T[]): BuilderCtor<T>[];\n    getVisitFn<T extends Type>(type: T): () => BuilderCtor<T>;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): () => BuilderCtor<T>;\n}\n\n/** @ignore */\nexport class GetBuilderCtor extends Visitor {\n    public visitNull                 () { return NullBuilder;                 }\n    public visitBool                 () { return BoolBuilder;                 }\n    public visitInt                  () { return IntBuilder;                  }\n    public visitInt8                 () { return Int8Builder;                 }\n    public visitInt16                () { return Int16Builder;                }\n    public visitInt32                () { return Int32Builder;                }\n    public visitInt64                () { return Int64Builder;                }\n    public visitUint8                () { return Uint8Builder;                }\n    public visitUint16               () { return Uint16Builder;               }\n    public visitUint32               () { return Uint32Builder;               }\n    public visitUint64               () { return Uint64Builder;               }\n    public visitFloat                () { return FloatBuilder;                }\n    public visitFloat16              () { return Float16Builder;              }\n    public visitFloat32              () { return Float32Builder;              }\n    public visitFloat64              () { return Float64Builder;              }\n    public visitUtf8                 () { return Utf8Builder;                 }\n    public visitBinary               () { return BinaryBuilder;               }\n    public visitFixedSizeBinary      () { return FixedSizeBinaryBuilder;      }\n    public visitDate                 () { return DateBuilder;                 }\n    public visitDateDay              () { return DateDayBuilder;              }\n    public visitDateMillisecond      () { return DateMillisecondBuilder;      }\n    public visitTimestamp            () { return TimestampBuilder;            }\n    public visitTimestampSecond      () { return TimestampSecondBuilder;      }\n    public visitTimestampMillisecond () { return TimestampMillisecondBuilder; }\n    public visitTimestampMicrosecond () { return TimestampMicrosecondBuilder; }\n    public visitTimestampNanosecond  () { return TimestampNanosecondBuilder;  }\n    public visitTime                 () { return TimeBuilder;                 }\n    public visitTimeSecond           () { return TimeSecondBuilder;           }\n    public visitTimeMillisecond      () { return TimeMillisecondBuilder;      }\n    public visitTimeMicrosecond      () { return TimeMicrosecondBuilder;      }\n    public visitTimeNanosecond       () { return TimeNanosecondBuilder;       }\n    public visitDecimal              () { return DecimalBuilder;              }\n    public visitList                 () { return ListBuilder;                 }\n    public visitStruct               () { return StructBuilder;               }\n    public visitUnion                () { return UnionBuilder;                }\n    public visitDenseUnion           () { return DenseUnionBuilder;           }\n    public visitSparseUnion          () { return SparseUnionBuilder;          }\n    public visitDictionary           () { return DictionaryBuilder;           }\n    public visitInterval             () { return IntervalBuilder;             }\n    public visitIntervalDayTime      () { return IntervalDayTimeBuilder;      }\n    public visitIntervalYearMonth    () { return IntervalYearMonthBuilder;    }\n    public visitFixedSizeList        () { return FixedSizeListBuilder;        }\n    public visitMap                  () { return MapBuilder;                  }\n}\n\n/** @ignore */\nexport const instance = new GetBuilderCtor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nexport { Builder, BuilderOptions } from '../builder';\nexport { BoolBuilder } from './bool';\nexport { NullBuilder } from './null';\nexport { DateBuilder, DateDayBuilder, DateMillisecondBuilder } from './date';\nexport { DecimalBuilder } from './decimal';\nexport { DictionaryBuilder } from './dictionary';\nexport { FixedSizeBinaryBuilder } from './fixedsizebinary';\nexport { FloatBuilder, Float16Builder, Float32Builder, Float64Builder } from './float';\nexport { IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder } from './int';\nexport { TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder } from './time';\nexport { TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder } from './timestamp';\nexport { IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder } from './interval';\nexport { Utf8Builder } from './utf8';\nexport { BinaryBuilder } from './binary';\nexport { ListBuilder } from './list';\nexport { FixedSizeListBuilder } from './fixedsizelist';\nexport { MapBuilder } from './map';\nexport { StructBuilder } from './struct';\nexport { UnionBuilder, SparseUnionBuilder, DenseUnionBuilder } from './union';\n\nimport { Type } from '../enum';\nimport { Field } from '../schema';\nimport { DataType } from '../type';\nimport { Utf8Builder } from './utf8';\nimport { BuilderType as B } from '../interfaces';\nimport { Builder, BuilderOptions } from '../builder';\nimport { instance as setVisitor } from '../visitor/set';\nimport { instance as getBuilderConstructor } from '../visitor/builderctor';\n\n/** @nocollapse */\nBuilder.new = newBuilder;\n\nfunction newBuilder<T extends DataType = any, TNull = any>(options: BuilderOptions<T, TNull>): B<T, TNull> {\n\n    const type = options.type;\n    const builder = new (getBuilderConstructor.getVisitFn<T>(type)())(options) as Builder<T, TNull>;\n\n    if (type.children && type.children.length > 0) {\n\n        const children = options['children'] || [] as BuilderOptions[];\n        const defaultOptions = { 'nullValues': options['nullValues'] };\n        const getChildOptions = Array.isArray(children)\n            ? ((_: Field, i: number) => children[i] || defaultOptions)\n            : (({ name }: Field) => children[name] || defaultOptions);\n\n        type.children.forEach((field, index) => {\n            const { type } = field;\n            const opts = getChildOptions(field, index);\n            builder.children.push(newBuilder({ ...opts, type }));\n        });\n    }\n\n    return builder as B<T, TNull>;\n}\n\n(Object.keys(Type) as any[])\n    .map((T: any) => Type[T] as any)\n    .filter((T: any): T is Type => typeof T === 'number' && T !== Type.NONE)\n    .forEach((typeId) => {\n        const BuilderCtor = getBuilderConstructor.visit(typeId);\n        BuilderCtor.prototype._setValue = setVisitor.getVisitFn(typeId);\n    });\n\n(Utf8Builder.prototype as any)._setValue = setVisitor.visitBinary;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/* tslint:disable:class-name */\n\nimport * as File_ from '../../fb/File';\nimport { flatbuffers } from 'flatbuffers';\n\nimport Long = flatbuffers.Long;\nimport Builder = flatbuffers.Builder;\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport _Block = File_.org.apache.arrow.flatbuf.Block;\nimport _Footer = File_.org.apache.arrow.flatbuf.Footer;\n\nimport { Schema } from '../../schema';\nimport { MetadataVersion } from '../../enum';\nimport { toUint8Array } from '../../util/buffer';\nimport { ArrayBufferViewInput } from '../../util/buffer';\n\n/** @ignore */\nclass Footer_ {\n\n    /** @nocollapse */\n    public static decode(buf: ArrayBufferViewInput) {\n        buf = new ByteBuffer(toUint8Array(buf));\n        const footer = _Footer.getRootAsFooter(buf);\n        const schema = Schema.decode(footer.schema()!);\n        return new OffHeapFooter(schema, footer) as Footer_;\n    }\n\n    /** @nocollapse */\n    public static encode(footer: Footer_) {\n\n        const b: Builder = new Builder();\n        const schemaOffset = Schema.encode(b, footer.schema);\n\n        _Footer.startRecordBatchesVector(b, footer.numRecordBatches);\n        [...footer.recordBatches()].slice().reverse().forEach((rb) => FileBlock.encode(b, rb));\n        const recordBatchesOffset = b.endVector();\n\n        _Footer.startDictionariesVector(b, footer.numDictionaries);\n        [...footer.dictionaryBatches()].slice().reverse().forEach((db) => FileBlock.encode(b, db));\n\n        const dictionaryBatchesOffset = b.endVector();\n\n        _Footer.startFooter(b);\n        _Footer.addSchema(b, schemaOffset);\n        _Footer.addVersion(b, MetadataVersion.V4);\n        _Footer.addRecordBatches(b, recordBatchesOffset);\n        _Footer.addDictionaries(b, dictionaryBatchesOffset);\n        _Footer.finishFooterBuffer(b, _Footer.endFooter(b));\n\n        return b.asUint8Array();\n    }\n\n    // @ts-ignore\n    protected _recordBatches: FileBlock[];\n    // @ts-ignore\n    protected _dictionaryBatches: FileBlock[];\n    public get numRecordBatches() { return this._recordBatches.length; }\n    public get numDictionaries() { return this._dictionaryBatches.length; }\n\n    constructor(public schema: Schema,\n                public version: MetadataVersion = MetadataVersion.V4,\n                recordBatches?: FileBlock[], dictionaryBatches?: FileBlock[]) {\n        recordBatches && (this._recordBatches = recordBatches);\n        dictionaryBatches && (this._dictionaryBatches = dictionaryBatches);\n    }\n\n    public *recordBatches(): Iterable<FileBlock> {\n        for (let block, i = -1, n = this.numRecordBatches; ++i < n;) {\n            if (block = this.getRecordBatch(i)) { yield block; }\n        }\n    }\n\n    public *dictionaryBatches(): Iterable<FileBlock> {\n        for (let block, i = -1, n = this.numDictionaries; ++i < n;) {\n            if (block = this.getDictionaryBatch(i)) { yield block; }\n        }\n    }\n\n    public getRecordBatch(index: number) {\n        return index >= 0\n            && index < this.numRecordBatches\n            && this._recordBatches[index] || null;\n    }\n\n    public getDictionaryBatch(index: number) {\n        return index >= 0\n            && index < this.numDictionaries\n            && this._dictionaryBatches[index] || null;\n    }\n}\n\nexport { Footer_ as Footer };\n\n/** @ignore */\nclass OffHeapFooter extends Footer_ {\n\n    public get numRecordBatches() { return this._footer.recordBatchesLength(); }\n    public get numDictionaries() { return this._footer.dictionariesLength(); }\n\n    constructor(schema: Schema, protected _footer: _Footer) {\n        super(schema, _footer.version());\n    }\n\n    public getRecordBatch(index: number) {\n        if (index >= 0 && index < this.numRecordBatches) {\n            const fileBlock = this._footer.recordBatches(index);\n            if (fileBlock) { return FileBlock.decode(fileBlock); }\n        }\n        return null;\n    }\n\n    public getDictionaryBatch(index: number) {\n        if (index >= 0 && index < this.numDictionaries) {\n            const fileBlock = this._footer.dictionaries(index);\n            if (fileBlock) { return FileBlock.decode(fileBlock); }\n        }\n        return null;\n    }\n}\n\n/** @ignore */\nexport class FileBlock {\n\n    /** @nocollapse */\n    public static decode(block: _Block) {\n        return new FileBlock(block.metaDataLength(), block.bodyLength(), block.offset());\n    }\n\n    /** @nocollapse */\n    public static encode(b: Builder, fileBlock: FileBlock) {\n        const { metaDataLength } = fileBlock;\n        const offset = new Long(fileBlock.offset, 0);\n        const bodyLength = new Long(fileBlock.bodyLength, 0);\n        return _Block.createBlock(b, offset, metaDataLength, bodyLength);\n    }\n\n    public offset: number;\n    public bodyLength: number;\n    public metaDataLength: number;\n\n    constructor(metaDataLength: number, bodyLength: Long | number, offset: Long | number) {\n        this.metaDataLength = metaDataLength;\n        this.offset = typeof offset === 'number' ? offset : offset.low;\n        this.bodyLength = typeof bodyLength === 'number' ? bodyLength : bodyLength.low;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport streamAdapters from './adapters';\nimport { decodeUtf8 } from '../util/utf8';\nimport { ITERATOR_DONE, Readable, Writable, AsyncQueue } from './interfaces';\nimport { toUint8Array, joinUint8Arrays, ArrayBufferViewInput } from '../util/buffer';\n\nimport {\n    isPromise, isFetchResponse,\n    isIterable, isAsyncIterable,\n    isReadableDOMStream, isReadableNodeStream\n} from '../util/compat';\n\n/** @ignore */\nexport type WritableSink<T> = Writable<T> | WritableStream<T> | NodeJS.WritableStream | null;\n/** @ignore */\nexport type ReadableSource<T> = Readable<T> | PromiseLike<T> | AsyncIterable<T> | ReadableStream<T> | NodeJS.ReadableStream | null;\n\n/** @ignore */\nexport class AsyncByteQueue<T extends ArrayBufferViewInput = Uint8Array> extends AsyncQueue<Uint8Array, T> {\n    public write(value: ArrayBufferViewInput | Uint8Array) {\n        if ((value = toUint8Array(value)).byteLength > 0) {\n            return super.write(value as T);\n        }\n    }\n    public toString(sync: true): string;\n    public toString(sync?: false): Promise<string>;\n    public toString(sync = false) {\n        return sync\n            ? decodeUtf8(this.toUint8Array(true))\n            : this.toUint8Array(false).then(decodeUtf8);\n    }\n    public toUint8Array(sync: true): Uint8Array;\n    public toUint8Array(sync?: false): Promise<Uint8Array>;\n    public toUint8Array(sync = false) {\n        return sync ? joinUint8Arrays(this._values as any[])[0] : (async () => {\n            let buffers = [], byteLength = 0;\n            for await (const chunk of this) {\n                buffers.push(chunk);\n                byteLength += chunk.byteLength;\n            }\n            return joinUint8Arrays(buffers, byteLength)[0];\n        })();\n    }\n}\n\n/** @ignore */\nexport class ByteStream implements IterableIterator<Uint8Array> {\n    // @ts-ignore\n    private source: ByteStreamSource<Uint8Array>;\n    constructor(source?: Iterable<ArrayBufferViewInput> | ArrayBufferViewInput) {\n        if (source) {\n            this.source = new ByteStreamSource(streamAdapters.fromIterable(source));\n        }\n    }\n    [Symbol.iterator]() { return this; }\n    public next(value?: any) { return this.source.next(value); }\n    public throw(value?: any) { return this.source.throw(value); }\n    public return(value?: any) { return this.source.return(value); }\n    public peek(size?: number | null) { return this.source.peek(size); }\n    public read(size?: number | null) { return this.source.read(size); }\n}\n\n/** @ignore */\nexport class AsyncByteStream implements Readable<Uint8Array>, AsyncIterableIterator<Uint8Array> {\n    // @ts-ignore\n    private source: AsyncByteStreamSource<Uint8Array>;\n    constructor(source?: PromiseLike<ArrayBufferViewInput> | Response | ReadableStream<ArrayBufferViewInput> | NodeJS.ReadableStream | AsyncIterable<ArrayBufferViewInput> | Iterable<ArrayBufferViewInput>) {\n        if (source instanceof AsyncByteStream) {\n            this.source = (source as AsyncByteStream).source;\n        } else if (source instanceof AsyncByteQueue) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        } else if (isReadableNodeStream(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromNodeStream(source));\n        } else if (isReadableDOMStream<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source));\n        } else if (isFetchResponse(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromDOMStream(source.body!));\n        } else if (isIterable<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromIterable(source));\n        } else if (isPromise<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        } else if (isAsyncIterable<ArrayBufferViewInput>(source)) {\n            this.source = new AsyncByteStreamSource(streamAdapters.fromAsyncIterable(source));\n        }\n    }\n    [Symbol.asyncIterator]() { return this; }\n    public next(value?: any) { return this.source.next(value); }\n    public throw(value?: any) { return this.source.throw(value); }\n    public return(value?: any) { return this.source.return(value); }\n    public get closed(): Promise<void> { return this.source.closed; }\n    public cancel(reason?: any) { return this.source.cancel(reason); }\n    public peek(size?: number | null) { return this.source.peek(size); }\n    public read(size?: number | null) { return this.source.read(size); }\n}\n\n/** @ignore */\ninterface ByteStreamSourceIterator<T> extends IterableIterator<T> {\n    next(value?: { cmd: 'peek' | 'read', size?: number | null }): IteratorResult<T>;\n}\n\n/** @ignore */\ninterface AsyncByteStreamSourceIterator<T> extends AsyncIterableIterator<T> {\n    next(value?: { cmd: 'peek' | 'read', size?: number | null }): Promise<IteratorResult<T>>;\n}\n\n/** @ignore */\nclass ByteStreamSource<T> {\n    constructor(protected source: ByteStreamSourceIterator<T>) {}\n    public cancel(reason?: any) { this.return(reason); }\n    public peek(size?: number | null): T | null { return this.next(size, 'peek').value; }\n    public read(size?: number | null): T | null { return this.next(size, 'read').value; }\n    public next(size?: number | null, cmd: 'peek' | 'read' = 'read') { return this.source.next({ cmd, size }); }\n    public throw(value?: any) { return Object.create((this.source.throw && this.source.throw(value)) || ITERATOR_DONE); }\n    public return(value?: any) { return Object.create((this.source.return && this.source.return(value)) || ITERATOR_DONE); }\n}\n\n/** @ignore */\nclass AsyncByteStreamSource<T> implements Readable<T> {\n\n    private _closedPromise: Promise<void>;\n    private _closedPromiseResolve?: (value?: any) => void;\n    constructor (protected source: ByteStreamSourceIterator<T> | AsyncByteStreamSourceIterator<T>) {\n        this._closedPromise = new Promise((r) => this._closedPromiseResolve = r);\n    }\n    public async cancel(reason?: any) { await this.return(reason); }\n    public get closed(): Promise<void> { return this._closedPromise; }\n    public async read(size?: number | null): Promise<T | null> { return (await this.next(size, 'read')).value; }\n    public async peek(size?: number | null): Promise<T | null> { return (await this.next(size, 'peek')).value; }\n    public async next(size?: number | null, cmd: 'peek' | 'read' = 'read') { return (await this.source.next({ cmd, size })); }\n    public async throw(value?: any) {\n        const result = (this.source.throw && await this.source.throw(value)) || ITERATOR_DONE;\n        this._closedPromiseResolve && this._closedPromiseResolve();\n        this._closedPromiseResolve = undefined;\n        return Object.create(result);\n    }\n    public async return(value?: any) {\n        const result = (this.source.return && await this.source.return(value)) || ITERATOR_DONE;\n        this._closedPromiseResolve && this._closedPromiseResolve();\n        this._closedPromiseResolve = undefined;\n        return Object.create(result);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { FileHandle } from './interfaces';\nimport { ByteStream, AsyncByteStream } from './stream';\nimport { ArrayBufferViewInput, toUint8Array } from '../util/buffer';\n\n/** @ignore */\nexport class RandomAccessFile extends ByteStream {\n    public size: number;\n    public position: number = 0;\n    protected buffer: Uint8Array | null;\n    constructor(buffer: ArrayBufferViewInput, byteLength?: number) {\n        super();\n        this.buffer = toUint8Array(buffer);\n        this.size = typeof byteLength === 'undefined' ? this.buffer.byteLength : byteLength;\n    }\n    public readInt32(position: number) {\n        const { buffer, byteOffset } = this.readAt(position, 4);\n        return new DataView(buffer, byteOffset).getInt32(0, true);\n    }\n    public seek(position: number) {\n        this.position = Math.min(position, this.size);\n        return position < this.size;\n    }\n    public read(nBytes?: number | null) {\n        const { buffer, size, position } = this;\n        if (buffer && position < size) {\n            if (typeof nBytes !== 'number') { nBytes = Infinity; }\n            this.position = Math.min(size,\n                 position + Math.min(size - position, nBytes));\n            return buffer.subarray(position, this.position);\n        }\n        return null;\n    }\n    public readAt(position: number, nBytes: number) {\n        const buf = this.buffer;\n        const end = Math.min(this.size, position + nBytes);\n        return buf ? buf.subarray(position, end) : new Uint8Array(nBytes);\n    }\n    public close() { this.buffer && (this.buffer = null); }\n    public throw(value?: any) { this.close(); return { done: true, value }; }\n    public return(value?: any) { this.close(); return { done: true, value }; }\n}\n\n/** @ignore */\nexport class AsyncRandomAccessFile extends AsyncByteStream {\n    // @ts-ignore\n    public size: number;\n    public position: number = 0;\n    public _pending?: Promise<void>;\n    protected _handle: FileHandle | null;\n    constructor(file: FileHandle, byteLength?: number) {\n        super();\n        this._handle = file;\n        if (typeof byteLength === 'number') {\n            this.size = byteLength;\n        } else {\n            this._pending = (async () => {\n                this.size = (await file.stat()).size;\n                delete this._pending;\n            })();\n        }\n    }\n    public async readInt32(position: number) {\n        const { buffer, byteOffset } = await this.readAt(position, 4);\n        return new DataView(buffer, byteOffset).getInt32(0, true);\n    }\n    public async seek(position: number) {\n        this._pending && await this._pending;\n        this.position = Math.min(position, this.size);\n        return position < this.size;\n    }\n    public async read(nBytes?: number | null) {\n        this._pending && await this._pending;\n        const { _handle: file, size, position } = this;\n        if (file && position < size) {\n            if (typeof nBytes !== 'number') { nBytes = Infinity; }\n            let pos = position, offset = 0, bytesRead = 0;\n            let end = Math.min(size, pos + Math.min(size - pos, nBytes));\n            let buffer = new Uint8Array(Math.max(0, (this.position = end) - pos));\n            while ((pos += bytesRead) < end && (offset += bytesRead) < buffer.byteLength) {\n                ({ bytesRead } = await file.read(buffer, offset, buffer.byteLength - offset, pos));\n            }\n            return buffer;\n        }\n        return null;\n    }\n    public async readAt(position: number, nBytes: number) {\n        this._pending && await this._pending;\n        const { _handle: file, size } = this;\n        if (file && (position + nBytes) < size) {\n            const end = Math.min(size, position + nBytes);\n            const buffer = new Uint8Array(end - position);\n            return (await file.read(buffer, 0, nBytes, position)).buffer;\n        }\n        return new Uint8Array(nBytes);\n    }\n    public async close() { const f = this._handle; this._handle = null; f && await f.close(); }\n    public async throw(value?: any) { await this.close(); return { done: true, value }; }\n    public async return(value?: any) { await this.close(); return { done: true, value }; }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nconst carryBit16 = 1 << 16;\n\n/** @ignore */\nfunction intAsHex(value: number): string {\n    if (value < 0) {\n        value = 0xFFFFFFFF + value + 1;\n    }\n    return `0x${value.toString(16)}`;\n}\n\n/** @ignore */\nconst kInt32DecimalDigits = 8;\n/** @ignore */\nconst kPowersOfTen = [1,\n                      10,\n                      100,\n                      1000,\n                      10000,\n                      100000,\n                      1000000,\n                      10000000,\n                      100000000];\n\n/** @ignore */\nexport class BaseInt64 {\n    constructor (protected buffer: Uint32Array) {}\n\n    public high(): number { return this.buffer[1]; }\n    public low (): number { return this.buffer[0]; }\n\n    protected _times(other: BaseInt64) {\n        // Break the left and right numbers into 16 bit chunks\n        // so that we can multiply them without overflow.\n        const L = new Uint32Array([\n            this.buffer[1] >>> 16,\n            this.buffer[1] & 0xFFFF,\n            this.buffer[0] >>> 16,\n            this.buffer[0] & 0xFFFF\n        ]);\n\n        const R = new Uint32Array([\n            other.buffer[1] >>> 16,\n            other.buffer[1] & 0xFFFF,\n            other.buffer[0] >>> 16,\n            other.buffer[0] & 0xFFFF\n        ]);\n\n        let product = L[3] * R[3];\n        this.buffer[0] = product & 0xFFFF;\n\n        let sum = product >>> 16;\n\n        product = L[2] * R[3];\n        sum += product;\n\n        product = (L[3] * R[2]) >>> 0;\n        sum += product;\n\n        this.buffer[0] += sum << 16;\n\n        this.buffer[1] = (sum >>> 0 < product ? carryBit16 : 0);\n\n        this.buffer[1] += sum >>> 16;\n        this.buffer[1] += L[1] * R[3] + L[2] * R[2] + L[3] * R[1];\n        this.buffer[1] += (L[0] * R[3] + L[1] * R[2] + L[2] * R[1] + L[3] * R[0]) << 16;\n\n        return this;\n      }\n\n    protected _plus(other: BaseInt64) {\n        const sum = (this.buffer[0] + other.buffer[0]) >>> 0;\n        this.buffer[1] += other.buffer[1];\n        if (sum < (this.buffer[0] >>> 0)) {\n          ++this.buffer[1];\n        }\n        this.buffer[0] = sum;\n    }\n\n    public lessThan(other: BaseInt64): boolean {\n        return this.buffer[1] < other.buffer[1] ||\n            (this.buffer[1] === other.buffer[1] && this.buffer[0] < other.buffer[0]);\n    }\n\n    public equals(other: BaseInt64): boolean {\n        return this.buffer[1] === other.buffer[1] && this.buffer[0] == other.buffer[0];\n    }\n\n    public greaterThan(other: BaseInt64): boolean {\n        return other.lessThan(this);\n    }\n\n    public hex(): string {\n        return `${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;\n    }\n}\n\n/** @ignore */\nexport class Uint64 extends BaseInt64 {\n    public times(other: Uint64): Uint64 {\n        this._times(other);\n        return this;\n    }\n\n    public plus(other: Uint64): Uint64 {\n        this._plus(other);\n        return this;\n    }\n\n    /** @nocollapse */\n    public static from(val: any, out_buffer = new Uint32Array(2)): Uint64 {\n        return Uint64.fromString(\n            typeof(val) === 'string' ? val : val.toString(),\n            out_buffer\n        );\n    }\n\n    /** @nocollapse */\n    public static fromNumber(num: number, out_buffer = new Uint32Array(2)): Uint64 {\n        // Always parse numbers as strings - pulling out high and low bits\n        // directly seems to lose precision sometimes\n        // For example:\n        //     > -4613034156400212000 >>> 0\n        //     721782784\n        // The correct lower 32-bits are 721782752\n        return Uint64.fromString(num.toString(), out_buffer);\n    }\n\n    /** @nocollapse */\n    public static fromString(str: string, out_buffer = new Uint32Array(2)): Uint64 {\n        const length = str.length;\n\n        let out = new Uint64(out_buffer);\n        for (let posn = 0; posn < length;) {\n            const group = kInt32DecimalDigits < length - posn ?\n                          kInt32DecimalDigits : length - posn;\n            const chunk = new Uint64(new Uint32Array([parseInt(str.substr(posn, group), 10), 0]));\n            const multiple = new Uint64(new Uint32Array([kPowersOfTen[group], 0]));\n\n            out.times(multiple);\n            out.plus(chunk);\n\n            posn += group;\n        }\n\n        return out;\n    }\n\n    /** @nocollapse */\n    public static convertArray(values: (string|number)[]): Uint32Array {\n        const data = new Uint32Array(values.length * 2);\n        for (let i = -1, n = values.length; ++i < n;) {\n            Uint64.from(values[i], new Uint32Array(data.buffer, data.byteOffset + 2 * i * 4, 2));\n        }\n        return data;\n    }\n\n    /** @nocollapse */\n    public static multiply(left: Uint64, right: Uint64): Uint64 {\n        let rtrn = new Uint64(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n\n    /** @nocollapse */\n    public static add(left: Uint64, right: Uint64): Uint64 {\n        let rtrn = new Uint64(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n}\n\n/** @ignore */\nexport class Int64 extends BaseInt64 {\n    public negate(): Int64 {\n        this.buffer[0] = ~this.buffer[0] + 1;\n        this.buffer[1] = ~this.buffer[1];\n\n        if (this.buffer[0] == 0) { ++this.buffer[1]; }\n        return this;\n    }\n\n    public times(other: Int64): Int64 {\n        this._times(other);\n        return this;\n    }\n\n    public plus(other: Int64): Int64 {\n        this._plus(other);\n        return this;\n    }\n\n    public lessThan(other: Int64): boolean {\n        // force high bytes to be signed\n        const this_high = this.buffer[1] << 0;\n        const other_high = other.buffer[1] << 0;\n        return this_high < other_high ||\n            (this_high === other_high && this.buffer[0] < other.buffer[0]);\n    }\n\n    /** @nocollapse */\n    public static from(val: any, out_buffer = new Uint32Array(2)): Int64 {\n        return Int64.fromString(\n            typeof(val) === 'string' ? val : val.toString(),\n            out_buffer\n        );\n    }\n\n    /** @nocollapse */\n    public static fromNumber(num: number, out_buffer = new Uint32Array(2)): Int64 {\n        // Always parse numbers as strings - pulling out high and low bits\n        // directly seems to lose precision sometimes\n        // For example:\n        //     > -4613034156400212000 >>> 0\n        //     721782784\n        // The correct lower 32-bits are 721782752\n        return Int64.fromString(num.toString(), out_buffer);\n    }\n\n    /** @nocollapse */\n    public static fromString(str: string, out_buffer = new Uint32Array(2)): Int64 {\n        // TODO: Assert that out_buffer is 0 and length = 2\n        const negate = str.startsWith('-');\n        const length = str.length;\n\n        let out = new Int64(out_buffer);\n        for (let posn = negate ? 1 : 0; posn < length;) {\n            const group = kInt32DecimalDigits < length - posn ?\n                          kInt32DecimalDigits : length - posn;\n            const chunk = new Int64(new Uint32Array([parseInt(str.substr(posn, group), 10), 0]));\n            const multiple = new Int64(new Uint32Array([kPowersOfTen[group], 0]));\n\n            out.times(multiple);\n            out.plus(chunk);\n\n            posn += group;\n        }\n        return negate ? out.negate() : out;\n    }\n\n    /** @nocollapse */\n    public static convertArray(values: (string|number)[]): Uint32Array {\n        const data = new Uint32Array(values.length * 2);\n        for (let i = -1, n = values.length; ++i < n;) {\n            Int64.from(values[i], new Uint32Array(data.buffer, data.byteOffset + 2 * i * 4, 2));\n        }\n        return data;\n    }\n\n    /** @nocollapse */\n    public static multiply(left: Int64, right: Int64): Int64 {\n        let rtrn = new Int64(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n\n    /** @nocollapse */\n    public static add(left: Int64, right: Int64): Int64 {\n        let rtrn = new Int64(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n}\n\n/** @ignore */\nexport class Int128 {\n    constructor (private buffer: Uint32Array) {\n        // buffer[3] MSB (high)\n        // buffer[2]\n        // buffer[1]\n        // buffer[0] LSB (low)\n    }\n\n    public high(): Int64 {\n        return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));\n    }\n\n    public low(): Int64 {\n        return new Int64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset, 2));\n    }\n\n    public negate(): Int128 {\n        this.buffer[0] = ~this.buffer[0] + 1;\n        this.buffer[1] = ~this.buffer[1];\n        this.buffer[2] = ~this.buffer[2];\n        this.buffer[3] = ~this.buffer[3];\n\n        if (this.buffer[0] == 0) { ++this.buffer[1]; }\n        if (this.buffer[1] == 0) { ++this.buffer[2]; }\n        if (this.buffer[2] == 0) { ++this.buffer[3]; }\n        return this;\n    }\n\n    public times(other: Int128): Int128 {\n        // Break the left and right numbers into 32 bit chunks\n        // so that we can multiply them without overflow.\n        const L0 = new Uint64(new Uint32Array([this.buffer[3],  0]));\n        const L1 = new Uint64(new Uint32Array([this.buffer[2],  0]));\n        const L2 = new Uint64(new Uint32Array([this.buffer[1],  0]));\n        const L3 = new Uint64(new Uint32Array([this.buffer[0],  0]));\n\n        const R0 = new Uint64(new Uint32Array([other.buffer[3], 0]));\n        const R1 = new Uint64(new Uint32Array([other.buffer[2], 0]));\n        const R2 = new Uint64(new Uint32Array([other.buffer[1], 0]));\n        const R3 = new Uint64(new Uint32Array([other.buffer[0], 0]));\n\n        let product = Uint64.multiply(L3, R3);\n        this.buffer[0] = product.low();\n\n        let sum = new Uint64(new Uint32Array([product.high(), 0]));\n\n        product = Uint64.multiply(L2, R3);\n        sum.plus(product);\n\n        product = Uint64.multiply(L3, R2);\n        sum.plus(product);\n\n        this.buffer[1] = sum.low();\n\n        this.buffer[3] = (sum.lessThan(product) ? 1 : 0);\n\n        this.buffer[2] = sum.high();\n        let high = new Uint64(new Uint32Array(this.buffer.buffer, this.buffer.byteOffset + 8, 2));\n\n        high.plus(Uint64.multiply(L1, R3))\n            .plus(Uint64.multiply(L2, R2))\n            .plus(Uint64.multiply(L3, R1));\n        this.buffer[3] += Uint64.multiply(L0, R3)\n                        .plus(Uint64.multiply(L1, R2))\n                        .plus(Uint64.multiply(L2, R1))\n                        .plus(Uint64.multiply(L3, R0)).low();\n\n        return this;\n    }\n\n    public plus(other: Int128): Int128 {\n        let sums = new Uint32Array(4);\n        sums[3] = (this.buffer[3] + other.buffer[3]) >>> 0;\n        sums[2] = (this.buffer[2] + other.buffer[2]) >>> 0;\n        sums[1] = (this.buffer[1] + other.buffer[1]) >>> 0;\n        sums[0] = (this.buffer[0] + other.buffer[0]) >>> 0;\n\n        if (sums[0] < (this.buffer[0] >>> 0)) {\n            ++sums[1];\n        }\n        if (sums[1] < (this.buffer[1] >>> 0)) {\n            ++sums[2];\n        }\n        if (sums[2] < (this.buffer[2] >>> 0)) {\n            ++sums[3];\n        }\n\n        this.buffer[3] = sums[3];\n        this.buffer[2] = sums[2];\n        this.buffer[1] = sums[1];\n        this.buffer[0] = sums[0];\n\n        return this;\n    }\n\n    public hex(): string {\n        return `${intAsHex(this.buffer[3])} ${intAsHex(this.buffer[2])} ${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;\n    }\n\n    /** @nocollapse */\n    public static multiply(left: Int128, right: Int128): Int128 {\n        let rtrn = new Int128(new Uint32Array(left.buffer));\n        return rtrn.times(right);\n    }\n\n    /** @nocollapse */\n    public static add(left: Int128, right: Int128): Int128 {\n        let rtrn = new Int128(new Uint32Array(left.buffer));\n        return rtrn.plus(right);\n    }\n\n    /** @nocollapse */\n    public static from(val: any, out_buffer = new Uint32Array(4)): Int128 {\n        return Int128.fromString(\n            typeof(val) === 'string' ? val : val.toString(),\n            out_buffer\n        );\n    }\n\n    /** @nocollapse */\n    public static fromNumber(num: number, out_buffer = new Uint32Array(4)): Int128 {\n        // Always parse numbers as strings - pulling out high and low bits\n        // directly seems to lose precision sometimes\n        // For example:\n        //     > -4613034156400212000 >>> 0\n        //     721782784\n        // The correct lower 32-bits are 721782752\n        return Int128.fromString(num.toString(), out_buffer);\n    }\n\n    /** @nocollapse */\n    public static fromString(str: string, out_buffer = new Uint32Array(4)): Int128 {\n        // TODO: Assert that out_buffer is 0 and length = 4\n        const negate = str.startsWith('-');\n        const length = str.length;\n\n        let out = new Int128(out_buffer);\n        for (let posn = negate ? 1 : 0; posn < length;) {\n            const group = kInt32DecimalDigits < length - posn ?\n                          kInt32DecimalDigits : length - posn;\n            const chunk = new Int128(new Uint32Array([parseInt(str.substr(posn, group), 10), 0, 0, 0]));\n            const multiple = new Int128(new Uint32Array([kPowersOfTen[group], 0, 0, 0]));\n\n            out.times(multiple);\n            out.plus(chunk);\n\n            posn += group;\n        }\n\n        return negate ? out.negate() : out;\n    }\n\n    /** @nocollapse */\n    public static convertArray(values: (string|number)[]): Uint32Array {\n        // TODO: Distinguish between string and number at compile-time\n        const data = new Uint32Array(values.length * 4);\n        for (let i = -1, n = values.length; ++i < n;) {\n            Int128.from(values[i], new Uint32Array(data.buffer, data.byteOffset + 4 * 4 * i, 4));\n        }\n        return data;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport * as type from '../type';\nimport { Field } from '../schema';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Visitor } from '../visitor';\nimport { packBools } from '../util/bit';\nimport { encodeUtf8 } from '../util/utf8';\nimport { Int64, Int128 } from '../util/int';\nimport { UnionMode, DateUnit } from '../enum';\nimport { toArrayBufferView } from '../util/buffer';\nimport { BufferRegion, FieldNode } from '../ipc/metadata/message';\n\n/** @ignore */\nexport interface VectorLoader extends Visitor {\n    visit<T extends DataType>(node: Field<T> | T): Data<T>;\n    visitMany<T extends DataType>(nodes: (Field<T> | T)[]): Data<T>[];\n}\n\n/** @ignore */\nexport class VectorLoader extends Visitor {\n    private bytes: Uint8Array;\n    private nodes: FieldNode[];\n    private nodesIndex: number = -1;\n    private buffers: BufferRegion[];\n    private buffersIndex: number = -1;\n    private dictionaries: Map<number, Vector<any>>;\n    constructor(bytes: Uint8Array, nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>) {\n        super();\n        this.bytes = bytes;\n        this.nodes = nodes;\n        this.buffers = buffers;\n        this.dictionaries = dictionaries;\n    }\n\n    public visit<T extends DataType>(node: Field<T> | T): Data<T> {\n        return super.visit(node instanceof Field ? node.type : node);\n    }\n\n    public visitNull            <T extends type.Null>            (type: T, { length,           } = this.nextFieldNode()) { return            Data.Null(type, 0, length);                                                                                                                                 }\n    public visitBool            <T extends type.Bool>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Bool(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitInt             <T extends type.Int>             (type: T, { length, nullCount } = this.nextFieldNode()) { return             Data.Int(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitFloat           <T extends type.Float>           (type: T, { length, nullCount } = this.nextFieldNode()) { return           Data.Float(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitUtf8            <T extends type.Utf8>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Utf8(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.readData(type));                                   }\n    public visitBinary          <T extends type.Binary>          (type: T, { length, nullCount } = this.nextFieldNode()) { return          Data.Binary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.readData(type));                                   }\n    public visitFixedSizeBinary <T extends type.FixedSizeBinary> (type: T, { length, nullCount } = this.nextFieldNode()) { return Data.FixedSizeBinary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitDate            <T extends type.Date_>           (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Date(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitTimestamp       <T extends type.Timestamp>       (type: T, { length, nullCount } = this.nextFieldNode()) { return       Data.Timestamp(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitTime            <T extends type.Time>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.Time(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitDecimal         <T extends type.Decimal>         (type: T, { length, nullCount } = this.nextFieldNode()) { return         Data.Decimal(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitList            <T extends type.List>            (type: T, { length, nullCount } = this.nextFieldNode()) { return            Data.List(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.visit(type.children[0]));                          }\n    public visitStruct          <T extends type.Struct>          (type: T, { length, nullCount } = this.nextFieldNode()) { return          Data.Struct(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.visitMany(type.children));                                                 }\n    public visitUnion           <T extends type.Union>           (type: T                                              ) { return type.mode === UnionMode.Sparse ? this.visitSparseUnion(type as type.SparseUnion) : this.visitDenseUnion(type as type.DenseUnion);                                      }\n    public visitDenseUnion      <T extends type.DenseUnion>      (type: T, { length, nullCount } = this.nextFieldNode()) { return           Data.Union(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readTypeIds(type), this.readOffsets(type), this.visitMany(type.children)); }\n    public visitSparseUnion     <T extends type.SparseUnion>     (type: T, { length, nullCount } = this.nextFieldNode()) { return           Data.Union(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readTypeIds(type), this.visitMany(type.children));                         }\n    public visitDictionary      <T extends type.Dictionary>      (type: T, { length, nullCount } = this.nextFieldNode()) { return      Data.Dictionary(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type.indices), this.readDictionary(type));                        }\n    public visitInterval        <T extends type.Interval>        (type: T, { length, nullCount } = this.nextFieldNode()) { return        Data.Interval(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readData(type));                                                           }\n    public visitFixedSizeList   <T extends type.FixedSizeList>   (type: T, { length, nullCount } = this.nextFieldNode()) { return   Data.FixedSizeList(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.visit(type.children[0]));                                                  }\n    public visitMap             <T extends type.Map_>            (type: T, { length, nullCount } = this.nextFieldNode()) { return             Data.Map(type, 0, length, nullCount, this.readNullBitmap(type, nullCount), this.readOffsets(type), this.visit(type.children[0]));                          }\n\n    protected nextFieldNode() { return this.nodes[++this.nodesIndex]; }\n    protected nextBufferRange() { return this.buffers[++this.buffersIndex]; }\n    protected readNullBitmap<T extends DataType>(type: T, nullCount: number, buffer = this.nextBufferRange()) {\n        return nullCount > 0 && this.readData(type, buffer) || new Uint8Array(0);\n    }\n    protected readOffsets<T extends DataType>(type: T, buffer?: BufferRegion) { return this.readData(type, buffer); }\n    protected readTypeIds<T extends DataType>(type: T, buffer?: BufferRegion) { return this.readData(type, buffer); }\n    protected readData<T extends DataType>(_type: T, { length, offset } = this.nextBufferRange()) {\n        return this.bytes.subarray(offset, offset + length);\n    }\n    protected readDictionary<T extends type.Dictionary>(type: T): Vector<T['dictionary']> {\n        return this.dictionaries.get(type.id)!;\n    }\n}\n\n/** @ignore */\nexport class JSONVectorLoader extends VectorLoader {\n    private sources: any[][];\n    constructor(sources: any[][], nodes: FieldNode[], buffers: BufferRegion[], dictionaries: Map<number, Vector<any>>) {\n        super(new Uint8Array(0), nodes, buffers, dictionaries);\n        this.sources = sources;\n    }\n    protected readNullBitmap<T extends DataType>(_type: T, nullCount: number, { offset } = this.nextBufferRange()) {\n        return nullCount <= 0 ? new Uint8Array(0) : packBools(this.sources[offset]);\n    }\n    protected readOffsets<T extends DataType>(_type: T, { offset } = this.nextBufferRange()) {\n        return toArrayBufferView(Uint8Array, toArrayBufferView(Int32Array, this.sources[offset]));\n    }\n    protected readTypeIds<T extends DataType>(type: T, { offset } = this.nextBufferRange()) {\n        return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, this.sources[offset]));\n    }\n    protected readData<T extends DataType>(type: T, { offset } = this.nextBufferRange()) {\n        const { sources } = this;\n        if (DataType.isTimestamp(type)) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));\n        } else if ((DataType.isInt(type) || DataType.isTime(type)) && type.bitWidth === 64) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));\n        } else if (DataType.isDate(type) && type.unit === DateUnit.MILLISECOND) {\n            return toArrayBufferView(Uint8Array, Int64.convertArray(sources[offset] as string[]));\n        } else if (DataType.isDecimal(type)) {\n            return toArrayBufferView(Uint8Array, Int128.convertArray(sources[offset] as string[]));\n        } else if (DataType.isBinary(type) || DataType.isFixedSizeBinary(type)) {\n            return binaryDataFromJSON(sources[offset] as string[]);\n        } else if (DataType.isBool(type)) {\n            return packBools(sources[offset] as number[]);\n        } else if (DataType.isUtf8(type)) {\n            return encodeUtf8((sources[offset] as string[]).join(''));\n        }\n        return toArrayBufferView(Uint8Array, toArrayBufferView(type.ArrayType, sources[offset].map((x) => +x)));\n    }\n}\n\n/** @ignore */\nfunction binaryDataFromJSON(values: string[]) {\n    // \"DATA\": [\"49BC7D5B6C47D2\",\"3F5FB6D9322026\"]\n    // There are definitely more efficient ways to do this... but it gets the\n    // job done.\n    const joined = values.join('');\n    const data = new Uint8Array(joined.length / 2);\n    for (let i = 0; i < joined.length; i += 2) {\n        data[i >> 1] = parseInt(joined.substr(i, 2), 16);\n    }\n    return data;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { flatbuffers } from 'flatbuffers';\nimport Long = flatbuffers.Long;\nimport Builder = flatbuffers.Builder;\nimport * as Schema_ from '../fb/Schema';\n\nimport * as type from '../type';\nimport { Visitor } from '../visitor';\n\nimport Null = Schema_.org.apache.arrow.flatbuf.Null;\nimport Int = Schema_.org.apache.arrow.flatbuf.Int;\nimport FloatingPoint = Schema_.org.apache.arrow.flatbuf.FloatingPoint;\nimport Binary = Schema_.org.apache.arrow.flatbuf.Binary;\nimport Bool = Schema_.org.apache.arrow.flatbuf.Bool;\nimport Utf8 = Schema_.org.apache.arrow.flatbuf.Utf8;\nimport Decimal = Schema_.org.apache.arrow.flatbuf.Decimal;\nimport Date = Schema_.org.apache.arrow.flatbuf.Date;\nimport Time = Schema_.org.apache.arrow.flatbuf.Time;\nimport Timestamp = Schema_.org.apache.arrow.flatbuf.Timestamp;\nimport Interval = Schema_.org.apache.arrow.flatbuf.Interval;\nimport List = Schema_.org.apache.arrow.flatbuf.List;\nimport Struct = Schema_.org.apache.arrow.flatbuf.Struct_;\nimport Union = Schema_.org.apache.arrow.flatbuf.Union;\nimport DictionaryEncoding = Schema_.org.apache.arrow.flatbuf.DictionaryEncoding;\nimport FixedSizeBinary = Schema_.org.apache.arrow.flatbuf.FixedSizeBinary;\nimport FixedSizeList = Schema_.org.apache.arrow.flatbuf.FixedSizeList;\nimport Map_ = Schema_.org.apache.arrow.flatbuf.Map;\n\n/** @ignore */\nexport interface TypeAssembler extends Visitor {\n    visit<T extends type.DataType>(node: T, builder: Builder): number | undefined;\n}\n\n/** @ignore */\nexport class TypeAssembler extends Visitor {\n    public visit<T extends type.DataType>(node: T, builder: Builder): number | undefined {\n        return (node == null || builder == null) ? undefined : super.visit(node, builder);\n    }\n    public visitNull<T extends type.Null>(_node: T, b: Builder) {\n        Null.startNull(b);\n        return Null.endNull(b);\n    }\n    public visitInt<T extends type.Int>(node: T, b: Builder) {\n        Int.startInt(b);\n        Int.addBitWidth(b, node.bitWidth);\n        Int.addIsSigned(b, node.isSigned);\n        return Int.endInt(b);\n    }\n    public visitFloat<T extends type.Float>(node: T, b: Builder) {\n        FloatingPoint.startFloatingPoint(b);\n        FloatingPoint.addPrecision(b, node.precision);\n        return FloatingPoint.endFloatingPoint(b);\n    }\n    public visitBinary<T extends type.Binary>(_node: T, b: Builder) {\n        Binary.startBinary(b);\n        return Binary.endBinary(b);\n    }\n    public visitBool<T extends type.Bool>(_node: T, b: Builder) {\n        Bool.startBool(b);\n        return Bool.endBool(b);\n    }\n    public visitUtf8<T extends type.Utf8>(_node: T, b: Builder) {\n        Utf8.startUtf8(b);\n        return Utf8.endUtf8(b);\n    }\n    public visitDecimal<T extends type.Decimal>(node: T, b: Builder) {\n        Decimal.startDecimal(b);\n        Decimal.addScale(b, node.scale);\n        Decimal.addPrecision(b, node.precision);\n        return Decimal.endDecimal(b);\n    }\n    public visitDate<T extends type.Date_>(node: T, b: Builder) {\n        Date.startDate(b);\n        Date.addUnit(b, node.unit);\n        return Date.endDate(b);\n    }\n    public visitTime<T extends type.Time>(node: T, b: Builder) {\n        Time.startTime(b);\n        Time.addUnit(b, node.unit);\n        Time.addBitWidth(b, node.bitWidth);\n        return Time.endTime(b);\n    }\n    public visitTimestamp<T extends type.Timestamp>(node: T, b: Builder) {\n        const timezone = (node.timezone && b.createString(node.timezone)) || undefined;\n        Timestamp.startTimestamp(b);\n        Timestamp.addUnit(b, node.unit);\n        if (timezone !== undefined) {\n            Timestamp.addTimezone(b, timezone);\n        }\n        return Timestamp.endTimestamp(b);\n    }\n    public visitInterval<T extends type.Interval>(node: T, b: Builder) {\n        Interval.startInterval(b);\n        Interval.addUnit(b, node.unit);\n        return Interval.endInterval(b);\n    }\n    public visitList<T extends type.List>(_node: T, b: Builder) {\n        List.startList(b);\n        return List.endList(b);\n    }\n    public visitStruct<T extends type.Struct>(_node: T, b: Builder) {\n        Struct.startStruct_(b);\n        return Struct.endStruct_(b);\n    }\n    public visitUnion<T extends type.Union>(node: T, b: Builder) {\n        Union.startTypeIdsVector(b, node.typeIds.length);\n        const typeIds = Union.createTypeIdsVector(b, node.typeIds);\n        Union.startUnion(b);\n        Union.addMode(b, node.mode);\n        Union.addTypeIds(b, typeIds);\n        return Union.endUnion(b);\n    }\n    public visitDictionary<T extends type.Dictionary>(node: T, b: Builder) {\n        const indexType = this.visit(node.indices, b);\n        DictionaryEncoding.startDictionaryEncoding(b);\n        DictionaryEncoding.addId(b, new Long(node.id, 0));\n        DictionaryEncoding.addIsOrdered(b, node.isOrdered);\n        if (indexType !== undefined) {\n            DictionaryEncoding.addIndexType(b, indexType);\n        }\n        return DictionaryEncoding.endDictionaryEncoding(b);\n    }\n    public visitFixedSizeBinary<T extends type.FixedSizeBinary>(node: T, b: Builder) {\n        FixedSizeBinary.startFixedSizeBinary(b);\n        FixedSizeBinary.addByteWidth(b, node.byteWidth);\n        return FixedSizeBinary.endFixedSizeBinary(b);\n    }\n    public visitFixedSizeList<T extends type.FixedSizeList>(node: T, b: Builder) {\n        FixedSizeList.startFixedSizeList(b);\n        FixedSizeList.addListSize(b, node.listSize);\n        return FixedSizeList.endFixedSizeList(b);\n    }\n    public visitMap<T extends type.Map_>(node: T, b: Builder) {\n        Map_.startMap(b);\n        Map_.addKeysSorted(b, node.keysSorted);\n        return Map_.endMap(b);\n    }\n}\n\n/** @ignore */\nexport const instance = new TypeAssembler();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Schema, Field } from '../../schema';\nimport {\n    DataType, Dictionary, TimeBitWidth,\n    Utf8, Binary, Decimal, FixedSizeBinary,\n    List, FixedSizeList, Map_, Struct, Union,\n    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys,\n} from '../../type';\n\nimport { DictionaryBatch, RecordBatch, FieldNode, BufferRegion } from './message';\nimport { TimeUnit, Precision, IntervalUnit, UnionMode, DateUnit } from '../../enum';\n\n/** @ignore */\nexport function schemaFromJSON(_schema: any, dictionaries: Map<number, DataType> = new Map()) {\n    return new Schema(\n        schemaFieldsFromJSON(_schema, dictionaries),\n        customMetadataFromJSON(_schema['customMetadata']),\n        dictionaries\n    );\n}\n\n/** @ignore */\nexport function recordBatchFromJSON(b: any) {\n    return new RecordBatch(\n        b['count'],\n        fieldNodesFromJSON(b['columns']),\n        buffersFromJSON(b['columns'])\n    );\n}\n\n/** @ignore */\nexport function dictionaryBatchFromJSON(b: any) {\n    return new DictionaryBatch(\n        recordBatchFromJSON(b['data']),\n        b['id'], b['isDelta']\n    );\n}\n\n/** @ignore */\nfunction schemaFieldsFromJSON(_schema: any, dictionaries?: Map<number, DataType>) {\n    return (_schema['fields'] || []).filter(Boolean).map((f: any) => Field.fromJSON(f, dictionaries));\n}\n\n/** @ignore */\nfunction fieldChildrenFromJSON(_field: any, dictionaries?: Map<number, DataType>): Field[] {\n    return (_field['children'] || []).filter(Boolean).map((f: any) => Field.fromJSON(f, dictionaries));\n}\n\n/** @ignore */\nfunction fieldNodesFromJSON(xs: any[]): FieldNode[] {\n    return (xs || []).reduce<FieldNode[]>((fieldNodes, column: any) => [\n        ...fieldNodes,\n        new FieldNode(\n            column['count'],\n            nullCountFromJSON(column['VALIDITY'])\n        ),\n        ...fieldNodesFromJSON(column['children'])\n    ], [] as FieldNode[]);\n}\n\n/** @ignore */\nfunction buffersFromJSON(xs: any[], buffers: BufferRegion[] = []): BufferRegion[] {\n    for (let i = -1, n = (xs || []).length; ++i < n;) {\n        const column = xs[i];\n        column['VALIDITY'] && buffers.push(new BufferRegion(buffers.length, column['VALIDITY'].length));\n        column['TYPE'] && buffers.push(new BufferRegion(buffers.length, column['TYPE'].length));\n        column['OFFSET'] && buffers.push(new BufferRegion(buffers.length, column['OFFSET'].length));\n        column['DATA'] && buffers.push(new BufferRegion(buffers.length, column['DATA'].length));\n        buffers = buffersFromJSON(column['children'], buffers);\n    }\n    return buffers;\n}\n\n/** @ignore */\nfunction nullCountFromJSON(validity: number[]) {\n    return (validity || []).reduce((sum, val) => sum + +(val === 0), 0);\n}\n\n/** @ignore */\nexport function fieldFromJSON(_field: any, dictionaries?: Map<number, DataType>) {\n\n    let id: number;\n    let keys: TKeys | null;\n    let field: Field | void;\n    let dictMeta: any;\n    let type: DataType<any>;\n    let dictType: Dictionary;\n\n    // If no dictionary encoding\n    if (!dictionaries || !(dictMeta = _field['dictionary'])) {\n        type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries));\n        field = new Field(_field['name'], type, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));\n    }\n    // tslint:disable\n    // If dictionary encoded and the first time we've seen this dictionary id, decode\n    // the data type and child fields, then wrap in a Dictionary type and insert the\n    // data type into the dictionary types map.\n    else if (!dictionaries.has(id = dictMeta['id'])) {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta['indexType']) ? indexTypeFromJSON(keys) as TKeys : new Int32();\n        dictionaries.set(id, type = typeFromJSON(_field, fieldChildrenFromJSON(_field, dictionaries)));\n        dictType = new Dictionary(type, keys, id, dictMeta['isOrdered']);\n        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));\n    }\n    // If dictionary encoded, and have already seen this dictionary Id in the schema, then reuse the\n    // data type and wrap in a new Dictionary type and field.\n    else {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta['indexType']) ? indexTypeFromJSON(keys) as TKeys : new Int32();\n        dictType = new Dictionary(dictionaries.get(id)!, keys, id, dictMeta['isOrdered']);\n        field = new Field(_field['name'], dictType, _field['nullable'], customMetadataFromJSON(_field['customMetadata']));\n    }\n    return field || null;\n}\n\n/** @ignore */\nfunction customMetadataFromJSON(_metadata?: object) {\n    return new Map<string, string>(Object.entries(_metadata || {}));\n}\n\n/** @ignore */\nfunction indexTypeFromJSON(_type: any) {\n    return new Int(_type['isSigned'], _type['bitWidth']);\n}\n\n/** @ignore */\nfunction typeFromJSON(f: any, children?: Field[]): DataType<any> {\n\n    const typeId = f['type']['name'];\n\n    switch (typeId) {\n        case 'NONE':   return new Null();\n        case 'null':   return new Null();\n        case 'binary': return new Binary();\n        case 'utf8':   return new Utf8();\n        case 'bool':   return new Bool();\n        case 'list':   return new List((children || [])[0]);\n        case 'struct': return new Struct(children || []);\n        case 'struct_': return new Struct(children || []);\n    }\n\n    switch (typeId) {\n        case 'int': {\n            const t = f['type'];\n            return new Int(t['isSigned'], t['bitWidth'] as IntBitWidth);\n        }\n        case 'floatingpoint': {\n            const t = f['type'];\n            return new Float(Precision[t['precision']] as any);\n        }\n        case 'decimal': {\n            const t = f['type'];\n            return new Decimal(t['scale'], t['precision']);\n        }\n        case 'date': {\n            const t = f['type'];\n            return new Date_(DateUnit[t['unit']] as any);\n        }\n        case 'time': {\n            const t = f['type'];\n            return new Time(TimeUnit[t['unit']] as any, t['bitWidth'] as TimeBitWidth);\n        }\n        case 'timestamp': {\n            const t = f['type'];\n            return new Timestamp(TimeUnit[t['unit']] as any, t['timezone']);\n        }\n        case 'interval': {\n            const t = f['type'];\n            return new Interval(IntervalUnit[t['unit']] as any);\n        }\n        case 'union': {\n            const t = f['type'];\n            return new Union(UnionMode[t['mode']] as any, (t['typeIds'] || []), children || []);\n        }\n        case 'fixedsizebinary': {\n            const t = f['type'];\n            return new FixedSizeBinary(t['byteWidth']);\n        }\n        case 'fixedsizelist': {\n            const t = f['type'];\n            return new FixedSizeList(t['listSize'], (children || [])[0]);\n        }\n        case 'map': {\n            const t = f['type'];\n            return new Map_((children || [])[0], t['keysSorted']);\n        }\n    }\n    throw new Error(`Unrecognized type: \"${typeId}\"`);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { flatbuffers } from 'flatbuffers';\nimport * as Schema_ from '../../fb/Schema';\nimport * as Message_ from '../../fb/Message';\n\nimport { Schema, Field } from '../../schema';\nimport { toUint8Array } from '../../util/buffer';\nimport { ArrayBufferViewInput } from '../../util/buffer';\nimport { MessageHeader, MetadataVersion } from '../../enum';\nimport { instance as typeAssembler } from '../../visitor/typeassembler';\nimport { fieldFromJSON, schemaFromJSON, recordBatchFromJSON, dictionaryBatchFromJSON } from './json';\n\nimport Long = flatbuffers.Long;\nimport Builder = flatbuffers.Builder;\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport _Int = Schema_.org.apache.arrow.flatbuf.Int;\nimport Type = Schema_.org.apache.arrow.flatbuf.Type;\nimport _Field = Schema_.org.apache.arrow.flatbuf.Field;\nimport _Schema = Schema_.org.apache.arrow.flatbuf.Schema;\nimport _Buffer = Schema_.org.apache.arrow.flatbuf.Buffer;\nimport _Message = Message_.org.apache.arrow.flatbuf.Message;\nimport _KeyValue = Schema_.org.apache.arrow.flatbuf.KeyValue;\nimport _FieldNode = Message_.org.apache.arrow.flatbuf.FieldNode;\nimport _Endianness = Schema_.org.apache.arrow.flatbuf.Endianness;\nimport _RecordBatch = Message_.org.apache.arrow.flatbuf.RecordBatch;\nimport _DictionaryBatch = Message_.org.apache.arrow.flatbuf.DictionaryBatch;\nimport _DictionaryEncoding = Schema_.org.apache.arrow.flatbuf.DictionaryEncoding;\n\nimport {\n    DataType, Dictionary, TimeBitWidth,\n    Utf8, Binary, Decimal, FixedSizeBinary,\n    List, FixedSizeList, Map_, Struct, Union,\n    Bool, Null, Int, Float, Date_, Time, Interval, Timestamp, IntBitWidth, Int32, TKeys,\n} from '../../type';\n\n/**\n * @ignore\n * @private\n **/\nexport class Message<T extends MessageHeader = any> {\n\n    /** @nocollapse */\n    public static fromJSON<T extends MessageHeader>(msg: any, headerType: T): Message<T> {\n        const message = new Message(0, MetadataVersion.V4, headerType);\n        message._createHeader = messageHeaderFromJSON(msg, headerType);\n        return message;\n    }\n\n    /** @nocollapse */\n    public static decode(buf: ArrayBufferViewInput) {\n        buf = new ByteBuffer(toUint8Array(buf));\n        const _message = _Message.getRootAsMessage(buf);\n        const bodyLength: Long = _message.bodyLength()!;\n        const version: MetadataVersion = _message.version();\n        const headerType: MessageHeader = _message.headerType();\n        const message = new Message(bodyLength, version, headerType);\n        message._createHeader = decodeMessageHeader(_message, headerType);\n        return message;\n    }\n\n    /** @nocollapse */\n    public static encode<T extends MessageHeader>(message: Message<T>) {\n        let b = new Builder(), headerOffset = -1;\n        if (message.isSchema()) {\n            headerOffset = Schema.encode(b, message.header() as Schema);\n        } else if (message.isRecordBatch()) {\n            headerOffset = RecordBatch.encode(b, message.header() as RecordBatch);\n        } else if (message.isDictionaryBatch()) {\n            headerOffset = DictionaryBatch.encode(b, message.header() as DictionaryBatch);\n        }\n        _Message.startMessage(b);\n        _Message.addVersion(b, MetadataVersion.V4);\n        _Message.addHeader(b, headerOffset);\n        _Message.addHeaderType(b, message.headerType);\n        _Message.addBodyLength(b, new Long(message.bodyLength, 0));\n        _Message.finishMessageBuffer(b, _Message.endMessage(b));\n        return b.asUint8Array();\n    }\n\n    /** @nocollapse */\n    public static from(header: Schema | RecordBatch | DictionaryBatch, bodyLength = 0) {\n        if (header instanceof Schema) {\n            return new Message(0, MetadataVersion.V4, MessageHeader.Schema, header);\n        }\n        if (header instanceof RecordBatch) {\n            return new Message(bodyLength, MetadataVersion.V4, MessageHeader.RecordBatch, header);\n        }\n        if (header instanceof DictionaryBatch) {\n            return new Message(bodyLength, MetadataVersion.V4, MessageHeader.DictionaryBatch, header);\n        }\n        throw new Error(`Unrecognized Message header: ${header}`);\n    }\n\n    // @ts-ignore\n    public body: Uint8Array;\n    protected _headerType: T;\n    protected _bodyLength: number;\n    protected _version: MetadataVersion;\n    public get type() { return this.headerType; }\n    public get version() { return this._version; }\n    public get headerType() { return this._headerType; }\n    public get bodyLength() { return this._bodyLength; }\n    // @ts-ignore\n    protected _createHeader: MessageHeaderDecoder;\n    public header() { return this._createHeader<T>(); }\n    public isSchema(): this is Message<MessageHeader.Schema> { return this.headerType === MessageHeader.Schema; }\n    public isRecordBatch(): this is Message<MessageHeader.RecordBatch> { return this.headerType === MessageHeader.RecordBatch; }\n    public isDictionaryBatch(): this is Message<MessageHeader.DictionaryBatch> { return this.headerType === MessageHeader.DictionaryBatch; }\n\n    constructor(bodyLength: Long | number, version: MetadataVersion, headerType: T, header?: any) {\n        this._version = version;\n        this._headerType = headerType;\n        this.body = new Uint8Array(0);\n        header && (this._createHeader = () => header);\n        this._bodyLength = typeof bodyLength === 'number' ? bodyLength : bodyLength.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class RecordBatch {\n    protected _length: number;\n    protected _nodes: FieldNode[];\n    protected _buffers: BufferRegion[];\n    public get nodes() { return this._nodes; }\n    public get length() { return this._length; }\n    public get buffers() { return this._buffers; }\n    constructor(length: Long | number, nodes: FieldNode[], buffers: BufferRegion[]) {\n        this._nodes = nodes;\n        this._buffers = buffers;\n        this._length = typeof length === 'number' ? length : length.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class DictionaryBatch {\n\n    protected _id: number;\n    protected _isDelta: boolean;\n    protected _data: RecordBatch;\n    public get id() { return this._id; }\n    public get data() { return this._data; }\n    public get isDelta() { return this._isDelta; }\n    public get length(): number { return this.data.length; }\n    public get nodes(): FieldNode[] { return this.data.nodes; }\n    public get buffers(): BufferRegion[] { return this.data.buffers; }\n\n    constructor(data: RecordBatch, id: Long | number, isDelta: boolean = false) {\n        this._data = data;\n        this._isDelta = isDelta;\n        this._id = typeof id === 'number' ? id : id.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class BufferRegion {\n    public offset: number;\n    public length: number;\n    constructor(offset: Long | number, length: Long | number) {\n        this.offset = typeof offset === 'number' ? offset : offset.low;\n        this.length = typeof length === 'number' ? length : length.low;\n    }\n}\n\n/**\n * @ignore\n * @private\n **/\nexport class FieldNode {\n    public length: number;\n    public nullCount: number;\n    constructor(length: Long | number, nullCount: Long | number) {\n        this.length = typeof length === 'number' ? length : length.low;\n        this.nullCount = typeof nullCount === 'number' ? nullCount : nullCount.low;\n    }\n}\n\n/** @ignore */\nfunction messageHeaderFromJSON(message: any, type: MessageHeader) {\n    return (() => {\n        switch (type) {\n            case MessageHeader.Schema: return Schema.fromJSON(message);\n            case MessageHeader.RecordBatch: return RecordBatch.fromJSON(message);\n            case MessageHeader.DictionaryBatch: return DictionaryBatch.fromJSON(message);\n        }\n        throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);\n    }) as MessageHeaderDecoder;\n}\n\n/** @ignore */\nfunction decodeMessageHeader(message: _Message, type: MessageHeader) {\n    return (() => {\n        switch (type) {\n            case MessageHeader.Schema: return Schema.decode(message.header(new _Schema())!);\n            case MessageHeader.RecordBatch: return RecordBatch.decode(message.header(new _RecordBatch())!, message.version());\n            case MessageHeader.DictionaryBatch: return DictionaryBatch.decode(message.header(new _DictionaryBatch())!, message.version());\n        }\n        throw new Error(`Unrecognized Message type: { name: ${MessageHeader[type]}, type: ${type} }`);\n    }) as MessageHeaderDecoder;\n}\n\nField['encode'] = encodeField;\nField['decode'] = decodeField;\nField['fromJSON'] = fieldFromJSON;\n\nSchema['encode'] = encodeSchema;\nSchema['decode'] = decodeSchema;\nSchema['fromJSON'] = schemaFromJSON;\n\nRecordBatch['encode'] = encodeRecordBatch;\nRecordBatch['decode'] = decodeRecordBatch;\nRecordBatch['fromJSON'] = recordBatchFromJSON;\n\nDictionaryBatch['encode'] = encodeDictionaryBatch;\nDictionaryBatch['decode'] = decodeDictionaryBatch;\nDictionaryBatch['fromJSON'] = dictionaryBatchFromJSON;\n\nFieldNode['encode'] = encodeFieldNode;\nFieldNode['decode'] = decodeFieldNode;\n\nBufferRegion['encode'] = encodeBufferRegion;\nBufferRegion['decode'] = decodeBufferRegion;\n\ndeclare module '../../schema' {\n    namespace Field {\n        export { encodeField as encode };\n        export { decodeField as decode };\n        export { fieldFromJSON as fromJSON };\n    }\n    namespace Schema {\n        export { encodeSchema as encode };\n        export { decodeSchema as decode };\n        export { schemaFromJSON as fromJSON };\n    }\n}\n\ndeclare module './message' {\n    namespace RecordBatch {\n        export { encodeRecordBatch as encode };\n        export { decodeRecordBatch as decode };\n        export { recordBatchFromJSON as fromJSON };\n    }\n    namespace DictionaryBatch {\n        export { encodeDictionaryBatch as encode };\n        export { decodeDictionaryBatch as decode };\n        export { dictionaryBatchFromJSON as fromJSON };\n    }\n    namespace FieldNode {\n        export { encodeFieldNode as encode };\n        export { decodeFieldNode as decode };\n    }\n    namespace BufferRegion {\n        export { encodeBufferRegion as encode };\n        export { decodeBufferRegion as decode };\n    }\n}\n\n/** @ignore */\nfunction decodeSchema(_schema: _Schema, dictionaries: Map<number, DataType> = new Map()) {\n    const fields = decodeSchemaFields(_schema, dictionaries);\n    return new Schema(fields, decodeCustomMetadata(_schema), dictionaries);\n}\n\n/** @ignore */\nfunction decodeRecordBatch(batch: _RecordBatch, version = MetadataVersion.V4) {\n    return new RecordBatch(batch.length(), decodeFieldNodes(batch), decodeBuffers(batch, version));\n}\n\n/** @ignore */\nfunction decodeDictionaryBatch(batch: _DictionaryBatch, version = MetadataVersion.V4) {\n    return new DictionaryBatch(RecordBatch.decode(batch.data()!, version), batch.id(), batch.isDelta());\n}\n\n/** @ignore */\nfunction decodeBufferRegion(b: _Buffer) {\n    return new BufferRegion(b.offset(), b.length());\n}\n\n/** @ignore */\nfunction decodeFieldNode(f: _FieldNode) {\n    return new FieldNode(f.length(), f.nullCount());\n}\n\n/** @ignore */\nfunction decodeFieldNodes(batch: _RecordBatch) {\n    const nodes = [] as FieldNode[];\n    for (let f, i = -1, j = -1, n = batch.nodesLength(); ++i < n;) {\n        if (f = batch.nodes(i)) {\n            nodes[++j] = FieldNode.decode(f);\n        }\n    }\n    return nodes;\n}\n\n/** @ignore */\nfunction decodeBuffers(batch: _RecordBatch, version: MetadataVersion) {\n    const bufferRegions = [] as BufferRegion[];\n    for (let b, i = -1, j = -1, n = batch.buffersLength(); ++i < n;) {\n        if (b = batch.buffers(i)) {\n        // If this Arrow buffer was written before version 4,\n        // advance the buffer's bb_pos 8 bytes to skip past\n        // the now-removed page_id field\n        if (version < MetadataVersion.V4) {\n                b.bb_pos += (8 * (i + 1));\n            }\n            bufferRegions[++j] = BufferRegion.decode(b);\n        }\n    }\n    return bufferRegions;\n}\n\n/** @ignore */\nfunction decodeSchemaFields(schema: _Schema, dictionaries?: Map<number, DataType>) {\n    const fields = [] as Field[];\n    for (let f, i = -1, j = -1, n = schema.fieldsLength(); ++i < n;) {\n        if (f = schema.fields(i)) {\n            fields[++j] = Field.decode(f, dictionaries);\n        }\n    }\n    return fields;\n}\n\n/** @ignore */\nfunction decodeFieldChildren(field: _Field, dictionaries?: Map<number, DataType>): Field[] {\n    const children = [] as Field[];\n    for (let f, i = -1, j = -1, n = field.childrenLength(); ++i < n;) {\n        if (f = field.children(i)) {\n            children[++j] = Field.decode(f, dictionaries);\n        }\n    }\n    return children;\n}\n\n/** @ignore */\nfunction decodeField(f: _Field, dictionaries?: Map<number, DataType>) {\n\n    let id: number;\n    let field: Field | void;\n    let type: DataType<any>;\n    let keys: _Int | TKeys | null;\n    let dictType: Dictionary;\n    let dictMeta: _DictionaryEncoding | null;\n\n    // If no dictionary encoding\n    if (!dictionaries || !(dictMeta = f.dictionary())) {\n        type = decodeFieldType(f, decodeFieldChildren(f, dictionaries));\n        field = new Field(f.name()!, type, f.nullable(), decodeCustomMetadata(f));\n    }\n    // tslint:disable\n    // If dictionary encoded and the first time we've seen this dictionary id, decode\n    // the data type and child fields, then wrap in a Dictionary type and insert the\n    // data type into the dictionary types map.\n    else if (!dictionaries.has(id = dictMeta.id().low)) {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta.indexType()) ? decodeIndexType(keys) as TKeys : new Int32();\n        dictionaries.set(id, type = decodeFieldType(f, decodeFieldChildren(f, dictionaries)));\n        dictType = new Dictionary(type, keys, id, dictMeta.isOrdered());\n        field = new Field(f.name()!, dictType, f.nullable(), decodeCustomMetadata(f));\n    }\n    // If dictionary encoded, and have already seen this dictionary Id in the schema, then reuse the\n    // data type and wrap in a new Dictionary type and field.\n    else {\n        // a dictionary index defaults to signed 32 bit int if unspecified\n        keys = (keys = dictMeta.indexType()) ? decodeIndexType(keys) as TKeys : new Int32();\n        dictType = new Dictionary(dictionaries.get(id)!, keys, id, dictMeta.isOrdered());\n        field = new Field(f.name()!, dictType, f.nullable(), decodeCustomMetadata(f));\n    }\n    return field || null;\n}\n\n/** @ignore */\nfunction decodeCustomMetadata(parent?: _Schema | _Field | null) {\n    const data = new Map<string, string>();\n    if (parent) {\n        for (let entry, key, i = -1, n = parent.customMetadataLength() | 0; ++i < n;) {\n            if ((entry = parent.customMetadata(i)) && (key = entry.key()) != null) {\n                data.set(key, entry.value()!);\n            }\n        }\n    }\n    return data;\n}\n\n/** @ignore */\nfunction decodeIndexType(_type: _Int) {\n    return new Int(_type.isSigned(), _type.bitWidth() as IntBitWidth);\n}\n\n/** @ignore */\nfunction decodeFieldType(f: _Field, children?: Field[]): DataType<any> {\n\n    const typeId = f.typeType();\n\n    switch (typeId) {\n        case Type.NONE:    return new Null();\n        case Type.Null:    return new Null();\n        case Type.Binary:  return new Binary();\n        case Type.Utf8:    return new Utf8();\n        case Type.Bool:    return new Bool();\n        case Type.List:    return new List((children || [])[0]);\n        case Type.Struct_: return new Struct(children || []);\n    }\n\n    switch (typeId) {\n        case Type.Int: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Int())!;\n            return new Int(t.isSigned(), t.bitWidth());\n        }\n        case Type.FloatingPoint: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.FloatingPoint())!;\n            return new Float(t.precision());\n        }\n        case Type.Decimal: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Decimal())!;\n            return new Decimal(t.scale(), t.precision());\n        }\n        case Type.Date: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Date())!;\n            return new Date_(t.unit());\n        }\n        case Type.Time: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Time())!;\n            return new Time(t.unit(), t.bitWidth() as TimeBitWidth);\n        }\n        case Type.Timestamp: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Timestamp())!;\n            return new Timestamp(t.unit(), t.timezone());\n        }\n        case Type.Interval: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Interval())!;\n            return new Interval(t.unit());\n        }\n        case Type.Union: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Union())!;\n            return new Union(t.mode(), t.typeIdsArray() || [], children || []);\n        }\n        case Type.FixedSizeBinary: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.FixedSizeBinary())!;\n            return new FixedSizeBinary(t.byteWidth());\n        }\n        case Type.FixedSizeList: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.FixedSizeList())!;\n            return new FixedSizeList(t.listSize(), (children || [])[0]);\n        }\n        case Type.Map: {\n            const t = f.type(new Schema_.org.apache.arrow.flatbuf.Map())!;\n            return new Map_((children || [])[0], t.keysSorted());\n        }\n    }\n    throw new Error(`Unrecognized type: \"${Type[typeId]}\" (${typeId})`);\n}\n\n/** @ignore */\nfunction encodeSchema(b: Builder, schema: Schema) {\n\n    const fieldOffsets = schema.fields.map((f) => Field.encode(b, f));\n\n    _Schema.startFieldsVector(b, fieldOffsets.length);\n\n    const fieldsVectorOffset = _Schema.createFieldsVector(b, fieldOffsets);\n\n    const metadataOffset = !(schema.metadata && schema.metadata.size > 0) ? -1 :\n        _Schema.createCustomMetadataVector(b, [...schema.metadata].map(([k, v]) => {\n            const key = b.createString(`${k}`);\n            const val = b.createString(`${v}`);\n            _KeyValue.startKeyValue(b);\n            _KeyValue.addKey(b, key);\n            _KeyValue.addValue(b, val);\n            return _KeyValue.endKeyValue(b);\n        }));\n\n    _Schema.startSchema(b);\n    _Schema.addFields(b, fieldsVectorOffset);\n    _Schema.addEndianness(b, platformIsLittleEndian ? _Endianness.Little : _Endianness.Big);\n\n    if (metadataOffset !== -1) { _Schema.addCustomMetadata(b, metadataOffset); }\n\n    return _Schema.endSchema(b);\n}\n\n/** @ignore */\nfunction encodeField(b: Builder, field: Field) {\n\n    let nameOffset = -1;\n    let typeOffset = -1;\n    let dictionaryOffset = -1;\n\n    let type = field.type;\n    let typeId: Type = <any> field.typeId;\n\n    if (!DataType.isDictionary(type)) {\n        typeOffset = typeAssembler.visit(type, b)!;\n    } else {\n        typeId = type.dictionary.typeId;\n        dictionaryOffset = typeAssembler.visit(type, b)!;\n        typeOffset = typeAssembler.visit(type.dictionary, b)!;\n    }\n\n    const childOffsets = (type.children || []).map((f: Field) => Field.encode(b, f));\n    const childrenVectorOffset = _Field.createChildrenVector(b, childOffsets);\n\n    const metadataOffset = !(field.metadata && field.metadata.size > 0) ? -1 :\n        _Field.createCustomMetadataVector(b, [...field.metadata].map(([k, v]) => {\n            const key = b.createString(`${k}`);\n            const val = b.createString(`${v}`);\n            _KeyValue.startKeyValue(b);\n            _KeyValue.addKey(b, key);\n            _KeyValue.addValue(b, val);\n            return _KeyValue.endKeyValue(b);\n        }));\n\n    if (field.name) {\n        nameOffset = b.createString(field.name);\n    }\n\n    _Field.startField(b);\n    _Field.addType(b, typeOffset);\n    _Field.addTypeType(b, typeId);\n    _Field.addChildren(b, childrenVectorOffset);\n    _Field.addNullable(b, !!field.nullable);\n\n    if (nameOffset !== -1) { _Field.addName(b, nameOffset); }\n    if (dictionaryOffset !== -1) { _Field.addDictionary(b, dictionaryOffset); }\n    if (metadataOffset !== -1) { _Field.addCustomMetadata(b, metadataOffset); }\n\n    return _Field.endField(b);\n}\n\n/** @ignore */\nfunction encodeRecordBatch(b: Builder, recordBatch: RecordBatch) {\n\n    const nodes = recordBatch.nodes || [];\n    const buffers = recordBatch.buffers || [];\n\n    _RecordBatch.startNodesVector(b, nodes.length);\n    nodes.slice().reverse().forEach((n) => FieldNode.encode(b, n));\n\n    const nodesVectorOffset = b.endVector();\n\n    _RecordBatch.startBuffersVector(b, buffers.length);\n    buffers.slice().reverse().forEach((b_) => BufferRegion.encode(b, b_));\n\n    const buffersVectorOffset = b.endVector();\n\n    _RecordBatch.startRecordBatch(b);\n    _RecordBatch.addLength(b, new Long(recordBatch.length, 0));\n    _RecordBatch.addNodes(b, nodesVectorOffset);\n    _RecordBatch.addBuffers(b, buffersVectorOffset);\n    return _RecordBatch.endRecordBatch(b);\n}\n\n/** @ignore */\nfunction encodeDictionaryBatch(b: Builder, dictionaryBatch: DictionaryBatch) {\n    const dataOffset = RecordBatch.encode(b, dictionaryBatch.data);\n    _DictionaryBatch.startDictionaryBatch(b);\n    _DictionaryBatch.addId(b, new Long(dictionaryBatch.id, 0));\n    _DictionaryBatch.addIsDelta(b, dictionaryBatch.isDelta);\n    _DictionaryBatch.addData(b, dataOffset);\n    return _DictionaryBatch.endDictionaryBatch(b);\n}\n\n/** @ignore */\nfunction encodeFieldNode(b: Builder, node: FieldNode) {\n    return _FieldNode.createFieldNode(b, new Long(node.length, 0), new Long(node.nullCount, 0));\n}\n\n/** @ignore */\nfunction encodeBufferRegion(b: Builder, node: BufferRegion) {\n    return _Buffer.createBuffer(b, new Long(node.offset, 0), new Long(node.length, 0));\n}\n\n/** @ignore */\nconst platformIsLittleEndian = (function() {\n    const buffer = new ArrayBuffer(2);\n    new DataView(buffer).setInt16(0, 256, true /* littleEndian */);\n    // Int16Array uses the platform's endianness.\n    return new Int16Array(buffer)[0] === 256;\n})();\n\n/** @ignore */\ntype MessageHeaderDecoder = <T extends MessageHeader>() => T extends MessageHeader.Schema ? Schema\n                                                         : T extends MessageHeader.RecordBatch ? RecordBatch\n                                                         : T extends MessageHeader.DictionaryBatch ? DictionaryBatch : never;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { MessageHeader } from '../enum';\nimport { flatbuffers } from 'flatbuffers';\nimport ByteBuffer = flatbuffers.ByteBuffer;\nimport { Message } from './metadata/message';\nimport { isFileHandle } from '../util/compat';\nimport { AsyncRandomAccessFile } from '../io/file';\nimport { toUint8Array, ArrayBufferViewInput } from '../util/buffer';\nimport { ByteStream, ReadableSource, AsyncByteStream } from '../io/stream';\nimport { ArrowJSON, ArrowJSONLike, ITERATOR_DONE, FileHandle } from '../io/interfaces';\n\n/** @ignore */ const invalidMessageType       = (type: MessageHeader) => `Expected ${MessageHeader[type]} Message in stream, but was null or length 0.`;\n/** @ignore */ const nullMessage              = (type: MessageHeader) => `Header pointer of flatbuffer-encoded ${MessageHeader[type]} Message is null or length 0.`;\n/** @ignore */ const invalidMessageMetadata   = (expected: number, actual: number) => `Expected to read ${expected} metadata bytes, but only read ${actual}.`;\n/** @ignore */ const invalidMessageBodyLength = (expected: number, actual: number) => `Expected to read ${expected} bytes for message body, but only read ${actual}.`;\n\n/** @ignore */\nexport class MessageReader implements IterableIterator<Message> {\n    protected source: ByteStream;\n    constructor(source: ByteStream | ArrayBufferViewInput | Iterable<ArrayBufferViewInput>) {\n        this.source = source instanceof ByteStream ? source : new ByteStream(source);\n    }\n    public [Symbol.iterator](): IterableIterator<Message> { return this as IterableIterator<Message>; }\n    public next(): IteratorResult<Message> {\n        let r;\n        if ((r = this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        // ARROW-6313: If the first 4 bytes are continuation indicator (-1), read\n        // the next 4 for the 32-bit metadata length. Otherwise, assume this is a\n        // pre-v0.15 message, where the first 4 bytes are the metadata length.\n        if ((r.value === -1) &&\n            (r = this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        if ((r = this.readMetadata(r.value)).done) { return ITERATOR_DONE; }\n        return (<any> r) as IteratorResult<Message>;\n    }\n    public throw(value?: any) { return this.source.throw(value); }\n    public return(value?: any) { return this.source.return(value); }\n    public readMessage<T extends MessageHeader>(type?: T | null) {\n        let r: IteratorResult<Message<T>>;\n        if ((r = this.next()).done) { return null; }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    public readMessageBody(bodyLength: number): Uint8Array {\n        if (bodyLength <= 0) { return new Uint8Array(0); }\n        const buf = toUint8Array(this.source.read(bodyLength));\n        if (buf.byteLength < bodyLength) {\n            throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));\n        }\n        // 1. Work around bugs in fs.ReadStream's internal Buffer pooling, see: https://github.com/nodejs/node/issues/24817\n        // 2. Work around https://github.com/whatwg/streams/blob/0ebe4b042e467d9876d80ae045de3843092ad797/reference-implementation/lib/helpers.js#L126\n        return /* 1. */ (buf.byteOffset % 8 === 0) &&\n               /* 2. */ (buf.byteOffset + buf.byteLength) <= buf.buffer.byteLength ? buf : buf.slice();\n    }\n    public readSchema(throwIfNull = false) {\n        const type = MessageHeader.Schema;\n        const message = this.readMessage(type);\n        const schema = message && message.header();\n        if (throwIfNull && !schema) {\n            throw new Error(nullMessage(type));\n        }\n        return schema;\n    }\n    protected readMetadataLength(): IteratorResult<number> {\n        const buf = this.source.read(PADDING);\n        const bb = buf && new ByteBuffer(buf);\n        const len = bb && bb.readInt32(0) || 0;\n        return { done: len === 0, value: len };\n    }\n    protected readMetadata(metadataLength: number): IteratorResult<Message> {\n        const buf = this.source.read(metadataLength);\n        if (!buf) { return ITERATOR_DONE; }\n        if (buf.byteLength < metadataLength) {\n            throw new Error(invalidMessageMetadata(metadataLength, buf.byteLength));\n        }\n        return { done: false, value: Message.decode(buf) };\n    }\n}\n\n/** @ignore */\nexport class AsyncMessageReader implements AsyncIterableIterator<Message> {\n    protected source: AsyncByteStream;\n    constructor(source: ReadableSource<Uint8Array>);\n    constructor(source: FileHandle, byteLength?: number);\n    constructor(source: any, byteLength?: number) {\n        this.source = source instanceof AsyncByteStream ? source\n            : isFileHandle(source)\n            ? new AsyncRandomAccessFile(source, byteLength!)\n            : new AsyncByteStream(source);\n    }\n    public [Symbol.asyncIterator](): AsyncIterableIterator<Message> { return this as AsyncIterableIterator<Message>; }\n    public async next(): Promise<IteratorResult<Message>> {\n        let r;\n        if ((r = await this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        // ARROW-6313: If the first 4 bytes are continuation indicator (-1), read\n        // the next 4 for the 32-bit metadata length. Otherwise, assume this is a\n        // pre-v0.15 message, where the first 4 bytes are the metadata length.\n        if ((r.value === -1) &&\n            (r = await this.readMetadataLength()).done) { return ITERATOR_DONE; }\n        if ((r = await this.readMetadata(r.value)).done) { return ITERATOR_DONE; }\n        return (<any> r) as IteratorResult<Message>;\n    }\n    public async throw(value?: any) { return await this.source.throw(value); }\n    public async return(value?: any) { return await this.source.return(value); }\n    public async readMessage<T extends MessageHeader>(type?: T | null) {\n        let r: IteratorResult<Message<T>>;\n        if ((r = await this.next()).done) { return null; }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    public async readMessageBody(bodyLength: number): Promise<Uint8Array> {\n        if (bodyLength <= 0) { return new Uint8Array(0); }\n        const buf = toUint8Array(await this.source.read(bodyLength));\n        if (buf.byteLength < bodyLength) {\n            throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));\n        }\n        // 1. Work around bugs in fs.ReadStream's internal Buffer pooling, see: https://github.com/nodejs/node/issues/24817\n        // 2. Work around https://github.com/whatwg/streams/blob/0ebe4b042e467d9876d80ae045de3843092ad797/reference-implementation/lib/helpers.js#L126\n        return /* 1. */ (buf.byteOffset % 8 === 0) &&\n               /* 2. */ (buf.byteOffset + buf.byteLength) <= buf.buffer.byteLength ? buf : buf.slice();\n    }\n    public async readSchema(throwIfNull = false) {\n        const type = MessageHeader.Schema;\n        const message = await this.readMessage(type);\n        const schema = message && message.header();\n        if (throwIfNull && !schema) {\n            throw new Error(nullMessage(type));\n        }\n        return schema;\n    }\n    protected async readMetadataLength(): Promise<IteratorResult<number>> {\n        const buf = await this.source.read(PADDING);\n        const bb = buf && new ByteBuffer(buf);\n        const len = bb && bb.readInt32(0) || 0;\n        return { done: len === 0, value: len };\n    }\n    protected async readMetadata(metadataLength: number): Promise<IteratorResult<Message>> {\n        const buf = await this.source.read(metadataLength);\n        if (!buf) { return ITERATOR_DONE; }\n        if (buf.byteLength < metadataLength) {\n            throw new Error(invalidMessageMetadata(metadataLength, buf.byteLength));\n        }\n        return { done: false, value: Message.decode(buf) };\n    }\n}\n\n/** @ignore */\nexport class JSONMessageReader extends MessageReader {\n    private _schema = false;\n    private _json: ArrowJSON;\n    private _body: any[] = [];\n    private _batchIndex = 0;\n    private _dictionaryIndex = 0;\n    constructor(source: ArrowJSON | ArrowJSONLike) {\n        super(new Uint8Array(0));\n        this._json = source instanceof ArrowJSON ? source : new ArrowJSON(source);\n    }\n    public next() {\n        const { _json } = this;\n        if (!this._schema) {\n            this._schema = true;\n            const message = Message.fromJSON(_json.schema, MessageHeader.Schema);\n            return { done: false, value: message };\n        }\n        if (this._dictionaryIndex < _json.dictionaries.length) {\n            const batch = _json.dictionaries[this._dictionaryIndex++];\n            this._body = batch['data']['columns'];\n            const message = Message.fromJSON(batch, MessageHeader.DictionaryBatch);\n            return { done: false, value: message };\n        }\n        if (this._batchIndex < _json.batches.length) {\n            const batch = _json.batches[this._batchIndex++];\n            this._body = batch['columns'];\n            const message = Message.fromJSON(batch, MessageHeader.RecordBatch);\n            return { done: false, value: message };\n        }\n        this._body = [];\n        return ITERATOR_DONE;\n    }\n    public readMessageBody(_bodyLength?: number) {\n        return flattenDataSources(this._body) as any;\n        function flattenDataSources(xs: any[]): any[][] {\n            return (xs || []).reduce<any[][]>((buffers, column: any) => [\n                ...buffers,\n                ...(column['VALIDITY'] && [column['VALIDITY']] || []),\n                ...(column['TYPE'] && [column['TYPE']] || []),\n                ...(column['OFFSET'] && [column['OFFSET']] || []),\n                ...(column['DATA'] && [column['DATA']] || []),\n                ...flattenDataSources(column['children'])\n            ], [] as any[][]);\n        }\n    }\n    public readMessage<T extends MessageHeader>(type?: T | null) {\n        let r: IteratorResult<Message<T>>;\n        if ((r = this.next()).done) { return null; }\n        if ((type != null) && r.value.headerType !== type) {\n            throw new Error(invalidMessageType(type));\n        }\n        return r.value;\n    }\n    public readSchema() {\n        const type = MessageHeader.Schema;\n        const message = this.readMessage(type);\n        const schema = message && message.header();\n        if (!message || !schema) {\n            throw new Error(nullMessage(type));\n        }\n        return schema;\n    }\n}\n\n/** @ignore */\nexport const PADDING = 4;\n/** @ignore */\nexport const MAGIC_STR = 'ARROW1';\n/** @ignore */\nexport const MAGIC = new Uint8Array(MAGIC_STR.length);\n\nfor (let i = 0; i < MAGIC_STR.length; i += 1 | 0) {\n    MAGIC[i] = MAGIC_STR.charCodeAt(i);\n}\n\n/** @ignore */\nexport function checkForMagicArrowString(buffer: Uint8Array, index = 0) {\n    for (let i = -1, n = MAGIC.length; ++i < n;) {\n        if (MAGIC[i] !== buffer[index + i]) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/** @ignore */\nexport const magicLength = MAGIC.length;\n/** @ignore */\nexport const magicAndPadding = magicLength + PADDING;\n/** @ignore */\nexport const magicX2AndPadding = magicLength * 2 + PADDING;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { Visitor } from '../visitor';\nimport { Type, UnionMode } from '../enum';\nimport { RecordBatch } from '../recordbatch';\nimport { VectorType as V } from '../interfaces';\nimport { rebaseValueOffsets } from '../util/buffer';\nimport { packBools, truncateBitmap } from '../util/bit';\nimport { selectVectorChildrenArgs } from '../util/args';\nimport { BufferRegion, FieldNode } from '../ipc/metadata/message';\nimport {\n    DataType, Dictionary,\n    Float, Int, Date_, Interval, Time, Timestamp, Union,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n} from '../type';\n\n/** @ignore */\nexport interface VectorAssembler extends Visitor {\n    visit<T extends Vector>(node: T): this;\n    visitMany<T extends Vector>(nodes: T[]): this[];\n    getVisitFn<T extends Type>(node: T): (vector: V<T>) => this;\n    getVisitFn<T extends DataType>(node: V<T> | Data<T> | T): (vector: V<T>) => this;\n\n    visitBool                 <T extends Bool>            (vector: V<T>): this;\n    visitInt                  <T extends Int>             (vector: V<T>): this;\n    visitFloat                <T extends Float>           (vector: V<T>): this;\n    visitUtf8                 <T extends Utf8>            (vector: V<T>): this;\n    visitBinary               <T extends Binary>          (vector: V<T>): this;\n    visitFixedSizeBinary      <T extends FixedSizeBinary> (vector: V<T>): this;\n    visitDate                 <T extends Date_>           (vector: V<T>): this;\n    visitTimestamp            <T extends Timestamp>       (vector: V<T>): this;\n    visitTime                 <T extends Time>            (vector: V<T>): this;\n    visitDecimal              <T extends Decimal>         (vector: V<T>): this;\n    visitList                 <T extends List>            (vector: V<T>): this;\n    visitStruct               <T extends Struct>          (vector: V<T>): this;\n    visitUnion                <T extends Union>           (vector: V<T>): this;\n    visitInterval             <T extends Interval>        (vector: V<T>): this;\n    visitFixedSizeList        <T extends FixedSizeList>   (vector: V<T>): this;\n    visitMap                  <T extends Map_>            (vector: V<T>): this;\n}\n\n/** @ignore */\nexport class VectorAssembler extends Visitor {\n\n    /** @nocollapse */\n    public static assemble<T extends Vector | RecordBatch>(...args: (T | T[])[]) {\n        const assembler = new VectorAssembler();\n        const vectorChildren = selectVectorChildrenArgs(RecordBatch, args);\n        const [assembleResult = assembler] = assembler.visitMany(vectorChildren);\n        return assembleResult;\n    }\n\n    private constructor() { super(); }\n\n    public visit<T extends Vector>(vector: T): this {\n        if (!DataType.isDictionary(vector.type)) {\n            const { data, length, nullCount } = vector;\n            if (length > 2147483647) {\n                /* istanbul ignore next */\n                throw new RangeError('Cannot write arrays larger than 2^31 - 1 in length');\n            }\n            if (!DataType.isNull(vector.type)) {\n                addBuffer.call(this, nullCount <= 0\n                    ? new Uint8Array(0) // placeholder validity buffer\n                    : truncateBitmap(data.offset, length, data.nullBitmap)\n                );\n            }\n            this.nodes.push(new FieldNode(length, nullCount));\n        }\n        return super.visit(vector);\n    }\n\n    public visitNull<T extends Null>(_nullV: V<T>) {\n        return this;\n    }\n    public visitDictionary<T extends Dictionary>(vector: V<T>) {\n        // Assemble the indices here, Dictionary assembled separately.\n        return this.visit(vector.indices);\n    }\n\n    public get nodes() { return this._nodes; }\n    public get buffers() { return this._buffers; }\n    public get byteLength() { return this._byteLength; }\n    public get bufferRegions() { return this._bufferRegions; }\n\n    protected _byteLength = 0;\n    protected _nodes: FieldNode[] = [];\n    protected _buffers: ArrayBufferView[] = [];\n    protected _bufferRegions: BufferRegion[] = [];\n}\n\n/** @ignore */\nfunction addBuffer(this: VectorAssembler, values: ArrayBufferView) {\n    const byteLength = (values.byteLength + 7) & ~7; // Round up to a multiple of 8\n    this.buffers.push(values);\n    this.bufferRegions.push(new BufferRegion(this._byteLength, byteLength));\n    this._byteLength += byteLength;\n    return this;\n}\n\n/** @ignore */\nfunction assembleUnion<T extends Union>(this: VectorAssembler, vector: V<T>) {\n    const { type, length, typeIds, valueOffsets } = vector;\n    // All Union Vectors have a typeIds buffer\n    addBuffer.call(this, typeIds);\n    // If this is a Sparse Union, treat it like all other Nested types\n    if (type.mode === UnionMode.Sparse) {\n        return assembleNestedVector.call(this, vector);\n    } else if (type.mode === UnionMode.Dense) {\n        // If this is a Dense Union, add the valueOffsets buffer and potentially slice the children\n        if (vector.offset <= 0) {\n            // If the Vector hasn't been sliced, write the existing valueOffsets\n            addBuffer.call(this, valueOffsets);\n            // We can treat this like all other Nested types\n            return assembleNestedVector.call(this, vector);\n        } else {\n            // A sliced Dense Union is an unpleasant case. Because the offsets are different for\n            // each child vector, we need to \"rebase\" the valueOffsets for each child\n            // Union typeIds are not necessary 0-indexed\n            const maxChildTypeId = typeIds.reduce((x, y) => Math.max(x, y), typeIds[0]);\n            const childLengths = new Int32Array(maxChildTypeId + 1);\n            // Set all to -1 to indicate that we haven't observed a first occurrence of a particular child yet\n            const childOffsets = new Int32Array(maxChildTypeId + 1).fill(-1);\n            const shiftedOffsets = new Int32Array(length);\n            // If we have a non-zero offset, then the value offsets do not start at\n            // zero. We must a) create a new offsets array with shifted offsets and\n            // b) slice the values array accordingly\n            const unshiftedOffsets = rebaseValueOffsets(-valueOffsets[0], length, valueOffsets);\n            for (let typeId, shift, index = -1; ++index < length;) {\n                if ((shift = childOffsets[typeId = typeIds[index]]) === -1) {\n                    shift = childOffsets[typeId] = unshiftedOffsets[typeId];\n                }\n                shiftedOffsets[index] = unshiftedOffsets[index] - shift;\n                ++childLengths[typeId];\n            }\n            addBuffer.call(this, shiftedOffsets);\n            // Slice and visit children accordingly\n            for (let child: Vector | null, childIndex = -1, numChildren = type.children.length; ++childIndex < numChildren;) {\n                if (child = vector.getChildAt(childIndex)) {\n                    const typeId = type.typeIds[childIndex];\n                    const childLength = Math.min(length, childLengths[typeId]);\n                    this.visit(child.slice(childOffsets[typeId], childLength));\n                }\n            }\n        }\n    }\n    return this;\n}\n\n/** @ignore */\nfunction assembleBoolVector<T extends Bool>(this: VectorAssembler, vector: V<T>) {\n    // Bool vector is a special case of FlatVector, as its data buffer needs to stay packed\n    let values: Uint8Array;\n    if (vector.nullCount >= vector.length) {\n        // If all values are null, just insert a placeholder empty data buffer (fastest path)\n        return addBuffer.call(this, new Uint8Array(0));\n    } else if ((values = vector.values) instanceof Uint8Array) {\n        // If values is already a Uint8Array, slice the bitmap (fast path)\n        return addBuffer.call(this, truncateBitmap(vector.offset, vector.length, values));\n    }\n    // Otherwise if the underlying data *isn't* a Uint8Array, enumerate the\n    // values as bools and re-pack them into a Uint8Array. This code isn't\n    // reachable unless you're trying to manipulate the Data internals,\n    // we we're only doing this for safety.\n    /* istanbul ignore next */\n    return addBuffer.call(this, packBools(vector));\n}\n\n/** @ignore */\nfunction assembleFlatVector<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval>(this: VectorAssembler, vector: V<T>) {\n    return addBuffer.call(this, vector.values.subarray(0, vector.length * vector.stride));\n}\n\n/** @ignore */\nfunction assembleFlatListVector<T extends Utf8 | Binary>(this: VectorAssembler, vector: V<T>) {\n    const { length, values, valueOffsets } = vector;\n    const firstOffset = valueOffsets[0];\n    const lastOffset = valueOffsets[length];\n    const byteLength = Math.min(lastOffset - firstOffset, values.byteLength - firstOffset);\n    // Push in the order FlatList types read their buffers\n    addBuffer.call(this, rebaseValueOffsets(-valueOffsets[0], length, valueOffsets)); // valueOffsets buffer first\n    addBuffer.call(this, values.subarray(firstOffset, firstOffset + byteLength)); // sliced values buffer second\n    return this;\n}\n\n/** @ignore */\nfunction assembleListVector<T extends Map_ | List | FixedSizeList>(this: VectorAssembler, vector: V<T>) {\n    const { length, valueOffsets } = vector;\n    // If we have valueOffsets (MapVector, ListVector), push that buffer first\n    if (valueOffsets) {\n        addBuffer.call(this, rebaseValueOffsets(valueOffsets[0], length, valueOffsets));\n    }\n    // Then insert the List's values child\n    return this.visit(vector.getChildAt(0)!);\n}\n\n/** @ignore */\nfunction assembleNestedVector<T extends Struct | Union>(this: VectorAssembler, vector: V<T>) {\n    return this.visitMany(vector.type.children.map((_, i) => vector.getChildAt(i)!).filter(Boolean))[0];\n}\n\nVectorAssembler.prototype.visitBool            =     assembleBoolVector;\nVectorAssembler.prototype.visitInt             =     assembleFlatVector;\nVectorAssembler.prototype.visitFloat           =     assembleFlatVector;\nVectorAssembler.prototype.visitUtf8            = assembleFlatListVector;\nVectorAssembler.prototype.visitBinary          = assembleFlatListVector;\nVectorAssembler.prototype.visitFixedSizeBinary =     assembleFlatVector;\nVectorAssembler.prototype.visitDate            =     assembleFlatVector;\nVectorAssembler.prototype.visitTimestamp       =     assembleFlatVector;\nVectorAssembler.prototype.visitTime            =     assembleFlatVector;\nVectorAssembler.prototype.visitDecimal         =     assembleFlatVector;\nVectorAssembler.prototype.visitList            =     assembleListVector;\nVectorAssembler.prototype.visitStruct          =   assembleNestedVector;\nVectorAssembler.prototype.visitUnion           =          assembleUnion;\nVectorAssembler.prototype.visitInterval        =     assembleFlatVector;\nVectorAssembler.prototype.visitFixedSizeList   =     assembleListVector;\nVectorAssembler.prototype.visitMap             =     assembleListVector;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Table } from '../table';\nimport { MAGIC } from './message';\nimport { Vector } from '../vector';\nimport { Column } from '../column';\nimport { DataType } from '../type';\nimport { Schema, Field } from '../schema';\nimport { Message } from './metadata/message';\nimport * as metadata from './metadata/message';\nimport { FileBlock, Footer } from './metadata/file';\nimport { MessageHeader, MetadataVersion } from '../enum';\nimport { WritableSink, AsyncByteQueue } from '../io/stream';\nimport { VectorAssembler } from '../visitor/vectorassembler';\nimport { JSONTypeAssembler } from '../visitor/jsontypeassembler';\nimport { JSONVectorAssembler } from '../visitor/jsonvectorassembler';\nimport { ArrayBufferViewInput, toUint8Array } from '../util/buffer';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from '../recordbatch';\nimport { Writable, ReadableInterop, ReadableDOMStreamOptions } from '../io/interfaces';\nimport { isPromise, isAsyncIterable, isWritableDOMStream, isWritableNodeStream, isIterable, isObject } from '../util/compat';\n\nexport interface RecordBatchStreamWriterOptions {\n    /**\n     *\n     */\n    autoDestroy?: boolean;\n    /**\n     * A flag indicating whether the RecordBatchWriter should construct pre-0.15.0\n     * encapsulated IPC Messages, which reserves  4 bytes for the Message metadata\n     * length instead of 8.\n     * @see https://issues.apache.org/jira/browse/ARROW-6313\n     */\n    writeLegacyIpcFormat?: boolean;\n}\n\nexport class RecordBatchWriter<T extends { [key: string]: DataType } = any> extends ReadableInterop<Uint8Array> implements Writable<RecordBatch<T>> {\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode(options?: import('stream').DuplexOptions & { autoDestroy: boolean }): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    public static throughDOM<T extends { [key: string]: DataType }>(\n        // @ts-ignore\n        writableStrategy?: QueuingStrategy<RecordBatch<T>> & { autoDestroy: boolean },\n        // @ts-ignore\n        readableStrategy?: { highWaterMark?: number, size?: any }\n    ): { writable: WritableStream<Table<T> | RecordBatch<T>>, readable: ReadableStream<Uint8Array> } {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    constructor(options?: RecordBatchStreamWriterOptions) {\n        super();\n        isObject(options) || (options = { autoDestroy: true, writeLegacyIpcFormat: false });\n        this._autoDestroy = (typeof options.autoDestroy === 'boolean') ? options.autoDestroy : true;\n        this._writeLegacyIpcFormat = (typeof options.writeLegacyIpcFormat === 'boolean') ? options.writeLegacyIpcFormat : false;\n    }\n\n    protected _position = 0;\n    protected _started = false;\n    protected _autoDestroy: boolean;\n    protected _writeLegacyIpcFormat: boolean;\n    // @ts-ignore\n    protected _sink = new AsyncByteQueue();\n    protected _schema: Schema | null = null;\n    protected _dictionaryBlocks: FileBlock[] = [];\n    protected _recordBatchBlocks: FileBlock[] = [];\n    protected _dictionaryDeltaOffsets = new Map<number, number>();\n\n    public toString(sync: true): string;\n    public toString(sync?: false): Promise<string>;\n    public toString(sync: any = false) {\n        return this._sink.toString(sync) as Promise<string> | string;\n    }\n    public toUint8Array(sync: true): Uint8Array;\n    public toUint8Array(sync?: false): Promise<Uint8Array>;\n    public toUint8Array(sync: any = false) {\n        return this._sink.toUint8Array(sync) as Promise<Uint8Array> | Uint8Array;\n    }\n\n    public writeAll(input: Table<T> | Iterable<RecordBatch<T>>): this;\n    public writeAll(input: AsyncIterable<RecordBatch<T>>): Promise<this>;\n    public writeAll(input: PromiseLike<AsyncIterable<RecordBatch<T>>>): Promise<this>;\n    public writeAll(input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>): Promise<this>;\n    public writeAll(input: PromiseLike<any> | Table<T> | Iterable<RecordBatch<T>> | AsyncIterable<RecordBatch<T>>) {\n        if (isPromise<any>(input)) {\n            return input.then((x) => this.writeAll(x));\n        } else if (isAsyncIterable<RecordBatch<T>>(input)) {\n            return writeAllAsync(this, input);\n        }\n        return writeAll(this, <any> input);\n    }\n\n    public get closed() { return this._sink.closed; }\n    public [Symbol.asyncIterator]() { return this._sink[Symbol.asyncIterator](); }\n    public toDOMStream(options?: ReadableDOMStreamOptions) { return this._sink.toDOMStream(options); }\n    public toNodeStream(options?: import('stream').ReadableOptions) { return this._sink.toNodeStream(options); }\n\n    public close() {\n        return this.reset()._sink.close();\n    }\n    public abort(reason?: any) {\n        return this.reset()._sink.abort(reason);\n    }\n    public finish() {\n        this._autoDestroy ? this.close() : this.reset(this._sink, this._schema);\n        return this;\n    }\n    public reset(sink: WritableSink<ArrayBufferViewInput> = this._sink, schema: Schema<T> | null = null) {\n\n        if ((sink === this._sink) || (sink instanceof AsyncByteQueue)) {\n            this._sink = sink as AsyncByteQueue;\n        } else {\n            this._sink = new AsyncByteQueue();\n            if (sink && isWritableDOMStream(sink)) {\n                this.toDOMStream({ type: 'bytes' }).pipeTo(sink);\n            } else if (sink && isWritableNodeStream(sink)) {\n                this.toNodeStream({ objectMode: false }).pipe(sink);\n            }\n        }\n\n        if (this._started && this._schema) {\n            this._writeFooter(this._schema);\n        }\n\n        this._started = false;\n        this._dictionaryBlocks = [];\n        this._recordBatchBlocks = [];\n        this._dictionaryDeltaOffsets = new Map();\n\n        if (!schema || !(schema.compareTo(this._schema))) {\n            if (schema === null) {\n                this._position = 0;\n                this._schema = null;\n            } else {\n                this._started = true;\n                this._schema = schema;\n                this._writeSchema(schema);\n            }\n        }\n\n        return this;\n    }\n\n    public write(payload?: Table<T> | RecordBatch<T> | Iterable<RecordBatch<T>> | null) {\n\n        let schema: Schema<T> | null = null;\n\n        if (!this._sink) {\n            throw new Error(`RecordBatchWriter is closed`);\n        } else if (payload === null || payload === undefined) {\n            return this.finish() && undefined;\n        } else if (payload instanceof Table && !(schema = payload.schema)) {\n            return this.finish() && undefined;\n        } else if (payload instanceof RecordBatch && !(schema = payload.schema)) {\n            return this.finish() && undefined;\n        }\n\n        if (schema && !schema.compareTo(this._schema)) {\n            if (this._started && this._autoDestroy) {\n                return this.close();\n            }\n            this.reset(this._sink, schema);\n        }\n\n        if (payload instanceof RecordBatch) {\n            if (!(payload instanceof _InternalEmptyPlaceholderRecordBatch)) {\n                this._writeRecordBatch(payload);\n            }\n        } else if (payload instanceof Table) {\n            this.writeAll(payload.chunks);\n        } else if (isIterable(payload)) {\n            this.writeAll(payload);\n        }\n    }\n\n    protected _writeMessage<T extends MessageHeader>(message: Message<T>, alignment = 8) {\n\n        const a = alignment - 1;\n        const buffer = Message.encode(message);\n        const flatbufferSize = buffer.byteLength;\n        const prefixSize = !this._writeLegacyIpcFormat ? 8 : 4;\n        const alignedSize = (flatbufferSize + prefixSize + a) & ~a;\n        const nPaddingBytes = alignedSize - flatbufferSize - prefixSize;\n\n        if (message.headerType === MessageHeader.RecordBatch) {\n            this._recordBatchBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));\n        } else if (message.headerType === MessageHeader.DictionaryBatch) {\n            this._dictionaryBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));\n        }\n\n        // If not in legacy pre-0.15.0 mode, write the stream continuation indicator\n        if (!this._writeLegacyIpcFormat) {\n            this._write(Int32Array.of(-1));\n        }\n        // Write the flatbuffer size prefix including padding\n        this._write(Int32Array.of(alignedSize - prefixSize));\n        // Write the flatbuffer\n        if (flatbufferSize > 0) { this._write(buffer); }\n        // Write any padding\n        return this._writePadding(nPaddingBytes);\n    }\n\n    protected _write(chunk: ArrayBufferViewInput) {\n        if (this._started) {\n            const buffer = toUint8Array(chunk);\n            if (buffer && buffer.byteLength > 0) {\n                this._sink.write(buffer);\n                this._position += buffer.byteLength;\n            }\n        }\n        return this;\n    }\n\n    protected _writeSchema(schema: Schema<T>) {\n        return this._writeMessage(Message.from(schema));\n    }\n\n    // @ts-ignore\n    protected _writeFooter(schema: Schema<T>) {\n        // eos bytes\n        return this._writeLegacyIpcFormat\n            ? this._write(Int32Array.of(0))\n            : this._write(Int32Array.of(-1, 0));\n    }\n\n    protected _writeMagic() {\n        return this._write(MAGIC);\n    }\n\n    protected _writePadding(nBytes: number) {\n        return nBytes > 0 ? this._write(new Uint8Array(nBytes)) : this;\n    }\n\n    protected _writeRecordBatch(batch: RecordBatch<T>) {\n        const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(batch);\n        const recordBatch = new metadata.RecordBatch(batch.length, nodes, bufferRegions);\n        const message = Message.from(recordBatch, byteLength);\n        return this\n            ._writeDictionaries(batch)\n            ._writeMessage(message)\n            ._writeBodyBuffers(buffers);\n    }\n\n    protected _writeDictionaryBatch(dictionary: Vector, id: number, isDelta = false) {\n        this._dictionaryDeltaOffsets.set(id, dictionary.length + (this._dictionaryDeltaOffsets.get(id) || 0));\n        const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(dictionary);\n        const recordBatch = new metadata.RecordBatch(dictionary.length, nodes, bufferRegions);\n        const dictionaryBatch = new metadata.DictionaryBatch(recordBatch, id, isDelta);\n        const message = Message.from(dictionaryBatch, byteLength);\n        return this\n            ._writeMessage(message)\n            ._writeBodyBuffers(buffers);\n    }\n\n    protected _writeBodyBuffers(buffers: ArrayBufferView[]) {\n        let buffer: ArrayBufferView;\n        let size: number, padding: number;\n        for (let i = -1, n = buffers.length; ++i < n;) {\n            if ((buffer = buffers[i]) && (size = buffer.byteLength) > 0) {\n                this._write(buffer);\n                if ((padding = ((size + 7) & ~7) - size) > 0) {\n                    this._writePadding(padding);\n                }\n            }\n        }\n        return this;\n    }\n\n    protected _writeDictionaries(batch: RecordBatch<T>) {\n        for (let [id, dictionary] of batch.dictionaries) {\n            let offset = this._dictionaryDeltaOffsets.get(id) || 0;\n            if (offset === 0 || (dictionary = dictionary.slice(offset)).length > 0) {\n                const chunks = 'chunks' in dictionary ? (dictionary as any).chunks : [dictionary];\n                for (const chunk of chunks) {\n                    this._writeDictionaryBatch(chunk, id, offset > 0);\n                    offset += chunk.length;\n                }\n            }\n        }\n        return this;\n    }\n}\n\n/** @ignore */\nexport class RecordBatchStreamWriter<T extends { [key: string]: DataType } = any> extends RecordBatchWriter<T> {\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: Table<T> | Iterable<RecordBatch<T>>, options?: RecordBatchStreamWriterOptions): RecordBatchStreamWriter<T>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: AsyncIterable<RecordBatch<T>>, options?: RecordBatchStreamWriterOptions): Promise<RecordBatchStreamWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<AsyncIterable<RecordBatch<T>>>, options?: RecordBatchStreamWriterOptions): Promise<RecordBatchStreamWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>, options?: RecordBatchStreamWriterOptions): Promise<RecordBatchStreamWriter<T>>;\n    /** @nocollapse */\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: any, options?: RecordBatchStreamWriterOptions) {\n        const writer = new RecordBatchStreamWriter<T>(options);\n        if (isPromise<any>(input)) {\n            return input.then((x) => writer.writeAll(x));\n        } else if (isAsyncIterable<RecordBatch<T>>(input)) {\n            return writeAllAsync(writer, input);\n        }\n        return writeAll(writer, input);\n    }\n}\n\n/** @ignore */\nexport class RecordBatchFileWriter<T extends { [key: string]: DataType } = any> extends RecordBatchWriter<T> {\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: Table<T> | Iterable<RecordBatch<T>>): RecordBatchFileWriter<T>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: AsyncIterable<RecordBatch<T>>): Promise<RecordBatchFileWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<AsyncIterable<RecordBatch<T>>>): Promise<RecordBatchFileWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>): Promise<RecordBatchFileWriter<T>>;\n    /** @nocollapse */\n    public static writeAll<T extends { [key: string]: DataType } = any>(input: any) {\n        const writer = new RecordBatchFileWriter<T>();\n        if (isPromise<any>(input)) {\n            return input.then((x) => writer.writeAll(x));\n        } else if (isAsyncIterable<RecordBatch<T>>(input)) {\n            return writeAllAsync(writer, input);\n        }\n        return writeAll(writer, input);\n    }\n\n    constructor() {\n        super();\n        this._autoDestroy = true;\n    }\n\n    // @ts-ignore\n    protected _writeSchema(schema: Schema<T>) {\n        return this._writeMagic()._writePadding(2);\n    }\n\n    protected _writeFooter(schema: Schema<T>) {\n        const buffer = Footer.encode(new Footer(\n            schema, MetadataVersion.V4,\n            this._recordBatchBlocks, this._dictionaryBlocks\n        ));\n        return super\n            ._writeFooter(schema) // EOS bytes for sequential readers\n            ._write(buffer) // Write the flatbuffer\n            ._write(Int32Array.of(buffer.byteLength)) // then the footer size suffix\n            ._writeMagic(); // then the magic suffix\n    }\n}\n\n/** @ignore */\nexport class RecordBatchJSONWriter<T extends { [key: string]: DataType } = any> extends RecordBatchWriter<T> {\n\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: Table<T> | Iterable<RecordBatch<T>>): RecordBatchJSONWriter<T>;\n    // @ts-ignore\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: AsyncIterable<RecordBatch<T>>): Promise<RecordBatchJSONWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: PromiseLike<AsyncIterable<RecordBatch<T>>>): Promise<RecordBatchJSONWriter<T>>;\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: PromiseLike<Table<T> | Iterable<RecordBatch<T>>>): Promise<RecordBatchJSONWriter<T>>;\n    /** @nocollapse */\n    public static writeAll<T extends { [key: string]: DataType } = any>(this: typeof RecordBatchWriter, input: any) {\n        return new RecordBatchJSONWriter<T>().writeAll(input as any);\n    }\n\n    private _recordBatches: RecordBatch[];\n    private _dictionaries: RecordBatch[];\n\n    constructor() {\n        super();\n        this._autoDestroy = true;\n        this._recordBatches = [];\n        this._dictionaries = [];\n    }\n\n    protected _writeMessage() { return this; }\n    // @ts-ignore\n    protected _writeFooter(schema: Schema<T>) { return this; }\n    protected _writeSchema(schema: Schema<T>) {\n        return this._write(`{\\n  \"schema\": ${\n            JSON.stringify({ fields: schema.fields.map(fieldToJSON) }, null, 2)\n        }`);\n    }\n    protected _writeDictionaries(batch: RecordBatch<T>) {\n        if (batch.dictionaries.size > 0) {\n            this._dictionaries.push(batch);\n        }\n        return this;\n    }\n    protected _writeDictionaryBatch(dictionary: Vector, id: number, isDelta = false) {\n        this._dictionaryDeltaOffsets.set(id, dictionary.length + (this._dictionaryDeltaOffsets.get(id) || 0));\n        this._write(this._dictionaryBlocks.length === 0 ? `    ` : `,\\n    `);\n        this._write(`${dictionaryBatchToJSON(dictionary, id, isDelta)}`);\n        this._dictionaryBlocks.push(new FileBlock(0, 0, 0));\n        return this;\n    }\n    protected _writeRecordBatch(batch: RecordBatch<T>) {\n        this._writeDictionaries(batch);\n        this._recordBatches.push(batch);\n        return this;\n    }\n    public close() {\n\n        if (this._dictionaries.length > 0) {\n            this._write(`,\\n  \"dictionaries\": [\\n`);\n            for (const batch of this._dictionaries) {\n                super._writeDictionaries(batch);\n            }\n            this._write(`\\n  ]`);\n        }\n\n        if (this._recordBatches.length > 0) {\n            for (let i = -1, n = this._recordBatches.length; ++i < n;) {\n                this._write(i === 0 ? `,\\n  \"batches\": [\\n    ` : `,\\n    `);\n                this._write(`${recordBatchToJSON(this._recordBatches[i])}`);\n                this._recordBatchBlocks.push(new FileBlock(0, 0, 0));\n            }\n            this._write(`\\n  ]`);\n        }\n\n        if (this._schema) {\n            this._write(`\\n}`);\n        }\n\n        this._dictionaries = [];\n        this._recordBatches = [];\n\n        return super.close();\n    }\n}\n\n/** @ignore */\nfunction writeAll<T extends { [key: string]: DataType } = any>(writer: RecordBatchWriter<T>, input: Table<T> | Iterable<RecordBatch<T>>) {\n    let chunks = input as Iterable<RecordBatch<T>>;\n    if (input instanceof Table) {\n        chunks = input.chunks;\n        writer.reset(undefined, input.schema);\n    }\n    for (const batch of chunks) {\n        writer.write(batch);\n    }\n    return writer.finish();\n}\n\n/** @ignore */\nasync function writeAllAsync<T extends { [key: string]: DataType } = any>(writer: RecordBatchWriter<T>, batches: AsyncIterable<RecordBatch<T>>) {\n    for await (const batch of batches) {\n        writer.write(batch);\n    }\n    return writer.finish();\n}\n\n/** @ignore */\nfunction fieldToJSON({ name, type, nullable }: Field): object {\n    const assembler = new JSONTypeAssembler();\n    return {\n        'name': name, 'nullable': nullable,\n        'type': assembler.visit(type),\n        'children': (type.children || []).map(fieldToJSON),\n        'dictionary': !DataType.isDictionary(type) ? undefined : {\n            'id': type.id,\n            'isOrdered': type.isOrdered,\n            'indexType': assembler.visit(type.indices)\n        }\n    };\n}\n\n/** @ignore */\nfunction dictionaryBatchToJSON(dictionary: Vector, id: number, isDelta = false) {\n    const field = new Field(`${id}`, dictionary.type, dictionary.nullCount > 0);\n    const columns = JSONVectorAssembler.assemble(new Column(field, [dictionary]));\n    return JSON.stringify({\n        'id': id,\n        'isDelta': isDelta,\n        'data': {\n            'count': dictionary.length,\n            'columns': columns\n        }\n    }, null, 2);\n}\n\n/** @ignore */\nfunction recordBatchToJSON(records: RecordBatch) {\n    return JSON.stringify({\n        'count': records.length,\n        'columns': JSONVectorAssembler.assemble(records)\n    }, null, 2);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Column } from '../column';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Data, Buffers } from '../data';\nimport { Schema, Field } from '../schema';\nimport { Chunked } from '../vector/chunked';\nimport { RecordBatch } from '../recordbatch';\n\nconst noopBuf = new Uint8Array(0);\nconst nullBufs = (bitmapLength: number) => <unknown> [\n    noopBuf, noopBuf, new Uint8Array(bitmapLength), noopBuf\n] as Buffers<any>;\n\n/** @ignore */\nexport function ensureSameLengthData<T extends { [key: string]: DataType } = any>(\n    schema: Schema<T>,\n    chunks: Data<T[keyof T]>[],\n    batchLength = chunks.reduce((l, c) => Math.max(l, c.length), 0)\n) {\n    let data: Data<T[keyof T]>;\n    let field: Field<T[keyof T]>;\n    let i = -1, n = chunks.length;\n    const fields = [...schema.fields];\n    const batchData = [] as Data<T[keyof T]>[];\n    const bitmapLength = ((batchLength + 63) & ~63) >> 3;\n    while (++i < n) {\n        if ((data = chunks[i]) && data.length === batchLength) {\n            batchData[i] = data;\n        } else {\n            (field = fields[i]).nullable || (fields[i] = fields[i].clone({ nullable: true }) as Field<T[keyof T]>);\n            batchData[i] = data ? data._changeLengthAndBackfillNullBitmap(batchLength)\n                : Data.new(field.type, 0, batchLength, batchLength, nullBufs(bitmapLength)) as Data<T[keyof T]>;\n        }\n    }\n    return [new Schema<T>(fields), batchLength, batchData] as [Schema<T>, number, Data<T[keyof T]>[]];\n}\n\n/** @ignore */\nexport function distributeColumnsIntoRecordBatches<T extends { [key: string]: DataType } = any>(columns: Column<T[keyof T]>[]): [Schema<T>, RecordBatch<T>[]] {\n    return distributeVectorsIntoRecordBatches<T>(new Schema<T>(columns.map(({ field }) => field)), columns);\n}\n\n/** @ignore */\nexport function distributeVectorsIntoRecordBatches<T extends { [key: string]: DataType } = any>(schema: Schema<T>, vecs: (Vector<T[keyof T]> | Chunked<T[keyof T]>)[]): [Schema<T>, RecordBatch<T>[]] {\n    return uniformlyDistributeChunksAcrossRecordBatches<T>(schema, vecs.map((v) => v instanceof Chunked ? v.chunks.map((c) => c.data) : [v.data]));\n}\n\n/** @ignore */\nfunction uniformlyDistributeChunksAcrossRecordBatches<T extends { [key: string]: DataType } = any>(schema: Schema<T>, columns: Data<T[keyof T]>[][]): [Schema<T>, RecordBatch<T>[]] {\n\n    const fields = [...schema.fields];\n    const batchArgs = [] as [number, Data<T[keyof T]>[]][];\n    const memo = { numBatches: columns.reduce((n, c) => Math.max(n, c.length), 0) };\n\n    let numBatches = 0, batchLength = 0;\n    let i: number = -1, numColumns = columns.length;\n    let child: Data<T[keyof T]>, childData: Data<T[keyof T]>[] = [];\n\n    while (memo.numBatches-- > 0) {\n\n        for (batchLength = Number.POSITIVE_INFINITY, i = -1; ++i < numColumns;) {\n            childData[i] = child = columns[i].shift()!;\n            batchLength = Math.min(batchLength, child ? child.length : batchLength);\n        }\n\n        if (isFinite(batchLength)) {\n            childData = distributeChildData(fields, batchLength, childData, columns, memo);\n            if (batchLength > 0) {\n                batchArgs[numBatches++] = [batchLength, childData.slice()];\n            }\n        }\n    }\n    return [\n        schema = new Schema<T>(fields, schema.metadata),\n        batchArgs.map((xs) => new RecordBatch(schema, ...xs))\n    ];\n}\n\n/** @ignore */\nfunction distributeChildData<T extends { [key: string]: DataType } = any>(fields: Field<T[keyof T]>[], batchLength: number, childData: Data<T[keyof T]>[], columns: Data<T[keyof T]>[][], memo: { numBatches: number }) {\n    let data: Data<T[keyof T]>;\n    let field: Field<T[keyof T]>;\n    let length = 0, i = -1, n = columns.length;\n    const bitmapLength = ((batchLength + 63) & ~63) >> 3;\n    while (++i < n) {\n        if ((data = childData[i]) && ((length = data.length) >= batchLength)) {\n            if (length === batchLength) {\n                childData[i] = data;\n            } else {\n                childData[i] = data.slice(0, batchLength);\n                data = data.slice(batchLength, length - batchLength);\n                memo.numBatches = Math.max(memo.numBatches, columns[i].unshift(data));\n            }\n        } else {\n            (field = fields[i]).nullable || (fields[i] = field.clone({ nullable: true }) as Field<T[keyof T]>);\n            childData[i] = data ? data._changeLengthAndBackfillNullBitmap(batchLength)\n                : Data.new(field.type, 0, batchLength, batchLength, nullBufs(bitmapLength)) as Data<T[keyof T]>;\n        }\n    }\n    return childData;\n}\n","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nexport default function _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { DataType } from '../type';\nimport { Chunked } from './chunked';\nimport { clampRange } from '../util/vector';\nimport { VectorType as V } from '../interfaces';\nimport { AbstractVector, Vector, Clonable, Sliceable, Applicative } from '../vector';\n\n/** @ignore */\nexport interface BaseVector<T extends DataType = any> extends Clonable<V<T>>, Sliceable<V<T>>, Applicative<T, Chunked<T>> {\n    slice(begin?: number, end?: number): V<T>;\n    concat(...others: Vector<T>[]): Chunked<T>;\n    clone<R extends DataType = T>(data: Data<R>, children?: Vector<R>[]): V<R>;\n}\n\n/** @ignore */\nexport abstract class BaseVector<T extends DataType = any> extends AbstractVector<T>\n    implements Clonable<V<T>>, Sliceable<V<T>>, Applicative<T, Chunked<T>> {\n\n    protected _children?: Vector[];\n\n    constructor(data: Data<T>, children?: Vector[]) {\n        super();\n        this._children = children;\n        this.numChildren = data.childData.length;\n        this._bindDataAccessors(this.data = data);\n    }\n\n    public readonly data: Data<T>;\n    public readonly numChildren: number;\n\n    public get type() { return this.data.type; }\n    public get typeId() { return this.data.typeId; }\n    public get length() { return this.data.length; }\n    public get offset() { return this.data.offset; }\n    public get stride() { return this.data.stride; }\n    public get nullCount() { return this.data.nullCount; }\n    public get byteLength() { return this.data.byteLength; }\n    public get VectorName() { return `${Type[this.typeId]}Vector`; }\n\n    public get ArrayType(): T['ArrayType'] { return this.type.ArrayType; }\n\n    public get values() { return this.data.values; }\n    public get typeIds() { return this.data.typeIds; }\n    public get nullBitmap() { return this.data.nullBitmap; }\n    public get valueOffsets() { return this.data.valueOffsets; }\n\n    public get [Symbol.toStringTag]() { return `${this.VectorName}<${this.type[Symbol.toStringTag]}>`; }\n\n    public clone<R extends DataType = T>(data: Data<R>, children = this._children) {\n        return Vector.new<R>(data, children) as any;\n    }\n\n    public concat(...others: Vector<T>[]) {\n        return Chunked.concat<T>(this, ...others);\n    }\n\n    public slice(begin?: number, end?: number) {\n        // Adjust args similar to Array.prototype.slice. Normalize begin/end to\n        // clamp between 0 and length, and wrap around on negative indices, e.g.\n        // slice(-1, 5) or slice(5, -1)\n        return clampRange(this, begin, end, this._sliceInternal);\n    }\n\n    public isValid(index: number): boolean {\n        if (this.nullCount > 0) {\n            const idx = this.offset + index;\n            const val = this.nullBitmap[idx >> 3];\n            const mask = (val & (1 << (idx % 8)));\n            return mask !== 0;\n        }\n        return true;\n    }\n\n    public getChildAt<R extends DataType = any>(index: number): Vector<R> | null {\n        return index < 0 || index >= this.numChildren ? null : (\n            (this._children || (this._children = []))[index] ||\n            (this._children[index] = Vector.new<R>(this.data.childData[index] as Data<R>))\n        ) as Vector<R>;\n    }\n\n    public toJSON(): any { return [...this]; }\n\n    protected _sliceInternal(self: this, begin: number, end: number) {\n        return self.clone(self.data.slice(begin, end - begin), null!);\n    }\n\n    // @ts-ignore\n    protected _bindDataAccessors(data: Data<T>) {\n        // Implementation in src/vectors/index.ts due to circular dependency/packaging shenanigans\n    }\n}\n\n(BaseVector.prototype as any)[Symbol.isConcatSpreadable] = true;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { Binary, Utf8 } from '../type';\n\n/** @ignore */\nexport class BinaryVector extends BaseVector<Binary> {\n    public asUtf8() {\n        return Vector.new(this.data.clone(new Utf8()));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Bool } from '../type';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\n\n/** @ignore */\nexport class BoolVector extends BaseVector<Bool> {\n    public static from<TNull = any>(input: Iterable<boolean | TNull>): BoolVector;\n    public static from<TNull = any>(input: AsyncIterable<boolean | TNull>): Promise<BoolVector>;\n    public static from<TNull = any>(input: VectorBuilderOptions<Bool, TNull>): Chunked<Bool>;\n    public static from<TNull = any>(input: VectorBuilderOptionsAsync<Bool, TNull>): Promise<Chunked<Bool>>;\n    /** @nocollapse */\n    public static from<TNull = any>(input: Iterable<boolean | TNull> | AsyncIterable<boolean | TNull> | VectorBuilderOptions<Bool, TNull> | VectorBuilderOptionsAsync<Bool, TNull>) {\n        return vectorFromValuesWithType(() => new Bool(), input);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DateUnit } from '../enum';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorType as V } from '../interfaces';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { Date_, DateDay, DateMillisecond  } from '../type';\n\n/** @ignore */\ntype FromArgs<T extends Date_> = [Iterable<Date>, T['unit']];\n\n/** @ignore */\nexport class DateVector<T extends Date_ = Date_> extends BaseVector<T> {\n    public static from<T extends DateUnit.DAY>(...args: FromArgs<DateDay>): V<DateDay>;\n    public static from<T extends DateUnit.MILLISECOND>(...args: FromArgs<DateMillisecond>): V<DateMillisecond>;\n    public static from<T extends Date_, TNull = any>(input: Iterable<Date | TNull>): V<T>;\n    public static from<T extends Date_, TNull = any>(input: AsyncIterable<Date | TNull>): Promise<V<T>>;\n    public static from<T extends Date_, TNull = any>(input: VectorBuilderOptions<T, TNull>): Chunked<T>;\n    public static from<T extends Date_, TNull = any>(input: VectorBuilderOptionsAsync<T, TNull>): Promise<Chunked<T>>;\n    /** @nocollapse */\n    public static from<T extends Date_, TNull = any>(...args: FromArgs<T> | [Iterable<Date | TNull> | AsyncIterable<Date | TNull> | VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>]) {\n        if (args.length === 2) {\n            return vectorFromValuesWithType(() => args[1] === DateUnit.DAY ? new DateDay() : new DateMillisecond() as T, args[0]);\n        }\n        return vectorFromValuesWithType(() => new DateMillisecond() as T, args[0]);\n    }\n}\n\n/** @ignore */\nexport class DateDayVector extends DateVector<DateDay> {}\n\n/** @ignore */\nexport class DateMillisecondVector extends DateVector<DateMillisecond> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Decimal } from '../type';\nimport { BaseVector } from './base';\n\n/** @ignore */\nexport class DecimalVector extends BaseVector<Decimal> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { VectorType as V } from '../interfaces';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { DataType, Dictionary, TKeys } from '../type';\n\n/** @ignore */\ntype FromArgs<T extends DataType = any, TKey extends TKeys = TKeys> = [Vector<T>, TKey, ArrayLike<number> | TKey['TArray']];\n\n/** @ignore */\nexport class DictionaryVector<T extends DataType = any, TKey extends TKeys = TKeys> extends BaseVector<Dictionary<T, TKey>> {\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(...args: FromArgs<T, TKey>): V<Dictionary<T, TKey>>;\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(input: VectorBuilderOptions<Dictionary<T, TKey>>): Vector<Dictionary<T, TKey>>;\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(input: VectorBuilderOptionsAsync<Dictionary<T, TKey>>): Promise<Vector<Dictionary<T, TKey>>>;\n    /** @nocollapse */\n    public static from<T extends DataType = any, TKey extends TKeys = TKeys>(...args: any[]) {\n        if (args.length === 3) {\n            const [values, indices, keys] = args as FromArgs<T, TKey>;\n            const type = new Dictionary(values.type, indices, null, null);\n            return Vector.new(Data.Dictionary(type, 0, keys.length, 0, null, keys, values));\n        }\n        return vectorFromValuesWithType(() => args[0].type, args[0]);\n    }\n\n    constructor(data: Data<Dictionary<T, TKey>>) {\n        super(data);\n        this.indices = Vector.new(data.clone(this.type.indices));\n    }\n\n    public readonly indices: V<TKey>;\n\n    public get dictionary() { return <Vector<T>> this.data.dictionary; }\n    public reverseLookup(value: T) { return this.dictionary.indexOf(value); }\n    public getKey(idx: number): TKey['TValue'] | null { return this.indices.get(idx); }\n    public getValue(key: number): T['TValue'] | null { return this.dictionary.get(key); }\n    public setKey(idx: number, key: TKey['TValue'] | null) { return this.indices.set(idx, key); }\n    public setValue(key: number, value: T['TValue'] | null) { return this.dictionary.set(key, value); }\n}\n\n(DictionaryVector.prototype as any).indices = null;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { FixedSizeBinary } from '../type';\n\n/** @ignore */\nexport class FixedSizeBinaryVector extends BaseVector<FixedSizeBinary> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { DataType, FixedSizeList } from '../type';\n\n/** @ignore */\nexport class FixedSizeListVector<T extends DataType = any> extends BaseVector<FixedSizeList<T>> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { Float, Float16, Float32, Float64, FloatArray } from '../type';\nimport { VectorType as V, TypedArrayConstructor } from '../interfaces';\n\n/** @ignore */\ntype FloatVectorConstructors =\n    typeof FloatVector   |\n    typeof Float16Vector |\n    typeof Float32Vector |\n    typeof Float64Vector ;\n\n/** @ignore */\ntype FromInput<T extends Float, TNull = any> =\n    FloatArray                          |\n    Iterable<T['TValue'] | TNull>       |\n    AsyncIterable<T['TValue'] | TNull>  |\n    VectorBuilderOptions<T, TNull>      |\n    VectorBuilderOptionsAsync<T, TNull> ;\n\n/** @ignore */\ntype FloatArrayCtor = TypedArrayConstructor<FloatArray>;\n\n/** @ignore */\nexport class FloatVector<T extends Float = Float> extends BaseVector<T> {\n\n    // Guaranteed zero-copy variants\n    public static from(this: typeof FloatVector, input: Uint16Array): Float16Vector;\n    public static from(this: typeof FloatVector, input: Float32Array): Float32Vector;\n    public static from(this: typeof FloatVector, input: Float64Array): Float64Vector;\n\n    // Zero-copy if input is a TypedArray of the same type as the\n    // Vector that from is called on, otherwise uses the Builders\n    public static from<TNull = any>(this: typeof Float16Vector,  input: FromInput<Float16, TNull>): Float16Vector;\n    public static from<TNull = any>(this: typeof Float32Vector,  input: FromInput<Float32, TNull>): Float32Vector;\n    public static from<TNull = any>(this: typeof Float64Vector,  input: FromInput<Float64, TNull>): Float64Vector;\n\n    // Not zero-copy\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: Iterable<T['TValue'] | TNull>): V<T>;\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: AsyncIterable<T['TValue'] | TNull>): Promise<V<T>>;\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: VectorBuilderOptions<T, TNull>): Chunked<T>;\n    public static from<T extends Float, TNull = any>(this: typeof FloatVector, input: VectorBuilderOptionsAsync<T, TNull>): Promise<Chunked<T>>;\n    /** @nocollapse */\n    public static from<T extends Float, TNull = any>(this: FloatVectorConstructors, input: FromInput<T, TNull>) {\n\n        let ArrowType = vectorTypeToDataType(this);\n\n        if ((input instanceof ArrayBuffer) || ArrayBuffer.isView(input)) {\n            let InputType = arrayTypeToDataType(input.constructor as FloatArrayCtor) || ArrowType;\n            // Special case, infer the Arrow DataType from the input if calling the base\n            // FloatVector.from with a TypedArray, e.g. `FloatVector.from(new Float32Array())`\n            if (ArrowType === null) {\n                ArrowType = InputType;\n            }\n            // If the DataType inferred from the Vector constructor matches the\n            // DataType inferred from the input arguments, return zero-copy view\n            if (ArrowType && ArrowType === InputType) {\n                let type = new ArrowType();\n                let length = input.byteLength / type.ArrayType.BYTES_PER_ELEMENT;\n                // If the ArrowType is Float16 but the input type isn't a Uint16Array,\n                // let the Float16Builder handle casting the input values to Uint16s.\n                if (!convertTo16Bit(ArrowType, input.constructor)) {\n                    return Vector.new(Data.Float(type, 0, length, 0, null, input as FloatArray));\n                }\n            }\n        }\n\n        if (ArrowType) {\n            // If the DataType inferred from the Vector constructor is different than\n            // the DataType inferred from the input TypedArray, or if input isn't a\n            // TypedArray, use the Builders to construct the result Vector\n            return vectorFromValuesWithType(() => new ArrowType!() as T, input);\n        }\n\n        if ((input instanceof DataView) || (input instanceof ArrayBuffer)) {\n            throw new TypeError(`Cannot infer float type from instance of ${input.constructor.name}`);\n        }\n\n        throw new TypeError('Unrecognized FloatVector input');\n    }\n}\n\n/** @ignore */\nexport class Float16Vector extends FloatVector<Float16> {\n    // Since JS doesn't have half floats, `toArray()` returns a zero-copy slice\n    // of the underlying Uint16Array data. This behavior ensures we don't incur\n    // extra compute or copies if you're calling `toArray()` in order to create\n    // a buffer for something like WebGL. Buf if you're using JS and want typed\n    // arrays of 4-to-8-byte precision, these methods will enumerate the values\n    // and clamp to the desired byte lengths.\n    public toFloat32Array() { return new Float32Array(this as Iterable<number>); }\n    public toFloat64Array() { return new Float64Array(this as Iterable<number>); }\n}\n\n/** @ignore */\nexport class Float32Vector extends FloatVector<Float32> {}\n/** @ignore */\nexport class Float64Vector extends FloatVector<Float64> {}\n\nconst convertTo16Bit = (typeCtor: any, dataCtor: any) => {\n    return (typeCtor === Float16) && (dataCtor !== Uint16Array);\n};\n\n/** @ignore */\nconst arrayTypeToDataType = (ctor: FloatArrayCtor) => {\n    switch (ctor) {\n        case Uint16Array:    return Float16;\n        case Float32Array:   return Float32;\n        case Float64Array:   return Float64;\n        default: return null;\n    }\n};\n\n/** @ignore */\nconst vectorTypeToDataType = (ctor: FloatVectorConstructors) => {\n    switch (ctor) {\n        case Float16Vector: return Float16;\n        case Float32Vector: return Float32;\n        case Float64Vector: return Float64;\n        default: return null;\n    }\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Interval, IntervalDayTime, IntervalYearMonth } from '../type';\n\n/** @ignore */\nexport class IntervalVector<T extends Interval = Interval> extends BaseVector<T> {}\n/** @ignore */\nexport class IntervalDayTimeVector extends IntervalVector<IntervalDayTime> {}\n/** @ignore */\nexport class IntervalYearMonthVector extends IntervalVector<IntervalYearMonth> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\nimport { BigInt64Array, BigUint64Array } from '../util/compat';\nimport { toBigInt64Array, toBigUint64Array } from '../util/buffer';\nimport { Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64, IntArray } from '../type';\nimport { VectorType as V, TypedArrayConstructor, BigIntArrayConstructor, BigIntArray } from '../interfaces';\n\n/** @ignore */\ntype IntVectorConstructors =\n    typeof IntVector    |\n    typeof Int8Vector   |\n    typeof Int16Vector  |\n    typeof Int32Vector  |\n    typeof Uint8Vector  |\n    typeof Uint16Vector |\n    typeof Uint32Vector |\n    typeof Int64Vector  |\n    typeof Uint64Vector ;\n\n/** @ignore */\ntype FromInput<T extends Int, TNull = any> =\n    IntArray | BigIntArray              |\n    Iterable<T['TValue'] | TNull>       |\n    AsyncIterable<T['TValue'] | TNull>  |\n    VectorBuilderOptions<T, TNull>      |\n    VectorBuilderOptionsAsync<T, TNull> ;\n\n/** @ignore */\ntype FromArgs<T extends Int, TNull = any> = [FromInput<T, TNull>, boolean?];\n\n/** @ignore */\ntype IntArrayCtor = TypedArrayConstructor<IntArray> | BigIntArrayConstructor<BigIntArray>;\n\n/** @ignore */\nexport class IntVector<T extends Int = Int> extends BaseVector<T> {\n\n    // Guaranteed zero-copy variants\n    public static from(this: typeof IntVector, input: Int8Array): Int8Vector;\n    public static from(this: typeof IntVector, input: Int16Array): Int16Vector;\n    public static from(this: typeof IntVector, input: Int32Array): Int32Vector;\n    public static from(this: typeof IntVector, input: BigInt64Array): Int64Vector;\n    public static from(this: typeof IntVector, input: Int32Array, is64bit: true): Int64Vector;\n    public static from(this: typeof IntVector, input: Uint8Array): Uint8Vector;\n    public static from(this: typeof IntVector, input: Uint16Array): Uint16Vector;\n    public static from(this: typeof IntVector, input: Uint32Array): Uint32Vector;\n    public static from(this: typeof IntVector, input: BigUint64Array): Uint64Vector;\n    public static from(this: typeof IntVector, input: Uint32Array, is64bit: true): Uint64Vector;\n\n    // Zero-copy if input is a TypedArray of the same type as the\n    // Vector that from is called on, otherwise uses the Builders\n    public static from<TNull = any>(this: typeof Int8Vector,   input: FromInput<Int8, TNull>): Int8Vector;\n    public static from<TNull = any>(this: typeof Int16Vector,  input: FromInput<Int16, TNull>): Int16Vector;\n    public static from<TNull = any>(this: typeof Int32Vector,  input: FromInput<Int32, TNull>): Int32Vector;\n    public static from<TNull = any>(this: typeof Int64Vector,  input: FromInput<Int64, TNull>): Int64Vector;\n    public static from<TNull = any>(this: typeof Uint8Vector,  input: FromInput<Uint8, TNull>): Uint8Vector;\n    public static from<TNull = any>(this: typeof Uint16Vector, input: FromInput<Uint16, TNull>): Uint16Vector;\n    public static from<TNull = any>(this: typeof Uint32Vector, input: FromInput<Uint32, TNull>): Uint32Vector;\n    public static from<TNull = any>(this: typeof Uint64Vector, input: FromInput<Uint64, TNull>): Uint64Vector;\n\n    // Not zero-copy\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: Iterable<T['TValue'] | TNull>): V<T>;\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: AsyncIterable<T['TValue'] | TNull>): Promise<V<T>>;\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: VectorBuilderOptions<T, TNull>): Chunked<T>;\n    public static from<T extends Int, TNull = any>(this: typeof IntVector, input: VectorBuilderOptionsAsync<T, TNull>): Promise<Chunked<T>>;\n    /** @nocollapse */\n    public static from<T extends Int, TNull = any>(this: IntVectorConstructors, ...args: FromArgs<T, TNull>) {\n\n        let [input, is64bit = false] = args;\n        let ArrowType = vectorTypeToDataType(this, is64bit);\n\n        if ((input instanceof ArrayBuffer) || ArrayBuffer.isView(input)) {\n            let InputType = arrayTypeToDataType(input.constructor as IntArrayCtor, is64bit) || ArrowType;\n            // Special case, infer the Arrow DataType from the input if calling the base\n            // IntVector.from with a TypedArray, e.g. `IntVector.from(new Int32Array())`\n            if (ArrowType === null) {\n                ArrowType = InputType;\n            }\n            // If the DataType inferred from the Vector constructor matches the\n            // DataType inferred from the input arguments, return zero-copy view\n            if (ArrowType && ArrowType === InputType) {\n                let type = new ArrowType();\n                let length = input.byteLength / type.ArrayType.BYTES_PER_ELEMENT;\n                // If the ArrowType is 64bit but the input type is 32bit pairs, update the logical length\n                if (convert32To64Bit(ArrowType, input.constructor)) {\n                    length *= 0.5;\n                }\n                return Vector.new(Data.Int(type, 0, length, 0, null, input as IntArray));\n            }\n        }\n\n        if (ArrowType) {\n            // If the DataType inferred from the Vector constructor is different than\n            // the DataType inferred from the input TypedArray, or if input isn't a\n            // TypedArray, use the Builders to construct the result Vector\n            return vectorFromValuesWithType(() => new ArrowType!() as T, input);\n        }\n\n        if ((input instanceof DataView) || (input instanceof ArrayBuffer)) {\n            throw new TypeError(`Cannot infer integer type from instance of ${input.constructor.name}`);\n        }\n\n        throw new TypeError('Unrecognized IntVector input');\n    }\n}\n\n/** @ignore */\nexport class Int8Vector extends IntVector<Int8> {}\n/** @ignore */\nexport class Int16Vector extends IntVector<Int16> {}\n/** @ignore */\nexport class Int32Vector extends IntVector<Int32> {}\n/** @ignore */\nexport class Int64Vector extends IntVector<Int64> {\n    public toBigInt64Array() {\n        return toBigInt64Array(this.values);\n    }\n    // @ts-ignore\n    private _values64: BigInt64Array;\n    public get values64(): BigInt64Array {\n        return this._values64 || (this._values64 = this.toBigInt64Array());\n    }\n}\n\n/** @ignore */\nexport class Uint8Vector extends IntVector<Uint8> {}\n/** @ignore */\nexport class Uint16Vector extends IntVector<Uint16> {}\n/** @ignore */\nexport class Uint32Vector extends IntVector<Uint32> {}\n/** @ignore */\nexport class Uint64Vector extends IntVector<Uint64> {\n    public toBigUint64Array() {\n        return toBigUint64Array(this.values);\n    }\n    // @ts-ignore\n    private _values64: BigUint64Array;\n    public get values64(): BigUint64Array {\n        return this._values64 || (this._values64 = this.toBigUint64Array());\n    }\n}\n\nconst convert32To64Bit = (typeCtor: any, dataCtor: any) => {\n    return (typeCtor === Int64 || typeCtor === Uint64) &&\n           (dataCtor === Int32Array || dataCtor === Uint32Array);\n};\n\n/** @ignore */\nconst arrayTypeToDataType = (ctor: IntArrayCtor, is64bit: boolean) => {\n    switch (ctor) {\n        case Int8Array:      return Int8;\n        case Int16Array:     return Int16;\n        case Int32Array:     return is64bit ? Int64 : Int32;\n        case BigInt64Array:  return Int64;\n        case Uint8Array:     return Uint8;\n        case Uint16Array:    return Uint16;\n        case Uint32Array:    return is64bit ? Uint64 : Uint32;\n        case BigUint64Array: return Uint64;\n        default: return null;\n    }\n};\n\n/** @ignore */\nconst vectorTypeToDataType = (ctor: IntVectorConstructors, is64bit: boolean) => {\n    switch (ctor) {\n        case Int8Vector:   return Int8;\n        case Int16Vector:  return Int16;\n        case Int32Vector:  return is64bit ? Int64 : Int32;\n        case Int64Vector:  return Int64;\n        case Uint8Vector:  return Uint8;\n        case Uint16Vector: return Uint16;\n        case Uint32Vector: return is64bit ? Uint64 : Uint32;\n        case Uint64Vector: return Uint64;\n        default: return null;\n    }\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { DataType, List } from '../type';\n\n/** @ignore */\nexport class ListVector<T extends DataType = any> extends BaseVector<List<T>> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { MapRow } from './row';\nimport { Field } from '../schema';\nimport { Vector } from '../vector';\nimport { BaseVector } from './base';\nimport { DataType, Map_, Struct, List } from '../type';\n\n/** @ignore */\nexport class MapVector<K extends DataType = any, V extends DataType = any> extends BaseVector<Map_<K, V>> {\n    public asList() {\n        const child = this.type.children[0] as Field<Struct<{ key: K, value: V }>>;\n        return Vector.new(this.data.clone(new List<Struct<{ key: K, value: V }>>(child)));\n    }\n    public bind(index: number): Map_<K, V>['TValue'] {\n        const child = this.getChildAt<Struct<{ key: K, value: V }>>(0);\n        const { [index]: begin, [index + 1]: end } = this.valueOffsets;\n        return new MapRow(child!.slice(begin, end));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Null } from '../type';\nimport { BaseVector } from './base';\n\n/** @ignore */\nexport class NullVector extends BaseVector<Null> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { StructRow } from './row';\nimport { BaseVector } from './base';\nimport { DataType, Struct } from '../type';\n\n/** @ignore */ const kRowIndex = Symbol.for('rowIndex');\n/** @ignore */\nexport class StructVector<T extends { [key: string]: DataType } = any> extends BaseVector<Struct<T>> {\n    // @ts-ignore\n    private _row: StructRow<T>;\n    public bind(index: number): Struct<T>['TValue'] {\n        const proto = this._row || (this._row = new StructRow<T>(this));\n        const bound = Object.create(proto);\n        bound[kRowIndex] = index;\n        return bound;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond } from '../type';\n\n/** @ignore */\nexport class TimestampVector<T extends Timestamp = Timestamp> extends BaseVector<T> {}\n/** @ignore */\nexport class TimestampSecondVector extends TimestampVector<TimestampSecond> {}\n/** @ignore */\nexport class TimestampMillisecondVector extends TimestampVector<TimestampMillisecond> {}\n/** @ignore */\nexport class TimestampMicrosecondVector extends TimestampVector<TimestampMicrosecond> {}\n/** @ignore */\nexport class TimestampNanosecondVector extends TimestampVector<TimestampNanosecond> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond } from '../type';\n\n/** @ignore */\nexport class TimeVector<T extends Time = Time> extends BaseVector<T> {}\n/** @ignore */\nexport class TimeSecondVector extends TimeVector<TimeSecond> {}\n/** @ignore */\nexport class TimeMillisecondVector extends TimeVector<TimeMillisecond> {}\n/** @ignore */\nexport class TimeMicrosecondVector extends TimeVector<TimeMicrosecond> {}\n/** @ignore */\nexport class TimeNanosecondVector extends TimeVector<TimeNanosecond> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { BaseVector } from './base';\nimport { Union, DenseUnion, SparseUnion} from '../type';\n\n/** @ignore */\nexport class UnionVector<T extends Union = Union> extends BaseVector<T> {\n    public get typeIdToChildIndex() { return this.data.type.typeIdToChildIndex; }\n}\n\n/** @ignore */\nexport class DenseUnionVector extends UnionVector<DenseUnion> {\n    public get valueOffsets() { return this.data.valueOffsets!; }\n}\n\n/** @ignore */\nexport class SparseUnionVector extends UnionVector<SparseUnion> {}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { Binary, Utf8 } from '../type';\nimport { VectorBuilderOptions } from './index';\nimport { vectorFromValuesWithType } from './index';\nimport { VectorBuilderOptionsAsync } from './index';\n\n/** @ignore */\nexport class Utf8Vector extends BaseVector<Utf8> {\n    public static from<TNull = any>(input: Iterable<string | TNull>): Utf8Vector;\n    public static from<TNull = any>(input: AsyncIterable<string | TNull>): Promise<Utf8Vector>;\n    public static from<TNull = any>(input: VectorBuilderOptions<Utf8, TNull>): Chunked<Utf8>;\n    public static from<TNull = any>(input: VectorBuilderOptionsAsync<Utf8, TNull>): Promise<Chunked<Utf8>>;\n    /** @nocollapse */\n    public static from<TNull = any>(input: Iterable<string | TNull> | AsyncIterable<string | TNull> | VectorBuilderOptions<Utf8, TNull> | VectorBuilderOptionsAsync<Utf8, TNull>) {\n        return vectorFromValuesWithType(() => new Utf8(), input);\n    }\n    public asBinary() {\n        return Vector.new(this.data.clone(new Binary()));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\n/** @ignore */\nexport function partial0<T>(visit: (node: T) => any) {\n    return function(this: T) { return visit(this); };\n}\n\n/** @ignore */\nexport function partial1<T>(visit: (node: T, a: any) => any) {\n    return function(this: T, a: any) { return visit(this, a); };\n}\n\n/** @ignore */\nexport function partial2<T>(visit: (node: T, a: any, b: any) => any) {\n    return function(this: T, a: any, b: any) { return visit(this, a, b); };\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { BN } from '../util/bn';\nimport { Visitor } from '../visitor';\nimport { decodeUtf8 } from '../util/utf8';\nimport { VectorType } from '../interfaces';\nimport { uint16ToFloat64 } from '../util/math';\nimport { Type, UnionMode, Precision, DateUnit, TimeUnit, IntervalUnit } from '../enum';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface GetVisitor extends Visitor {\n    visit<T extends VectorType>  (node: T, index: number): T['TValue'];\n    visitMany<T extends VectorType>  (nodes: T[], indices: number[]): T['TValue'][];\n    getVisitFn<T extends Type>    (node: T): (vector: VectorType<T>, index: number) => VectorType<T>['TValue'];\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>, index: number) => VectorType<T>['TValue'];\n    visitNull                 <T extends Null>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitBool                 <T extends Bool>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt                  <T extends Int>                  (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt8                 <T extends Int8>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt16                <T extends Int16>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt32                <T extends Int32>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitInt64                <T extends Int64>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint8                <T extends Uint8>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint16               <T extends Uint16>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint32               <T extends Uint32>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitUint64               <T extends Uint64>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat                <T extends Float>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat16              <T extends Float16>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat32              <T extends Float32>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitFloat64              <T extends Float64>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitUtf8                 <T extends Utf8>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitBinary               <T extends Binary>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitFixedSizeBinary      <T extends FixedSizeBinary>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitDate                 <T extends Date_>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitDateDay              <T extends DateDay>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitDateMillisecond      <T extends DateMillisecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestamp            <T extends Timestamp>            (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampSecond      <T extends TimestampSecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampMillisecond <T extends TimestampMillisecond> (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampMicrosecond <T extends TimestampMicrosecond> (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimestampNanosecond  <T extends TimestampNanosecond>  (vector: VectorType<T>, index: number): T['TValue'];\n    visitTime                 <T extends Time>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeSecond           <T extends TimeSecond>           (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeMillisecond      <T extends TimeMillisecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeMicrosecond      <T extends TimeMicrosecond>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitTimeNanosecond       <T extends TimeNanosecond>       (vector: VectorType<T>, index: number): T['TValue'];\n    visitDecimal              <T extends Decimal>              (vector: VectorType<T>, index: number): T['TValue'];\n    visitList                 <T extends List>                 (vector: VectorType<T>, index: number): T['TValue'];\n    visitStruct               <T extends Struct>               (vector: VectorType<T>, index: number): T['TValue'];\n    visitUnion                <T extends Union>                (vector: VectorType<T>, index: number): T['TValue'];\n    visitDenseUnion           <T extends DenseUnion>           (vector: VectorType<T>, index: number): T['TValue'];\n    visitSparseUnion          <T extends SparseUnion>          (vector: VectorType<T>, index: number): T['TValue'];\n    visitDictionary           <T extends Dictionary>           (vector: VectorType<T>, index: number): T['TValue'];\n    visitInterval             <T extends Interval>             (vector: VectorType<T>, index: number): T['TValue'];\n    visitIntervalDayTime      <T extends IntervalDayTime>      (vector: VectorType<T>, index: number): T['TValue'];\n    visitIntervalYearMonth    <T extends IntervalYearMonth>    (vector: VectorType<T>, index: number): T['TValue'];\n    visitFixedSizeList        <T extends FixedSizeList>        (vector: VectorType<T>, index: number): T['TValue'];\n    visitMap                  <T extends Map_>                 (vector: VectorType<T>, index: number): T['TValue'];\n}\n\n/** @ignore */\nexport class GetVisitor extends Visitor {}\n\n/** @ignore */const epochDaysToMs = (data: Int32Array, index: number) => 86400000 * data[index];\n/** @ignore */const epochMillisecondsLongToMs = (data: Int32Array, index: number) => 4294967296 * (data[index + 1]) + (data[index] >>> 0);\n/** @ignore */const epochMicrosecondsLongToMs = (data: Int32Array, index: number) => 4294967296 * (data[index + 1] / 1000) + ((data[index] >>> 0) / 1000);\n/** @ignore */const epochNanosecondsLongToMs = (data: Int32Array, index: number) => 4294967296 * (data[index + 1] / 1000000) + ((data[index] >>> 0) / 1000000);\n\n/** @ignore */const epochMillisecondsToDate = (epochMs: number) => new Date(epochMs);\n/** @ignore */const epochDaysToDate = (data: Int32Array, index: number) => epochMillisecondsToDate(epochDaysToMs(data, index));\n/** @ignore */const epochMillisecondsLongToDate = (data: Int32Array, index: number) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index));\n\n/** @ignore */\nconst getNull = <T extends Null>(_vector: VectorType<T>, _index: number): T['TValue'] => null;\n/** @ignore */\nconst getVariableWidthBytes = (values: Uint8Array, valueOffsets: Int32Array, index: number) => {\n    const { [index]: x, [index + 1]: y } = valueOffsets;\n    return x != null && y != null ? values.subarray(x, y) : null as any;\n};\n\n/** @ignore */\nconst getBool = <T extends Bool>({ offset, values }: VectorType<T>, index: number): T['TValue'] => {\n    const idx = offset + index;\n    const byte = values[idx >> 3];\n    return (byte & 1 << (idx % 8)) !== 0;\n};\n\n/** @ignore */\ntype Numeric1X = Int8 | Int16 | Int32 | Uint8 | Uint16 | Uint32 | Float32 | Float64;\n/** @ignore */\ntype Numeric2X = Int64 | Uint64;\n\n/** @ignore */\nconst getDateDay         = <T extends DateDay>        ({ values         }: VectorType<T>, index: number): T['TValue'] => epochDaysToDate(values, index);\n/** @ignore */\nconst getDateMillisecond = <T extends DateMillisecond>({ values         }: VectorType<T>, index: number): T['TValue'] => epochMillisecondsLongToDate(values, index * 2);\n/** @ignore */\nconst getNumeric         = <T extends Numeric1X>      ({ stride, values }: VectorType<T>, index: number): T['TValue'] => values[stride * index];\n/** @ignore */\nconst getFloat16         = <T extends Float16>        ({ stride, values }: VectorType<T>, index: number): T['TValue'] => uint16ToFloat64(values[stride * index]);\n/** @ignore */\nconst getBigInts         = <T extends Numeric2X>({ stride, values, type }: VectorType<T>, index: number): T['TValue'] => <any> BN.new(values.subarray(stride * index, stride * (index + 1)), type.isSigned);\n/** @ignore */\nconst getFixedSizeBinary = <T extends FixedSizeBinary>({ stride, values }: VectorType<T>, index: number): T['TValue'] => values.subarray(stride * index, stride * (index + 1));\n\n/** @ignore */\nconst getBinary = <T extends Binary>({ values, valueOffsets }: VectorType<T>, index: number): T['TValue'] => getVariableWidthBytes(values, valueOffsets, index);\n/** @ignore */\nconst getUtf8 = <T extends Utf8>({ values, valueOffsets }: VectorType<T>, index: number): T['TValue'] => {\n    const bytes = getVariableWidthBytes(values, valueOffsets, index);\n    return bytes !== null ? decodeUtf8(bytes) : null as any;\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst getInt = <T extends Int>(vector: VectorType<T>, index: number): T['TValue'] => (\n    vector.type.bitWidth < 64\n        ? getNumeric(vector as VectorType<Numeric1X>, index)\n        : getBigInts(vector as VectorType<Numeric2X>, index)\n);\n\n/* istanbul ignore next */\n/** @ignore */\nconst getFloat = <T extends Float> (vector: VectorType<T>, index: number): T['TValue'] => (\n    vector.type.precision !== Precision.HALF\n        ? getNumeric(vector as VectorType<Numeric1X>, index)\n        : getFloat16(vector as VectorType<Float16>, index)\n);\n\n/* istanbul ignore next */\n/** @ignore */\nconst getDate = <T extends Date_> (vector: VectorType<T>, index: number): T['TValue'] => (\n    vector.type.unit === DateUnit.DAY\n        ? getDateDay(vector as VectorType<DateDay>, index)\n        : getDateMillisecond(vector as VectorType<DateMillisecond>, index)\n);\n\n/** @ignore */\nconst getTimestampSecond      = <T extends TimestampSecond>     ({ values }: VectorType<T>, index: number): T['TValue'] => 1000 * epochMillisecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampMillisecond = <T extends TimestampMillisecond>({ values }: VectorType<T>, index: number): T['TValue'] => epochMillisecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampMicrosecond = <T extends TimestampMicrosecond>({ values }: VectorType<T>, index: number): T['TValue'] => epochMicrosecondsLongToMs(values, index * 2);\n/** @ignore */\nconst getTimestampNanosecond  = <T extends TimestampNanosecond> ({ values }: VectorType<T>, index: number): T['TValue'] => epochNanosecondsLongToMs(values, index * 2);\n/* istanbul ignore next */\n/** @ignore */\nconst getTimestamp            = <T extends Timestamp>(vector: VectorType<T>, index: number): T['TValue'] => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      getTimestampSecond(vector as VectorType<TimestampSecond>, index);\n        case TimeUnit.MILLISECOND: return getTimestampMillisecond(vector as VectorType<TimestampMillisecond>, index);\n        case TimeUnit.MICROSECOND: return getTimestampMicrosecond(vector as VectorType<TimestampMicrosecond>, index);\n        case TimeUnit.NANOSECOND:  return  getTimestampNanosecond(vector as VectorType<TimestampNanosecond>, index);\n    }\n};\n\n/** @ignore */\nconst getTimeSecond      = <T extends TimeSecond>     ({ values, stride }: VectorType<T>, index: number): T['TValue'] => values[stride * index];\n/** @ignore */\nconst getTimeMillisecond = <T extends TimeMillisecond>({ values, stride }: VectorType<T>, index: number): T['TValue'] => values[stride * index];\n/** @ignore */\nconst getTimeMicrosecond = <T extends TimeMicrosecond>({ values         }: VectorType<T>, index: number): T['TValue'] => BN.signed(values.subarray(2 * index, 2 * (index + 1)));\n/** @ignore */\nconst getTimeNanosecond  = <T extends TimeNanosecond> ({ values         }: VectorType<T>, index: number): T['TValue'] => BN.signed(values.subarray(2 * index, 2 * (index + 1)));\n/* istanbul ignore next */\n/** @ignore */\nconst getTime            = <T extends Time>(vector: VectorType<T>, index: number): T['TValue'] => {\n    switch (vector.type.unit) {\n        case TimeUnit.SECOND:      return      getTimeSecond(vector as VectorType<TimeSecond>, index);\n        case TimeUnit.MILLISECOND: return getTimeMillisecond(vector as VectorType<TimeMillisecond>, index);\n        case TimeUnit.MICROSECOND: return getTimeMicrosecond(vector as VectorType<TimeMicrosecond>, index);\n        case TimeUnit.NANOSECOND:  return  getTimeNanosecond(vector as VectorType<TimeNanosecond>, index);\n    }\n};\n\n/** @ignore */\nconst getDecimal = <T extends Decimal>({ values }: VectorType<T>, index: number): T['TValue'] => BN.decimal(values.subarray(4 * index, 4 * (index + 1)));\n\n/** @ignore */\nconst getList = <T extends List>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const child = vector.getChildAt(0)!, { valueOffsets, stride } = vector;\n    return child.slice(valueOffsets[index * stride], valueOffsets[(index * stride) + 1]) as T['TValue'];\n};\n\n/** @ignore */\nconst getMap = <T extends Map_>(vector: VectorType<T>, index: number): T['TValue'] => {\n    return vector.bind(index) as T['TValue'];\n};\n\n/** @ignore */\nconst getStruct = <T extends Struct>(vector: VectorType<T>, index: number): T['TValue'] => {\n    return vector.bind(index) as T['TValue'];\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst getUnion = <\n    V extends VectorType<Union> | VectorType<DenseUnion> | VectorType<SparseUnion>\n>(vector: V, index: number): V['TValue'] => {\n    return vector.type.mode === UnionMode.Dense ?\n        getDenseUnion(vector as VectorType<DenseUnion>, index) :\n        getSparseUnion(vector as VectorType<SparseUnion>, index);\n};\n\n/** @ignore */\nconst getDenseUnion = <T extends DenseUnion>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    return child ? child.get(vector.valueOffsets[index]) : null;\n};\n\n/** @ignore */\nconst getSparseUnion = <T extends SparseUnion>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const childIndex = vector.typeIdToChildIndex[vector.typeIds[index]];\n    const child = vector.getChildAt(childIndex);\n    return child ? child.get(index) : null;\n};\n\n/** @ignore */\nconst getDictionary = <T extends Dictionary>(vector: VectorType<T>, index: number): T['TValue'] => {\n    return vector.getValue(vector.getKey(index)!);\n};\n\n/* istanbul ignore next */\n/** @ignore */\nconst getInterval = <T extends Interval>(vector: VectorType<T>, index: number): T['TValue'] =>\n    (vector.type.unit === IntervalUnit.DAY_TIME)\n        ? getIntervalDayTime(vector as VectorType<IntervalDayTime>, index)\n        : getIntervalYearMonth(vector as VectorType<IntervalYearMonth>, index);\n\n/** @ignore */\nconst getIntervalDayTime = <T extends IntervalDayTime>({ values }: VectorType<T>, index: number): T['TValue'] => values.subarray(2 * index, 2 * (index + 1));\n\n/** @ignore */\nconst getIntervalYearMonth = <T extends IntervalYearMonth>({ values }: VectorType<T>, index: number): T['TValue'] => {\n    const interval = values[index];\n    const int32s = new Int32Array(2);\n    int32s[0] = interval / 12 | 0; /* years */\n    int32s[1] = interval % 12 | 0; /* months */\n    return int32s;\n};\n\n/** @ignore */\nconst getFixedSizeList = <T extends FixedSizeList>(vector: VectorType<T>, index: number): T['TValue'] => {\n    const child = vector.getChildAt(0)!, { stride } = vector;\n    return child.slice(index * stride, (index + 1) * stride) as T['TValue'];\n};\n\nGetVisitor.prototype.visitNull                 =                 getNull;\nGetVisitor.prototype.visitBool                 =                 getBool;\nGetVisitor.prototype.visitInt                  =                  getInt;\nGetVisitor.prototype.visitInt8                 =              getNumeric;\nGetVisitor.prototype.visitInt16                =              getNumeric;\nGetVisitor.prototype.visitInt32                =              getNumeric;\nGetVisitor.prototype.visitInt64                =              getBigInts;\nGetVisitor.prototype.visitUint8                =              getNumeric;\nGetVisitor.prototype.visitUint16               =              getNumeric;\nGetVisitor.prototype.visitUint32               =              getNumeric;\nGetVisitor.prototype.visitUint64               =              getBigInts;\nGetVisitor.prototype.visitFloat                =                getFloat;\nGetVisitor.prototype.visitFloat16              =              getFloat16;\nGetVisitor.prototype.visitFloat32              =              getNumeric;\nGetVisitor.prototype.visitFloat64              =              getNumeric;\nGetVisitor.prototype.visitUtf8                 =                 getUtf8;\nGetVisitor.prototype.visitBinary               =               getBinary;\nGetVisitor.prototype.visitFixedSizeBinary      =      getFixedSizeBinary;\nGetVisitor.prototype.visitDate                 =                 getDate;\nGetVisitor.prototype.visitDateDay              =              getDateDay;\nGetVisitor.prototype.visitDateMillisecond      =      getDateMillisecond;\nGetVisitor.prototype.visitTimestamp            =            getTimestamp;\nGetVisitor.prototype.visitTimestampSecond      =      getTimestampSecond;\nGetVisitor.prototype.visitTimestampMillisecond = getTimestampMillisecond;\nGetVisitor.prototype.visitTimestampMicrosecond = getTimestampMicrosecond;\nGetVisitor.prototype.visitTimestampNanosecond  =  getTimestampNanosecond;\nGetVisitor.prototype.visitTime                 =                 getTime;\nGetVisitor.prototype.visitTimeSecond           =           getTimeSecond;\nGetVisitor.prototype.visitTimeMillisecond      =      getTimeMillisecond;\nGetVisitor.prototype.visitTimeMicrosecond      =      getTimeMicrosecond;\nGetVisitor.prototype.visitTimeNanosecond       =       getTimeNanosecond;\nGetVisitor.prototype.visitDecimal              =              getDecimal;\nGetVisitor.prototype.visitList                 =                 getList;\nGetVisitor.prototype.visitStruct               =               getStruct;\nGetVisitor.prototype.visitUnion                =                getUnion;\nGetVisitor.prototype.visitDenseUnion           =           getDenseUnion;\nGetVisitor.prototype.visitSparseUnion          =          getSparseUnion;\nGetVisitor.prototype.visitDictionary           =           getDictionary;\nGetVisitor.prototype.visitInterval             =             getInterval;\nGetVisitor.prototype.visitIntervalDayTime      =      getIntervalDayTime;\nGetVisitor.prototype.visitIntervalYearMonth    =    getIntervalYearMonth;\nGetVisitor.prototype.visitFixedSizeList        =        getFixedSizeList;\nGetVisitor.prototype.visitMap                  =                  getMap;\n\n/** @ignore */\nexport const instance = new GetVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { getBool, iterateBits } from '../util/bit';\nimport { createElementComparator } from '../util/vector';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface IndexOfVisitor extends Visitor {\n    visit<T extends VectorType>  (node: T, value: T['TValue'] | null, index?: number): number;\n    visitMany <T extends VectorType>  (nodes: T[], values: (T['TValue'] | null)[], indices: (number | undefined)[]): number[];\n    getVisitFn<T extends Type>    (node: T): (vector: VectorType<T>, value: VectorType<T>['TValue'] | null, index?: number) => number;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>, value:         T['TValue'] | null, index?: number) => number;\n    visitNull                 <T extends Null>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitBool                 <T extends Bool>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt                  <T extends Int>                 (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt8                 <T extends Int8>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt16                <T extends Int16>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt32                <T extends Int32>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInt64                <T extends Int64>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint8                <T extends Uint8>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint16               <T extends Uint16>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint32               <T extends Uint32>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUint64               <T extends Uint64>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat                <T extends Float>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat16              <T extends Float16>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat32              <T extends Float32>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFloat64              <T extends Float64>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUtf8                 <T extends Utf8>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitBinary               <T extends Binary>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDate                 <T extends Date_>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDateDay              <T extends DateDay>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDateMillisecond      <T extends DateMillisecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestamp            <T extends Timestamp>           (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampSecond      <T extends TimestampSecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampMillisecond <T extends TimestampMillisecond>(vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond>(vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimestampNanosecond  <T extends TimestampNanosecond> (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTime                 <T extends Time>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeSecond           <T extends TimeSecond>          (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeMillisecond      <T extends TimeMillisecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitTimeNanosecond       <T extends TimeNanosecond>      (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDecimal              <T extends Decimal>             (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitList                 <T extends List>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitStruct               <T extends Struct>              (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitUnion                <T extends Union>               (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDenseUnion           <T extends DenseUnion>          (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitSparseUnion          <T extends SparseUnion>         (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitDictionary           <T extends Dictionary>          (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitInterval             <T extends Interval>            (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitIntervalDayTime      <T extends IntervalDayTime>     (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>   (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitFixedSizeList        <T extends FixedSizeList>       (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n    visitMap                  <T extends Map_>                (vector: VectorType<T>, value: T['TValue'] | null, index?: number): number;\n}\n\n/** @ignore */\nexport class IndexOfVisitor extends Visitor {}\n\n/** @ignore */\nfunction nullIndexOf(vector: VectorType<Null>, searchElement?: null) {\n    // if you're looking for nulls and the vector isn't empty, we've got 'em!\n    return searchElement === null && vector.length > 0 ? 0 : -1;\n}\n\n/** @ignore */\nfunction indexOfNull<T extends DataType>(vector: VectorType<T>, fromIndex?: number): number {\n    const { nullBitmap } = vector;\n    if (!nullBitmap || vector.nullCount <= 0) {\n        return -1;\n    }\n    let i = 0;\n    for (const isValid of iterateBits(nullBitmap, vector.data.offset + (fromIndex || 0), vector.length, nullBitmap, getBool)) {\n        if (!isValid) { return i; }\n        ++i;\n    }\n    return -1;\n}\n\n/** @ignore */\nfunction indexOfValue<T extends DataType>(vector: VectorType<T>, searchElement?: T['TValue'] | null, fromIndex?: number): number {\n    if (searchElement === undefined) { return -1; }\n    if (searchElement === null) { return indexOfNull(vector, fromIndex); }\n    const compare = createElementComparator(searchElement);\n    for (let i = (fromIndex || 0) - 1, n = vector.length; ++i < n;) {\n        if (compare(vector.get(i))) {\n            return i;\n        }\n    }\n    return -1;\n}\n\n/** @ignore */\nfunction indexOfUnion<T extends DataType>(vector: VectorType<T>, searchElement?: T['TValue'] | null, fromIndex?: number): number {\n    // Unions are special -- they do have a nullBitmap, but so can their children.\n    // If the searchElement is null, we don't know whether it came from the Union's\n    // bitmap or one of its childrens'. So we don't interrogate the Union's bitmap,\n    // since that will report the wrong index if a child has a null before the Union.\n    const compare = createElementComparator(searchElement);\n    for (let i = (fromIndex || 0) - 1, n = vector.length; ++i < n;) {\n        if (compare(vector.get(i))) {\n            return i;\n        }\n    }\n    return -1;\n}\n\nIndexOfVisitor.prototype.visitNull                 =  nullIndexOf;\nIndexOfVisitor.prototype.visitBool                 = indexOfValue;\nIndexOfVisitor.prototype.visitInt                  = indexOfValue;\nIndexOfVisitor.prototype.visitInt8                 = indexOfValue;\nIndexOfVisitor.prototype.visitInt16                = indexOfValue;\nIndexOfVisitor.prototype.visitInt32                = indexOfValue;\nIndexOfVisitor.prototype.visitInt64                = indexOfValue;\nIndexOfVisitor.prototype.visitUint8                = indexOfValue;\nIndexOfVisitor.prototype.visitUint16               = indexOfValue;\nIndexOfVisitor.prototype.visitUint32               = indexOfValue;\nIndexOfVisitor.prototype.visitUint64               = indexOfValue;\nIndexOfVisitor.prototype.visitFloat                = indexOfValue;\nIndexOfVisitor.prototype.visitFloat16              = indexOfValue;\nIndexOfVisitor.prototype.visitFloat32              = indexOfValue;\nIndexOfVisitor.prototype.visitFloat64              = indexOfValue;\nIndexOfVisitor.prototype.visitUtf8                 = indexOfValue;\nIndexOfVisitor.prototype.visitBinary               = indexOfValue;\nIndexOfVisitor.prototype.visitFixedSizeBinary      = indexOfValue;\nIndexOfVisitor.prototype.visitDate                 = indexOfValue;\nIndexOfVisitor.prototype.visitDateDay              = indexOfValue;\nIndexOfVisitor.prototype.visitDateMillisecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimestamp            = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampSecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampMillisecond = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampMicrosecond = indexOfValue;\nIndexOfVisitor.prototype.visitTimestampNanosecond  = indexOfValue;\nIndexOfVisitor.prototype.visitTime                 = indexOfValue;\nIndexOfVisitor.prototype.visitTimeSecond           = indexOfValue;\nIndexOfVisitor.prototype.visitTimeMillisecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimeMicrosecond      = indexOfValue;\nIndexOfVisitor.prototype.visitTimeNanosecond       = indexOfValue;\nIndexOfVisitor.prototype.visitDecimal              = indexOfValue;\nIndexOfVisitor.prototype.visitList                 = indexOfValue;\nIndexOfVisitor.prototype.visitStruct               = indexOfValue;\nIndexOfVisitor.prototype.visitUnion                = indexOfValue;\nIndexOfVisitor.prototype.visitDenseUnion           = indexOfUnion;\nIndexOfVisitor.prototype.visitSparseUnion          = indexOfUnion;\nIndexOfVisitor.prototype.visitDictionary           = indexOfValue;\nIndexOfVisitor.prototype.visitInterval             = indexOfValue;\nIndexOfVisitor.prototype.visitIntervalDayTime      = indexOfValue;\nIndexOfVisitor.prototype.visitIntervalYearMonth    = indexOfValue;\nIndexOfVisitor.prototype.visitFixedSizeList        = indexOfValue;\nIndexOfVisitor.prototype.visitMap                  = indexOfValue;\n\n/** @ignore */\nexport const instance = new IndexOfVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { iterateBits } from '../util/bit';\nimport { instance as getVisitor } from './get';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface IteratorVisitor extends Visitor {\n    visit<T extends VectorType>(node: T): IterableIterator<T['TValue'] | null>;\n    visitMany <T extends VectorType>(nodes: T[]): IterableIterator<T['TValue'] | null>[];\n    getVisitFn<T extends Type>(node: T): (vector: VectorType<T>) => IterableIterator<VectorType<T>['TValue'] | null>;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>) => IterableIterator<VectorType<T>['TValue'] | null>;\n    visitNull                 <T extends Null>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitBool                 <T extends Bool>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt                  <T extends Int>                  (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt8                 <T extends Int8>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt16                <T extends Int16>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt32                <T extends Int32>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInt64                <T extends Int64>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint8                <T extends Uint8>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint16               <T extends Uint16>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint32               <T extends Uint32>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUint64               <T extends Uint64>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat                <T extends Float>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat16              <T extends Float16>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat32              <T extends Float32>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFloat64              <T extends Float64>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUtf8                 <T extends Utf8>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitBinary               <T extends Binary>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFixedSizeBinary      <T extends FixedSizeBinary>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDate                 <T extends Date_>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDateDay              <T extends DateDay>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDateMillisecond      <T extends DateMillisecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestamp            <T extends Timestamp>            (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampSecond      <T extends TimestampSecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampMillisecond <T extends TimestampMillisecond> (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampMicrosecond <T extends TimestampMicrosecond> (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimestampNanosecond  <T extends TimestampNanosecond>  (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTime                 <T extends Time>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeSecond           <T extends TimeSecond>           (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeMillisecond      <T extends TimeMillisecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeMicrosecond      <T extends TimeMicrosecond>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitTimeNanosecond       <T extends TimeNanosecond>       (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDecimal              <T extends Decimal>              (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitList                 <T extends List>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitStruct               <T extends Struct>               (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitUnion                <T extends Union>                (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDenseUnion           <T extends DenseUnion>           (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitSparseUnion          <T extends SparseUnion>          (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitDictionary           <T extends Dictionary>           (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitInterval             <T extends Interval>             (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitIntervalDayTime      <T extends IntervalDayTime>      (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitIntervalYearMonth    <T extends IntervalYearMonth>    (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitFixedSizeList        <T extends FixedSizeList>        (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n    visitMap                  <T extends Map_>                 (vector: VectorType<T>): IterableIterator<T['TValue'] | null>;\n}\n\n/** @ignore */\nexport class IteratorVisitor extends Visitor {}\n\n/** @ignore */\nfunction nullableIterator<T extends DataType>(vector: VectorType<T>): IterableIterator<T['TValue'] | null> {\n    const getFn = getVisitor.getVisitFn(vector);\n    return iterateBits<T['TValue'] | null>(\n        vector.nullBitmap, vector.offset, vector.length, vector,\n        (vec: VectorType<T>, idx: number, nullByte: number, nullBit: number) =>\n            ((nullByte & 1 << nullBit) !== 0) ? getFn(vec, idx) : null\n    );\n}\n\n/** @ignore */\nfunction vectorIterator<T extends DataType>(vector: VectorType<T>): IterableIterator<T['TValue'] | null> {\n\n    // If nullable, iterate manually\n    if (vector.nullCount > 0) {\n        return nullableIterator<T>(vector);\n    }\n\n    const { type, typeId, length } = vector;\n\n    // Fast case, defer to native iterators if possible\n    if (vector.stride === 1 && (\n        (typeId === Type.Timestamp) ||\n        (typeId === Type.Int && (type as Int).bitWidth !== 64) ||\n        (typeId === Type.Time && (type as Time).bitWidth !== 64) ||\n        (typeId === Type.Float && (type as Float).precision > 0 /* Precision.HALF */)\n    )) {\n        return vector.values.subarray(0, length)[Symbol.iterator]();\n    }\n\n    // Otherwise, iterate manually\n    return (function* (getFn) {\n        for (let index = -1; ++index < length;) {\n            yield getFn(vector, index);\n        }\n    })(getVisitor.getVisitFn(vector));\n}\n\nIteratorVisitor.prototype.visitNull                 = vectorIterator;\nIteratorVisitor.prototype.visitBool                 = vectorIterator;\nIteratorVisitor.prototype.visitInt                  = vectorIterator;\nIteratorVisitor.prototype.visitInt8                 = vectorIterator;\nIteratorVisitor.prototype.visitInt16                = vectorIterator;\nIteratorVisitor.prototype.visitInt32                = vectorIterator;\nIteratorVisitor.prototype.visitInt64                = vectorIterator;\nIteratorVisitor.prototype.visitUint8                = vectorIterator;\nIteratorVisitor.prototype.visitUint16               = vectorIterator;\nIteratorVisitor.prototype.visitUint32               = vectorIterator;\nIteratorVisitor.prototype.visitUint64               = vectorIterator;\nIteratorVisitor.prototype.visitFloat                = vectorIterator;\nIteratorVisitor.prototype.visitFloat16              = vectorIterator;\nIteratorVisitor.prototype.visitFloat32              = vectorIterator;\nIteratorVisitor.prototype.visitFloat64              = vectorIterator;\nIteratorVisitor.prototype.visitUtf8                 = vectorIterator;\nIteratorVisitor.prototype.visitBinary               = vectorIterator;\nIteratorVisitor.prototype.visitFixedSizeBinary      = vectorIterator;\nIteratorVisitor.prototype.visitDate                 = vectorIterator;\nIteratorVisitor.prototype.visitDateDay              = vectorIterator;\nIteratorVisitor.prototype.visitDateMillisecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimestamp            = vectorIterator;\nIteratorVisitor.prototype.visitTimestampSecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimestampMillisecond = vectorIterator;\nIteratorVisitor.prototype.visitTimestampMicrosecond = vectorIterator;\nIteratorVisitor.prototype.visitTimestampNanosecond  = vectorIterator;\nIteratorVisitor.prototype.visitTime                 = vectorIterator;\nIteratorVisitor.prototype.visitTimeSecond           = vectorIterator;\nIteratorVisitor.prototype.visitTimeMillisecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimeMicrosecond      = vectorIterator;\nIteratorVisitor.prototype.visitTimeNanosecond       = vectorIterator;\nIteratorVisitor.prototype.visitDecimal              = vectorIterator;\nIteratorVisitor.prototype.visitList                 = vectorIterator;\nIteratorVisitor.prototype.visitStruct               = vectorIterator;\nIteratorVisitor.prototype.visitUnion                = vectorIterator;\nIteratorVisitor.prototype.visitDenseUnion           = vectorIterator;\nIteratorVisitor.prototype.visitSparseUnion          = vectorIterator;\nIteratorVisitor.prototype.visitDictionary           = vectorIterator;\nIteratorVisitor.prototype.visitInterval             = vectorIterator;\nIteratorVisitor.prototype.visitIntervalDayTime      = vectorIterator;\nIteratorVisitor.prototype.visitIntervalYearMonth    = vectorIterator;\nIteratorVisitor.prototype.visitFixedSizeList        = vectorIterator;\nIteratorVisitor.prototype.visitMap                  = vectorIterator;\n\n/** @ignore */\nexport const instance = new IteratorVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { instance as iteratorVisitor } from './iterator';\nimport {\n    DataType, Dictionary,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary, List, FixedSizeList, Map_, Struct,\n    Float, Float16, Float32, Float64,\n    Int, Uint8, Uint16, Uint32, Uint64, Int8, Int16, Int32, Int64,\n    Date_, DateDay, DateMillisecond,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Union, DenseUnion, SparseUnion,\n} from '../type';\n\n/** @ignore */\nexport interface ToArrayVisitor extends Visitor {\n    visit<T extends VectorType>(node: T): T['TArray'];\n    visitMany<T extends VectorType>(nodes: T[]): T['TArray'][];\n    getVisitFn<T extends Type>(node: T): (vector: VectorType<T>) => VectorType<T>['TArray'];\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (vector: VectorType<T>) => VectorType<T>['TArray'];\n    visitNull                                    <T extends Null>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitBool                                    <T extends Bool>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt                                     <T extends Int>                 (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt8                                    <T extends Int8>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt16                                   <T extends Int16>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt32                                   <T extends Int32>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInt64                                   <T extends Int64>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint8                                   <T extends Uint8>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint16                                  <T extends Uint16>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint32                                  <T extends Uint32>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUint64                                  <T extends Uint64>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat                                   <T extends Float>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat16                                 <T extends Float16>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat32                                 <T extends Float32>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFloat64                                 <T extends Float64>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUtf8                                    <T extends Utf8>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitBinary                                  <T extends Binary>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFixedSizeBinary                         <T extends FixedSizeBinary>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDate                                    <T extends Date_>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDateDay                                 <T extends DateDay>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDateMillisecond                         <T extends DateMillisecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestamp                               <T extends Timestamp>           (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampSecond                         <T extends TimestampSecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampMillisecond                    <T extends TimestampMillisecond>(vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampMicrosecond                    <T extends TimestampMicrosecond>(vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimestampNanosecond                     <T extends TimestampNanosecond> (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTime                                    <T extends Time>                (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeSecond                              <T extends TimeSecond>          (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeMillisecond                         <T extends TimeMillisecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeMicrosecond                         <T extends TimeMicrosecond>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitTimeNanosecond                          <T extends TimeNanosecond>      (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDecimal                                 <T extends Decimal>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitList                <R extends DataType, T extends List<R>>             (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitStruct                                  <T extends Struct>              (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitUnion                                   <T extends Union>               (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDenseUnion                              <T extends DenseUnion>          (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitSparseUnion                             <T extends SparseUnion>         (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitDictionary          <R extends DataType, T extends Dictionary<R>>       (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitInterval                                <T extends Interval>            (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitIntervalDayTime                         <T extends IntervalDayTime>     (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitIntervalYearMonth                       <T extends IntervalYearMonth>   (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitFixedSizeList       <R extends DataType, T extends FixedSizeList<R>>    (vector: VectorType<T>): VectorType<T>['TArray'];\n    visitMap                                     <T extends Map_>                (vector: VectorType<T>): VectorType<T>['TArray'];\n}\n\n/** @ignore */\nexport class ToArrayVisitor extends Visitor {}\n\n/** @ignore */\nfunction arrayOfVector<T extends DataType>(vector: VectorType<T>): T['TArray'] {\n\n    const { type, length, stride } = vector;\n\n    // Fast case, return subarray if possible\n    switch (type.typeId) {\n        case Type.Int:\n        case Type.Float: case Type.Decimal:\n        case Type.Time: case Type.Timestamp:\n            return vector.values.subarray(0, length * stride);\n    }\n\n    // Otherwise if not primitive, slow copy\n    return [...iteratorVisitor.visit(vector)] as T['TArray'];\n}\n\nToArrayVisitor.prototype.visitNull                 = arrayOfVector;\nToArrayVisitor.prototype.visitBool                 = arrayOfVector;\nToArrayVisitor.prototype.visitInt                  = arrayOfVector;\nToArrayVisitor.prototype.visitInt8                 = arrayOfVector;\nToArrayVisitor.prototype.visitInt16                = arrayOfVector;\nToArrayVisitor.prototype.visitInt32                = arrayOfVector;\nToArrayVisitor.prototype.visitInt64                = arrayOfVector;\nToArrayVisitor.prototype.visitUint8                = arrayOfVector;\nToArrayVisitor.prototype.visitUint16               = arrayOfVector;\nToArrayVisitor.prototype.visitUint32               = arrayOfVector;\nToArrayVisitor.prototype.visitUint64               = arrayOfVector;\nToArrayVisitor.prototype.visitFloat                = arrayOfVector;\nToArrayVisitor.prototype.visitFloat16              = arrayOfVector;\nToArrayVisitor.prototype.visitFloat32              = arrayOfVector;\nToArrayVisitor.prototype.visitFloat64              = arrayOfVector;\nToArrayVisitor.prototype.visitUtf8                 = arrayOfVector;\nToArrayVisitor.prototype.visitBinary               = arrayOfVector;\nToArrayVisitor.prototype.visitFixedSizeBinary      = arrayOfVector;\nToArrayVisitor.prototype.visitDate                 = arrayOfVector;\nToArrayVisitor.prototype.visitDateDay              = arrayOfVector;\nToArrayVisitor.prototype.visitDateMillisecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimestamp            = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampSecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampMillisecond = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampMicrosecond = arrayOfVector;\nToArrayVisitor.prototype.visitTimestampNanosecond  = arrayOfVector;\nToArrayVisitor.prototype.visitTime                 = arrayOfVector;\nToArrayVisitor.prototype.visitTimeSecond           = arrayOfVector;\nToArrayVisitor.prototype.visitTimeMillisecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimeMicrosecond      = arrayOfVector;\nToArrayVisitor.prototype.visitTimeNanosecond       = arrayOfVector;\nToArrayVisitor.prototype.visitDecimal              = arrayOfVector;\nToArrayVisitor.prototype.visitList                 = arrayOfVector;\nToArrayVisitor.prototype.visitStruct               = arrayOfVector;\nToArrayVisitor.prototype.visitUnion                = arrayOfVector;\nToArrayVisitor.prototype.visitDenseUnion           = arrayOfVector;\nToArrayVisitor.prototype.visitSparseUnion          = arrayOfVector;\nToArrayVisitor.prototype.visitDictionary           = arrayOfVector;\nToArrayVisitor.prototype.visitInterval             = arrayOfVector;\nToArrayVisitor.prototype.visitIntervalDayTime      = arrayOfVector;\nToArrayVisitor.prototype.visitIntervalYearMonth    = arrayOfVector;\nToArrayVisitor.prototype.visitFixedSizeList        = arrayOfVector;\nToArrayVisitor.prototype.visitMap                  = arrayOfVector;\n\n/** @ignore */\nexport const instance = new ToArrayVisitor();\n","/* istanbul ignore file */\n\n// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Visitor } from '../visitor';\nimport { VectorType } from '../interfaces';\nimport { Type, TimeUnit } from '../enum';\nimport { Schema, Field } from '../schema';\nimport {\n    DataType, Dictionary,\n    Float, Int, Date_, Interval, Time, Timestamp,\n    Bool, Null, Utf8, Binary, Decimal, FixedSizeBinary,\n    List, FixedSizeList, Map_, Struct, Union,\n} from '../type';\n\n/** @ignore */ const sum = (x: number, y: number) => x + y;\n/** @ignore */ const variableWidthColumnErrorMessage = (type: DataType) => `Cannot compute the byte width of variable-width column ${type}`;\n\n/** @ignore */\nexport interface ByteWidthVisitor extends Visitor {\n    visit<T extends DataType>(node: T): number;\n    visitMany<T extends DataType>(nodes: T[]): number[];\n    getVisitFn<T extends Type>    (node: T): (type: DataType<T>) => number;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): (type: T) => number;\n}\n\n/** @ignore */\nexport class ByteWidthVisitor extends Visitor {\n    public visitNull            (____: Null            ) { return 0; }\n    public visitInt             (type: Int             ) { return type.bitWidth / 8; }\n    public visitFloat           (type: Float           ) { return type.ArrayType.BYTES_PER_ELEMENT; }\n    public visitBinary          (type: Binary          ) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    public visitUtf8            (type: Utf8            ) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    public visitBool            (____: Bool            ) { return 1 / 8; }\n    public visitDecimal         (____: Decimal         ) { return 16; }\n    public visitDate            (type: Date_           ) { return (type.unit + 1) * 4; }\n    public visitTime            (type: Time            ) { return type.bitWidth / 8; }\n    public visitTimestamp       (type: Timestamp       ) { return type.unit === TimeUnit.SECOND ? 4 : 8; }\n    public visitInterval        (type: Interval        ) { return (type.unit + 1) * 4; }\n    public visitList            (type: List            ) { throw new Error(variableWidthColumnErrorMessage(type)); }\n    public visitStruct          (type: Struct          ) { return this.visitFields(type.children).reduce(sum, 0); }\n    public visitUnion           (type: Union           ) { return this.visitFields(type.children).reduce(sum, 0); }\n    public visitFixedSizeBinary (type: FixedSizeBinary ) { return type.byteWidth; }\n    public visitFixedSizeList   (type: FixedSizeList   ) { return type.listSize * this.visitFields(type.children).reduce(sum, 0); }\n    public visitMap             (type: Map_            ) { return this.visitFields(type.children).reduce(sum, 0); }\n    public visitDictionary      (type: Dictionary      ) { return this.visit(type.indices); }\n    public visitFields          (fields: Field[]       ) { return (fields || []).map((field) => this.visit(field.type)); }\n    public visitSchema          (schema: Schema        ) { return this.visitFields(schema.fields).reduce(sum, 0); }\n}\n\n/** @ignore */\nexport const instance = new ByteWidthVisitor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { DataType } from '../type';\nimport { Visitor } from '../visitor';\nimport { VectorType, VectorCtor } from '../interfaces';\n\nimport { BinaryVector } from '../vector/binary';\nimport { BoolVector } from '../vector/bool';\nimport { DateVector, DateDayVector, DateMillisecondVector } from '../vector/date';\nimport { DecimalVector } from '../vector/decimal';\nimport { DictionaryVector } from '../vector/dictionary';\nimport { FixedSizeBinaryVector } from '../vector/fixedsizebinary';\nimport { FixedSizeListVector } from '../vector/fixedsizelist';\nimport { FloatVector, Float16Vector, Float32Vector, Float64Vector } from '../vector/float';\nimport { IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector } from '../vector/interval';\nimport { IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector } from '../vector/int';\nimport { ListVector } from '../vector/list';\nimport { MapVector } from '../vector/map';\nimport { NullVector } from '../vector/null';\nimport { StructVector } from '../vector/struct';\nimport { TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector } from '../vector/timestamp';\nimport { TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector } from '../vector/time';\nimport { UnionVector, DenseUnionVector, SparseUnionVector } from '../vector/union';\nimport { Utf8Vector } from '../vector/utf8';\n\n/** @ignore */\nexport interface GetVectorConstructor extends Visitor {\n    visit<T extends Type>(node: T): VectorCtor<T>;\n    visitMany <T extends Type>(nodes: T[]): VectorCtor<T>[];\n    getVisitFn<T extends Type>(node: T): () => VectorCtor<T>;\n    getVisitFn<T extends DataType>(node: VectorType<T> | Data<T> | T): () => VectorCtor<T>;\n}\n\n/** @ignore */\nexport class GetVectorConstructor extends Visitor {\n    public visitNull                 () { return NullVector; }\n    public visitBool                 () { return BoolVector; }\n    public visitInt                  () { return IntVector; }\n    public visitInt8                 () { return Int8Vector; }\n    public visitInt16                () { return Int16Vector; }\n    public visitInt32                () { return Int32Vector; }\n    public visitInt64                () { return Int64Vector; }\n    public visitUint8                () { return Uint8Vector; }\n    public visitUint16               () { return Uint16Vector; }\n    public visitUint32               () { return Uint32Vector; }\n    public visitUint64               () { return Uint64Vector; }\n    public visitFloat                () { return FloatVector; }\n    public visitFloat16              () { return Float16Vector; }\n    public visitFloat32              () { return Float32Vector; }\n    public visitFloat64              () { return Float64Vector; }\n    public visitUtf8                 () { return Utf8Vector; }\n    public visitBinary               () { return BinaryVector; }\n    public visitFixedSizeBinary      () { return FixedSizeBinaryVector; }\n    public visitDate                 () { return DateVector; }\n    public visitDateDay              () { return DateDayVector; }\n    public visitDateMillisecond      () { return DateMillisecondVector; }\n    public visitTimestamp            () { return TimestampVector; }\n    public visitTimestampSecond      () { return TimestampSecondVector; }\n    public visitTimestampMillisecond () { return TimestampMillisecondVector; }\n    public visitTimestampMicrosecond () { return TimestampMicrosecondVector; }\n    public visitTimestampNanosecond  () { return TimestampNanosecondVector; }\n    public visitTime                 () { return TimeVector; }\n    public visitTimeSecond           () { return TimeSecondVector; }\n    public visitTimeMillisecond      () { return TimeMillisecondVector; }\n    public visitTimeMicrosecond      () { return TimeMicrosecondVector; }\n    public visitTimeNanosecond       () { return TimeNanosecondVector; }\n    public visitDecimal              () { return DecimalVector; }\n    public visitList                 () { return ListVector; }\n    public visitStruct               () { return StructVector; }\n    public visitUnion                () { return UnionVector; }\n    public visitDenseUnion           () { return DenseUnionVector; }\n    public visitSparseUnion          () { return SparseUnionVector; }\n    public visitDictionary           () { return DictionaryVector; }\n    public visitInterval             () { return IntervalVector; }\n    public visitIntervalDayTime      () { return IntervalDayTimeVector; }\n    public visitIntervalYearMonth    () { return IntervalYearMonthVector; }\n    public visitFixedSizeList        () { return FixedSizeListVector; }\n    public visitMap                  () { return MapVector; }\n}\n\n/** @ignore */\nexport const instance = new GetVectorConstructor();\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nexport { Vector } from '../vector';\nexport { BaseVector } from './base';\nexport { BinaryVector } from './binary';\nexport { BoolVector } from './bool';\nexport { Chunked } from './chunked';\nexport { DateVector, DateDayVector, DateMillisecondVector } from './date';\nexport { DecimalVector } from './decimal';\nexport { DictionaryVector } from './dictionary';\nexport { FixedSizeBinaryVector } from './fixedsizebinary';\nexport { FixedSizeListVector } from './fixedsizelist';\nexport { FloatVector, Float16Vector, Float32Vector, Float64Vector } from './float';\nexport { IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector } from './interval';\nexport { IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector } from './int';\nexport { ListVector } from './list';\nexport { MapVector } from './map';\nexport { NullVector } from './null';\nexport { StructVector } from './struct';\nexport { TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector } from './timestamp';\nexport { TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector } from './time';\nexport { UnionVector, DenseUnionVector, SparseUnionVector } from './union';\nexport { Utf8Vector } from './utf8';\nexport { MapRow, StructRow } from './row';\n\nimport * as fn from '../util/fn';\nimport { Data } from '../data';\nimport { Type } from '../enum';\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { Chunked } from './chunked';\nimport { BaseVector } from './base';\nimport { setBool } from '../util/bit';\nimport { isIterable, isAsyncIterable } from '../util/compat';\nimport { Builder, IterableBuilderOptions } from '../builder';\nimport { VectorType as V, VectorCtorArgs } from '../interfaces';\nimport { instance as getVisitor } from '../visitor/get';\nimport { instance as setVisitor } from '../visitor/set';\nimport { instance as indexOfVisitor } from '../visitor/indexof';\nimport { instance as toArrayVisitor } from '../visitor/toarray';\nimport { instance as iteratorVisitor } from '../visitor/iterator';\nimport { instance as byteWidthVisitor } from '../visitor/bytewidth';\nimport { instance as getVectorConstructor } from '../visitor/vectorctor';\n\ndeclare module '../vector' {\n    namespace Vector {\n        export { newVector as new };\n        export { vectorFrom as from };\n    }\n}\n\ndeclare module './base' {\n    namespace BaseVector {\n        export { vectorFrom as from };\n    }\n    interface BaseVector<T extends DataType> {\n        get(index: number): T['TValue'] | null;\n        set(index: number, value: T['TValue'] | null): void;\n        indexOf(value: T['TValue'] | null, fromIndex?: number): number;\n        toArray(): T['TArray'];\n        getByteWidth(): number;\n        [Symbol.iterator](): IterableIterator<T['TValue'] | null>;\n    }\n}\n\n/** @nocollapse */\nVector.new = newVector;\n\n/** @nocollapse */\nVector.from = vectorFrom;\n\n/** @ignore */\nfunction newVector<T extends DataType>(data: Data<T>, ...args: VectorCtorArgs<V<T>>): V<T> {\n    return new (getVectorConstructor.getVisitFn<T>(data)())(data, ...args) as V<T>;\n}\n\n/** @ignore */\nexport interface VectorBuilderOptions<T extends DataType, TNull = any> extends IterableBuilderOptions<T, TNull> { values: Iterable<T['TValue'] | TNull>; }\n/** @ignore */\nexport interface VectorBuilderOptionsAsync<T extends DataType, TNull = any> extends IterableBuilderOptions<T, TNull> { values: AsyncIterable<T['TValue'] | TNull>; }\n\n/** @ignore */\nexport function vectorFromValuesWithType<T extends DataType, TNull = any>(newDataType: () => T, input: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull> | VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>) {\n    if (isIterable(input)) {\n        return Vector.from({ 'nullValues': [null, undefined], type: newDataType(), 'values': input }) as V<T>;\n    } else if (isAsyncIterable(input)) {\n        return Vector.from({ 'nullValues': [null, undefined], type: newDataType(), 'values': input }) as Promise<V<T>>;\n    }\n    const {\n        'values': values = [],\n        'type': type = newDataType(),\n        'nullValues': nullValues = [null, undefined],\n    } = { ...input };\n    return isIterable(values)\n        ? Vector.from({ nullValues, ...input, type } as VectorBuilderOptions<T, TNull>)\n        : Vector.from({ nullValues, ...input, type } as VectorBuilderOptionsAsync<T, TNull>);\n}\n\n/** @ignore */\nfunction vectorFrom<T extends DataType = any, TNull = any>(input: VectorBuilderOptions<T, TNull>): Vector<T>;\nfunction vectorFrom<T extends DataType = any, TNull = any>(input: VectorBuilderOptionsAsync<T, TNull>): Promise<Vector<T>>;\nfunction vectorFrom<T extends DataType = any, TNull = any>(input: VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>) {\n    const { 'values': values = [], ...options } = { 'nullValues': [null, undefined], ...input } as VectorBuilderOptions<T, TNull> | VectorBuilderOptionsAsync<T, TNull>;\n    if (isIterable<T['TValue'] | TNull>(values)) {\n        const chunks = [...Builder.throughIterable(options)(values)];\n        return chunks.length === 1 ? chunks[0] : Chunked.concat<T>(chunks);\n    }\n    return (async (chunks: V<T>[]) => {\n        const transform = Builder.throughAsyncIterable(options);\n        for await (const chunk of transform(values)) {\n            chunks.push(chunk);\n        }\n        return chunks.length === 1 ? chunks[0] : Chunked.concat<T>(chunks);\n    })([]);\n}\n\n//\n// We provide the following method implementations for code navigability purposes only.\n// They're overridden at runtime below with the specific Visitor implementation for each type,\n// short-circuiting the usual Visitor traversal and reducing intermediate lookups and calls.\n// This comment is here to remind you to not set breakpoints in these function bodies, or to inform\n// you why the breakpoints you have already set are not being triggered. Have a great day!\n//\n\nBaseVector.prototype.get = function baseVectorGet<T extends DataType>(this: BaseVector<T>, index: number): T['TValue'] | null {\n    return getVisitor.visit(this, index);\n};\n\nBaseVector.prototype.set = function baseVectorSet<T extends DataType>(this: BaseVector<T>, index: number, value: T['TValue'] | null): void {\n    return setVisitor.visit(this, index, value);\n};\n\nBaseVector.prototype.indexOf = function baseVectorIndexOf<T extends DataType>(this: BaseVector<T>, value: T['TValue'] | null, fromIndex?: number): number {\n    return indexOfVisitor.visit(this, value, fromIndex);\n};\n\nBaseVector.prototype.toArray = function baseVectorToArray<T extends DataType>(this: BaseVector<T>): T['TArray'] {\n    return toArrayVisitor.visit(this);\n};\n\nBaseVector.prototype.getByteWidth = function baseVectorGetByteWidth<T extends DataType>(this: BaseVector<T>): number {\n    return byteWidthVisitor.visit(this.type);\n};\n\nBaseVector.prototype[Symbol.iterator] = function baseVectorSymbolIterator<T extends DataType>(this: BaseVector<T>): IterableIterator<T['TValue'] | null> {\n    return iteratorVisitor.visit(this);\n};\n\n(BaseVector.prototype as any)._bindDataAccessors = bindBaseVectorDataAccessors;\n\n// Perf: bind and assign the operator Visitor methods to each of the Vector subclasses for each Type\n(Object.keys(Type) as any[])\n    .map((T: any) => Type[T] as any)\n    .filter((T: any): T is Type => typeof T === 'number')\n    .filter((typeId) => typeId !== Type.NONE)\n    .forEach((typeId) => {\n        const VectorCtor = getVectorConstructor.visit(typeId);\n        VectorCtor.prototype['get'] = fn.partial1(getVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['set'] = fn.partial2(setVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['indexOf'] = fn.partial2(indexOfVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['toArray'] = fn.partial0(toArrayVisitor.getVisitFn(typeId));\n        VectorCtor.prototype['getByteWidth'] = partialType0(byteWidthVisitor.getVisitFn(typeId));\n        VectorCtor.prototype[Symbol.iterator] = fn.partial0(iteratorVisitor.getVisitFn(typeId));\n    });\n\n/** @ignore */\nfunction partialType0<T extends Vector>(visit: (node: T['type']) => any) {\n    return function(this: T) { return visit(this.type); };\n}\n\n/** @ignore */\nfunction wrapNullableGet<T extends DataType, V extends Vector<T>, F extends (i: number) => any>(fn: F): (...args: Parameters<F>) => ReturnType<F> {\n    return function(this: V, i: number) { return this.isValid(i) ? fn.call(this, i) : null; };\n}\n\n/** @ignore */\nfunction wrapNullableSet<T extends DataType, V extends BaseVector<T>, F extends (i: number, a: any) => void>(fn: F): (...args: Parameters<F>) => void {\n    return function(this: V, i: number, a: any) {\n        if (setBool(this.nullBitmap, this.offset + i, !(a === null || a === undefined))) {\n            fn.call(this, i, a);\n        }\n    };\n}\n\n/** @ignore */\nfunction bindBaseVectorDataAccessors<T extends DataType>(this: BaseVector<T>) {\n    const nullBitmap = this.nullBitmap;\n    if (nullBitmap && nullBitmap.byteLength > 0) {\n        this.get = wrapNullableGet(this.get);\n        this.set = wrapNullableSet(this.set);\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Column } from './column';\nimport { Schema, Field } from './schema';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from './recordbatch';\nimport { DataFrame } from './compute/dataframe';\nimport { RecordBatchReader } from './ipc/reader';\nimport { DataType, RowLike, Struct } from './type';\nimport { selectColumnArgs, selectArgs } from './util/args';\nimport { Clonable, Sliceable, Applicative } from './vector';\nimport { isPromise, isIterable, isAsyncIterable } from './util/compat';\nimport { RecordBatchFileWriter, RecordBatchStreamWriter } from './ipc/writer';\nimport { distributeColumnsIntoRecordBatches, distributeVectorsIntoRecordBatches } from './util/recordbatch';\nimport { Vector, Chunked, StructVector, VectorBuilderOptions, VectorBuilderOptionsAsync } from './vector/index';\n\ntype VectorMap = { [key: string]: Vector };\ntype Fields<T extends { [key: string]: DataType }> = (keyof T)[] | Field<T[keyof T]>[];\ntype ChildData<T extends { [key: string]: DataType }> = Data<T[keyof T]>[] | Vector<T[keyof T]>[];\ntype Columns<T extends { [key: string]: DataType }> = Column<T[keyof T]>[] | Column<T[keyof T]>[][];\n\nexport interface Table<T extends { [key: string]: DataType } = any> {\n\n    get(index: number): Struct<T>['TValue'];\n    [Symbol.iterator](): IterableIterator<RowLike<T>>;\n\n    slice(begin?: number, end?: number): Table<T>;\n    concat(...others: Vector<Struct<T>>[]): Table<T>;\n    clone(chunks?: RecordBatch<T>[], offsets?: Uint32Array): Table<T>;\n\n    scan(next: import('./compute/dataframe').NextFunc, bind?: import('./compute/dataframe').BindFunc): void;\n    scanReverse(next: import('./compute/dataframe').NextFunc, bind?: import('./compute/dataframe').BindFunc): void;\n    countBy(name: import('./compute/predicate').Col | string): import('./compute/dataframe').CountByResult;\n    filter(predicate: import('./compute/predicate').Predicate): import('./compute/dataframe').FilteredDataFrame<T>;\n}\n\nexport class Table<T extends { [key: string]: DataType } = any>\n    extends Chunked<Struct<T>>\n    implements DataFrame<T>,\n               Clonable<Table<T>>,\n               Sliceable<Table<T>>,\n               Applicative<Struct<T>, Table<T>> {\n\n    /** @nocollapse */\n    public static empty<T extends { [key: string]: DataType } = {}>(schema = new Schema<T>([])) { return new Table<T>(schema, []); }\n\n    public static from(): Table<{}>;\n    public static from<T extends { [key: string]: DataType } = any>(source: RecordBatchReader<T>): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg0): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg2): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg1): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg3): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg4): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArg5): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: PromiseLike<RecordBatchReader<T>>): Promise<Table<T>>;\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptions<Struct<T>, TNull>): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptionsAsync<Struct<T>, TNull>): Promise<Table<T>>;\n    /** @nocollapse */\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(input?: any) {\n\n        if (!input) { return Table.empty(); }\n\n        if (typeof input === 'object') {\n            let table = isIterable(input['values']) ? tableFromIterable<T, TNull>(input)\n                 : isAsyncIterable(input['values']) ? tableFromAsyncIterable<T, TNull>(input)\n                                                    : null;\n            if (table !== null) { return table; }\n        }\n\n        let reader = RecordBatchReader.from<T>(input) as RecordBatchReader<T> | Promise<RecordBatchReader<T>>;\n\n        if (isPromise<RecordBatchReader<T>>(reader)) {\n            return (async () => await Table.from(await reader))();\n        }\n        if (reader.isSync() && (reader = reader.open())) {\n            return !reader.schema ? Table.empty() : new Table<T>(reader.schema, [...reader]);\n        }\n        return (async (opening) => {\n            const reader = await opening;\n            const schema = reader.schema;\n            const batches: RecordBatch[] = [];\n            if (schema) {\n                for await (let batch of reader) {\n                    batches.push(batch);\n                }\n                return new Table<T>(schema, batches);\n            }\n            return Table.empty();\n        })(reader.open());\n    }\n\n    /** @nocollapse */\n    public static async fromAsync<T extends { [key: string]: DataType } = any>(source: import('./ipc/reader').FromArgs): Promise<Table<T>> {\n        return await Table.from<T>(source as any);\n    }\n\n    /** @nocollapse */\n    public static fromStruct<T extends { [key: string]: DataType } = any>(vector: Vector<Struct<T>>) {\n        return Table.new<T>(vector.data.childData as Data<T[keyof T]>[], vector.type.children);\n    }\n\n    /**\n     * @summary Create a new Table from a collection of Columns or Vectors,\n     * with an optional list of names or Fields.\n     *\n     *\n     * `Table.new` accepts an Object of\n     * Columns or Vectors, where the keys will be used as the field names\n     * for the Schema:\n     * ```ts\n     * const i32s = Int32Vector.from([1, 2, 3]);\n     * const f32s = Float32Vector.from([.1, .2, .3]);\n     * const table = Table.new({ i32: i32s, f32: f32s });\n     * assert(table.schema.fields[0].name === 'i32');\n     * ```\n     *\n     * It also accepts a a list of Vectors with an optional list of names or\n     * Fields for the resulting Schema. If the list is omitted or a name is\n     * missing, the numeric index of each Vector will be used as the name:\n     * ```ts\n     * const i32s = Int32Vector.from([1, 2, 3]);\n     * const f32s = Float32Vector.from([.1, .2, .3]);\n     * const table = Table.new([i32s, f32s], ['i32']);\n     * assert(table.schema.fields[0].name === 'i32');\n     * assert(table.schema.fields[1].name === '1');\n     * ```\n     *\n     * If the supplied arguments are Columns, `Table.new` will infer the Schema\n     * from the Columns:\n     * ```ts\n     * const i32s = Column.new('i32', Int32Vector.from([1, 2, 3]));\n     * const f32s = Column.new('f32', Float32Vector.from([.1, .2, .3]));\n     * const table = Table.new(i32s, f32s);\n     * assert(table.schema.fields[0].name === 'i32');\n     * assert(table.schema.fields[1].name === 'f32');\n     * ```\n     *\n     * If the supplied Vector or Column lengths are unequal, `Table.new` will\n     * extend the lengths of the shorter Columns, allocating additional bytes\n     * to represent the additional null slots. The memory required to allocate\n     * these additional bitmaps can be computed as:\n     * ```ts\n     * let additionalBytes = 0;\n     * for (let vec in shorter_vectors) {\n     *     additionalBytes += (((longestLength - vec.length) + 63) & ~63) >> 3;\n     * }\n     * ```\n     *\n     * For example, an additional null bitmap for one million null values would require\n     * 125,000 bytes (`((1e6 + 63) & ~63) >> 3`), or approx. `0.11MiB`\n     */\n    public static new<T extends { [key: string]: DataType } = any>(...columns: Columns<T>): Table<T>;\n    public static new<T extends VectorMap = any>(children: T): Table<{ [P in keyof T]: T[P]['type'] }>;\n    public static new<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): Table<T>;\n    /** @nocollapse */\n    public static new(...cols: any[]) {\n        return new Table(...distributeColumnsIntoRecordBatches(selectColumnArgs(cols)));\n    }\n\n    constructor(batches: RecordBatch<T>[]);\n    constructor(...batches: RecordBatch<T>[]);\n    constructor(schema: Schema<T>, batches: RecordBatch<T>[]);\n    constructor(schema: Schema<T>, ...batches: RecordBatch<T>[]);\n    constructor(...args: any[]) {\n\n        let schema: Schema<T> = null!;\n\n        if (args[0] instanceof Schema) { schema = args.shift(); }\n\n        let chunks = selectArgs<RecordBatch<T>>(RecordBatch, args);\n\n        if (!schema && !(schema = chunks[0] && chunks[0].schema)) {\n            throw new TypeError('Table must be initialized with a Schema or at least one RecordBatch');\n        }\n\n        chunks[0] || (chunks[0] = new _InternalEmptyPlaceholderRecordBatch(schema));\n\n        super(new Struct(schema.fields), chunks);\n\n        this._schema = schema;\n        this._chunks = chunks;\n    }\n\n    protected _schema: Schema<T>;\n    // List of inner RecordBatches\n    protected _chunks: RecordBatch<T>[];\n    protected _children?: Column<T[keyof T]>[];\n\n    public get schema() { return this._schema; }\n    public get length() { return this._length; }\n    public get chunks() { return this._chunks; }\n    public get numCols() { return this._numChildren; }\n\n    public clone(chunks = this._chunks) {\n        return new Table<T>(this._schema, chunks);\n    }\n\n    public getColumn<R extends keyof T>(name: R): Column<T[R]> {\n        return this.getColumnAt(this.getColumnIndex(name)) as Column<T[R]>;\n    }\n    public getColumnAt<R extends DataType = any>(index: number): Column<R> | null {\n        return this.getChildAt(index);\n    }\n    public getColumnIndex<R extends keyof T>(name: R) {\n        return this._schema.fields.findIndex((f) => f.name === name);\n    }\n    public getChildAt<R extends DataType = any>(index: number): Column<R> | null {\n        if (index < 0 || index >= this.numChildren) { return null; }\n        let field: Field<R>, child: Column<R>;\n        const fields = (this._schema as Schema<any>).fields;\n        const columns = this._children || (this._children = []) as Column[];\n        if (child = columns[index]) { return child as Column<R>; }\n        if (field = fields[index]) {\n            const chunks = this._chunks\n                .map((chunk) => chunk.getChildAt<R>(index))\n                .filter((vec): vec is Vector<R> => vec != null);\n            if (chunks.length > 0) {\n                return (columns[index] = new Column<R>(field, chunks));\n            }\n        }\n        return null;\n    }\n\n    // @ts-ignore\n    public serialize(encoding = 'binary', stream = true) {\n        const Writer = !stream\n            ? RecordBatchFileWriter\n            : RecordBatchStreamWriter;\n        return Writer.writeAll(this).toUint8Array(true);\n    }\n    public count(): number {\n        return this._length;\n    }\n    public select<K extends keyof T = any>(...columnNames: K[]) {\n        const nameToIndex = this._schema.fields.reduce((m, f, i) => m.set(f.name as K, i), new Map<K, number>());\n        return this.selectAt(...columnNames.map((columnName) => nameToIndex.get(columnName)!).filter((x) => x > -1));\n    }\n    public selectAt<K extends T[keyof T] = any>(...columnIndices: number[]) {\n        const schema = this._schema.selectAt<K>(...columnIndices);\n        return new Table(schema, this._chunks.map(({ length, data: { childData } }) => {\n            return new RecordBatch(schema, length, columnIndices.map((i) => childData[i]).filter(Boolean));\n        }));\n    }\n    public assign<R extends { [key: string]: DataType } = any>(other: Table<R>) {\n\n        const fields = this._schema.fields;\n        const [indices, oldToNew] = other.schema.fields.reduce((memo, f2, newIdx) => {\n            const [indices, oldToNew] = memo;\n            const i = fields.findIndex((f) => f.name === f2.name);\n            ~i ? (oldToNew[i] = newIdx) : indices.push(newIdx);\n            return memo;\n        }, [[], []] as number[][]);\n\n        const schema = this._schema.assign(other.schema);\n        const columns = [\n            ...fields.map((_f, i, _fs, j = oldToNew[i]) =>\n                (j === undefined ? this.getColumnAt(i) : other.getColumnAt(j))!),\n            ...indices.map((i) => other.getColumnAt(i)!)\n        ].filter(Boolean) as Column<(T & R)[keyof T | keyof R]>[];\n\n        return new Table<T & R>(...distributeVectorsIntoRecordBatches<any>(schema, columns));\n    }\n}\n\nfunction tableFromIterable<T extends { [key: string]: DataType } = any, TNull = any>(input: VectorBuilderOptions<Struct<T>, TNull>) {\n    const { type } = input;\n    if (type instanceof Struct) {\n        return Table.fromStruct(StructVector.from(input as VectorBuilderOptions<Struct<T>, TNull>));\n    }\n    return null;\n}\n\nfunction tableFromAsyncIterable<T extends { [key: string]: DataType } = any, TNull = any>(input: VectorBuilderOptionsAsync<Struct<T>, TNull>) {\n    const { type } = input;\n    if (type instanceof Struct) {\n        return StructVector.from(input as VectorBuilderOptionsAsync<Struct<T>, TNull>).then((vector) => Table.fromStruct(vector));\n    }\n    return null;\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Data } from './data';\nimport { Table } from './table';\nimport { Vector } from './vector';\nimport { Visitor } from './visitor';\nimport { Schema, Field } from './schema';\nimport { isIterable } from './util/compat';\nimport { Chunked } from './vector/chunked';\nimport { selectFieldArgs } from './util/args';\nimport { DataType, Struct, Dictionary } from './type';\nimport { ensureSameLengthData } from './util/recordbatch';\nimport { Clonable, Sliceable, Applicative } from './vector';\nimport { StructVector, VectorBuilderOptions, VectorBuilderOptionsAsync } from './vector/index';\n\ntype VectorMap = { [key: string]: Vector };\ntype Fields<T extends { [key: string]: DataType }> = (keyof T)[] | Field<T[keyof T]>[];\ntype ChildData<T extends { [key: string]: DataType }> = (Data<T[keyof T]> | Vector<T[keyof T]>)[];\n\nexport interface RecordBatch<T extends { [key: string]: DataType } = any> {\n    concat(...others: Vector<Struct<T>>[]): Table<T>;\n    slice(begin?: number, end?: number): RecordBatch<T>;\n    clone(data: Data<Struct<T>>, children?: Vector[]): RecordBatch<T>;\n}\n\nexport class RecordBatch<T extends { [key: string]: DataType } = any>\n    extends StructVector<T>\n    implements Clonable<RecordBatch<T>>,\n               Sliceable<RecordBatch<T>>,\n               Applicative<Struct<T>, Table<T>> {\n\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptions<Struct<T>, TNull>): Table<T>;\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptionsAsync<Struct<T>, TNull>): Promise<Table<T>>;\n    /** @nocollapse */\n    public static from<T extends { [key: string]: DataType } = any, TNull = any>(options: VectorBuilderOptions<Struct<T>, TNull> | VectorBuilderOptionsAsync<Struct<T>, TNull>) {\n        if (isIterable<(Struct<T>)['TValue'] | TNull>(options['values'])) {\n            return Table.from(options as VectorBuilderOptions<Struct<T>, TNull>);\n        }\n        return Table.from(options as VectorBuilderOptionsAsync<Struct<T>, TNull>);\n    }\n\n    public static new<T extends VectorMap = any>(children: T): RecordBatch<{ [P in keyof T]: T[P]['type'] }>;\n    public static new<T extends { [key: string]: DataType } = any>(children: ChildData<T>, fields?: Fields<T>): RecordBatch<T>;\n    /** @nocollapse */\n    public static new<T extends { [key: string]: DataType } = any>(...args: any[]) {\n        const [fs, xs] = selectFieldArgs<T>(args);\n        const vs = xs.filter((x): x is Vector<T[keyof T]> => x instanceof Vector);\n        return new RecordBatch(...ensureSameLengthData(new Schema<T>(fs), vs.map((x) => x.data)));\n    }\n\n    protected _schema: Schema;\n    protected _dictionaries?: Map<number, Vector>;\n\n    constructor(schema: Schema<T>, length: number, children: (Data | Vector)[]);\n    constructor(schema: Schema<T>, data: Data<Struct<T>>, children?: Vector[]);\n    constructor(...args: any[]) {\n        let data: Data<Struct<T>>;\n        let schema = args[0] as Schema<T>;\n        let children: Vector[] | undefined;\n        if (args[1] instanceof Data) {\n            [, data, children] = (args as [any, Data<Struct<T>>, Vector<T[keyof T]>[]?]);\n        } else {\n            const fields = schema.fields as Field<T[keyof T]>[];\n            const [, length, childData] = args as [any, number, Data<T[keyof T]>[]];\n            data = Data.Struct(new Struct<T>(fields), 0, length, 0, null, childData);\n        }\n        super(data, children);\n        this._schema = schema;\n    }\n\n    public clone(data: Data<Struct<T>>, children = this._children) {\n        return new RecordBatch<T>(this._schema, data, children);\n    }\n\n    public concat(...others: Vector<Struct<T>>[]): Table<T> {\n        const schema = this._schema, chunks = Chunked.flatten(this, ...others);\n        return new Table(schema, chunks.map(({ data }) => new RecordBatch(schema, data)));\n    }\n\n    public get schema() { return this._schema; }\n    public get numCols() { return this._schema.fields.length; }\n    public get dictionaries() {\n        return this._dictionaries || (this._dictionaries = DictionaryCollector.collect(this));\n    }\n\n    public select<K extends keyof T = any>(...columnNames: K[]) {\n        const nameToIndex = this._schema.fields.reduce((m, f, i) => m.set(f.name as K, i), new Map<K, number>());\n        return this.selectAt(...columnNames.map((columnName) => nameToIndex.get(columnName)!).filter((x) => x > -1));\n    }\n    public selectAt<K extends T[keyof T] = any>(...columnIndices: number[]) {\n        const schema = this._schema.selectAt(...columnIndices);\n        const childData = columnIndices.map((i) => this.data.childData[i]).filter(Boolean);\n        return new RecordBatch<{ [key: string]: K }>(schema, this.length, childData);\n    }\n}\n\n/**\n * An internal class used by the `RecordBatchReader` and `RecordBatchWriter`\n * implementations to differentiate between a stream with valid zero-length\n * RecordBatches, and a stream with a Schema message, but no RecordBatches.\n * @see https://github.com/apache/arrow/pull/4373\n * @ignore\n * @private\n */\n/* tslint:disable:class-name */\nexport class _InternalEmptyPlaceholderRecordBatch<T extends { [key: string]: DataType } = any> extends RecordBatch<T> {\n    constructor(schema: Schema<T>) {\n        super(schema, 0, schema.fields.map((f) => Data.new(f.type, 0, 0, 0)));\n    }\n}\n\n/** @ignore */\nclass DictionaryCollector extends Visitor {\n    public dictionaries = new Map<number, Vector>();\n    public static collect<T extends RecordBatch>(batch: T) {\n        return new DictionaryCollector().visit(\n            batch.data, new Struct(batch.schema.fields)\n        ).dictionaries;\n    }\n    public visit(data: Data, type: DataType) {\n        if (DataType.isDictionary(type)) {\n            return this.visitDictionary(data, type);\n        } else {\n            data.childData.forEach((child, i) =>\n                this.visit(child, type.children[i].type));\n        }\n        return this;\n    }\n    public visitDictionary(data: Data, type: Dictionary) {\n        const dictionary = data.dictionary;\n        if (dictionary && dictionary.length > 0) {\n            this.dictionaries.set(type.id, dictionary);\n        }\n        return this;\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { DataType } from '../type';\nimport { MessageHeader } from '../enum';\nimport { Footer } from './metadata/file';\nimport { Schema, Field } from '../schema';\nimport streamAdapters from '../io/adapters';\nimport { Message } from './metadata/message';\nimport * as metadata from './metadata/message';\nimport { ArrayBufferViewInput } from '../util/buffer';\nimport { ByteStream, AsyncByteStream } from '../io/stream';\nimport { RandomAccessFile, AsyncRandomAccessFile } from '../io/file';\nimport { VectorLoader, JSONVectorLoader } from '../visitor/vectorloader';\nimport { RecordBatch, _InternalEmptyPlaceholderRecordBatch } from '../recordbatch';\nimport {\n    FileHandle,\n    ArrowJSONLike,\n    ITERATOR_DONE,\n    ReadableInterop,\n} from '../io/interfaces';\nimport {\n    MessageReader, AsyncMessageReader, JSONMessageReader,\n    checkForMagicArrowString, magicLength, magicAndPadding, magicX2AndPadding\n} from './message';\nimport {\n    isPromise,\n    isIterable, isAsyncIterable,\n    isIteratorResult, isArrowJSON,\n    isFileHandle, isFetchResponse,\n    isReadableDOMStream, isReadableNodeStream\n} from '../util/compat';\n\n/** @ignore */ export type FromArg0 = ArrowJSONLike;\n/** @ignore */ export type FromArg1 = PromiseLike<ArrowJSONLike>;\n/** @ignore */ export type FromArg2 = Iterable<ArrayBufferViewInput> | ArrayBufferViewInput;\n/** @ignore */ export type FromArg3 = PromiseLike<Iterable<ArrayBufferViewInput> | ArrayBufferViewInput>;\n/** @ignore */ export type FromArg4 = Response | NodeJS.ReadableStream | ReadableStream<ArrayBufferViewInput> | AsyncIterable<ArrayBufferViewInput>;\n/** @ignore */ export type FromArg5 = FileHandle | PromiseLike<FileHandle> | PromiseLike<FromArg4>;\n/** @ignore */ export type FromArgs = FromArg0 | FromArg1 | FromArg2 | FromArg3 | FromArg4 | FromArg5;\n\n/** @ignore */ type OpenOptions = { autoDestroy?: boolean; };\n/** @ignore */ type RecordBatchReaders<T extends { [key: string]: DataType } = any> = RecordBatchFileReader<T> | RecordBatchStreamReader<T>;\n/** @ignore */ type AsyncRecordBatchReaders<T extends { [key: string]: DataType } = any> = AsyncRecordBatchFileReader<T> | AsyncRecordBatchStreamReader<T>;\n/** @ignore */ type RecordBatchFileReaders<T extends { [key: string]: DataType } = any> = RecordBatchFileReader<T> | AsyncRecordBatchFileReader<T>;\n/** @ignore */ type RecordBatchStreamReaders<T extends { [key: string]: DataType } = any> = RecordBatchStreamReader<T> | AsyncRecordBatchStreamReader<T>;\n\nexport class RecordBatchReader<T extends { [key: string]: DataType } = any> extends ReadableInterop<RecordBatch<T>> {\n\n    protected _impl: RecordBatchReaderImpls<T>;\n    protected constructor(impl: RecordBatchReaderImpls<T>) {\n        super();\n        this._impl = impl;\n    }\n\n    public get closed() { return this._impl.closed; }\n    public get schema() { return this._impl.schema; }\n    public get autoDestroy() { return this._impl.autoDestroy; }\n    public get dictionaries() { return this._impl.dictionaries; }\n    public get numDictionaries() { return this._impl.numDictionaries; }\n    public get numRecordBatches() { return this._impl.numRecordBatches; }\n    public get footer() { return this._impl.isFile() ? this._impl.footer : null; }\n\n    public isSync(): this is RecordBatchReaders<T> { return this._impl.isSync(); }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return this._impl.isAsync(); }\n    public isFile(): this is RecordBatchFileReaders<T> { return this._impl.isFile(); }\n    public isStream(): this is RecordBatchStreamReaders<T> { return this._impl.isStream(); }\n\n    public next() {\n        return this._impl.next();\n    }\n    public throw(value?: any) {\n        return this._impl.throw(value);\n    }\n    public return(value?: any) {\n        return this._impl.return(value);\n    }\n    public cancel() {\n        return this._impl.cancel();\n    }\n    public reset(schema?: Schema<T> | null): this {\n        this._impl.reset(schema);\n        this._DOMStream = undefined;\n        this._nodeStream = undefined;\n        return this;\n    }\n    public open(options?: OpenOptions) {\n        const opening = this._impl.open(options);\n        return isPromise(opening) ? opening.then(() => this) : this;\n    }\n    public readRecordBatch(index: number): RecordBatch<T> | null | Promise<RecordBatch<T> | null> {\n        return this._impl.isFile() ? this._impl.readRecordBatch(index) : null;\n    }\n    public [Symbol.iterator](): IterableIterator<RecordBatch<T>> {\n        return (<IterableIterator<RecordBatch<T>>> this._impl)[Symbol.iterator]();\n    }\n    public [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> {\n        return (<AsyncIterableIterator<RecordBatch<T>>> this._impl)[Symbol.asyncIterator]();\n    }\n    public toDOMStream() {\n        return streamAdapters.toDOMStream<RecordBatch<T>>(\n            (this.isSync()\n                ? { [Symbol.iterator]: () => this } as Iterable<RecordBatch<T>>\n                : { [Symbol.asyncIterator]: () => this } as AsyncIterable<RecordBatch<T>>));\n    }\n    public toNodeStream() {\n        return streamAdapters.toNodeStream<RecordBatch<T>>(\n            (this.isSync()\n                ? { [Symbol.iterator]: () => this } as Iterable<RecordBatch<T>>\n                : { [Symbol.asyncIterator]: () => this } as AsyncIterable<RecordBatch<T>>),\n            { objectMode: true });\n    }\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode(options?: import('stream').DuplexOptions & { autoDestroy: boolean }): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    public static throughDOM<T extends { [key: string]: DataType }>(\n        // @ts-ignore\n        writableStrategy?: ByteLengthQueuingStrategy,\n        // @ts-ignore\n        readableStrategy?: { autoDestroy: boolean }\n    ): { writable: WritableStream<Uint8Array>, readable: ReadableStream<RecordBatch<T>> } {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    public static from<T extends RecordBatchReader>(source: T): T;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg0): RecordBatchStreamReader<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg1): Promise<RecordBatchStreamReader<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg2): RecordBatchFileReader<T> | RecordBatchStreamReader<T>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg3): Promise<RecordBatchFileReader<T> | RecordBatchStreamReader<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg4): Promise<RecordBatchFileReader<T> | AsyncRecordBatchReaders<T>>;\n    public static from<T extends { [key: string]: DataType } = any>(source: FromArg5): Promise<AsyncRecordBatchFileReader<T> | AsyncRecordBatchStreamReader<T>>;\n    /** @nocollapse */\n    public static from<T extends { [key: string]: DataType } = any>(source: any) {\n        if (source instanceof RecordBatchReader) {\n            return source;\n        } else if (isArrowJSON(source)) {\n            return fromArrowJSON<T>(source);\n        } else if (isFileHandle(source)) {\n            return fromFileHandle<T>(source);\n        } else if (isPromise<any>(source)) {\n            return (async () => await RecordBatchReader.from<any>(await source))();\n        } else if (isFetchResponse(source) || isReadableDOMStream(source) || isReadableNodeStream(source) || isAsyncIterable(source)) {\n            return fromAsyncByteStream<T>(new AsyncByteStream(source));\n        }\n        return fromByteStream<T>(new ByteStream(source));\n    }\n\n    public static readAll<T extends RecordBatchReader>(source: T): T extends RecordBatchReaders ? IterableIterator<T> : AsyncIterableIterator<T>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg0): IterableIterator<RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg1): AsyncIterableIterator<RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg2): IterableIterator<RecordBatchFileReader<T> | RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg3): AsyncIterableIterator<RecordBatchFileReader<T> | RecordBatchStreamReader<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg4): AsyncIterableIterator<RecordBatchFileReader<T> | AsyncRecordBatchReaders<T>>;\n    public static readAll<T extends { [key: string]: DataType } = any>(source: FromArg5): AsyncIterableIterator<AsyncRecordBatchFileReader<T> | AsyncRecordBatchStreamReader<T>>;\n    /** @nocollapse */\n    public static readAll<T extends { [key: string]: DataType } = any>(source: any) {\n        if (source instanceof RecordBatchReader) {\n            return source.isSync() ? readAllSync(source) : readAllAsync(source as AsyncRecordBatchReaders<T>);\n        } else if (isArrowJSON(source) || ArrayBuffer.isView(source) || isIterable<ArrayBufferViewInput>(source) || isIteratorResult(source)) {\n            return readAllSync<T>(source) as IterableIterator<RecordBatchReaders<T>>;\n        }\n        return readAllAsync<T>(source) as AsyncIterableIterator<RecordBatchReaders<T> | AsyncRecordBatchReaders<T>>;\n    }\n}\n\n//\n// Since TS is a structural type system, we define the following subclass stubs\n// so that concrete types exist to associate with with the interfaces below.\n//\n// The implementation for each RecordBatchReader is hidden away in the set of\n// `RecordBatchReaderImpl` classes in the second half of this file. This allows\n// us to export a single RecordBatchReader class, and swap out the impl based\n// on the io primitives or underlying arrow (JSON, file, or stream) at runtime.\n//\n// Async/await makes our job a bit harder, since it forces everything to be\n// either fully sync or fully async. This is why the logic for the reader impls\n// has been duplicated into both sync and async variants. Since the RBR\n// delegates to its impl, an RBR with an AsyncRecordBatchFileReaderImpl for\n// example will return async/await-friendly Promises, but one with a (sync)\n// RecordBatchStreamReaderImpl will always return values. Nothing should be\n// different about their logic, aside from the async handling. This is also why\n// this code looks highly structured, as it should be nearly identical and easy\n// to follow.\n//\n\n/** @ignore */\nexport class RecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    constructor(protected _impl: RecordBatchStreamReaderImpl<T>) { super (_impl); }\n    public [Symbol.iterator]() { return (this._impl as IterableIterator<RecordBatch<T>>)[Symbol.iterator](); }\n    public async *[Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> { yield* this[Symbol.iterator](); }\n}\n/** @ignore */\nexport class AsyncRecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    constructor(protected _impl: AsyncRecordBatchStreamReaderImpl<T>) { super (_impl); }\n    public [Symbol.iterator](): IterableIterator<RecordBatch<T>> { throw new Error(`AsyncRecordBatchStreamReader is not Iterable`); }\n    public [Symbol.asyncIterator]() { return (this._impl as AsyncIterableIterator<RecordBatch<T>>)[Symbol.asyncIterator](); }\n}\n/** @ignore */\nexport class RecordBatchFileReader<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReader<T> {\n    constructor(protected _impl: RecordBatchFileReaderImpl<T>) { super (_impl); }\n}\n/** @ignore */\nexport class AsyncRecordBatchFileReader<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReader<T> {\n    constructor(protected _impl: AsyncRecordBatchFileReaderImpl<T>) { super (_impl); }\n}\n\n//\n// Now override the return types for each sync/async RecordBatchReader variant\n//\n\n/** @ignore */\nexport interface RecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    open(options?: OpenOptions | undefined): this;\n    cancel(): void;\n    throw(value?: any): IteratorResult<any>;\n    return(value?: any): IteratorResult<any>;\n    next(value?: any): IteratorResult<RecordBatch<T>>;\n}\n\n/** @ignore */\nexport interface AsyncRecordBatchStreamReader<T extends { [key: string]: DataType } = any> extends RecordBatchReader<T> {\n    open(options?: OpenOptions | undefined): Promise<this>;\n    cancel(): Promise<void>;\n    throw(value?: any): Promise<IteratorResult<any>>;\n    return(value?: any): Promise<IteratorResult<any>>;\n    next(value?: any): Promise<IteratorResult<RecordBatch<T>>>;\n}\n\n/** @ignore */\nexport interface RecordBatchFileReader<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReader<T> {\n    footer: Footer;\n    readRecordBatch(index: number): RecordBatch<T> | null;\n}\n\n/** @ignore */\nexport interface AsyncRecordBatchFileReader<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReader<T> {\n    footer: Footer;\n    readRecordBatch(index: number): Promise<RecordBatch<T> | null>;\n}\n\n/** @ignore */\ntype RecordBatchReaderImpls<T extends { [key: string]: DataType } = any> =\n     RecordBatchJSONReaderImpl<T> |\n     RecordBatchFileReaderImpl<T> |\n     RecordBatchStreamReaderImpl<T> |\n     AsyncRecordBatchFileReaderImpl<T> |\n     AsyncRecordBatchStreamReaderImpl<T>;\n\n/** @ignore */\ninterface RecordBatchReaderImpl<T extends { [key: string]: DataType } = any> {\n\n    closed: boolean;\n    schema: Schema<T>;\n    autoDestroy: boolean;\n    dictionaries: Map<number, Vector>;\n\n    isFile(): this is RecordBatchFileReaders<T>;\n    isStream(): this is RecordBatchStreamReaders<T>;\n    isSync(): this is RecordBatchReaders<T>;\n    isAsync(): this is AsyncRecordBatchReaders<T>;\n\n    reset(schema?: Schema<T> | null): this;\n}\n\n/** @ignore */\ninterface RecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> {\n\n    open(options?: OpenOptions): this;\n    cancel(): void;\n\n    throw(value?: any): IteratorResult<any>;\n    return(value?: any): IteratorResult<any>;\n    next(value?: any): IteratorResult<RecordBatch<T>>;\n\n    [Symbol.iterator](): IterableIterator<RecordBatch<T>>;\n}\n\n/** @ignore */\ninterface AsyncRecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> {\n\n    open(options?: OpenOptions): Promise<this>;\n    cancel(): Promise<void>;\n\n    throw(value?: any): Promise<IteratorResult<any>>;\n    return(value?: any): Promise<IteratorResult<any>>;\n    next(value?: any): Promise<IteratorResult<RecordBatch<T>>>;\n\n    [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>>;\n}\n\n/** @ignore */\ninterface RecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReaderImpl<T> {\n    readRecordBatch(index: number): RecordBatch<T> | null;\n}\n\n/** @ignore */\ninterface AsyncRecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReaderImpl<T> {\n    readRecordBatch(index: number): Promise<RecordBatch<T> | null>;\n}\n\n/** @ignore */\nabstract class RecordBatchReaderImpl<T extends { [key: string]: DataType } = any> implements RecordBatchReaderImpl<T> {\n\n    // @ts-ignore\n    public schema: Schema;\n    public closed = false;\n    public autoDestroy = true;\n    public dictionaries: Map<number, Vector>;\n\n    protected _dictionaryIndex = 0;\n    protected _recordBatchIndex = 0;\n    public get numDictionaries() { return this._dictionaryIndex; }\n    public get numRecordBatches() { return this._recordBatchIndex; }\n\n    constructor(dictionaries = new Map<number, Vector>()) {\n        this.dictionaries = dictionaries;\n    }\n\n    public isSync(): this is RecordBatchReaders<T> { return false; }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return false; }\n    public isFile(): this is RecordBatchFileReaders<T> { return false; }\n    public isStream(): this is RecordBatchStreamReaders<T> { return false; }\n\n    public reset(schema?: Schema<T> | null) {\n        this._dictionaryIndex = 0;\n        this._recordBatchIndex = 0;\n        this.schema = <any> schema;\n        this.dictionaries = new Map();\n        return this;\n    }\n\n    protected _loadRecordBatch(header: metadata.RecordBatch, body: any) {\n        return new RecordBatch<T>(this.schema, header.length, this._loadVectors(header, body, this.schema.fields));\n    }\n    protected _loadDictionaryBatch(header: metadata.DictionaryBatch, body: any) {\n        const { id, isDelta, data } = header;\n        const { dictionaries, schema } = this;\n        const dictionary = dictionaries.get(id);\n        if (isDelta || !dictionary) {\n            const type = schema.dictionaries.get(id)!;\n            return (dictionary && isDelta ? dictionary.concat(\n                Vector.new(this._loadVectors(data, body, [type])[0])) :\n                Vector.new(this._loadVectors(data, body, [type])[0])) as Vector;\n        }\n        return dictionary;\n    }\n    protected _loadVectors(header: metadata.RecordBatch, body: any, types: (Field | DataType)[]) {\n        return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);\n    }\n}\n\n/** @ignore */\nclass RecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> implements IterableIterator<RecordBatch<T>> {\n\n    protected _reader: MessageReader;\n    protected _handle: ByteStream | ArrowJSONLike;\n\n    constructor(source: ByteStream | ArrowJSONLike, dictionaries?: Map<number, Vector>) {\n        super(dictionaries);\n        this._reader = !isArrowJSON(source)\n            ? new MessageReader(this._handle = source)\n            : new JSONMessageReader(this._handle = source);\n    }\n\n    public isSync(): this is RecordBatchReaders<T> { return true; }\n    public isStream(): this is RecordBatchStreamReaders<T> { return true; }\n    public [Symbol.iterator](): IterableIterator<RecordBatch<T>> {\n        return this as IterableIterator<RecordBatch<T>>;\n    }\n    public cancel() {\n        if (!this.closed && (this.closed = true)) {\n            this.reset()._reader.return();\n            this._reader = <any> null;\n            this.dictionaries = <any> null;\n        }\n    }\n    public open(options?: OpenOptions) {\n        if (!this.closed) {\n            this.autoDestroy = shouldAutoDestroy(this, options);\n            if (!(this.schema || (this.schema = this._reader.readSchema()!))) {\n                this.cancel();\n            }\n        }\n        return this;\n    }\n    public throw(value?: any): IteratorResult<any> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return this.reset()._reader.throw(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public return(value?: any): IteratorResult<any> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return this.reset()._reader.return(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public next(): IteratorResult<RecordBatch<T>> {\n        if (this.closed) { return ITERATOR_DONE; }\n        let message: Message | null, { _reader: reader } = this;\n        while (message = this._readNextMessageAndValidate()) {\n            if (message.isSchema()) {\n                this.reset(message.header());\n            } else if (message.isRecordBatch()) {\n                this._recordBatchIndex++;\n                const header = message.header();\n                const buffer = reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return { done: false, value: recordBatch };\n            } else if (message.isDictionaryBatch()) {\n                this._dictionaryIndex++;\n                const header = message.header();\n                const buffer = reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n        if (this.schema && this._recordBatchIndex === 0) {\n            this._recordBatchIndex++;\n            return { done: false, value: new _InternalEmptyPlaceholderRecordBatch<T>(this.schema) };\n        }\n        return this.return();\n    }\n    protected _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null) {\n        return this._reader.readMessage<T>(type);\n    }\n}\n\n/** @ignore */\nclass AsyncRecordBatchStreamReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchReaderImpl<T> implements AsyncIterableIterator<RecordBatch<T>> {\n\n    protected _handle: AsyncByteStream;\n    protected _reader: AsyncMessageReader;\n\n    constructor(source: AsyncByteStream, dictionaries?: Map<number, Vector>) {\n        super(dictionaries);\n        this._reader = new AsyncMessageReader(this._handle = source);\n    }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return true; }\n    public isStream(): this is RecordBatchStreamReaders<T> { return true; }\n    public [Symbol.asyncIterator](): AsyncIterableIterator<RecordBatch<T>> {\n        return this as AsyncIterableIterator<RecordBatch<T>>;\n    }\n    public async cancel() {\n        if (!this.closed && (this.closed = true)) {\n            await this.reset()._reader.return();\n            this._reader = <any> null;\n            this.dictionaries = <any> null;\n        }\n    }\n    public async open(options?: OpenOptions) {\n        if (!this.closed) {\n            this.autoDestroy = shouldAutoDestroy(this, options);\n            if (!(this.schema || (this.schema = (await this._reader.readSchema())!))) {\n                await this.cancel();\n            }\n        }\n        return this;\n    }\n    public async throw(value?: any): Promise<IteratorResult<any>> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return await this.reset()._reader.throw(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public async return(value?: any): Promise<IteratorResult<any>> {\n        if (!this.closed && this.autoDestroy && (this.closed = true)) {\n            return await this.reset()._reader.return(value);\n        }\n        return ITERATOR_DONE;\n    }\n    public async next() {\n        if (this.closed) { return ITERATOR_DONE; }\n        let message: Message | null, { _reader: reader } = this;\n        while (message = await this._readNextMessageAndValidate()) {\n            if (message.isSchema()) {\n                await this.reset(message.header());\n            } else if (message.isRecordBatch()) {\n                this._recordBatchIndex++;\n                const header = message.header();\n                const buffer = await reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return { done: false, value: recordBatch };\n            } else if (message.isDictionaryBatch()) {\n                this._dictionaryIndex++;\n                const header = message.header();\n                const buffer = await reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n        if (this.schema && this._recordBatchIndex === 0) {\n            this._recordBatchIndex++;\n            return { done: false, value: new _InternalEmptyPlaceholderRecordBatch<T>(this.schema) };\n        }\n        return await this.return();\n    }\n    protected async _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null) {\n        return await this._reader.readMessage<T>(type);\n    }\n}\n\n/** @ignore */\nclass RecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReaderImpl<T> {\n\n    // @ts-ignore\n    protected _footer?: Footer;\n    // @ts-ignore\n    protected _handle: RandomAccessFile;\n    public get footer() { return this._footer!; }\n    public get numDictionaries() { return this._footer ? this._footer.numDictionaries : 0; }\n    public get numRecordBatches() { return this._footer ? this._footer.numRecordBatches : 0; }\n\n    constructor(source: RandomAccessFile | ArrayBufferViewInput, dictionaries?: Map<number, Vector>) {\n        super(source instanceof RandomAccessFile ? source : new RandomAccessFile(source), dictionaries);\n    }\n    public isSync(): this is RecordBatchReaders<T> { return true; }\n    public isFile(): this is RecordBatchFileReaders<T> { return true; }\n    public open(options?: OpenOptions) {\n        if (!this.closed && !this._footer) {\n            this.schema = (this._footer = this._readFooter()).schema;\n            for (const block of this._footer.dictionaryBatches()) {\n                block && this._readDictionaryBatch(this._dictionaryIndex++);\n            }\n        }\n        return super.open(options);\n    }\n    public readRecordBatch(index: number) {\n        if (this.closed) { return null; }\n        if (!this._footer) { this.open(); }\n        const block = this._footer && this._footer.getRecordBatch(index);\n        if (block && this._handle.seek(block.offset)) {\n            const message = this._reader.readMessage(MessageHeader.RecordBatch);\n            if (message && message.isRecordBatch()) {\n                const header = message.header();\n                const buffer = this._reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return recordBatch;\n            }\n        }\n        return null;\n    }\n    protected _readDictionaryBatch(index: number) {\n        const block = this._footer && this._footer.getDictionaryBatch(index);\n        if (block && this._handle.seek(block.offset)) {\n            const message = this._reader.readMessage(MessageHeader.DictionaryBatch);\n            if (message && message.isDictionaryBatch()) {\n                const header = message.header();\n                const buffer = this._reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n    }\n    protected _readFooter() {\n        const { _handle } = this;\n        const offset = _handle.size - magicAndPadding;\n        const length = _handle.readInt32(offset);\n        const buffer = _handle.readAt(offset - length, length);\n        return Footer.decode(buffer);\n    }\n    protected _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null): Message<T> | null {\n        if (!this._footer) { this.open(); }\n        if (this._footer && this._recordBatchIndex < this.numRecordBatches) {\n            const block = this._footer && this._footer.getRecordBatch(this._recordBatchIndex);\n            if (block && this._handle.seek(block.offset)) {\n                return this._reader.readMessage(type);\n            }\n        }\n        return null;\n    }\n}\n\n/** @ignore */\nclass AsyncRecordBatchFileReaderImpl<T extends { [key: string]: DataType } = any> extends AsyncRecordBatchStreamReaderImpl<T>\n    implements AsyncRecordBatchFileReaderImpl<T> {\n\n    protected _footer?: Footer;\n    // @ts-ignore\n    protected _handle: AsyncRandomAccessFile;\n    public get footer() { return this._footer!; }\n    public get numDictionaries() { return this._footer ? this._footer.numDictionaries : 0; }\n    public get numRecordBatches() { return this._footer ? this._footer.numRecordBatches : 0; }\n\n    constructor(source: FileHandle, byteLength?: number, dictionaries?: Map<number, Vector>);\n    constructor(source: FileHandle | AsyncRandomAccessFile, dictionaries?: Map<number, Vector>);\n    constructor(source: FileHandle | AsyncRandomAccessFile, ...rest: any[]) {\n        const byteLength = typeof rest[0] !== 'number' ? <number> rest.shift() : undefined;\n        const dictionaries = rest[0] instanceof Map ? <Map<number, Vector>> rest.shift() : undefined;\n        super(source instanceof AsyncRandomAccessFile ? source : new AsyncRandomAccessFile(source, byteLength), dictionaries);\n    }\n    public isFile(): this is RecordBatchFileReaders<T> { return true; }\n    public isAsync(): this is AsyncRecordBatchReaders<T> { return true; }\n    public async open(options?: OpenOptions) {\n        if (!this.closed && !this._footer) {\n            this.schema = (this._footer = await this._readFooter()).schema;\n            for (const block of this._footer.dictionaryBatches()) {\n                block && await this._readDictionaryBatch(this._dictionaryIndex++);\n            }\n        }\n        return await super.open(options);\n    }\n    public async readRecordBatch(index: number) {\n        if (this.closed) { return null; }\n        if (!this._footer) { await this.open(); }\n        const block = this._footer && this._footer.getRecordBatch(index);\n        if (block && (await this._handle.seek(block.offset))) {\n            const message = await this._reader.readMessage(MessageHeader.RecordBatch);\n            if (message && message.isRecordBatch()) {\n                const header = message.header();\n                const buffer = await this._reader.readMessageBody(message.bodyLength);\n                const recordBatch = this._loadRecordBatch(header, buffer);\n                return recordBatch;\n            }\n        }\n        return null;\n    }\n    protected async _readDictionaryBatch(index: number) {\n        const block = this._footer && this._footer.getDictionaryBatch(index);\n        if (block && (await this._handle.seek(block.offset))) {\n            const message = await this._reader.readMessage(MessageHeader.DictionaryBatch);\n            if (message && message.isDictionaryBatch()) {\n                const header = message.header();\n                const buffer = await this._reader.readMessageBody(message.bodyLength);\n                const vector = this._loadDictionaryBatch(header, buffer);\n                this.dictionaries.set(header.id, vector);\n            }\n        }\n    }\n    protected async _readFooter() {\n        const { _handle } = this;\n        _handle._pending && await _handle._pending;\n        const offset = _handle.size - magicAndPadding;\n        const length = await _handle.readInt32(offset);\n        const buffer = await _handle.readAt(offset - length, length);\n        return Footer.decode(buffer);\n    }\n    protected async _readNextMessageAndValidate<T extends MessageHeader>(type?: T | null): Promise<Message<T> | null> {\n        if (!this._footer) { await this.open(); }\n        if (this._footer && this._recordBatchIndex < this.numRecordBatches) {\n            const block = this._footer.getRecordBatch(this._recordBatchIndex);\n            if (block && await this._handle.seek(block.offset)) {\n                return await this._reader.readMessage(type);\n            }\n        }\n        return null;\n    }\n}\n\n/** @ignore */\nclass RecordBatchJSONReaderImpl<T extends { [key: string]: DataType } = any> extends RecordBatchStreamReaderImpl<T> {\n    constructor(source: ArrowJSONLike, dictionaries?: Map<number, Vector>) {\n        super(source, dictionaries);\n    }\n    protected _loadVectors(header: metadata.RecordBatch, body: any, types: (Field | DataType)[]) {\n        return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries).visitMany(types);\n    }\n}\n\n//\n// Define some helper functions and static implementations down here. There's\n// a bit of branching in the static methods that can lead to the same routines\n// being executed, so we've broken those out here for readability.\n//\n\n/** @ignore */\nfunction shouldAutoDestroy(self: { autoDestroy: boolean }, options?: OpenOptions) {\n    return options && (typeof options['autoDestroy'] === 'boolean') ? options['autoDestroy'] : self['autoDestroy'];\n}\n\n/** @ignore */\nfunction* readAllSync<T extends { [key: string]: DataType } = any>(source: RecordBatchReaders<T> | FromArg0 | FromArg2) {\n    const reader = RecordBatchReader.from<T>(<any> source) as RecordBatchReaders<T>;\n    try {\n        if (!reader.open({ autoDestroy: false }).closed) {\n            do { yield reader; } while (!(reader.reset().open()).closed);\n        }\n    } finally { reader.cancel(); }\n}\n\n/** @ignore */\nasync function* readAllAsync<T extends { [key: string]: DataType } = any>(source: AsyncRecordBatchReaders<T> | FromArg1 | FromArg3 | FromArg4 | FromArg5) {\n    const reader = await RecordBatchReader.from<T>(<any> source) as RecordBatchReader<T>;\n    try {\n        if (!(await reader.open({ autoDestroy: false })).closed) {\n            do { yield reader; } while (!(await reader.reset().open()).closed);\n        }\n    } finally { await reader.cancel(); }\n}\n\n/** @ignore */\nfunction fromArrowJSON<T extends { [key: string]: DataType }>(source: ArrowJSONLike) {\n    return new RecordBatchStreamReader(new RecordBatchJSONReaderImpl<T>(source));\n}\n\n/** @ignore */\nfunction fromByteStream<T extends { [key: string]: DataType }>(source: ByteStream) {\n    const bytes = source.peek((magicLength + 7) & ~7);\n    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes)\n        ? new RecordBatchStreamReader(new RecordBatchStreamReaderImpl<T>(source))\n        : new RecordBatchFileReader(new RecordBatchFileReaderImpl<T>(source.read()))\n        : new RecordBatchStreamReader(new RecordBatchStreamReaderImpl<T>(function*(): any {}()));\n}\n\n/** @ignore */\nasync function fromAsyncByteStream<T extends { [key: string]: DataType }>(source: AsyncByteStream) {\n    const bytes = await source.peek((magicLength + 7) & ~7);\n    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes)\n        ? new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl<T>(source))\n        : new RecordBatchFileReader(new RecordBatchFileReaderImpl<T>(await source.read()))\n        : new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl<T>(async function*(): any {}()));\n}\n\n/** @ignore */\nasync function fromFileHandle<T extends { [key: string]: DataType }>(source: FileHandle) {\n    const { size } = await source.stat();\n    const file = new AsyncRandomAccessFile(source, size);\n    if (size >= magicX2AndPadding) {\n        if (checkForMagicArrowString(await file.readAt(0, (magicLength + 7) & ~7))) {\n            return new AsyncRecordBatchFileReader(new AsyncRecordBatchFileReaderImpl<T>(file));\n        }\n    }\n    return new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl<T>(file));\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../../type';\nimport { Vector } from '../../vector';\nimport { VectorType as V } from '../../interfaces';\nimport { Builder, BuilderOptions } from '../../builder/index';\n\n/** @ignore */\nexport interface BuilderTransformOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    queueingStrategy?: 'bytes' | 'count';\n    dictionaryHashFunction?: (value: any) => string | number;\n    readableStrategy?: { highWaterMark?: number, size?: any, type?: 'bytes'; };\n    writableStrategy?: { highWaterMark?: number, size?: any, type?: 'bytes'; };\n    valueToChildTypeId?: (builder: Builder<T, TNull>, value: any, offset: number) => number;\n}\n\n/** @ignore */\nexport function builderThroughDOMStream<T extends DataType = any, TNull = any>(options: BuilderTransformOptions<T, TNull>) {\n    return new BuilderTransform(options);\n}\n\n/** @ignore */\nexport class BuilderTransform<T extends DataType = any, TNull = any> {\n\n    public readable: ReadableStream<V<T>>;\n    public writable: WritableStream<T['TValue'] | TNull>;\n    public _controller: ReadableStreamDefaultController<V<T>> | null;\n\n    private _numChunks = 0;\n    private _finished = false;\n    private _bufferedSize = 0;\n    private _builder: Builder<T, TNull>;\n    private _getSize: (builder: Builder<T, TNull>) => number;\n\n    constructor(options: BuilderTransformOptions<T, TNull>) {\n\n        // Access properties by string indexers to defeat closure compiler\n\n        const {\n            ['readableStrategy']: readableStrategy,\n            ['writableStrategy']: writableStrategy,\n            ['queueingStrategy']: queueingStrategy = 'count',\n            ...builderOptions\n        } = options;\n\n        this._controller = null;\n        this._builder = Builder.new<T, TNull>(builderOptions);\n        this._getSize = queueingStrategy !== 'bytes' ? chunkLength : chunkByteLength;\n\n        const { ['highWaterMark']: readableHighWaterMark = queueingStrategy === 'bytes' ? 2 ** 14 : 1000 } = { ...readableStrategy };\n        const { ['highWaterMark']: writableHighWaterMark = queueingStrategy === 'bytes' ? 2 ** 14 : 1000 } = { ...writableStrategy };\n\n        this['readable'] = new ReadableStream<V<T>>({\n            ['cancel']: ()  => { this._builder.clear(); },\n            ['pull']: (c) => { this._maybeFlush(this._builder, this._controller = c); },\n            ['start']: (c) => { this._maybeFlush(this._builder, this._controller = c); },\n        }, {\n            'highWaterMark': readableHighWaterMark,\n            'size': queueingStrategy !== 'bytes' ? chunkLength : chunkByteLength,\n        });\n\n        this['writable'] = new WritableStream({\n            ['abort']: () => { this._builder.clear(); },\n            ['write']: () => { this._maybeFlush(this._builder, this._controller); },\n            ['close']: () => { this._maybeFlush(this._builder.finish(), this._controller); },\n        }, {\n            'highWaterMark': writableHighWaterMark,\n            'size': (value: T['TValue'] | TNull) => this._writeValueAndReturnChunkSize(value),\n        });\n    }\n\n    private _writeValueAndReturnChunkSize(value: T['TValue'] | TNull) {\n        const bufferedSize = this._bufferedSize;\n        this._bufferedSize = this._getSize(this._builder.append(value));\n        return this._bufferedSize - bufferedSize;\n    }\n\n    private _maybeFlush(builder: Builder<T, TNull>, controller: ReadableStreamDefaultController<V<T>> | null) {\n        if (controller === null) { return; }\n        if (this._bufferedSize >= controller.desiredSize!) {\n            ++this._numChunks && this._enqueue(controller, builder.toVector());\n        }\n        if (builder.finished) {\n            if (builder.length > 0 || this._numChunks === 0) {\n                ++this._numChunks && this._enqueue(controller, builder.toVector());\n            }\n            if (!this._finished && (this._finished = true)) {\n                this._enqueue(controller, null);\n            }\n        }\n    }\n\n    private _enqueue(controller: ReadableStreamDefaultController<V<T>>, chunk: V<T> | null) {\n        this._bufferedSize = 0;\n        this._controller = null;\n        chunk === null ? controller.close() : controller.enqueue(chunk);\n    }\n}\n\n/** @ignore */ const chunkLength = <T extends DataType = any>(chunk: Vector<T> | Builder<T>) => chunk.length;\n/** @ignore */ const chunkByteLength = <T extends DataType = any>(chunk: Vector<T> | Builder<T>) => chunk.byteLength;\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from '../vector';\nimport { RecordBatch } from '../recordbatch';\nimport { DictionaryVector } from '../vector/dictionary';\n\n/** @ignore */\nexport type ValueFunc<T> = (idx: number, cols: RecordBatch) => T | null;\n/** @ignore */\nexport type PredicateFunc = (idx: number, cols: RecordBatch) => boolean;\n\n/** @ignore */\nexport abstract class Value<T> {\n    eq(other: Value<T> | T): Predicate {\n        if (!(other instanceof Value)) { other = new Literal(other); }\n        return new Equals(this, other);\n    }\n    le(other: Value<T> | T): Predicate {\n        if (!(other instanceof Value)) { other = new Literal(other); }\n        return new LTeq(this, other);\n    }\n    ge(other: Value<T> | T): Predicate {\n        if (!(other instanceof Value)) { other = new Literal(other); }\n        return new GTeq(this, other);\n    }\n    lt(other: Value<T> | T): Predicate {\n        return new Not(this.ge(other));\n    }\n    gt(other: Value<T> | T): Predicate {\n        return new Not(this.le(other));\n    }\n    ne(other: Value<T> | T): Predicate {\n        return new Not(this.eq(other));\n    }\n}\n\n/** @ignore */\nexport class Literal<T= any> extends Value<T> {\n    constructor(public v: T) { super(); }\n}\n\n/** @ignore */\nexport class Col<T= any> extends Value<T> {\n    // @ts-ignore\n    public vector: Vector;\n    // @ts-ignore\n    public colidx: number;\n\n    constructor(public name: string) { super(); }\n    bind(batch: RecordBatch): (idx: number, batch?: RecordBatch) => any {\n        if (!this.colidx) {\n            // Assume column index doesn't change between calls to bind\n            //this.colidx = cols.findIndex(v => v.name.indexOf(this.name) != -1);\n            this.colidx = -1;\n            const fields = batch.schema.fields;\n            for (let idx = -1; ++idx < fields.length;) {\n                if (fields[idx].name === this.name) {\n                    this.colidx = idx;\n                    break;\n                }\n            }\n            if (this.colidx < 0) { throw new Error(`Failed to bind Col \"${this.name}\"`); }\n        }\n\n        const vec = this.vector = batch.getChildAt(this.colidx)!;\n        return (idx: number) => vec.get(idx);\n    }\n}\n\n/** @ignore */\nexport abstract class Predicate {\n    abstract bind(batch: RecordBatch): PredicateFunc;\n    and(...expr: Predicate[]): And { return new And(this, ...expr); }\n    or(...expr: Predicate[]): Or { return new Or(this, ...expr); }\n    not(): Predicate { return new Not(this); }\n}\n\n/** @ignore */\nexport abstract class ComparisonPredicate<T= any> extends Predicate {\n    constructor(public readonly left: Value<T>, public readonly right: Value<T>) {\n        super();\n    }\n\n    bind(batch: RecordBatch) {\n        if (this.left instanceof Literal) {\n            if (this.right instanceof Literal) {\n                return this._bindLitLit(batch, this.left, this.right);\n            } else { // right is a Col\n\n                return this._bindLitCol(batch, this.left, this.right as Col);\n            }\n        } else { // left is a Col\n            if (this.right instanceof Literal) {\n                return this._bindColLit(batch, this.left as Col, this.right);\n            } else { // right is a Col\n                return this._bindColCol(batch, this.left as Col, this.right as Col);\n            }\n        }\n    }\n\n    protected abstract _bindLitLit(batch: RecordBatch, left: Literal, right: Literal): PredicateFunc;\n    protected abstract _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc;\n    protected abstract _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc;\n    protected abstract _bindLitCol(batch: RecordBatch, lit: Literal, col: Col): PredicateFunc;\n}\n\n/** @ignore */\nexport abstract class CombinationPredicate extends Predicate {\n    readonly children: Predicate[];\n    constructor(...children: Predicate[]) {\n        super();\n        this.children = children;\n    }\n}\n// add children to prototype so it doesn't get mangled in es2015/umd\n(<any> CombinationPredicate.prototype).children = Object.freeze([]); // freeze for safety\n\n/** @ignore */\nexport class And extends CombinationPredicate {\n    constructor(...children: Predicate[]) {\n        // Flatten any Ands\n        children = children.reduce((accum: Predicate[], p: Predicate): Predicate[] => {\n            return accum.concat(p instanceof And ? p.children : p);\n        }, []);\n        super(...children);\n    }\n    bind(batch: RecordBatch) {\n        const bound = this.children.map((p) => p.bind(batch));\n        return (idx: number, batch: RecordBatch) => bound.every((p) => p(idx, batch));\n    }\n}\n\n/** @ignore */\nexport class Or extends CombinationPredicate {\n    constructor(...children: Predicate[]) {\n        // Flatten any Ors\n        children = children.reduce((accum: Predicate[], p: Predicate): Predicate[] => {\n            return accum.concat(p instanceof Or ? p.children : p);\n        }, []);\n        super(...children);\n    }\n    bind(batch: RecordBatch) {\n        const bound = this.children.map((p) => p.bind(batch));\n        return (idx: number, batch: RecordBatch) => bound.some((p) => p(idx, batch));\n    }\n}\n\n/** @ignore */\nexport class Equals extends ComparisonPredicate {\n    // Helpers used to cache dictionary reverse lookups between calls to bind\n    private lastDictionary: Vector|undefined;\n    private lastKey: number|undefined;\n\n    protected _bindLitLit(_batch: RecordBatch, left: Literal, right: Literal): PredicateFunc {\n        const rtrn: boolean = left.v == right.v;\n        return () => rtrn;\n    }\n\n    protected _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx: number, batch: RecordBatch) => left_func(idx, batch) == right_func(idx, batch);\n    }\n\n    protected _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc {\n        const col_func = col.bind(batch);\n        if (col.vector instanceof DictionaryVector) {\n            let key: any;\n            const vector = col.vector as DictionaryVector;\n            if (vector.dictionary !== this.lastDictionary) {\n                key = vector.reverseLookup(lit.v);\n                this.lastDictionary = vector.dictionary;\n                this.lastKey = key;\n            } else {\n                key = this.lastKey;\n            }\n\n            if (key === -1) {\n                // the value doesn't exist in the dictionary - always return\n                // false\n                // TODO: special-case of PredicateFunc that encapsulates this\n                // \"always false\" behavior. That way filtering operations don't\n                // have to bother checking\n                return () => false;\n            } else {\n                return (idx: number) => {\n                    return vector.getKey(idx) === key;\n                };\n            }\n        } else {\n            return (idx: number, cols: RecordBatch) => col_func(idx, cols) == lit.v;\n        }\n    }\n\n    protected _bindLitCol(batch: RecordBatch, lit: Literal, col: Col) {\n        // Equals is commutative\n        return this._bindColLit(batch, col, lit);\n    }\n}\n\n/** @ignore */\nexport class LTeq extends ComparisonPredicate {\n    protected _bindLitLit(_batch: RecordBatch, left: Literal, right: Literal): PredicateFunc {\n        const rtrn: boolean = left.v <= right.v;\n        return () => rtrn;\n    }\n\n    protected _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx: number, cols: RecordBatch) => left_func(idx, cols) <= right_func(idx, cols);\n    }\n\n    protected _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => col_func(idx, cols) <= lit.v;\n    }\n\n    protected _bindLitCol(batch: RecordBatch, lit: Literal, col: Col) {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => lit.v <= col_func(idx, cols);\n    }\n}\n\n/** @ignore */\nexport class GTeq extends ComparisonPredicate {\n    protected _bindLitLit(_batch: RecordBatch, left: Literal, right: Literal): PredicateFunc {\n        const rtrn: boolean = left.v >= right.v;\n        return () => rtrn;\n    }\n\n    protected _bindColCol(batch: RecordBatch, left: Col, right: Col): PredicateFunc {\n        const left_func = left.bind(batch);\n        const right_func = right.bind(batch);\n        return (idx: number, cols: RecordBatch) => left_func(idx, cols) >= right_func(idx, cols);\n    }\n\n    protected _bindColLit(batch: RecordBatch, col: Col, lit: Literal): PredicateFunc {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => col_func(idx, cols) >= lit.v;\n    }\n\n    protected _bindLitCol(batch: RecordBatch, lit: Literal, col: Col) {\n        const col_func = col.bind(batch);\n        return (idx: number, cols: RecordBatch) => lit.v >= col_func(idx, cols);\n    }\n}\n\n/** @ignore */\nexport class Not extends Predicate {\n    constructor(public readonly child: Predicate) {\n        super();\n    }\n\n    bind(batch: RecordBatch) {\n        const func = this.child.bind(batch);\n        return (idx: number, batch: RecordBatch) => !func(idx, batch);\n    }\n}\n\n/** @ignore */\nexport class CustomPredicate extends Predicate {\n    constructor(private next: PredicateFunc, private bind_: (batch: RecordBatch) => void) {\n        super();\n    }\n\n    bind(batch: RecordBatch) {\n        this.bind_(batch);\n        return this.next;\n    }\n}\n\nexport function lit(v: any): Value<any> { return new Literal(v); }\nexport function col(n: string): Col<any> { return new Col(n); }\nexport function and(...p: Predicate[]): And { return new And(...p); }\nexport function or(...p: Predicate[]): Or { return new Or(...p); }\nexport function custom(next: PredicateFunc, bind: (batch: RecordBatch) => void) {\n    return new CustomPredicate(next, bind);\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Table } from '../table';\nimport { Vector } from '../vector';\nimport { IntVector } from '../vector/int';\nimport { Field, Schema } from '../schema';\nimport { Predicate, Col } from './predicate';\nimport { RecordBatch } from '../recordbatch';\nimport { VectorType as V } from '../interfaces';\nimport { DataType, Int, Struct, Dictionary } from '../type';\n\n/** @ignore */\nexport type BindFunc = (batch: RecordBatch) => void;\n/** @ignore */\nexport type NextFunc = (idx: number, batch: RecordBatch) => void;\n\nTable.prototype.countBy = function(this: Table, name: Col | string) { return new DataFrame(this.chunks).countBy(name); };\nTable.prototype.scan = function(this: Table, next: NextFunc, bind?: BindFunc) { return new DataFrame(this.chunks).scan(next, bind); };\nTable.prototype.scanReverse = function(this: Table, next: NextFunc, bind?: BindFunc) { return new DataFrame(this.chunks).scanReverse(next, bind); };\nTable.prototype.filter = function(this: Table, predicate: Predicate): FilteredDataFrame { return new DataFrame(this.chunks).filter(predicate); };\n\nexport class DataFrame<T extends { [key: string]: DataType } = any> extends Table<T> {\n    public filter(predicate: Predicate): FilteredDataFrame<T> {\n        return new FilteredDataFrame<T>(this.chunks, predicate);\n    }\n    public scan(next: NextFunc, bind?: BindFunc) {\n        const batches = this.chunks, numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            if (bind) { bind(batch); }\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                next(index, batch);\n            }\n        }\n    }\n    public scanReverse(next: NextFunc, bind?: BindFunc) {\n        const batches = this.chunks, numBatches = batches.length;\n        for (let batchIndex = numBatches; --batchIndex >= 0;) {\n            // load batches\n            const batch = batches[batchIndex];\n            if (bind) { bind(batch); }\n            // yield all indices\n            for (let index = batch.length; --index >= 0;) {\n                next(index, batch);\n            }\n        }\n    }\n    public countBy(name: Col | string) {\n        const batches = this.chunks, numBatches = batches.length;\n        const count_by = typeof name === 'string' ? new Col(name) : name as Col;\n        // Assume that all dictionary batches are deltas, which means that the\n        // last record batch has the most complete dictionary\n        count_by.bind(batches[numBatches - 1]);\n        const vector = count_by.vector as V<Dictionary>;\n        if (!DataType.isDictionary(vector.type)) {\n            throw new Error('countBy currently only supports dictionary-encoded columns');\n        }\n\n        const countByteLength = Math.ceil(Math.log(vector.length) / Math.log(256));\n        const CountsArrayType = countByteLength == 4 ? Uint32Array :\n                                countByteLength >= 2 ? Uint16Array : Uint8Array;\n\n        const counts = new CountsArrayType(vector.dictionary.length);\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            // rebind the countBy Col\n            count_by.bind(batch);\n            const keys = (count_by.vector as V<Dictionary>).indices;\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                let key = keys.get(index);\n                if (key !== null) { counts[key]++; }\n            }\n        }\n        return new CountByResult(vector.dictionary, IntVector.from(counts));\n    }\n}\n\n/** @ignore */\nexport class CountByResult<T extends DataType = any, TCount extends Int = Int> extends Table<{ values: T,  counts: TCount }> {\n    constructor(values: Vector<T>, counts: V<TCount>) {\n        type R = { values: T, counts: TCount };\n        const schema = new Schema<R>([\n            new Field('values', values.type),\n            new Field('counts', counts.type)\n        ]);\n        super(new RecordBatch<R>(schema, counts.length, [values, counts]));\n    }\n    public toJSON(): Object {\n        const values = this.getColumnAt(0)!;\n        const counts = this.getColumnAt(1)!;\n        const result = {} as { [k: string]: number | null };\n        for (let i = -1; ++i < this.length;) {\n            result[values.get(i)] = counts.get(i);\n        }\n        return result;\n    }\n}\n\n/** @ignore */\nexport class FilteredDataFrame<T extends { [key: string]: DataType } = any> extends DataFrame<T> {\n    private _predicate: Predicate;\n    constructor (batches: RecordBatch<T>[], predicate: Predicate) {\n        super(batches);\n        this._predicate = predicate;\n    }\n    public scan(next: NextFunc, bind?: BindFunc) {\n        // inlined version of this:\n        // this.parent.scan((idx, columns) => {\n        //     if (this.predicate(idx, columns)) next(idx, columns);\n        // });\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            let isBound = false;\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                if (predicate(index, batch)) {\n                    // bind batches lazily - if predicate doesn't match anything\n                    // in the batch we don't need to call bind on the batch\n                    if (bind && !isBound) {\n                        bind(batch);\n                        isBound = true;\n                    }\n                    next(index, batch);\n                }\n            }\n        }\n    }\n    public scanReverse(next: NextFunc, bind?: BindFunc) {\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = numBatches; --batchIndex >= 0;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            let isBound = false;\n            // yield all indices\n            for (let index = batch.length; --index >= 0;) {\n                if (predicate(index, batch)) {\n                    // bind batches lazily - if predicate doesn't match anything\n                    // in the batch we don't need to call bind on the batch\n                    if (bind && !isBound) {\n                        bind(batch);\n                        isBound = true;\n                    }\n                    next(index, batch);\n                }\n            }\n        }\n    }\n    public count(): number {\n        // inlined version of this:\n        // let sum = 0;\n        // this.parent.scan((idx, columns) => {\n        //     if (this.predicate(idx, columns)) ++sum;\n        // });\n        // return sum;\n        let sum = 0;\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                if (predicate(index, batch)) { ++sum; }\n            }\n        }\n        return sum;\n    }\n    public *[Symbol.iterator](): IterableIterator<Struct<T>['TValue']> {\n        // inlined version of this:\n        // this.parent.scan((idx, columns) => {\n        //     if (this.predicate(idx, columns)) next(idx, columns);\n        // });\n        const batches = this._chunks;\n        const numBatches = batches.length;\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            // TODO: bind batches lazily\n            // If predicate doesn't match anything in the batch we don't need\n            // to bind the callback\n            const predicate = this._predicate.bind(batch);\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                if (predicate(index, batch)) { yield batch.get(index) as any; }\n            }\n        }\n    }\n    public filter(predicate: Predicate): FilteredDataFrame<T> {\n        return new FilteredDataFrame<T>(\n            this._chunks,\n            this._predicate.and(predicate)\n        );\n    }\n    public countBy(name: Col | string) {\n        const batches = this._chunks, numBatches = batches.length;\n        const count_by = typeof name === 'string' ? new Col(name) : name as Col;\n        // Assume that all dictionary batches are deltas, which means that the\n        // last record batch has the most complete dictionary\n        count_by.bind(batches[numBatches - 1]);\n        const vector = count_by.vector as V<Dictionary>;\n        if (!DataType.isDictionary(vector.type)) {\n            throw new Error('countBy currently only supports dictionary-encoded columns');\n        }\n\n        const countByteLength = Math.ceil(Math.log(vector.length) / Math.log(256));\n        const CountsArrayType = countByteLength == 4 ? Uint32Array :\n                                countByteLength >= 2 ? Uint16Array : Uint8Array;\n\n        const counts = new CountsArrayType(vector.dictionary.length);\n\n        for (let batchIndex = -1; ++batchIndex < numBatches;) {\n            // load batches\n            const batch = batches[batchIndex];\n            const predicate = this._predicate.bind(batch);\n            // rebind the countBy Col\n            count_by.bind(batch);\n            const keys = (count_by.vector as V<Dictionary>).indices;\n            // yield all indices\n            for (let index = -1, numRows = batch.length; ++index < numRows;) {\n                let key = keys.get(index);\n                if (key !== null && predicate(index, batch)) { counts[key]++; }\n            }\n        }\n        return new CountByResult(vector.dictionary, IntVector.from(counts));\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nexport { ArrowType, DateUnit, IntervalUnit, MessageHeader, MetadataVersion, Precision, TimeUnit, Type, UnionMode, BufferType } from './enum';\nexport { Data } from './data';\nexport {\n    DataType,\n    Null,\n    Bool,\n    Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64,\n    Float, Float16, Float32, Float64,\n    Utf8,\n    Binary,\n    FixedSizeBinary,\n    Date_, DateDay, DateMillisecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Decimal,\n    List,\n    Struct,\n    Union, DenseUnion, SparseUnion,\n    Dictionary,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    FixedSizeList,\n    Map_,\n} from './type';\n\nexport { Table } from './table';\nexport { Column } from './column';\nexport { Visitor } from './visitor';\nexport { Schema, Field } from './schema';\nexport {\n    Vector,\n    BaseVector,\n    BinaryVector,\n    BoolVector,\n    Chunked,\n    DateVector, DateDayVector, DateMillisecondVector,\n    DecimalVector,\n    DictionaryVector,\n    FixedSizeBinaryVector,\n    FixedSizeListVector,\n    FloatVector, Float16Vector, Float32Vector, Float64Vector,\n    IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector,\n    IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector,\n    ListVector,\n    MapVector,\n    NullVector,\n    StructVector,\n    TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector,\n    TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector,\n    UnionVector, DenseUnionVector, SparseUnionVector,\n    Utf8Vector,\n} from './vector/index';\n\nexport {\n    Builder,\n    BinaryBuilder,\n    BoolBuilder,\n    DateBuilder, DateDayBuilder, DateMillisecondBuilder,\n    DecimalBuilder,\n    DictionaryBuilder,\n    FixedSizeBinaryBuilder,\n    FixedSizeListBuilder,\n    FloatBuilder, Float16Builder, Float32Builder, Float64Builder,\n    IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder,\n    IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder,\n    ListBuilder,\n    MapBuilder,\n    NullBuilder,\n    StructBuilder,\n    TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder,\n    TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder,\n    UnionBuilder, DenseUnionBuilder, SparseUnionBuilder,\n    Utf8Builder,\n} from './builder/index';\n\nexport { ByteStream, AsyncByteStream, AsyncByteQueue, ReadableSource, WritableSink } from './io/stream';\nexport { RecordBatchReader, RecordBatchFileReader, RecordBatchStreamReader, AsyncRecordBatchFileReader, AsyncRecordBatchStreamReader } from './ipc/reader';\nexport { RecordBatchWriter, RecordBatchFileWriter, RecordBatchStreamWriter, RecordBatchJSONWriter } from './ipc/writer';\nexport { MessageReader, AsyncMessageReader, JSONMessageReader } from './ipc/message';\nexport { Message } from './ipc/metadata/message';\nexport { RecordBatch } from './recordbatch';\nexport { ArrowJSONLike, FileHandle, Readable, Writable, ReadableWritable, ReadableDOMStreamOptions } from './io/interfaces';\nexport { DataFrame, FilteredDataFrame, CountByResult, BindFunc, NextFunc } from './compute/dataframe';\n\nimport * as util_bn_ from './util/bn';\nimport * as util_int_ from './util/int';\nimport * as util_bit_ from './util/bit';\nimport * as util_math_ from './util/math';\nimport * as util_buffer_ from './util/buffer';\nimport * as util_vector_ from './util/vector';\nimport * as predicate from './compute/predicate';\n\nexport { predicate };\n/** @ignore */\nexport const util = {\n    ...util_bn_,\n    ...util_int_,\n    ...util_bit_,\n    ...util_math_,\n    ...util_buffer_,\n    ...util_vector_\n};\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport streamAdapters from './io/adapters';\nimport { Builder } from './builder/index';\nimport { RecordBatchReader } from './ipc/reader';\nimport { RecordBatchWriter } from './ipc/writer';\nimport { toDOMStream } from './io/whatwg/iterable';\nimport { builderThroughDOMStream } from './io/whatwg/builder';\nimport { recordBatchReaderThroughDOMStream } from './io/whatwg/reader';\nimport { recordBatchWriterThroughDOMStream } from './io/whatwg/writer';\n\nstreamAdapters.toDOMStream = toDOMStream;\nBuilder['throughDOM'] = builderThroughDOMStream;\nRecordBatchReader['throughDOM'] = recordBatchReaderThroughDOMStream;\nRecordBatchWriter['throughDOM'] = recordBatchWriterThroughDOMStream;\n\nexport {\n    ArrowType, DateUnit, IntervalUnit, MessageHeader, MetadataVersion, Precision, TimeUnit, Type, UnionMode, BufferType,\n    Data,\n    DataType,\n    Null,\n    Bool,\n    Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64,\n    Float, Float16, Float32, Float64,\n    Utf8,\n    Binary,\n    FixedSizeBinary,\n    Date_, DateDay, DateMillisecond,\n    Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond,\n    Time, TimeSecond, TimeMillisecond, TimeMicrosecond, TimeNanosecond,\n    Decimal,\n    List,\n    Struct,\n    Union, DenseUnion, SparseUnion,\n    Dictionary,\n    Interval, IntervalDayTime, IntervalYearMonth,\n    FixedSizeList,\n    Map_,\n    Table,\n    Column,\n    Schema, Field,\n    Visitor,\n    Vector,\n    BaseVector,\n    BinaryVector,\n    BoolVector,\n    Chunked,\n    DateVector, DateDayVector, DateMillisecondVector,\n    DecimalVector,\n    DictionaryVector,\n    FixedSizeBinaryVector,\n    FixedSizeListVector,\n    FloatVector, Float16Vector, Float32Vector, Float64Vector,\n    IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector,\n    IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector,\n    ListVector,\n    MapVector,\n    NullVector,\n    StructVector,\n    TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector,\n    TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector,\n    UnionVector, DenseUnionVector, SparseUnionVector,\n    Utf8Vector,\n    ByteStream, AsyncByteStream, AsyncByteQueue, ReadableSource, WritableSink,\n    RecordBatchReader, RecordBatchFileReader, RecordBatchStreamReader, AsyncRecordBatchFileReader, AsyncRecordBatchStreamReader,\n    RecordBatchWriter, RecordBatchFileWriter, RecordBatchStreamWriter, RecordBatchJSONWriter,\n    MessageReader, AsyncMessageReader, JSONMessageReader,\n    Message,\n    RecordBatch,\n    ArrowJSONLike, FileHandle, Readable, Writable, ReadableWritable, ReadableDOMStreamOptions,\n    DataFrame, FilteredDataFrame, CountByResult, BindFunc, NextFunc,\n    predicate,\n    util,\n    Builder,\n    BinaryBuilder,\n    BoolBuilder,\n    DateBuilder, DateDayBuilder, DateMillisecondBuilder,\n    DecimalBuilder,\n    DictionaryBuilder,\n    FixedSizeBinaryBuilder,\n    FixedSizeListBuilder,\n    FloatBuilder, Float16Builder, Float32Builder, Float64Builder,\n    IntervalBuilder, IntervalDayTimeBuilder, IntervalYearMonthBuilder,\n    IntBuilder, Int8Builder, Int16Builder, Int32Builder, Int64Builder, Uint8Builder, Uint16Builder, Uint32Builder, Uint64Builder,\n    ListBuilder,\n    MapBuilder,\n    NullBuilder,\n    StructBuilder,\n    TimestampBuilder, TimestampSecondBuilder, TimestampMillisecondBuilder, TimestampMicrosecondBuilder, TimestampNanosecondBuilder,\n    TimeBuilder, TimeSecondBuilder, TimeMillisecondBuilder, TimeMicrosecondBuilder, TimeNanosecondBuilder,\n    UnionBuilder, DenseUnionBuilder, SparseUnionBuilder,\n    Utf8Builder,\n} from './Arrow';\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { toUint8Array } from '../../util/buffer';\nimport { ReadableDOMStreamOptions } from '../../io/interfaces';\nimport { isIterable, isAsyncIterable } from '../../util/compat';\n\n/** @ignore */\nexport function toDOMStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: ReadableDOMStreamOptions): ReadableStream<T> {\n    if (isAsyncIterable<T>(source)) { return asyncIterableAsReadableDOMStream(source, options); }\n    if (isIterable<T>(source)) { return iterableAsReadableDOMStream(source, options); }\n    /* istanbul ignore next */\n    throw new Error(`toDOMStream() must be called with an Iterable or AsyncIterable`);\n}\n\n/** @ignore */\nfunction iterableAsReadableDOMStream<T>(source: Iterable<T>, options?: ReadableDOMStreamOptions) {\n\n    let it: Iterator<T> | null = null;\n    const bm = (options && options.type === 'bytes') || false;\n    const hwm = options && options.highWaterMark || (2 ** 24);\n\n    return new ReadableStream<T>({\n        ...options as any,\n        start(controller) { next(controller, it || (it = source[Symbol.iterator]())); },\n        pull(controller) { it ? (next(controller, it)) : controller.close(); },\n        cancel() { (it && (it.return && it.return()) || true) && (it = null); }\n    }, { highWaterMark: bm ? hwm : undefined, ...options });\n\n    function next(controller: ReadableStreamDefaultController<T>, it: Iterator<T>) {\n        let buf: Uint8Array;\n        let r: IteratorResult<T> | null = null;\n        let size = controller.desiredSize || null;\n        while (!(r = it.next(bm ? size : null)).done) {\n            if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {\n                size != null && bm && (size = size - buf.byteLength + 1);\n                r.value = <any> buf;\n            }\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) { return; }\n        }\n        controller.close();\n    }\n}\n\n/** @ignore */\nfunction asyncIterableAsReadableDOMStream<T>(source: AsyncIterable<T>, options?: ReadableDOMStreamOptions) {\n\n    let it: AsyncIterator<T> | null = null;\n    const bm = (options && options.type === 'bytes') || false;\n    const hwm = options && options.highWaterMark || (2 ** 24);\n\n    return new ReadableStream<T>({\n        ...options as any,\n        async start(controller) { await next(controller, it || (it = source[Symbol.asyncIterator]())); },\n        async pull(controller) { it ? (await next(controller, it)) : controller.close(); },\n        async cancel() { (it && (it.return && await it.return()) || true) && (it = null); },\n    }, { highWaterMark: bm ? hwm : undefined, ...options });\n\n    async function next(controller: ReadableStreamDefaultController<T>, it: AsyncIterator<T>) {\n        let buf: Uint8Array;\n        let r: IteratorResult<T> | null = null;\n        let size = controller.desiredSize || null;\n        while (!(r = await it.next(bm ? size : null)).done) {\n            if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {\n                size != null && bm && (size = size - buf.byteLength + 1);\n                r.value = <any> buf;\n            }\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) { return; }\n        }\n        controller.close();\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../../type';\nimport { RecordBatch } from '../../recordbatch';\nimport { AsyncByteQueue } from '../../io/stream';\nimport { RecordBatchReader } from '../../ipc/reader';\n\n/** @ignore */\nexport function recordBatchReaderThroughDOMStream<T extends { [key: string]: DataType } = any>(writableStrategy?: ByteLengthQueuingStrategy, readableStrategy?: { autoDestroy: boolean }) {\n\n    const queue = new AsyncByteQueue();\n    let reader: RecordBatchReader<T> | null = null;\n\n    const readable = new ReadableStream<RecordBatch<T>>({\n        async cancel() { await queue.close(); },\n        async start(controller) { await next(controller, reader || (reader = await open())); },\n        async pull(controller) { reader ? await next(controller, reader) : controller.close(); }\n    });\n\n    return { writable: new WritableStream(queue, { 'highWaterMark': 2 ** 14, ...writableStrategy }), readable };\n\n    async function open() {\n        return await (await RecordBatchReader.from<T>(queue)).open(readableStrategy);\n    }\n\n    async function next(controller: ReadableStreamDefaultController<RecordBatch<T>>, reader: RecordBatchReader<T>) {\n        let size = controller.desiredSize;\n        let r: IteratorResult<RecordBatch<T>> | null = null;\n        while (!(r = await reader.next()).done) {\n            controller.enqueue(r.value);\n            if (size != null && --size <= 0) {\n                return;\n            }\n        }\n        controller.close();\n    }\n}\n","// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { DataType } from '../../type';\nimport { RecordBatch } from '../../recordbatch';\nimport { AsyncByteStream } from '../../io/stream';\nimport { RecordBatchWriter } from '../../ipc/writer';\n\n/** @ignore */\nexport function recordBatchWriterThroughDOMStream<T extends { [key: string]: DataType } = any>(\n    this: typeof RecordBatchWriter,\n    writableStrategy?: QueuingStrategy<RecordBatch<T>> & { autoDestroy: boolean },\n    readableStrategy?: { highWaterMark?: number, size?: any }\n) {\n\n    const writer = new this<T>(writableStrategy);\n    const reader = new AsyncByteStream(writer);\n    const readable = new ReadableStream({\n        type: 'bytes',\n        async cancel() { await reader.cancel(); },\n        async pull(controller) { await next(controller); },\n        async start(controller) { await next(controller); },\n    }, { 'highWaterMark': 2 ** 14, ...readableStrategy });\n\n    return { writable: new WritableStream(writer, writableStrategy), readable };\n\n    async function next(controller: ReadableStreamDefaultController<Uint8Array>) {\n        let buf: Uint8Array | null = null;\n        let size = controller.desiredSize;\n        while (buf = await reader.read(size || null)) {\n            controller.enqueue(buf);\n            if (size != null && (size -= buf.byteLength) <= 0) { return; }\n        }\n        controller.close();\n    }\n}\n","/**\n * @license\n * Copyright 2018-2021 Streamlit Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Table, Type } from \"apache-arrow\";\nvar ArrowTable = /** @class */ (function () {\n    function ArrowTable(dataBuffer, indexBuffer, columnsBuffer, styler) {\n        var _this = this;\n        this.getCell = function (rowIndex, columnIndex) {\n            var isBlankCell = rowIndex < _this.headerRows && columnIndex < _this.headerColumns;\n            var isIndexCell = rowIndex >= _this.headerRows && columnIndex < _this.headerColumns;\n            var isColumnsCell = rowIndex < _this.headerRows && columnIndex >= _this.headerColumns;\n            if (isBlankCell) {\n                var classNames = [\"blank\"];\n                if (columnIndex > 0) {\n                    classNames.push(\"level\" + rowIndex);\n                }\n                return {\n                    type: \"blank\",\n                    classNames: classNames.join(\" \"),\n                    content: \"\"\n                };\n            }\n            else if (isColumnsCell) {\n                var dataColumnIndex = columnIndex - _this.headerColumns;\n                var classNames = [\n                    \"col_heading\",\n                    \"level\" + rowIndex,\n                    \"col\" + dataColumnIndex\n                ];\n                return {\n                    type: \"columns\",\n                    classNames: classNames.join(\" \"),\n                    content: _this.getContent(_this.columnsTable, dataColumnIndex, rowIndex)\n                };\n            }\n            else if (isIndexCell) {\n                var dataRowIndex = rowIndex - _this.headerRows;\n                var classNames = [\n                    \"row_heading\",\n                    \"level\" + columnIndex,\n                    \"row\" + dataRowIndex\n                ];\n                return {\n                    type: \"index\",\n                    id: \"T_\" + _this.uuid + \"level\" + columnIndex + \"_row\" + dataRowIndex,\n                    classNames: classNames.join(\" \"),\n                    content: _this.getContent(_this.indexTable, dataRowIndex, columnIndex)\n                };\n            }\n            else {\n                var dataRowIndex = rowIndex - _this.headerRows;\n                var dataColumnIndex = columnIndex - _this.headerColumns;\n                var classNames = [\n                    \"data\",\n                    \"row\" + dataRowIndex,\n                    \"col\" + dataColumnIndex\n                ];\n                var content = _this.styler\n                    ? _this.getContent(_this.styler.displayValuesTable, dataRowIndex, dataColumnIndex)\n                    : _this.getContent(_this.dataTable, dataRowIndex, dataColumnIndex);\n                return {\n                    type: \"data\",\n                    id: \"T_\" + _this.uuid + \"row\" + dataRowIndex + \"_col\" + dataColumnIndex,\n                    classNames: classNames.join(\" \"),\n                    content: content\n                };\n            }\n        };\n        this.getContent = function (table, rowIndex, columnIndex) {\n            var column = table.getColumnAt(columnIndex);\n            if (column === null) {\n                return \"\";\n            }\n            var columnTypeId = _this.getColumnTypeId(table, columnIndex);\n            switch (columnTypeId) {\n                case Type.Timestamp: {\n                    return _this.nanosToDate(column.get(rowIndex));\n                }\n                default: {\n                    return column.get(rowIndex);\n                }\n            }\n        };\n        this.dataTable = Table.from(dataBuffer);\n        this.indexTable = Table.from(indexBuffer);\n        this.columnsTable = Table.from(columnsBuffer);\n        this.styler = styler\n            ? {\n                caption: styler.caption,\n                displayValuesTable: Table.from(styler.displayValues),\n                styles: styler.styles,\n                uuid: styler.uuid\n            }\n            : undefined;\n    }\n    Object.defineProperty(ArrowTable.prototype, \"rows\", {\n        get: function () {\n            return this.indexTable.length + this.columnsTable.numCols;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"columns\", {\n        get: function () {\n            return this.indexTable.numCols + this.columnsTable.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"headerRows\", {\n        get: function () {\n            return this.rows - this.dataRows;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"headerColumns\", {\n        get: function () {\n            return this.columns - this.dataColumns;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"dataRows\", {\n        get: function () {\n            return this.dataTable.length;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"dataColumns\", {\n        get: function () {\n            return this.dataTable.numCols;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"uuid\", {\n        get: function () {\n            return this.styler && this.styler.uuid;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"caption\", {\n        get: function () {\n            return this.styler && this.styler.caption;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"styles\", {\n        get: function () {\n            return this.styler && this.styler.styles;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"table\", {\n        get: function () {\n            return this.dataTable;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"index\", {\n        get: function () {\n            return this.indexTable;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(ArrowTable.prototype, \"columnTable\", {\n        get: function () {\n            return this.columnsTable;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Serialize arrow table.\n     */\n    ArrowTable.prototype.serialize = function () {\n        return {\n            data: this.dataTable.serialize(),\n            index: this.indexTable.serialize(),\n            columns: this.columnsTable.serialize()\n        };\n    };\n    /**\n     * Returns apache-arrow specific typeId of column.\n     */\n    ArrowTable.prototype.getColumnTypeId = function (table, columnIndex) {\n        return table.schema.fields[columnIndex].type.typeId;\n    };\n    ArrowTable.prototype.nanosToDate = function (nanos) {\n        return new Date(nanos / 1e6);\n    };\n    return ArrowTable;\n}());\nexport { ArrowTable };\n","/**\n * @license\n * Copyright 2018-2021 Streamlit Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\n// Safari doesn't support the EventTarget class, so we use a shim.\nimport { EventTarget } from \"event-target-shim\";\nimport { ArrowTable } from \"./ArrowTable\";\n/** Messages from Component -> Streamlit */\nvar ComponentMessageType;\n(function (ComponentMessageType) {\n    // A component sends this message when it's ready to receive messages\n    // from Streamlit. Streamlit won't send any messages until it gets this.\n    // Data: { apiVersion: number }\n    ComponentMessageType[\"COMPONENT_READY\"] = \"streamlit:componentReady\";\n    // The component has a new widget value. Send it back to Streamlit, which\n    // will then re-run the app.\n    // Data: { value: any }\n    ComponentMessageType[\"SET_COMPONENT_VALUE\"] = \"streamlit:setComponentValue\";\n    // The component has a new height for its iframe.\n    // Data: { height: number }\n    ComponentMessageType[\"SET_FRAME_HEIGHT\"] = \"streamlit:setFrameHeight\";\n})(ComponentMessageType || (ComponentMessageType = {}));\n/**\n * Streamlit communication API.\n *\n * Components can send data to Streamlit via the functions defined here,\n * and receive data from Streamlit via the `events` property.\n */\nvar Streamlit = /** @class */ (function () {\n    function Streamlit() {\n    }\n    /**\n     * The Streamlit component API version we're targetting.\n     * There's currently only 1!\n     */\n    Streamlit.API_VERSION = 1;\n    Streamlit.RENDER_EVENT = \"streamlit:render\";\n    /** Dispatches events received from Streamlit. */\n    Streamlit.events = new EventTarget();\n    Streamlit.registeredMessageListener = false;\n    /**\n     * Tell Streamlit that the component is ready to start receiving data.\n     * Streamlit will defer emitting RENDER events until it receives the\n     * COMPONENT_READY message.\n     */\n    Streamlit.setComponentReady = function () {\n        if (!Streamlit.registeredMessageListener) {\n            // Register for message events if we haven't already\n            window.addEventListener(\"message\", Streamlit.onMessageEvent);\n            Streamlit.registeredMessageListener = true;\n        }\n        Streamlit.sendBackMsg(ComponentMessageType.COMPONENT_READY, {\n            apiVersion: Streamlit.API_VERSION\n        });\n    };\n    /**\n     * Report the component's height to Streamlit.\n     * This should be called every time the component changes its DOM - that is,\n     * when it's first loaded, and any time it updates.\n     */\n    Streamlit.setFrameHeight = function (height) {\n        if (height === undefined) {\n            // `height` is optional. If undefined, it defaults to scrollHeight,\n            // which is the entire height of the element minus its border,\n            // scrollbar, and margin.\n            height = document.body.scrollHeight;\n        }\n        if (height === Streamlit.lastFrameHeight) {\n            // Don't bother updating if our height hasn't changed.\n            return;\n        }\n        Streamlit.lastFrameHeight = height;\n        Streamlit.sendBackMsg(ComponentMessageType.SET_FRAME_HEIGHT, { height: height });\n    };\n    /**\n     * Set the component's value. This value will be returned to the Python\n     * script, and the script will be re-run.\n     *\n     * For example:\n     *\n     * JavaScript:\n     * Streamlit.setComponentValue(\"ahoy!\")\n     *\n     * Python:\n     * value = st.my_component(...)\n     * st.write(value) # -> \"ahoy!\"\n     *\n     * The value must be an ArrowTable, a typed array, an ArrayBuffer, or be\n     * serializable to JSON.\n     */\n    Streamlit.setComponentValue = function (value) {\n        var dataType;\n        if (value instanceof ArrowTable) {\n            dataType = \"dataframe\";\n            value = value.serialize();\n        }\n        else if (isTypedArray(value)) {\n            // All typed arrays get sent as Uint8Array, because that's what our\n            // protobuf library uses for the \"bytes\" field type.\n            dataType = \"bytes\";\n            value = new Uint8Array(value.buffer);\n        }\n        else if (value instanceof ArrayBuffer) {\n            dataType = \"bytes\";\n            value = new Uint8Array(value);\n        }\n        else {\n            dataType = \"json\";\n        }\n        Streamlit.sendBackMsg(ComponentMessageType.SET_COMPONENT_VALUE, {\n            value: value,\n            dataType: dataType\n        });\n    };\n    /** Receive a ForwardMsg from the Streamlit app */\n    Streamlit.onMessageEvent = function (event) {\n        var type = event.data[\"type\"];\n        switch (type) {\n            case Streamlit.RENDER_EVENT:\n                Streamlit.onRenderMessage(event.data);\n                break;\n        }\n    };\n    /**\n     * Handle an untyped Streamlit render event and redispatch it as a\n     * StreamlitRenderEvent.\n     */\n    Streamlit.onRenderMessage = function (data) {\n        var args = data[\"args\"];\n        if (args == null) {\n            console.error(\"Got null args in onRenderMessage. This should never happen\");\n            args = {};\n        }\n        // Parse our dataframe arguments with arrow, and merge them into our args dict\n        var dataframeArgs = data[\"dfs\"] && data[\"dfs\"].length > 0\n            ? Streamlit.argsDataframeToObject(data[\"dfs\"])\n            : {};\n        args = __assign(__assign({}, args), dataframeArgs);\n        var disabled = Boolean(data[\"disabled\"]);\n        var theme = data[\"theme\"];\n        if (theme) {\n            _injectTheme(theme);\n        }\n        // Dispatch a render event!\n        var eventData = { disabled: disabled, args: args, theme: theme };\n        var event = new CustomEvent(Streamlit.RENDER_EVENT, {\n            detail: eventData\n        });\n        Streamlit.events.dispatchEvent(event);\n    };\n    Streamlit.argsDataframeToObject = function (argsDataframe) {\n        var argsDataframeArrow = argsDataframe.map(function (_a) {\n            var key = _a.key, value = _a.value;\n            return [key, Streamlit.toArrowTable(value)];\n        });\n        return Object.fromEntries(argsDataframeArrow);\n    };\n    Streamlit.toArrowTable = function (df) {\n        var _a = df.data, data = _a.data, index = _a.index, columns = _a.columns, styler = _a.styler;\n        return new ArrowTable(data, index, columns, styler);\n    };\n    /** Post a message to the Streamlit app. */\n    Streamlit.sendBackMsg = function (type, data) {\n        window.parent.postMessage(__assign({ isStreamlitMessage: true, type: type }, data), \"*\");\n    };\n    return Streamlit;\n}());\nexport { Streamlit };\nvar _injectTheme = function (theme) {\n    var style = document.createElement(\"style\");\n    document.head.appendChild(style);\n    style.innerHTML = \"\\n    :root {\\n      --primary-color: \" + theme.primaryColor + \";\\n      --background-color: \" + theme.backgroundColor + \";\\n      --secondary-background-color: \" + theme.secondaryBackgroundColor + \";\\n      --text-color: \" + theme.textColor + \";\\n      --font: \" + theme.font + \";\\n    }\\n\\n    body {\\n      background-color: var(--background-color);\\n      color: var(--text-color);\\n    }\\n  \";\n};\n/** True if the value is a TypedArray. */\nfunction isTypedArray(value) {\n    var isBigIntArray = false;\n    try {\n        isBigIntArray =\n            value instanceof BigInt64Array || value instanceof BigUint64Array;\n    }\n    catch (e) {\n        // Ignore cause Safari does not support this\n        // https://caniuse.com/mdn-javascript_builtins_bigint64array\n    }\n    return (value instanceof Int8Array ||\n        value instanceof Uint8Array ||\n        value instanceof Uint8ClampedArray ||\n        value instanceof Int16Array ||\n        value instanceof Uint16Array ||\n        value instanceof Int32Array ||\n        value instanceof Uint32Array ||\n        value instanceof Float32Array ||\n        value instanceof Float64Array ||\n        isBigIntArray);\n}\n","/**\n * @license\n * Copyright 2018-2021 Streamlit Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *    http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport hoistNonReactStatics from \"hoist-non-react-statics\";\nimport React from \"react\";\nimport { Streamlit } from \"./streamlit\";\n/**\n * Optional Streamlit React-based component base class.\n *\n * You are not required to extend this base class to create a Streamlit\n * component. If you decide not to extend it, you should implement the\n * `componentDidMount` and `componentDidUpdate` functions in your own class,\n * so that your plugin properly resizes.\n */\nvar StreamlitComponentBase = /** @class */ (function (_super) {\n    __extends(StreamlitComponentBase, _super);\n    function StreamlitComponentBase() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    StreamlitComponentBase.prototype.componentDidMount = function () {\n        // After we're rendered for the first time, tell Streamlit that our height\n        // has changed.\n        Streamlit.setFrameHeight();\n    };\n    StreamlitComponentBase.prototype.componentDidUpdate = function () {\n        // After we're updated, tell Streamlit that our height may have changed.\n        Streamlit.setFrameHeight();\n    };\n    return StreamlitComponentBase;\n}(React.PureComponent));\nexport { StreamlitComponentBase };\n/**\n * Wrapper for React-based Streamlit components.\n *\n * Bootstraps the communication interface between Streamlit and the component.\n */\nexport function withStreamlitConnection(WrappedComponent) {\n    var ComponentWrapper = /** @class */ (function (_super) {\n        __extends(ComponentWrapper, _super);\n        function ComponentWrapper(props) {\n            var _this = _super.call(this, props) || this;\n            _this.componentDidMount = function () {\n                // Set up event listeners, and signal to Streamlit that we're ready.\n                // We won't render the component until we receive the first RENDER_EVENT.\n                Streamlit.events.addEventListener(Streamlit.RENDER_EVENT, _this.onRenderEvent);\n                Streamlit.setComponentReady();\n            };\n            _this.componentDidUpdate = function () {\n                // If our child threw an error, we display it in render(). In this\n                // case, the child won't be mounted and therefore won't call\n                // `setFrameHeight` on its own. We do it here so that the rendered\n                // error will be visible.\n                if (_this.state.componentError != null) {\n                    Streamlit.setFrameHeight();\n                }\n            };\n            _this.componentWillUnmount = function () {\n                Streamlit.events.removeEventListener(Streamlit.RENDER_EVENT, _this.onRenderEvent);\n            };\n            /**\n             * Streamlit is telling this component to redraw.\n             * We save the render data in State, so that it can be passed to the\n             * component in our own render() function.\n             */\n            _this.onRenderEvent = function (event) {\n                // Update our state with the newest render data\n                var renderEvent = event;\n                _this.setState({ renderData: renderEvent.detail });\n            };\n            _this.render = function () {\n                // If our wrapped component threw an error, display it.\n                if (_this.state.componentError != null) {\n                    return (React.createElement(\"div\", null,\n                        React.createElement(\"h1\", null, \"Component Error\"),\n                        React.createElement(\"span\", null, _this.state.componentError.message)));\n                }\n                // Don't render until we've gotten our first RENDER_EVENT from Streamlit.\n                if (_this.state.renderData == null) {\n                    return null;\n                }\n                return (React.createElement(WrappedComponent, { width: window.innerWidth, disabled: _this.state.renderData.disabled, args: _this.state.renderData.args, theme: _this.state.renderData.theme }));\n            };\n            _this.state = {\n                renderData: undefined,\n                componentError: undefined\n            };\n            return _this;\n        }\n        /**\n         * Error boundary function. This will be called if our wrapped\n         * component throws an error. We store the caught error in our state,\n         * and display it in the next render().\n         */\n        ComponentWrapper.getDerivedStateFromError = function (error) {\n            return { componentError: error };\n        };\n        return ComponentWrapper;\n    }(React.PureComponent));\n    return hoistNonReactStatics(ComponentWrapper, WrappedComponent);\n}\n","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\n\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var b=\"function\"===typeof Symbol&&Symbol.for,c=b?Symbol.for(\"react.element\"):60103,d=b?Symbol.for(\"react.portal\"):60106,e=b?Symbol.for(\"react.fragment\"):60107,f=b?Symbol.for(\"react.strict_mode\"):60108,g=b?Symbol.for(\"react.profiler\"):60114,h=b?Symbol.for(\"react.provider\"):60109,k=b?Symbol.for(\"react.context\"):60110,l=b?Symbol.for(\"react.async_mode\"):60111,m=b?Symbol.for(\"react.concurrent_mode\"):60111,n=b?Symbol.for(\"react.forward_ref\"):60112,p=b?Symbol.for(\"react.suspense\"):60113,q=b?\nSymbol.for(\"react.suspense_list\"):60120,r=b?Symbol.for(\"react.memo\"):60115,t=b?Symbol.for(\"react.lazy\"):60116,v=b?Symbol.for(\"react.block\"):60121,w=b?Symbol.for(\"react.fundamental\"):60117,x=b?Symbol.for(\"react.responder\"):60118,y=b?Symbol.for(\"react.scope\"):60119;\nfunction z(a){if(\"object\"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;\nexports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};\nexports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||\"object\"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;\n","/** @license React v16.14.0\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var l=require(\"object-assign\"),n=\"function\"===typeof Symbol&&Symbol.for,p=n?Symbol.for(\"react.element\"):60103,q=n?Symbol.for(\"react.portal\"):60106,r=n?Symbol.for(\"react.fragment\"):60107,t=n?Symbol.for(\"react.strict_mode\"):60108,u=n?Symbol.for(\"react.profiler\"):60114,v=n?Symbol.for(\"react.provider\"):60109,w=n?Symbol.for(\"react.context\"):60110,x=n?Symbol.for(\"react.forward_ref\"):60112,y=n?Symbol.for(\"react.suspense\"):60113,z=n?Symbol.for(\"react.memo\"):60115,A=n?Symbol.for(\"react.lazy\"):\n60116,B=\"function\"===typeof Symbol&&Symbol.iterator;function C(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}\nvar D={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},E={};function F(a,b,c){this.props=a;this.context=b;this.refs=E;this.updater=c||D}F.prototype.isReactComponent={};F.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(C(85));this.updater.enqueueSetState(this,a,b,\"setState\")};F.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};\nfunction G(){}G.prototype=F.prototype;function H(a,b,c){this.props=a;this.context=b;this.refs=E;this.updater=c||D}var I=H.prototype=new G;I.constructor=H;l(I,F.prototype);I.isPureReactComponent=!0;var J={current:null},K=Object.prototype.hasOwnProperty,L={key:!0,ref:!0,__self:!0,__source:!0};\nfunction M(a,b,c){var e,d={},g=null,k=null;if(null!=b)for(e in void 0!==b.ref&&(k=b.ref),void 0!==b.key&&(g=\"\"+b.key),b)K.call(b,e)&&!L.hasOwnProperty(e)&&(d[e]=b[e]);var f=arguments.length-2;if(1===f)d.children=c;else if(1<f){for(var h=Array(f),m=0;m<f;m++)h[m]=arguments[m+2];d.children=h}if(a&&a.defaultProps)for(e in f=a.defaultProps,f)void 0===d[e]&&(d[e]=f[e]);return{$$typeof:p,type:a,key:g,ref:k,props:d,_owner:J.current}}\nfunction N(a,b){return{$$typeof:p,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===p}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+(\"\"+a).replace(/[=:]/g,function(a){return b[a]})}var P=/\\/+/g,Q=[];function R(a,b,c,e){if(Q.length){var d=Q.pop();d.result=a;d.keyPrefix=b;d.func=c;d.context=e;d.count=0;return d}return{result:a,keyPrefix:b,func:c,context:e,count:0}}\nfunction S(a){a.result=null;a.keyPrefix=null;a.func=null;a.context=null;a.count=0;10>Q.length&&Q.push(a)}\nfunction T(a,b,c,e){var d=typeof a;if(\"undefined\"===d||\"boolean\"===d)a=null;var g=!1;if(null===a)g=!0;else switch(d){case \"string\":case \"number\":g=!0;break;case \"object\":switch(a.$$typeof){case p:case q:g=!0}}if(g)return c(e,a,\"\"===b?\".\"+U(a,0):b),1;g=0;b=\"\"===b?\".\":b+\":\";if(Array.isArray(a))for(var k=0;k<a.length;k++){d=a[k];var f=b+U(d,k);g+=T(d,f,c,e)}else if(null===a||\"object\"!==typeof a?f=null:(f=B&&a[B]||a[\"@@iterator\"],f=\"function\"===typeof f?f:null),\"function\"===typeof f)for(a=f.call(a),k=\n0;!(d=a.next()).done;)d=d.value,f=b+U(d,k++),g+=T(d,f,c,e);else if(\"object\"===d)throw c=\"\"+a,Error(C(31,\"[object Object]\"===c?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":c,\"\"));return g}function V(a,b,c){return null==a?0:T(a,\"\",b,c)}function U(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(a.key):b.toString(36)}function W(a,b){a.func.call(a.context,b,a.count++)}\nfunction aa(a,b,c){var e=a.result,d=a.keyPrefix;a=a.func.call(a.context,b,a.count++);Array.isArray(a)?X(a,e,c,function(a){return a}):null!=a&&(O(a)&&(a=N(a,d+(!a.key||b&&b.key===a.key?\"\":(\"\"+a.key).replace(P,\"$&/\")+\"/\")+c)),e.push(a))}function X(a,b,c,e,d){var g=\"\";null!=c&&(g=(\"\"+c).replace(P,\"$&/\")+\"/\");b=R(b,g,e,d);V(a,aa,b);S(b)}var Y={current:null};function Z(){var a=Y.current;if(null===a)throw Error(C(321));return a}\nvar ba={ReactCurrentDispatcher:Y,ReactCurrentBatchConfig:{suspense:null},ReactCurrentOwner:J,IsSomeRendererActing:{current:!1},assign:l};exports.Children={map:function(a,b,c){if(null==a)return a;var e=[];X(a,e,null,b,c);return e},forEach:function(a,b,c){if(null==a)return a;b=R(null,null,b,c);V(a,W,b);S(b)},count:function(a){return V(a,function(){return null},null)},toArray:function(a){var b=[];X(a,b,null,function(a){return a});return b},only:function(a){if(!O(a))throw Error(C(143));return a}};\nexports.Component=F;exports.Fragment=r;exports.Profiler=u;exports.PureComponent=H;exports.StrictMode=t;exports.Suspense=y;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ba;\nexports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw Error(C(267,a));var e=l({},a.props),d=a.key,g=a.ref,k=a._owner;if(null!=b){void 0!==b.ref&&(g=b.ref,k=J.current);void 0!==b.key&&(d=\"\"+b.key);if(a.type&&a.type.defaultProps)var f=a.type.defaultProps;for(h in b)K.call(b,h)&&!L.hasOwnProperty(h)&&(e[h]=void 0===b[h]&&void 0!==f?f[h]:b[h])}var h=arguments.length-2;if(1===h)e.children=c;else if(1<h){f=Array(h);for(var m=0;m<h;m++)f[m]=arguments[m+2];e.children=f}return{$$typeof:p,type:a.type,\nkey:d,ref:g,props:e,_owner:k}};exports.createContext=function(a,b){void 0===b&&(b=null);a={$$typeof:w,_calculateChangedBits:b,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null};a.Provider={$$typeof:v,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};exports.forwardRef=function(a){return{$$typeof:x,render:a}};exports.isValidElement=O;\nexports.lazy=function(a){return{$$typeof:A,_ctor:a,_status:-1,_result:null}};exports.memo=function(a,b){return{$$typeof:z,type:a,compare:void 0===b?null:b}};exports.useCallback=function(a,b){return Z().useCallback(a,b)};exports.useContext=function(a,b){return Z().useContext(a,b)};exports.useDebugValue=function(){};exports.useEffect=function(a,b){return Z().useEffect(a,b)};exports.useImperativeHandle=function(a,b,c){return Z().useImperativeHandle(a,b,c)};\nexports.useLayoutEffect=function(a,b){return Z().useLayoutEffect(a,b)};exports.useMemo=function(a,b){return Z().useMemo(a,b)};exports.useReducer=function(a,b,c){return Z().useReducer(a,b,c)};exports.useRef=function(a){return Z().useRef(a)};exports.useState=function(a){return Z().useState(a)};exports.version=\"16.14.0\";\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = GeneratorFunctionPrototype;\n  define(Gp, \"constructor\", GeneratorFunctionPrototype);\n  define(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction);\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  });\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(Gp, \"toString\", function() {\n    return \"[object Generator]\";\n  });\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, in modern engines\n  // we can explicitly access globalThis. In older engines we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n"],"sourceRoot":""}
\ No newline at end of file